几个月前，我把这个问题当作一次面试的难题。最近，在考虑博客材料时，它突然成为一个很好的例子，可用于从功能上解决问题。写完博客文章后，我将立即发布解决方案。

注意：这个问题是一年前在StackOverflow上提出的，在回答了几个（不正确）答案后被否决。我认为这是一个显而易见的面试或作业问题，因此被否决了。我们在这里的答案应该是经过深思熟虑的代码，以便有人不要考虑使用它们！

在比赛中，您使用以下策略下注。每当您输掉一个赌注时，就将下一轮的赌注值翻倍。每当您获胜时，下一轮的赌注将为一美元。您通过下注一美元开始本轮比赛。

例如，如果您以20美元开始，并且在第一轮中赢得赌注，在接下来的两轮中输掉赌注，然后在第四轮中赢得赌注，您将得到20 + 1-1-2 +4 = 22美元。

您应该完成函数，该函数带有g两个参数：

1. 第一个参数是一个整数a，它是我们开始下注时所拥有的初始资金。
2. 第二个参数是一个字符串r。结果的第i个字符将是“ W”（胜利）或“ L”（失败），表示第i回合的结果。

您的函数应该返回所有回合之后您将拥有的金额。

如果在某个时候您的帐户中没有足够的资金来支付下注的价值，那么您必须停止并退还当时的金额。

样品运行

1st round - Loss: 15-1 = 14
2nd round - Loss: 14-2 = 12 (Bet doubles)
3rd round - Loss: 12-4 = 8
4th round - Win: 8 + 8 = 16
5th round - Loss:16-1 = 15 (Since the previous bet was a win, this bet has a value of 1 dollar)
6th round - Loss: 15-2 = 13
7th round - Loss: 13-4 = 9
8th round - Loss: 9-8 = 1

1在这种情况下函数返回

获胜者由隐含函数定义中的最少字符数确定。如果需要，可以通过语言进行合作。我知道我的可以改善！

GolfScript，33个字符

{
1\{2$2$<!{1&{+1}{:b-b.+}if.}*;}/;
}:g;

示例（在线）：

> 13 'LLLWLLLL'
6
> 4 'LWWLWLWWWL'
9
> 5 'LLLWWWLLWLWW'
2
> 2 'LW'
1

带注释的代码：

1\            # prepare stack a b r
{             # for each char in r
  2$2$<!{     #   if a>=b  
    1&        #     take last bit of character (i.e. 0 for L and 1 for W)
    {         #     if W
      +       #       a <- a+b
      1       #       b <- 1
    }{        #     else
      :b-     #       a <- a-b
      b.+     #       b <- 2*b
    }if       #     end if
    .         #     create dummy value
  }*          #   end if
  ;           #   drop (i.e. either the dummy or the character)
}/            # end for
;             # discard current bet value

Python 2，72 68 62字节

def g(a,s,n=1):
 for c in s:
    if a>=n:a,n=((a+n,1),(a-n,2*n))[c<'W']
 return a

这样称呼：g(15,'LLLWLLLL')。

这只是在字符串中循环，改变了我们根据角色获得的金钱价值。

这是在此功能上运行测试的示例程序：

import random
def g(a,s,n=1):
 for c in s:
    if a>=n:a,n=((a+n,1),(a-n,2*n))[c<'W']
 return a

for i in range(14):
    s=''.join(('L','W')[random.randint(0, 1)] for e in range(random.randint(10, 15)))
    print'g(%i,%s):'%(i,`s`),
    print g(i,s)

样本输出：

g(0,'LLWWWWWWLWWWWW'): 0
g(1,'WLLWWWWWWWW'): 1
g(2,'WWWLLLWLLW'): 2
g(3,'LLLLWLWLWWWWLL'): 0
g(4,'LWWWWLWLWWW'): 12
g(5,'WWLWWLLWWW'): 12
g(6,'LLLWWWLLLLWLLWL'): 3
g(7,'WWLLWWLWLWLWLLL'): 7
g(8,'WLLLWWWWWLLWLL'): 2
g(9,'WWWLLWLLLLLWL'): 6
g(10,'LWWWWLLLWL'): 7
g(11,'WLLLLWLWWWW'): 5
g(12,'WLLWWLWWWL'): 17
g(13,'LLLWLLWLWLWLWW'): 6

只需对测试仪进行一点改动，我们就可以得到许多运行的平均利润：

import random
def g(a,s,n=1):
 for c in s:
    if a>=n:a,n=((a+n,1),(a-n,2*n))[c<'W']
 return a

r=[]
for i in range(5000):
    for i in range(1000):
        s=''.join(('L','W')[random.randint(0, 1)] for e in range(random.randint(10, 15)))
        r+=[i-g(i,s)]
a=0
for n in r:
    a+=n
print float(a)/len(r)

示例输出（花了一段时间，因为我们调用了函数5000000时间）：

-0.0156148

编辑：感谢霍华德和丹尼进一步打高尔夫球。

编辑：现在程序检查是否有足够的钱进行下注。这实际上节省了字节。

R，95个字符

g=function(a,r){n=1;for(i in 1:nchar(r)){s=substr(r,i,i);if(s=='L'){a=a-n;n=n*2}else{a=a+n;n=1};if(n>a)break};a}

缩进：

g=function(a,r){
    n=1
    for(i in 1:nchar(r)){
        s=substr(r,i,i)
        if(s=='L'){
            a=a-n
            n=n*2
            }else{
                a=a+n
                n=1
                }
        if(n>a)break
        }
    a
    }

用法：

> g(15,'LLWLLLL')
[1] 1
> g(20,'WLLW')
[1] 22
> g(13,'LLWLLLLWWLWWWLWLWW')
[1] 7

J- 63 55字符

现在增加了不正确的好处！甚至和以前一样长。

((+/\@,(0{<#[)_,~|@]);@('W'<@(2^i.@#);.1@,}:)*_1^=&'L')

将起始金额作为左侧参数，将获胜/亏损连胜视为右侧。

说明：该程序平均分为两个功能的组合，下面将详细介绍。第一种将获胜/亏损连胜转换为带有相应符号的下注值，然后第二个实际上根据给定的初始资金和这种转换后的获胜/亏损连胜计算出答案。

;@('W'<@(2^i.@#);.1@,}:)*_1^=&'L'   NB. win/loss as sole argument
                         _1^=&'L'   NB. -1 for every L, +1 for W
      <@(      );.1                 NB. split vector into streaks:
   'W'              ,}:             NB.  cut on wins, shift right by 1
         2^i.@#                     NB. for each, make doubling run
;@(                    )*           NB. unsplit, multiply by signs

(+/\@,(0{<#[)_,~|@])   NB. money on left, above result on right
                |@]    NB. absolute value of bets 
             _,~       NB. append infinity to end
 +/\@,                 NB. partial sums with initial money
      (  <  )          NB. 1 whenever money in account < bet
          #[           NB. select those money values corresp. to 1s
       0{              NB. take first such item

请注意，我们在进行部分和之前先将钱加到赌注上，但是我们将无限注追加到赌注值列表的末尾。这就是使下一个下注的帐户价值转移的原因，并且使用无穷大允许我们始终将最后一个元素作为包罗万象。

用法：

   15 ((+/\@,(0{<#[)_,~|@]);@('W'<@(2^i.@#);.1@,}:)*_1^=&'L') 'LLLWLLLL'
1
   NB. naming for convenience
   f =: ((+/\@,(0{<#[)_,~|@]);@('W'<@(2^i.@#);.1@,}:)*_1^=&'L')
   20 f 'WLLW'
22
   2 f 'LW'
1
   13 f 'LLWLLLLWWLWWWLWLWW'
7
   12 13 14 15 28 29 30 31 (f"0 _) 'LLWLLLLWWLWWWLWLWW'  NB. for each left argument
6 7 0 1 14 15 39 40

JavaScript（ECMAScript 6草案）-62 51 50个字符（在函数主体中）

function g(a,r,t=0,b=1)
a>=b&&(c=r[t])?g((c=c>'L')?a+b:a-b,r,t+1,c||2*b):a

g用两个参数定义一个递归函数：

• a-您目前拥有的金额；和
• r -获胜/失败的字符串。

还有两个可选参数：

• t-当前下注的索引（最初是0）
• b-当前下注的金额（还是再次开始1）。

取消高尔夫：

function g(a,r,t=0,b=1){      // declare a function g with arguments a,r,t,b where
                              // t defaults to 0 and b defaults to 1
c = r[t];                     // get the character in the win/loss string for the current
                              // round.
if (   a>=b                   // check if we have enough money
    && c )                    // and if the string has not ended
{
  if ( c > 'L' )              // check if we've won the round
  {
    return g(a+b,r,t+1,1);    // if so call g again adding the winnings and resetting the
                              // cost.
  } else {
    return g(a-b,r,t+1,2*b);  // otherwise, subtract from the total money and double the
                              // cost.
  }
} else {
  return a;                   // If we've run out of money or got to the end then return
                              // the current total.
}}

JavaScript（ECMAScript 6）-61 58 54个字符（在函数主体中）

function g(a,r)
(b=1,[b=b>a?b:x>'L'?(a+=b,1):(a-=b,b*2)for(x of r)],a)

说明：

(b=1,                        // Initialise the cost to 1
 [                           // for each character x of r using array comprehension
     b=
       b>a?b                 // if we have run out of money do b=b
       :x>'L'?(a+=b,1)       // else if we've won collect the winnings and reset b=1
             :(a-=b,2*b)     // else subtract the cost from the total money and double
                             // the cost for next round.
  for(x of r)]               // Repeat for each character
                             // array.
,a)                          // Finally, return a.

测验

console.log(g(0,'LLLLLWWLWWLW')) // 0
console.log(g(1,'WWWLLLWWWWLLWW')) //1
console.log(g(2,'LLWLWWWWWWWL')) //1
console.log(g(3,'WWWWWWWLLLWL')) //3
console.log(g(4,'LWWLWLWWWL')) //9
console.log(g(5,'LLLWWWLLWLWW')) //2
console.log(g(6,'LWLLLLWWLWWW')) //0
console.log(g(7,'WWLWWLLLWLWLW')) //4
console.log(g(8,'WWLWWLLWLWL')) //13
console.log(g(9,'WWWLLLWLLWLWWW')) //5
console.log(g(10,'WLWLLWWWWWWWL')) //18
console.log(g(11,'WLWLWLWLLLWLLW')) //17
console.log(g(12,'WWLWWWLLWL')) //17
console.log(g(13,'WWWWLWLWWW')) //21
console.log(g(15,'LLLW')) //16
console.log(g(15,'LLLL')) //0
console.log(g(14,'LLLL')) //7
console.log(g(2,'LW')) //1
console.log(g(2,'LL')) //1
console.log(g(2,'WLL')) //0

Python，74个字节

def g(a,r,b=1):
 for l in r:
  if l>"L":a+=b;b=1
  else:a-=b;b*=2
 return a

我定义了函数g，该函数取a（开始时的钱数）和r（下注的结果），将第一个下注的数量初始化为1。然后，对于每个下注结果，如果是如果获胜（r中的“ W”），您将获得金钱，然后赌注回到1。否则，您输掉了赌注的金额，而下一个赌注的金额翻倍。最后，它退还您的钱。您可以像这样使用它：

print g(20,"WLLW") # 22
print g(15,"LLLWLLLL") # 1

我认为这可以进一步打高尔夫。

C，107个字符

f(int a,char*r,int n){return*r&&n<a?*r<77?f(a-n,r+1,n*2):f(a+n,r+1,1):a;}g(int a, char*r){return f(a,r,1);}

我在这里使用递归函数，因为在大多数情况下，实现较短。但是我不确定是否是这种情况，因为我需要制作一个附加的包装器函数，因此我的函数实际上只接受2个参数。f当前下注（累加器）需要函数中的第三个参数。

如果没有包装函数，则此解决方案的长度仅为73个字符，但是您需要传递一个值为1的附加参数（初始赌注）才能获得正确的结果。

松散：

f(int a,char*r,int n){
    return *r&&n<a
                ?*r<77
                    ?f(a-n,r+1,n*2)
                    :f(a+n,r+1,1)
                :a;
}
g(int a,char*r){
    return f(a,r,1);
}

C，90

g(int a,char*r){int c=1;while(*r){*r++%2?c=1,a++:(c*=2);if(c>a){c/=2;break;}}return++a-c;}

Javascript，63

function g(a,s){x=1;for(i in s)if(x<=a)s[i]>'L'?(a+=x,x=1):(a-=x,x*=2);return a}

样品运行：

console.log(g(15, 'LLLWLLLL'));  //1
console.log(g(20, 'WLLW'));  //22
console.log(g(13, 'LLWLLLLWWLWWWLWLWW')); //7

带记录的JSFiddle

取消高尔夫：

function g(a,s){
  x=1;                //bet starts at 1
  for(i in s)         //loop through win/lose string
    if(x<=a)          //check if we still have money to bet
      s[i]>'L'?
        (a+=x,x=1):   //win: add the bet amount to your total, and reset bet to 1
        (a-=x,x*=2);  //lose: subtract the bet amount from your total, and double your bet
  return a            //return your money
}

函数内的Javascript（ES5）69 64 60字节

function g(a,r){b=1;for(i in r)b=b>a?b:r[i]>'L'?(a+=b,1):(a-=b,b*2);return a}

变化：（相同长度）

function g(a,r,b){for(i in r)b=b?b>a?b:r[i]>'L'?(a+=b,1):(a-=b,b*2):1;return a}

测试案例：（取自plannapus的解决方案）

g(15,'LLWLLLL'); // 1
g(20,'WLLW'); // 22
g(13,'LLWLLLLWWLWWWLWLWW'); // 7

哈斯克尔（62）

g a=fst.foldl(\(t,b)l->if l=='W'then(t+b,1)else(t-b,2*t))(a,1)

或两个参数都命名为（65个字符）：

g a r=fst$foldl(\(t,b)l->if l=='W'then(t+b,1)else(t-b,2*t))(a,1)r

注意g a r = 1 + a + the number of Ws in r + the number of trailing Ls in r（69）：

g a r=a+1+l(filter(=='W')r)-2^l(takeWhile(/='W')(reverse r))
l=length

Python 2 – 65字节

现在被当前最好的Python解决方案击败，但我不能不分享它：

def g(r,a,b=1):
    if r>"">a>=b:a=g(r[1:],*[(a+b,1),(a-b,b*2)][r[0]<"W"])
    return a

与其他一些Python解决方案一样，我使用函数参数b在函数定义之外进行声明，但是由于函数是递归的，因此除了在这里打高尔夫球之外，这实际上还可以达到其他目的。

我还需要更改函数参数的顺序，以便将元组拆包为函数参数即可工作。

如果您想知道，r>"">a>=b是的缩写r and a>=b。

Ruby，76个64（在函数体内）字节

编辑：通过删除3个字节改进了答案：

n=1;r.each_char{|c|;c>'L'?(a+=n;n=1):(a-=n;n*=2);break if n>a};a

使用func（82个字节）：

def g(a,r);n=1;r.each_char{|c|;c>'L'?(a,n=a+n,1):(a,n=a-n,n*2);break if n>a};a;end

使用lambda（76个字节）：

g=->a,r{n=1;r.each_char{|c|;c>'L'?(a,n=a+n,1):(a,n=a-n,n*2);break if n>a};a}

运行 ：

p g.call(15, 'LLLWLLLL') # 1
p g.call(20, 'WLLW') # 22
p g.call(13, 'LLWLLLLWWLWWWLWLWW') # 7

C＃，方法内部74个字符

我在这个网站上的第一次尝试...

int b=1;foreach(var c in r)if(b<=a){a+=c>'L'?b:-b;b=c>'L'?1:b*2;}return a;

或者，更具可读性：

int bet = 1;
foreach (var chr in r)
{                       // these brackets are left out in short version
   if (bet <= a)
   {
       a += chr > 'L' ? bet : -bet;
       bet = chr > 'L' ? 1 : bet * 2;
   }
}
return a;

很天真，没有很多花招……主要是利用char顺序和字符串可枚举的优势。当玩家的钱用完时，通过多余的循环来节省一些字符。

Golfscript，51 41 36 35字节

内部功能

1\{@2$-@2*@(1&{@@+1@}*.3$3$<!*}do;;

假设我们从一开始就获得了正数的钱，而输赢字符串将是非空的，因此至少可以进行一次下注。

例

{
  # Push initial bet amount.
  1\
  # STACK: Money Bet Outcomes
  {
    # Subtract bet amount from money.
    @2$-
    # STACK: Bet Outcomes Money
    # Double bet amount.
    @2*
    # STACK: Outcomes Money Bet
    # Remove first character from win-loss string and check if its ASCII code is odd.
    @(1&
    # STACK: Money Bet Outcomes Boolean
    # If it is, we've won, so add the doubled bet amount to the money and push 1 as the
    # new bet amont.
    {@@+1@}*
    # STACK: Money Bet Outcomes
    # Duplicate win-loss string, bet amonut and money.
    .3$3$
    # STACK: Money Bet Outcomes Outcomes Bet Money
    # If the next bet amount is less than our money and the win-loss string is not empty,
    # repeat the loop.
    <!*
    # STACK: Money Bet Outcomes Boolean
  }do
  # STACK: Money Bet Outcomes
  ;;
  # STACK: Money
}:f                                      # Define function.

];                                       # Clear stack.

20 'WLLW'               f
2  'LW'                 f
13 'LLWLLLLWWLWWWLWLWW' f
14 'LLWLLLLWWLWWWLWLWW' f

]p                                       # Print results as array.

给

[22 1 7 0]

在线尝试。

C＃，123

return q.Aggregate(new{b=1,c=w,x=1},(l,o)=>l.x<0?l:o=='W'?new{b=1,c=l.c+l.b,x=1}:new{b=l.b*2,c=l.c-l.b,x=l.c-l.b-l.b*2}).c;

.NET小提琴

一篇博客文章解释

Java，95个字节（内部函数）

int b=1;for(int c:r.getBytes()){if(m-b<0)return m;if(c<87){m-=b;b*=2;}else{m+=b;b=1;}}return m;

在线尝试！

Ruby，84个字符

def g(a,r,n=1)
return a if !r[0]||n>a
s=r[1..-1]
r[0]<?M?g(a-n,s,n*2):g(a+n,s,1)
end

与我在C语言中的其他答案相同的方法，但是我想尝试使用红宝石进行代码高尔夫。C版本的优点在于，我不需要创建包装函数，只需使用默认值作为参数即可。

K，76

g:{x+/-1_last'{(,1_*x),(("LW"!/:((2*;{1});(-:;::)))@\:**x)@\:x 1}\[(y;1;0)]}

。

k)g[15;"LLLWLLLL"]
1
k)g[20;"WLLW"]
22
k)g[50;"WLLLWLWLWLWLW"]
56

Python，86

def y(a,s):
 for l in s.split('W'):
    a+=1;k=2**len(l)
    if k>a:return int(bin(a)[3:],2)
 return a-k

我知道这绝不是最短的解决方案，但是我想展示一种不同的方法，该方法针对损失条纹而不是个人下注进行迭代。int(bin(a)[3:],2)给出a删除后的二进制表示形式中具有最高有效位的整数，该整数是该人失去2的增幂直到不能再下注之后所拥有的金额，因为当前a比其高1实际金额。此版本假定初始资本为正。

C- 64 59（内部功能）

另一个C答案。它利用了变量的值保留在堆栈上这一事实。因此，这对于某些编译器来说是失败的，但是无论我在哪里进行测试，它都可以正常工作。另外，我%2从tia拿来保存角色。抱歉!

f(int s,char*r){
    int a=1;
    for(;*r&&(*r++%2?s+=a,a=1:s<a?0:(s-=a,a*=2)););
    a=s;
}

批次-212

@echo off&setlocal enabledelayedexpansion&set r=%2&set a=%1&set c=1&powershell "&{'%2'.length-1}">f&set/pl=<f
for /l %%a in (0,1,%l%)do if "!r:~%%a,1!"=="L" (set/aa-=!c!&set/ac*=2) else set/aa+=!c!&set c=1
echo %a%

范例-

H:\uprof>bet.bat 15 LLLWLLLL
1

Japt，38个字节

V¬r@Z=WX<Z?X:Y¶'L?W=ZÑX-Z:(W=1X+Z}UW=1

尝试一下

可能需要打高尔夫球:)，但似乎得到正确的结果。

注意：这是一个完整的程序，通过添加前缀可以轻松转换为功能UV{。函数内部的字节数将相同。

Transpiled JS解释：

// V: input string of W's and L's
V
  // split V into an array of characters
  .q()
  // reduce
  .r(function(X, Y, Z) {
    return
      // W contains the current bet,
      // save it to a temp variable Z
      Z = W,
      // do we have enough to bet?
      X < Z
        // not enough to bet, return the previous amount
        ? X
         // we can bet, did we lose this round
         : Y === "L"
           // we lost, increment bet and decrease holdings
           ? (W = Z * 2, X - Z)
           // we won, reset bet and increase holdings
           : (W = 1, X + Z)
   },
   // U: initial holdings
   U,
   // initialize bet to 1
   W = 1
 )

PowerShell，68 81字节

param($n,$s)$w=1;$s|% t*y|%{if($n-ge$w){$n+=(-$w,$w)[$_%2];$w/=(.5,$w)[$_%2]}};$n

在线尝试！

这项挑战需要一些非常尴尬的任务，这意味着我无法将一个重大更新链接在一起。它确实使用了这样的事实：ASCII中的“ W”为87，而“ L”为76，因此2的修改使您可以访问简单的true / false值。|% t*y是toCharArray的标准快捷方式，使用除法更新下注是我发现的最便宜的方法（将损失除以一半（加倍），或将其除以胜利（将其设为1） ）。

再加上很多字节，因为我错过了约束。可以打高尔夫球

05AB1E，19 个字节

vDX@iy'WQiX+1UëXxU-

@Howard的GolfScript答案端口，因此请确保也对他进行投票！

注意05AB1E没有功能，因此它是一个完整的程序。
首先输入字符串，然后输入整数（STDIN中的换行符）。

在线尝试或验证更多测试用例。

说明：

v               # Loop over each character `y` of the (implicit) input-string:
 D              #  Duplicate the current integer
                #  (which is the implicit input-integer in the first iteration)
  X@i           #  If the integer is larger than or equal to variable `X`:
                #  (NOTE: variable `X` is 1 by default)
     y'WQi     '#   If the current character `y` is a 'W':
          X+    #    Increase the integer by `X`
          1U    #    And reset variable `X` to 1
         ë      #   Else (the current character `y` is an 'L' instead):
          X  -  #    Decrease the integer by `X`
           xU   #    And set variable `X` to double its current value
                # (the integer at the top of the stack is implicitly output after the loop)