数ヶ月前、私はインタビューのための事前スクリーニングのパズルとしてこの質問をしました。最近、ブログの素材について考えると、問題を機能的に解決するための良い例として頭に浮かびました。ブログ投稿を書き終えたらすぐに、これに対する解決策を投稿します。

注：この質問は1年前にStackOverflowで尋ねられたもので、いくつかの（誤った）回答の後に採択されました。明らかなインタビューや宿題の質問であると断定されたと思います。ここでの答えは、誰かがそれらを使用することを考えないように、十分に深くコード化されるべきです！

レースでは、次の戦略を使用して賭けます。ベットを失うたびに、次のラウンドのベットの値を2倍にします。勝つたびに、次のラウンドの賭け金は1ドルになります。1ドルを賭けてラウンドを開始します。

たとえば、20ドルで開始し、最初のラウンドで賭けに勝ち、次の2つのラウンドで賭けを失い、4番目のラウンドで賭けに勝った場合、20 + 1-1-2になります。 +4 = 22ドル。

次のg2つの引数を取る関数を完了することが期待されています。

1. 最初の引数は整数aで、これは賭けを開始するときに持っている最初のお金です。
2. 2番目の引数は文字列rです。結果のi番目の文字は、i番目のラウンドの結果を示す 'W'（勝ち）または 'L'（負け）のいずれかになります。

あなたの関数は、すべてのラウンドがプレイされた後に持っているお金の量を返す必要があります。

ある時点で、ベットの価値をカバーするのに十分なお金がアカウントにない場合、その時点で持っている合計額を停止して返さなければなりません。

サンプル実行

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)

サンプル出力（関数timeを呼び出しているため、かなり時間がかかり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')

左の引数として開始金額を取り、右の勝ち/負けの連勝を取ります。

説明：プログラムは、以下に詳述する2つの関数の構成のようなものに均等に分割されます。1つ目は勝ち/負けの連勝を対応する符号で賭けの値に変え、2つ目は最初のお金とこの勝ち/負けの連勝を与えられた答えを実際に計算します。

;@('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

g2つの引数を持つ再帰関数を定義します。

• a-あなたが持っている現在の金額。そして
• r -勝ち/負けの文字列。

そして、2つのオプションの引数：

• 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

a（開始時に持っている金額）とr（賭けの結果）をとる関数gを定義しました。最初の賭けの量を1に初期化します。次に、賭けの結果ごとに勝ち（rの「W」）を獲得し、ベットは1に戻ります。それ以外の場合、ベット額を失い、次のベット額は2倍になります。最後に、あなたが持っているお金を返します。次のように使用できます。

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つの引数しか受け取らないように、追加のラッパー関数を作成する必要があるからです。functionの3番目の引数は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 w / logging

ゴルフをしていない：

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ソリューションにbeatられていますが、共有することはできません。

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。

ルビー、 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

ラムダ（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;;

これは、正の金額で開始し、勝ち負けの文字列が空ではないことを前提としているため、少なくとも1つの賭けを行うことができます。

例

{
  # 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;

オンラインでお試しください！

ルビー、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での他の答えと同じアプローチですが、Code-Golfingでルビーを試したかったのです。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。これは、aが現在1より高いため、2の累乗を失ってから賭けができなくなるまでのお金の量です。実際の金額。このバージョンでは、初期資本がプラスであると想定しています。

C- 64 59（内部機能）

さらに別のCの答え。変数の値がスタックにとどまるという事実を利用します。そのため、これは一部のコンパイラでは失敗しますが、テストしたところはどこでも正常に動作しました。また、%2キャラクターを保存するためにfrom 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

オンラインでお試しください！

この課題にはいくつかの非常に厄介な割り当てが必要です。つまり、1つの大きな更新を連結できませんでした。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)