Il y a plusieurs mois, j'avais cette question comme un puzzle de présélection pour une interview. Récemment, en pensant au matériel de blog, il m'est apparu comme un bon exemple à utiliser pour résoudre un problème de manière fonctionnelle. Je publierai ma solution dès que j'aurai fini d'écrire mon blog.

REMARQUE: Cette question a été posée sur StackOverflow il y a un an et a été déclassée après quelques réponses (incorrectes). Je suppose qu'il a été sous-estimé pour être une interview évidente ou une question de devoirs. Nos réponses ici devraient être suffisamment approfondies pour que quelqu'un ne pense pas à les utiliser!

Dans une course, vous misez en utilisant la stratégie suivante. Chaque fois que vous perdez une mise, vous doublez la valeur de la mise pour le tour suivant. Chaque fois que vous gagnez, la mise pour le prochain tour sera d'un dollar. Vous commencez le tour en misant un dollar.

Par exemple, si vous commencez avec 20 dollars et que vous gagnez le pari au premier tour, perdez le pari aux deux tours suivants et gagnez ensuite le pari au quatrième tour, vous vous retrouverez avec 20 + 1-1-2 +4 = 22 dollars.

Vous devez terminer la fonction g, qui prend deux arguments:

1. Le premier argument est un entier aqui est l'argent initial que nous avons lorsque nous commençons les paris.
2. Le deuxième argument est une chaîne r. Le ième caractère du résultat sera soit «W» (victoire) ou «L» (perte), dénotant le résultat du ième tour.

Votre fonction devrait retourner le montant d'argent que vous aurez après avoir joué tous les tours.

Si à un moment donné, vous n'avez pas assez d'argent sur votre compte pour couvrir la valeur du pari, vous devez arrêter et retourner la somme que vous avez à ce moment-là.

Exemple d'exécution

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 fonction retourne 1dans ce cas

Le gagnant est déterminé par le moins de caractères à L'INTÉRIEUR de la définition de fonction implicite. Coopérez par langue si vous le souhaitez. Je sais que le mien peut être amélioré!

GolfScript, 33 caractères

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

Exemples (en ligne ):

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

Code annoté:

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 octets

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

Appelez cela comme ceci: g(15,'LLLWLLLL').

Cela passe simplement à travers la chaîne, changeant la valeur de l'argent que nous avons en fonction du personnage.

Voici un exemple de programme qui exécute des tests sur cette fonction:

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)

Exemple de sortie:

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

Avec un petit changement dans le testeur, nous pouvons obtenir le bénéfice moyen de nombreuses exécutions:

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)

Exemple de sortie (a pris un certain temps, car nous appelons la fonction 5000000times):

-0.0156148

Edit: Merci à Howard et Danny pour le golf.

EDIT: le programme vérifie maintenant s'il y a suffisamment d'argent pour faire le pari. Cela économise en fait des octets.

R, 95 caractères

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}

Dentelé:

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
    }

Usage:

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

J - 63 55 car

Maintenant avec le bonus supplémentaire de ne pas être incorrect! C'est même exactement aussi longtemps qu'avant.

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

Prend le montant de départ comme argument de gauche et la séquence de victoires / défaites à droite.

Explication: Le programme se divise également en quelque chose comme une composition de deux fonctions, toutes deux détaillées ci-dessous. Le premier transforme la séquence de victoires / défaites en valeurs des paris, avec le signe correspondant, puis le second détermine la réponse en fonction de l'argent initial et de cette séquence de victoires / défaites transformée.

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

Notez que nous ajoutons l'argent aux paris avant de prendre les sommes partielles, mais nous ajoutons le pari infini à la fin de la liste des valeurs de pari. C'est ce qui décale la valeur du compte au-dessus du pari suivant, et l'utilisation de l'infini nous permet d'avoir toujours le dernier élément comme fourre-tout.

Usage:

   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 Draft) - 62 51 50 caractères (dans le corps de la fonction)

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

Définit une fonction récursive gavec deux arguments:

• a- le montant actuel que vous avez; et
• r - la chaîne de victoires / défaites.

Et deux arguments facultatifs:

• t- l'indice du tour de paris en cours (initialement 0)
• b- le montant d'argent pour le pari en cours (à nouveau initialement 1).

Non golfé:

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 Caractères (dans le corps de la fonction)

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

Explication:

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

Les tests

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 octets

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

J'ai défini la fonction g qui prend a (le montant d'argent que vous avez au début) et r (qui est le résultat des paris) Il initialise le montant du premier pari à 1. Puis pour chaque résultat des paris, s'il est une victoire ("W" en r) vous gagnez de l'argent et la mise revient à 1. Sinon, vous perdez le montant de la mise, et le montant pour la prochaine mise double. Enfin, il rend l'argent que vous avez. Vous pouvez l'utiliser comme ceci:

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

Je pense que cela peut être joué en plus.

C, 107 caractères

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

J'utilise une fonction récursive ici, car la plupart du temps, l'implémentation est plus courte. Mais je ne sais pas trop si c'est le cas ici, car j'avais besoin de créer une fonction wrapper supplémentaire, donc ma fonction ne prend en fait que 2 arguments. Le troisième argument en fonction fest nécessaire pour la mise actuelle (l'accumulateur).

Sans la fonction wrapper, cette solution ne compterait que 73 caractères, mais vous auriez besoin de passer un paramètre supplémentaire avec la valeur 1 (le pari initial) pour obtenir le bon résultat.

non golfé:

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}

Exemples de cycles:

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

JSFiddle avec enregistrement

Non golfé:

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 octets dans la fonction

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}

Déclinaison: ( même longueur )

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}

Cas de test: ( tirés de la solution de 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)

ou avec les deux arguments nommés (65 caractères):

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

Notez que 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 octets

Maintenant battu par la meilleure solution Python actuelle, mais je ne peux pas ne pas la partager:

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

Comme certaines autres solutions Python, j'utilise les arguments de fonction pour déclarer b dehors de la définition de la fonction, mais comme la fonction est récursive, cela sert en fait un autre objectif que de jouer au golf ici.

J'ai également eu besoin de changer l'ordre des arguments de fonction pour que le décompactage de tuple en arguments de fonction fonctionne.

Au cas où vous vous poseriez la question, r>"">a>=b c'est court pour r and a>=b.

Rubis, 76 64 (dans le corps de la fonction) octets

EDIT: amélioré la réponse en supprimant 3 octets:

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

en utilisant func (82 octets):

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

en utilisant lambda (76 octets):

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 course :

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

C #, 74 caractères à l'intérieur de la méthode

Ma toute première tentative sur ce site ...

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

Ou, plus lisible:

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;

Assez naïf, pas beaucoup de trucs ... profitant principalement du caractère ordinal et de la chaîne dénombrable. Sauvegarde de quelques personnages en boucle superflue lorsque le joueur manque d'argent.

Golfscript, 51 41 36 35 octets

Fonction intérieure

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

Cela suppose que nous commençons avec une somme d'argent positive et que la chaîne gagnant-perdant ne sera pas vide, de sorte qu'au moins un pari puisse être effectué.

Exemple

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

donne

[22 1 7 0]

Essayez-le en ligne.

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;

Le violon .NET

Un article de blog expliquant

Java, 95 octets (fonction interne)

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;

Essayez-le en ligne!

Ruby, 84 caractères

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

Même approche que mon autre réponse en C, mais je voulais essayer ruby ​​pour Code-Golfing. L'avantage de la version C est que je n'ai pas besoin de créer une fonction wrapper, je peux simplement utiliser les valeurs par défaut pour les paramètres.

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

Je sais que c'est loin d'être la solution la plus courte, mais je voulais démontrer une approche différente, qui répète les séquences de pertes plutôt que les paris individuels. int(bin(a)[3:],2)donne l'entier avec le bit le plus significatif de la représentation binaire de asupprimé, qui est la somme d'argent que la personne aura après avoir perdu des pouvoirs croissants de 2 jusqu'à ce qu'elle ne puisse plus parier, car a est actuellement 1 plus élevé que le sien. montant réel d'argent. Cette version suppose que le capital initial est positif.

C - 64 59 (fonction intérieure)

Encore une autre réponse C. Il profite du fait que la valeur de la variable reste sur la pile. Donc, mon échec avec certains compilateurs, mais cela a fonctionné correctement partout où j'ai testé. De plus, j'ai pris le %2tia pour sauver un personnage. Pardon!

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

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

Exemple -

H:\uprof>bet.bat 15 LLLWLLLL
1

Japt , 38 octets

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

Essayez-le

A probablement besoin de jouer au golf :) Mais il semble obtenir des résultats corrects.

REMARQUE Il s'agit d'un programme complet qui est trivial pour se transformer en fonction en ajoutantUV{ . Le nombre d'octets à l'intérieur de la fonction sera le même.

Transpiled JS expliqué:

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

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

Essayez-le en ligne!

Ce défi nécessite des tâches très délicates, ce qui signifie que je ne pouvais pas enchaîner une grosse mise à jour. Il utilise le fait que «W» est 87 en ASCII et «L» est 76, donc le modding par 2 vous donne accès à des valeurs vraies / fausses faciles. |% t*yest le raccourci standard toCharArray et la mise à jour du pari en utilisant la division s'est avérée être le moyen le moins cher que je pouvais trouver (le divise par moitié en cas de perte (en le doublant), ou le divise par lui-même en cas de victoire (en le définissant sur 1) ).

Plus de nombreux octets parce que j'ai manqué la contrainte. Va travailler sur le golf sur le patch

05AB1E , 19 octets

vDX@iy'WQiX+1UëXxU-

Port de @Howard réponse GolfScript s » , alors assurez - vous de lui Upvote aussi bien!

Notez que 05AB1E n'a aucune fonction, c'est donc un programme complet à la place.
Prend l'entrée chaîne en premier et l'entrée entière en second (nouvelle ligne délimitée dans STDIN).

Essayez-le en ligne ou vérifiez d'autres cas de test .

Explication:

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)