Diversi mesi fa ho avuto questa domanda come puzzle pre-screening per un'intervista. Di recente, quando ho pensato al materiale del blog, mi è venuto in mente come un buon esempio da utilizzare per risolvere un problema funzionalmente. Pubblicherò la mia soluzione non appena avrò finito di scrivere il mio post sul blog.

NOTA: questa domanda è stata posta su StackOverflow un anno fa ed è stata sottoposta a downgrade dopo alcune (errate) risposte. Presumo che sia stato sottoposto a downgrade per ovvia intervista o domanda a casa. Le nostre risposte qui dovrebbero essere codificate a sufficienza per impedire a qualcuno di pensare di usarle!

In una gara, scommetti usando la seguente strategia. Ogni volta che perdi una scommessa, raddoppi il valore della scommessa per il round successivo. Ogni volta che vinci, la scommessa per il prossimo round sarà di un dollaro. Inizi il round scommettendo un dollaro.

Ad esempio, se inizi con 20 dollari e vinci la scommessa nel primo round, perdi la scommessa nei due round successivi e poi vinci la scommessa nel quarto round, finirai con 20 + 1-1-2 +4 = 22 dollari.

Ci si aspetta che completi la funzione g, che accetta due argomenti:

1. Il primo argomento è un numero intero ache è il denaro iniziale che abbiamo quando abbiamo iniziato le scommesse.
2. Il secondo argomento è una stringa r. Il suo carattere di risultato sarà 'W' (vittoria) o 'L' (perdita), indicando il risultato del suo turno.

La tua funzione dovrebbe restituire la quantità di denaro che avrai dopo aver giocato tutti i round.

Se a un certo punto non hai abbastanza soldi nel tuo conto per coprire il valore della scommessa, devi fermarti e restituire la somma che hai a quel punto.

Esecuzione del campione

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

La funzione ritorna 1in questo caso

Il vincitore è determinato dal numero minimo di caratteri INTERNI della definizione di funzione implicita. Cooperare per lingua se lo si desidera. So che il mio può essere migliorato!

GolfScript, 33 caratteri

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

Esempi ( online ):

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

Codice annotato:

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

Chiamatela in questo modo: g(15,'LLLWLLLL').

Questo semplicemente scorre attraverso la stringa, cambiando il valore del denaro che abbiamo basato sul personaggio.

Ecco un programma di esempio che esegue test su questa funzione:

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)

Uscita campione:

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

Con una piccola modifica al tester, possiamo ottenere il profitto medio di molte corse:

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)

Esempio di output (ci è voluto un po 'di tempo, poiché stiamo chiamando i 5000000tempi delle funzioni ):

-0.0156148

Modifica: grazie a Howard e Danny per l'ulteriore golf.

EDIT: ora il programma controlla se ci sono abbastanza soldi per fare la scommessa. Questo in realtà salva byte.

R, 95 caratteri

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}

rientrato:

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
    }

Uso:

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

J - 63 55 char

Ora con l'ulteriore vantaggio di non essere errato! È esattamente esattamente come prima.

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

Prende la quantità iniziale di denaro come argomento sinistro e la sequenza di vincite / perdite a destra.

Spiegazione: Il programma si divide uniformemente in qualcosa come una composizione di due funzioni, entrambe descritte di seguito. Il primo trasforma la serie di vincite / perdite nei valori delle scommesse, con il segno corrispondente, quindi la seconda individua effettivamente la risposta data la somma iniziale e questa sequenza di vincite / perdite trasformata.

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

Nota che anteponiamo il denaro alle scommesse prima di prendere le somme parziali, ma aggiungiamo la scommessa infinita alla fine dell'elenco dei valori della scommessa. Questo è ciò che sposta il valore dell'account in cima alla scommessa successiva e l'uso di infinito ci consente di avere sempre l'ultimo elemento come un catch-all.

Uso:

   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 (bozza ECMAScript 6) - 62 51 50 caratteri (nel corpo della funzione)

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

Definisce una funzione ricorsiva gcon due argomenti:

• a- l'attuale quantità di denaro che hai; e
• r - la serie di vincite / perdite.

E due argomenti opzionali:

• t- l'indice dell'attuale giro di scommesse (inizialmente 0)
• b- la quantità di denaro per la scommessa corrente (di nuovo inizialmente 1).

Ungolfed:

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 caratteri (nel corpo della funzione)

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

Spiegazione:

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

test

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

Ho definito la funzione g che accetta a (la quantità di denaro che hai all'inizio) er (che è il risultato delle scommesse) Inizializza l'importo della prima scommessa su 1. Quindi per ogni risultato delle scommesse, se è una vincita ("W" in r) guadagni i soldi e la scommessa ritorna a 1. Altrimenti perdi l'importo della scommessa e l'importo della scommessa successiva raddoppia. Alla fine restituisce i soldi che hai. Puoi usarlo in questo modo:

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

Penso che questo possa essere anche giocato a golf.

C, 107 caratteri

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

Sto usando una funzione ricorsiva qui, perché la maggior parte delle volte l'implementazione è più breve. Ma non sono del tutto sicuro se questo è il caso, perché avevo bisogno di fare una funzione wrapper aggiuntiva, quindi la mia funzione prende in realtà solo 2 argomenti. Il terzo argomento in funzione fè necessario per la scommessa corrente (l'accumulatore).

Senza la funzione wrapper questa soluzione sarebbe lunga solo 73 caratteri, ma sarebbe necessario passare un parametro aggiuntivo con il valore 1 (la puntata iniziale) per ottenere il risultato corretto.

ungolfed:

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}

Esecuzioni campione:

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

JSFiddle w / logging

Ungolfed:

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 all'interno della funzione

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}

Variazione: ( stessa lunghezza )

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}

Casi di test: ( tratto dalla soluzione di 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)

o con entrambi gli argomenti nominati (65 caratteri):

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

Si noti che 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

Ora battuto dalla migliore soluzione Python attuale, ma non posso non condividerla:

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

Come alcune altre soluzioni Python, uso gli argomenti della funzione per dichiarare b al di fuori della definizione della funzione, ma poiché la funzione è ricorsiva, questo in realtà serve a scopi diversi dal golf qui.

Avevo anche bisogno di cambiare l'ordine degli argomenti della funzione affinché la tupla scompattasse gli argomenti della funzione per funzionare.

Nel caso ti chiedi, r>"">a>=bè l'abbreviazione di r and a>=b.

Ruby, 76 64 byte (nel corpo della funzione)

EDIT: migliorata la risposta rimuovendo 3 byte:

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

utilizzando 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

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

la corsa :

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

C #, 74 caratteri all'interno del metodo

Il mio primo tentativo su questo sito ...

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

O, più leggibile:

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;

Abbastanza ingenuo, non così tanti trucchi ... sfruttando principalmente il carattere ordinario e la stringa enumerabile. Risparmio di alcuni personaggi con un ciclo estraneo quando il giocatore esaurisce i soldi.

Golfscript, 51 41 36 35 byte

Funzione interna

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

Ciò presuppone che iniziamo con una somma di denaro positiva e che la stringa di vincita sia non vuota, in modo che almeno una scommessa possa essere eseguita.

Esempio

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

dà

[22 1 7 0]

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

Il violino .NET

Un post sul blog che spiega

Java, 95 byte (funzione interna)

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;

Provalo online!

Rubino, 84 caratteri

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

Stesso approccio dell'altra mia risposta in C, ma volevo provare ruby ​​per Code-Golf. Il vantaggio della versione C è che non ho bisogno di creare una funzione wrapper, posso semplicemente usare i valori predefiniti per i parametri.

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

So che questo non è affatto vicino alla soluzione più breve, ma volevo dimostrare un approccio diverso, che ripercorre le serie di perdite piuttosto che le singole scommesse. int(bin(a)[3:],2)fornisce il numero intero con il bit più significativo della rappresentazione binaria di acancellato, che è la quantità di denaro che la persona avrà dopo aver perso poteri crescenti di 2 fino a quando non potrà più scommettere, perché a è attualmente 1 più alto del suo quantità effettiva di denaro. Questa versione presuppone che il capitale iniziale sia positivo.

C - 64 59 (Funzione interna)

Ancora un'altra risposta C. Sfrutta il fatto che il valore della variabile rimane nello stack. Quindi questo non riesce con alcuni compilatori, ma ha funzionato correttamente ovunque io abbia provato. Inoltre, ho preso la %2tia per salvare un personaggio. Scusate!

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

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

Esempio -

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

Provalo

Probabilmente ha bisogno di un po 'di golf :) Ma sembra ottenere risultati corretti.

NOTA Questo è un programma completo che è banale da trasformare in una funzione anticipando UV{. Il conteggio dei byte all'interno della funzione sarà lo stesso.

Spiegato JS spiegato:

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

Provalo online!

Questa sfida ha bisogno di alcuni incarichi molto imbarazzanti, il che significa che non ho potuto mettere insieme un grosso aggiornamento. Usa il fatto che 'W' è 87 in ASCII e 'L' è 76, quindi il modding per 2 ti dà accesso a semplici valori vero / falso. |% t*yè il collegamento standard a CharArray e l'aggiornamento della scommessa usando la divisione si è rivelato il modo più economico che ho trovato (lo divide per metà in perdita (raddoppiandolo) o lo divide da solo in caso di vittoria (impostandolo su 1) ).

Inoltre molti byte perché ho perso il vincolo. Funzionerà a golf giù la patch

05AB1E , 19 byte

vDX@iy'WQiX+1UëXxU-

Porto di @Howard s' GolfScript risposta , quindi assicuratevi di lui upvote, come pure!

Si noti che 05AB1E non ha funzioni, quindi si tratta invece di un programma completo.
Accetta prima l'input della stringa e poi l'input dell'intero intero (newline delimitato in STDIN).

Provalo online o verifica alcuni altri casi di test .

Spiegazione:

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)