Kilka miesięcy temu miałem to pytanie jako łamigłówkę przed przesiewową rozmową kwalifikacyjną. Ostatnio, gdy myślę o blogu, pojawił się w mojej głowie jako dobry przykład, który można wykorzystać do funkcjonalnego rozwiązania problemu. Prześlę swoje rozwiązanie tego problemu, gdy tylko skończę pisać mój blog.

UWAGA: To pytanie zostało zadane na StackOverflow rok temu i zostało odrzucone po kilku (niepoprawnych) odpowiedziach. Zakładam, że zostało to uznane za oczywiste pytanie za wywiad lub zadanie domowe. Nasze odpowiedzi powinny być wystarczająco głęboko zakodowane w golfa, aby ktoś nie pomyślał o ich użyciu!

W wyścigu obstawiasz stosując następującą strategię. Ilekroć przegrywasz zakład, podwajasz wartość zakładu w następnej rundzie. Za każdym razem, gdy wygrasz, zakład na następną rundę będzie wynosić jednego dolara. Rundę zaczynasz od obstawienia jednego dolara.

Na przykład, jeśli zaczniesz od 20 dolarów i wygrasz zakład w pierwszej rundzie, przegrasz zakład w następnych dwóch rundach, a następnie wygrasz zakład w czwartej rundzie, skończysz z 20 + 1-1-2 +4 = 22 dolary.

Oczekuje się, że ukończysz funkcję g, która wymaga dwóch argumentów:

1. Pierwszym argumentem jest liczba całkowita, aktóra jest kwotą początkową, jaką mamy, kiedy rozpoczynamy obstawianie.
2. Drugi argument to ciąg znaków r. I-tą postacią wyniku będzie „W” (wygrana) lub „L” (przegrana), oznaczający wynik i-tej rundy.

Twoja funkcja powinna zwrócić ilość pieniędzy, którą będziesz mieć po rozegraniu wszystkich rund.

Jeśli w którymś momencie nie masz wystarczającej ilości pieniędzy na koncie, aby pokryć wartość zakładu, musisz przerwać i zwrócić sumę, którą masz w tym momencie.

Przykładowy przebieg

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

W 1tym przypadku funkcja powraca

Zwycięzca jest określany przez najmniejszą liczbę znaków WEWNĄTRZ domyślnej definicji funkcji. W razie potrzeby współpracuj według języka. Wiem, że moje można ulepszyć!

GolfScript, 33 znaki

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

Przykłady ( online ):

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

Kod z adnotacjami:

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 bajtów

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

Nazwijmy to tak: g(15,'LLLWLLLL').

To po prostu zapętla łańcuch, zmieniając wartość pieniędzy, które mamy na podstawie postaci.

Oto przykładowy program, który uruchamia testy tej funkcji:

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)

Przykładowe dane wyjściowe:

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

Po niewielkiej zmianie testera możemy uzyskać średni zysk z wielu przebiegów:

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)

Przykładowe dane wyjściowe (zajęło sporo czasu, ponieważ wywołujemy 5000000czasy funkcji ):

-0.0156148

Edycja: Podziękowania dla Howarda i Danny'ego za dalszą grę w golfa.

EDYCJA: teraz program sprawdza, czy jest wystarczająco dużo pieniędzy, aby postawić zakład. To faktycznie oszczędza bajty.

R, 95 znaków

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}

Zębaty:

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
    }

Stosowanie:

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

J - 63 55 znaków

Teraz z dodatkową premią za nie bycie niepoprawnym! To nawet dokładnie tak długo jak wcześniej.

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

Bierze początkową kwotę pieniędzy jako lewy argument i pasmo wygranej / straty po prawej stronie.

Objaśnienie: Program dzieli się równomiernie na coś w rodzaju kompozycji dwóch funkcji, obie wyszczególnione poniżej. Pierwszy przekształca pasmo wygranych / przegranych w wartości zakładów, z odpowiednim znakiem, a następnie drugi faktycznie rozpoznaje odpowiedź, biorąc pod uwagę początkowe pieniądze i tę przekształconą pasmo wygranych / przegranych.

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

Pamiętaj, że przekazujemy pieniądze na zakłady przed pobraniem kwot częściowych, ale dołączamy nieskończony zakład na końcu listy wartości zakładów. Właśnie to przesuwa wartość konta nad następny zakład, a użycie nieskończoności pozwala nam zawsze mieć ostatni element jako catch-all.

Stosowanie:

   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 (wersja robocza ECMAScript 6) - 62 51 50 znaków (w treści funkcji)

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

Definiuje funkcję rekurencyjną gz dwoma argumentami:

• a- aktualna ilość posiadanych pieniędzy; i
• r - ciąg zwycięstw / strat.

I dwa opcjonalne argumenty:

• t - indeks bieżącej rundy zakładów (początkowo 0 )
• b - kwota pieniędzy na bieżący zakład (ponownie początkowo 1 ).

Nie golfowany:

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 znaków (w treści funkcji)

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

Wyjaśnienie:

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

Testy

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 bajty

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

Zdefiniowałem funkcję g, która bierze (ilość pieniędzy, którą masz na początku) ir (która jest wynikiem zakładów) Inicjuje kwotę pierwszego zakładu na 1. Następnie dla każdego wyniku zakładów, jeśli jest wygrana („W” wr) zyskujesz pieniądze, a zakład wraca do 1. W przeciwnym razie przegrywasz kwotę zakładu, a kwota następnego zakładu podwaja się. Wreszcie zwraca pieniądze, które masz. Możesz użyć tego w następujący sposób:

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

Myślę, że można to jeszcze pograć w golfa.

C, 107 znaków

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

Używam tutaj funkcji rekurencyjnej, ponieważ przez większość czasu implementacja jest krótsza. Ale nie jestem do końca pewien, czy tak jest tutaj, ponieważ musiałem utworzyć dodatkową funkcję otoki, więc moja funkcja faktycznie bierze tylko 2 argumenty. Trzeci argument w funkcji fjest potrzebny dla bieżącego zakładu (akumulatora).

Bez funkcji otoki rozwiązanie to miałoby tylko 73 znaki, ale trzeba by przekazać dodatkowy parametr o wartości 1 (zakład początkowy), aby uzyskać właściwy wynik.

bez golfa:

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}

Przykładowe przebiegi:

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

JSFiddle z logowaniem

Nie golfowany:

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 bajtów w ramach funkcji

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}

Wariacja: (ta sama długość )

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}

Przypadki testowe: ( wzięte z rozwiązania plannapusa )

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)

lub z nazwanymi obydwoma argumentami (65 znaków):

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

Uwaga: 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 bajtów

Teraz pobity przez obecne najlepsze rozwiązanie Python, ale nie mogę go nie udostępnić:

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

Podobnie jak niektóre inne rozwiązania Pythona, używam argumentów funkcji do deklarowania b poza definicją funkcji, ale ponieważ funkcja jest rekurencyjna, w rzeczywistości służy to celowi innemu niż gra w golfa.

Musiałem także zmienić kolejność argumentów funkcji, aby krotka rozpakowała się w argumenty funkcji aby działało .

Jeśli się zastanawiasz, r>"">a>=bjest skrótem r and a>=b.

Ruby, 76 64 (w ciele funkcji) bajtów

EDYCJA: poprawiono odpowiedź, usuwając 3 bajty:

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

przy użyciu func (82 bajtów):

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

przy użyciu lambda (76 bajtów):

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}

bieg :

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

C #, 74 znaki wewnątrz metody

Moja pierwsza próba na tej stronie ...

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

Lub bardziej czytelny:

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;

Dość naiwny, nie tyle sztuczek ... głównie wykorzystujących porządek char i porządek strunowy. Uratowanie kilku postaci przez zewnętrzne zapętlenie, gdy graczowi zabraknie pieniędzy.

Golfscript, 51 41 36 35 bajtów

Funkcja wewnętrzna

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

Zakłada się, że zaczynamy od dodatniej kwoty pieniężnej i że łańcuch wygranych i przegranych będzie niepusty, aby można było wykonać co najmniej jeden zakład.

Przykład

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

daje

[22 1 7 0]

Wypróbuj online.

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;

Skrzypce .NET

Wpis na blogu wyjaśniający

Java, 95 bajtów (funkcja wewnętrzna)

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;

Wypróbuj online!

Ruby, 84 znaków

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

Takie samo podejście jak moja inna odpowiedź w C, ale chciałem spróbować ruby ​​do gry w golfa. Zaletą wersji C jest to, że nie muszę tworzyć funkcji otoki, mogę po prostu użyć domyślnych wartości parametrów.

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

Wiem, że to nigdzie nie jest w pobliżu najkrótszego rozwiązania, ale chciałem wykazać inne podejście, które powtarza serię przegranych zamiast pojedynczych zakładów. int(bin(a)[3:],2)podaje liczbę całkowitą z najbardziej znaczącym bitem reprezentacji binarnej ausuniętej, czyli kwotę, którą osoba będzie miała po utracie rosnących uprawnień 2, dopóki nie będzie już mogła obstawiać, ponieważ a jest obecnie o 1 wyższy niż jego faktyczna ilość pieniędzy. Ta wersja zakłada, że ​​kapitał początkowy jest dodatni.

C - 64 59 (funkcja wewnętrzna)

Jeszcze jedna odpowiedź C. Wykorzystuje fakt, że wartość zmiennej pozostaje na stosie. To moja porażka z niektórymi kompilatorami, ale działała poprawnie gdziekolwiek testowałem. Również wziąłem %2z tia, aby uratować postać. Przepraszam!

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

Partia - 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%

Przykład -

H:\uprof>bet.bat 15 LLLWLLLL
1

Japt , 38 bajtów

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

Spróbuj

Prawdopodobnie potrzebuje gry w golfa :) Ale wydaje się, że osiąga prawidłowe wyniki.

UWAGA Jest to pełny program, który w prosty sposób można zamienić w funkcję przez dodanieUV{ . Liczba bajtów w funkcji będzie taka sama.

Wyjaśnienie 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 bajtów

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

Wypróbuj online!

To wyzwanie wymaga kilku niezręcznych zadań, co oznacza, że ​​nie mogłem połączyć jednej dużej aktualizacji. Wykorzystuje fakt, że „W” wynosi 87 w ASCII, a „L” wynosi 76, więc modowanie o 2 daje dostęp do łatwych wartości prawda / fałsz. |% t*yto standardowy skrót toCharArray, a aktualizacja zakładu za pomocą podziału okazała się najtańszym sposobem, jaki mogłem znaleźć (dzieli go albo przez połowę straty (podwajając), albo dzieli się sam przez siebie wygraną (ustawiając na 1) ).

Plus wiele bajtów, ponieważ brakowało mi ograniczenia. Będzie działać na polu golfowym

05AB1E , 19 bajtów

vDX@iy'WQiX+1UëXxU-

Port odpowiedzi GolfScript na @Howard , dlatego też oceń go!

Zauważ, że 05AB1E nie ma żadnych funkcji, więc jest to pełny program.
Najpierw pobiera ciąg znaków, a drugi liczbę całkowitą (znak nowej linii w STDIN).

Wypróbuj online lub sprawdź kilka innych przypadków testowych .

Wyjaśnienie:

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)