Vài tháng trước tôi có câu hỏi này như một câu đố sàng lọc trước cho một cuộc phỏng vấn. Gần đây khi nghĩ về tài liệu blog, nó xuất hiện trong đầu tôi như một ví dụ tốt để sử dụng để giải quyết vấn đề một cách chức năng. Tôi sẽ đăng giải pháp của mình cho vấn đề này ngay khi tôi viết xong bài đăng trên blog của mình.

LƯU Ý: Câu hỏi này đã được hỏi trên StackOverflow một năm trước và đã bị bỏ qua sau một vài câu trả lời (không chính xác). Tôi cho rằng nó đã bị đánh giá thấp vì là một câu hỏi phỏng vấn hoặc bài tập về nhà rõ ràng. Câu trả lời của chúng tôi ở đây phải là mã golf đủ sâu để ai đó không nghĩ về việc sử dụng chúng!

Trong một cuộc đua, bạn đặt cược bằng chiến lược sau. Bất cứ khi nào bạn thua cược, bạn sẽ nhân đôi giá trị của cược cho vòng tiếp theo. Bất cứ khi nào bạn giành chiến thắng, đặt cược cho vòng tiếp theo sẽ là một đô la. Bạn bắt đầu vòng bằng cách đặt cược một đô la.

Ví dụ: nếu bạn bắt đầu với 20 đô la và bạn thắng cược ở vòng đầu tiên, thua cược trong hai vòng tiếp theo và sau đó thắng cược ở vòng thứ tư, bạn sẽ kết thúc với tỷ số 20 + 1-1-2 +4 = 22 đô la.

Bạn sẽ hoàn thành hàm g, trong đó có hai đối số:

1. Đối số đầu tiên là một số nguyên alà số tiền ban đầu chúng ta có khi chúng ta bắt đầu cá cược.
2. Đối số thứ hai là một chuỗi r. Ký tự thứ i của kết quả sẽ là 'W' (thắng) hoặc 'L' (thua), biểu thị kết quả của vòng thứ i.

Chức năng của bạn sẽ trả lại số tiền bạn sẽ có sau khi tất cả các vòng được chơi.

Nếu tại một thời điểm nào đó bạn không có đủ tiền trong tài khoản của mình để trang trải giá trị của cược, bạn phải dừng và trả lại số tiền bạn có tại thời điểm đó.

Chạy mẫu

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

Hàm trả về 1trong trường hợp này

Người chiến thắng được xác định bởi số lượng ký tự ít nhất bên trong định nghĩa hàm ngụ ý. Hợp tác theo ngôn ngữ nếu muốn. Tôi biết của tôi có thể được cải thiện!

GolfScript, 33 ký tự

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

Ví dụ ( trực tuyến ):

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

Mã chú thích:

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 byte

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ọi nó như vậy : g(15,'LLLWLLLL').

Điều này chỉ đơn giản là vòng lặp thông qua chuỗi, thay đổi giá trị của số tiền mà chúng ta có dựa trên nhân vật.

Đây là một chương trình mẫu chạy thử nghiệm trên chức năng này:

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)

Đầu ra mẫu:

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

Với một chút thay đổi đối với người thử nghiệm, chúng tôi có thể nhận được lợi nhuận trung bình của nhiều lần chạy:

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)

Đầu ra mẫu (mất khá nhiều thời gian, vì chúng ta đang gọi 5000000thời gian của hàm ):

-0.0156148

Chỉnh sửa: Cảm ơn Howard và Danny đã chơi gôn.

EDIT: bây giờ chương trình kiểm tra xem có đủ tiền để đặt cược không. Điều này thực sự tiết kiệm byte.

R, 95 ký tự

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}

Thụt lề:

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
    }

Sử dụng:

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

J - 63 55 char

Bây giờ với tiền thưởng thêm không phải là không chính xác! Nó thậm chí còn chính xác như trước đây.

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

Lấy số tiền bắt đầu làm đối số bên trái và chuỗi thắng / thua ở bên phải.

Giải thích: Chương trình chia đều thành một thứ giống như một thành phần của hai chức năng, cả hai chi tiết dưới đây. Lần đầu tiên biến chuỗi thắng / thua thành giá trị của các cược, với dấu tương ứng, và sau đó lần thứ hai thực sự tìm ra câu trả lời cho số tiền ban đầu và chuỗi thắng / thua được chuyển đổi này.

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

Lưu ý rằng chúng tôi trả trước tiền cho các cược trước khi tính tổng một phần, nhưng chúng tôi sẽ đặt cược vô hạn vào cuối danh sách các giá trị đặt cược. Đây là những gì làm thay đổi giá trị của tài khoản vượt trội của lần đặt cược tiếp theo và việc sử dụng vô hạn cho phép chúng tôi luôn có yếu tố cuối cùng là tất cả.

Sử dụng:

   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 (Bản nháp ECMAScript 6) - 62 51 50 Ký tự (trong thân hàm)

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

Xác định hàm đệ quy gvới hai đối số:

• a- số tiền hiện tại bạn có; và
• r - chuỗi thắng / thua.

Và hai đối số tùy chọn:

• t- chỉ số của vòng đặt cược hiện tại (ban đầu 0)
• b- số tiền cho đặt cược hiện tại (một lần nữa ban đầu 1).

Ung dung:

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 Ký tự (trong thân hàm)

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

Giải trình:

(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.

Xét nghiệm

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 byte

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

Tôi đã xác định hàm g lấy một (số tiền bạn có khi bắt đầu) và r (là kết quả của các lần đặt cược) Nó khởi tạo số tiền của lần đặt cược đầu tiên là 1. Sau đó, cho mỗi kết quả của các lần đặt cược, nếu đó là một chiến thắng ("W" trong r) bạn kiếm được tiền và đặt cược trở lại 1. Khác bạn sẽ mất số tiền đặt cược và số tiền cho lần đặt cược tiếp theo tăng gấp đôi. Cuối cùng nó trả lại số tiền bạn có. Bạn có thể sử dụng nó như thế này:

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

Tôi nghĩ rằng điều này có thể được chơi golf hơn nữa.

C, 107 ký tự

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);}

Tôi đang sử dụng một hàm đệ quy ở đây, vì phần lớn thời gian thực hiện ngắn hơn. Nhưng tôi không chắc chắn nếu đó là trường hợp ở đây, bởi vì tôi cần phải thực hiện một hàm bao bọc bổ sung để thực tế chức năng của tôi chỉ có 2 đối số. Đối số thứ ba trong chức năng flà cần thiết cho đặt cược hiện tại (bộ tích lũy).

Nếu không có chức năng bao bọc, giải pháp này sẽ chỉ dài 73 ký tự, nhưng bạn sẽ cần truyền một tham số bổ sung với giá trị 1 (đặt cược bẩm sinh) để có kết quả chính xác.

vô dụng:

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}

Chạy mẫu:

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

JSFiddle w / đăng nhập

Ung dung:

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 byte trong chức năng

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}

Biến thể: ( cùng chiều dài )

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}

Các trường hợp thử nghiệm: ( lấy từ giải pháp của plannapus )

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

Haskell, 62

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

hoặc với cả hai đối số có tên (65 ký tự):

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

Lưu ý rằng 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 byte

Bây giờ bị đánh bại bởi giải pháp Python tốt nhất hiện tại, nhưng tôi không thể chia sẻ nó:

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

Như một số giải pháp Python khác, tôi sử dụng các đối số hàm để khai báo bbên ngoài định nghĩa hàm, nhưng vì hàm này là đệ quy, nên điều này thực sự phục vụ một số mục đích khác ngoài việc chơi golf ở đây.

Tôi cũng cần phải thay đổi thứ tự của các đối số hàm để bộ giải nén được giải nén thành các đối số hàm hoạt động.

Trong trường hợp bạn tự hỏi, r>"">a>=blà viết tắt của r and a>=b.

Ruby, 76 64 (trong thân hàm) byte

EDIT: đã cải thiện câu trả lời bằng cách xóa 3 byte:

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

sử dụng func (82 byte):

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

sử dụng lambda (76 byte):

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}

chạy:

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

Phương thức C #, 74 ký tự bên trong

Nỗ lực đầu tiên của tôi trên trang web này ...

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

Hoặc, dễ đọc hơn:

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;

Khá ngây thơ, không có nhiều mánh khóe ... chủ yếu là lợi dụng char là thứ tự và chuỗi là vô số. Lưu một vài ký tự bằng cách lặp ngoại lai khi người chơi hết tiền.

Golfscript, 51 41 36 35 byte

Chức năng bên trong

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

Điều này giả định rằng chúng tôi bắt đầu với một số tiền dương và chuỗi thắng thua sẽ không trống, do đó ít nhất một lần đặt cược có thể được thực hiện.

Thí dụ

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

cho

[22 1 7 0]

Hãy thử trực tuyến.

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 Fiddle

Một bài viết trên blog giải thích

Java, 95 byte (hàm bên trong)

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;

Hãy thử trực tuyến!

Ruby, 84 ký tự

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ách tiếp cận tương tự như câu trả lời khác của tôi trong C, nhưng tôi muốn thử ruby ​​cho Code-Golfing. Ưu điểm của phiên bản C là tôi không cần tạo chức năng bao bọc, tôi chỉ có thể sử dụng các giá trị mặc định cho tham số.

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

Con trăn, 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

Tôi biết đây không phải là giải pháp ngắn nhất, nhưng tôi muốn chứng minh một cách tiếp cận khác, đó là lặp đi lặp lại trên các vệt thua thay vì cá cược. int(bin(a)[3:],2)cung cấp cho số nguyên có bit đáng kể nhất từ ​​biểu diễn nhị phân ađã bị xóa, đó là số tiền mà người đó sẽ có sau khi mất quyền hạn tăng thêm 2 cho đến khi không thể đặt cược nữa, bởi vì hiện tại cao hơn 1 số tiền thực tế. Phiên bản này giả định vốn ban đầu là tích cực.

C - 64 59 (Chức năng bên trong)

Lại một câu trả lời C. Nó lợi dụng thực tế là giá trị của biến vẫn nằm trên ngăn xếp. Vì vậy, đây là thất bại của tôi với một số trình biên dịch, nhưng nó đã hoạt động đúng ở bất cứ nơi nào tôi đã thử nghiệm. Ngoài ra, tôi lấy %2từ tia để cứu một nhân vật. Lấy làm tiếc!

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;
}

Mẻ - 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%

Mẫu -

H:\uprof>bet.bat 15 LLLWLLLL
1

Japt , 38 byte

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

Thử nó

Có lẽ cần một số chơi golf :) Nhưng nó dường như nhận được kết quả chính xác.

LƯU Ý Đây là một chương trình đầy đủ tầm thường để biến thành một chức năng bằng cách trả trước UV{. Số byte bên trong hàm sẽ giống nhau.

Transpiled JS đã giải thích:

// 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 byte

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

Hãy thử trực tuyến!

Thử thách này cần một số bài tập rất khó xử, nghĩa là tôi không thể kết hợp một bản cập nhật lớn. Nó sử dụng thực tế là 'W' là 87 trong ASCII và 'L' là 76 vì vậy việc sửa đổi bằng 2 cho phép bạn truy cập vào các giá trị đúng / sai dễ dàng. |% t*ylà lối tắt toCharArray tiêu chuẩn và cập nhật cá cược bằng cách sử dụng phép chia hóa ra là cách rẻ nhất mà tôi có thể tìm thấy (chia cho một nửa cho một lần thua (nhân đôi) hoặc chia nó cho một chiến thắng (đặt nó thành 1) ).

Cộng với nhiều byte vì tôi đã bỏ lỡ ràng buộc. Sẽ làm việc trên sân golf xuống bản vá

05AB1E , 19 byte

vDX@iy'WQiX+1UëXxU-

Cảng @Howard 's GolfScript câu trả lời , vì vậy hãy chắc chắn để upvote ông cũng!

Lưu ý rằng 05AB1E không có chức năng, vì vậy đây là một chương trình đầy đủ thay thế.
Lấy đầu vào chuỗi trước và đầu vào số nguyên thứ hai (dòng mới được phân tách bằng STDIN).

Hãy thử trực tuyến hoặc xác minh một số trường hợp thử nghiệm .

Giải trình:

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)