Vor einigen Monaten hatte ich diese Frage als Vorrätsel für ein Interview. Wenn ich kürzlich über Blog-Material nachdachte, tauchte es in meinem Kopf als gutes Beispiel für die funktionale Lösung eines Problems auf. Ich werde meine Lösung hier veröffentlichen, sobald ich mit dem Schreiben meines Blogposts fertig bin.

HINWEIS: Diese Frage wurde vor einem Jahr bei StackOverflow gestellt und nach einigen (falschen) Antworten abgelehnt. Ich nehme an, es wurde als offensichtliche Interview- oder Hausaufgabenfrage abgelehnt. Unsere Antworten sollten so tief in den Code eingearbeitet sein, dass jemand nicht daran denken kann, sie zu verwenden!

In einem Rennen setzen Sie mit der folgenden Strategie. Immer wenn Sie eine Wette verlieren, verdoppeln Sie den Wert der Wette für die nächste Runde. Wann immer Sie gewinnen, beträgt der Einsatz für die nächste Runde einen Dollar. Sie beginnen die Runde mit einem Einsatz von einem Dollar.

Wenn Sie zum Beispiel mit 20 Dollar beginnen und die Wette in der ersten Runde gewinnen, die Wette in den nächsten zwei Runden verlieren und dann die Wette in der vierten Runde gewinnen, erhalten Sie 20 + 1-1-2 +4 = 22 Dollar.

Es wird erwartet, dass Sie die Funktion abschließen g, für die zwei Argumente erforderlich sind:

1. Das erste Argument ist eine Ganzzahl, adie das anfängliche Geld ist, das wir haben, wenn wir mit dem Wetten beginnen.
2. Das zweite Argument ist eine Zeichenfolge r. Der i-te Charakter des Ergebnisses ist entweder "W" (Sieg) oder "L" (Niederlage), was das Ergebnis der i-ten Runde bezeichnet.

Ihre Funktion sollte den Geldbetrag zurückgeben, den Sie haben, nachdem alle Runden gespielt wurden.

Wenn Sie irgendwann nicht mehr genug Geld auf Ihrem Konto haben, um den Wert der Wette zu decken, müssen Sie anhalten und den Betrag zurückgeben, den Sie zu diesem Zeitpunkt haben.

Probelauf

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

Die Funktion kehrt 1in diesem Fall zurück

Der Gewinner wird durch die Mindestanzahl von Zeichen IN der implizierten Funktionsdefinition bestimmt. Arbeiten Sie auf Wunsch nach Sprache zusammen. Ich weiß, meine kann verbessert werden!

GolfScript, 33 Zeichen

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

Beispiele ( online ):

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

Kommentierter Code:

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 Bytes

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

Nennen Sie es , wie so: g(15,'LLLWLLLL').

Dies durchläuft einfach die Zeichenfolge und ändert den Wert des Geldes, das wir basierend auf dem Charakter haben.

Hier ist ein Beispielprogramm, das Tests für diese Funktion ausführt:

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)

Beispielausgabe:

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

Mit einer kleinen Änderung am Tester können wir den durchschnittlichen Gewinn vieler Läufe erzielen:

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)

Beispielausgabe (hat eine Weile gedauert, da wir die Funktion 5000000times aufrufen ):

-0.0156148

Edit: Danke an Howard und Danny für das weitere Golfen.

BEARBEITEN: Jetzt prüft das Programm, ob genügend Geld vorhanden ist, um die Wette abzuschließen. Das spart tatsächlich Bytes.

R, 95 Zeichen

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}

Eingerückt:

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
    }

Verwendung:

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

J - 63 55 char

Jetzt mit dem zusätzlichen Bonus, nicht falsch zu sein! Es ist sogar genauso lange wie zuvor.

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

Nimmt den Startbetrag als linkes Argument und die Gewinn- / Verlustserie auf der rechten Seite.

Erläuterung: Das Programm teilt sich gleichmäßig in eine Art Komposition aus zwei Funktionen auf, die beide nachstehend beschrieben werden. Der erste verwandelt die Gewinn- / Verlust-Serie in die Werte der Einsätze mit dem entsprechenden Vorzeichen, und der zweite berechnet die Antwort unter Berücksichtigung des ursprünglichen Geldes und dieser umgewandelten Gewinn- / Verlust-Serie.

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

Beachten Sie, dass wir den Wetten das Geld voranstellen, bevor wir die Teilsummen nehmen, aber den unendlichen Einsatz an das Ende der Liste der Einsatzwerte anhängen. Dies ist es, was den Wert des Kontos über die nächste Wette verschiebt, und die Verwendung von Unendlich ermöglicht es uns, immer das letzte Element als Allheilmittel zu haben.

Verwendung:

   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 Zeichen (im Funktionskörper)

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

Definiert eine rekursive Funktion gmit zwei Argumenten:

• a- den aktuellen Geldbetrag, den Sie haben; und
• r - die Folge von Gewinnen / Verlusten.

Und zwei optionale Argumente:

• t- der Index der aktuellen Wettrunde (anfangs 0)
• b- Der Geldbetrag für die aktuelle Wette (zunächst erneut 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 Zeichen (im Funktionskörper)

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

Erläuterung:

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

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 Bytes

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

Ich habe die Funktion g definiert, die a (den Geldbetrag, den Sie zu Beginn haben) und r (den die Ergebnisse der Wetten sind) nimmt. Sie initialisiert den Betrag der ersten Wette bei 1. Dann für jedes Ergebnis der Wetten, falls dies der Fall ist Bei einem Gewinn ("W" in r) erhalten Sie das Geld und die Wette wird auf 1 zurückgesetzt. Andernfalls verlieren Sie den Betrag der Wette und der Betrag für die nächste Wette verdoppelt sich. Schließlich gibt es das Geld zurück, das Sie haben. Du kannst es so benutzen:

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

Ich denke, das kann man noch weiter spielen.

C, 107 Zeichen

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

Ich benutze hier eine rekursive Funktion, da die Implementierung meistens kürzer ist. Ich bin mir jedoch nicht ganz sicher, ob dies der Fall ist, da ich eine zusätzliche Wrapper-Funktion erstellen musste, damit meine Funktion tatsächlich nur zwei Argumente akzeptiert. Das dritte Argument in Funktion fwird für die aktuelle Wette benötigt (der Akkumulator).

Ohne die Wrapper-Funktion wäre diese Lösung nur 73 Zeichen lang, aber Sie müssten einen zusätzlichen Parameter mit dem Wert 1 (die Anfangswette) übergeben, um das richtige Ergebnis zu erhalten.

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}

Probeläufe:

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

JSFiddle mit Protokollierung

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 Bytes innerhalb der Funktion

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}

Variation: ( gleiche Länge )

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}

Testfälle: ( entnommen aus Plannapus-Lösung )

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)

oder mit beiden Argumenten (65 Zeichen):

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

Beachte, dass 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 Bytes

Jetzt von der derzeit besten Python-Lösung geschlagen, aber ich kann es nicht teilen:

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

Wie bei einigen anderen Python-Lösungen verwende ich die Funktionsargumente zum Deklarieren baußerhalb der Funktionsdefinition, aber da die Funktion rekursiv ist, dient dies tatsächlich einem anderen Zweck als dem Golfen.

Ich musste auch die Reihenfolge der Funktionsargumente ändern, damit das Tupel, das in Funktionsargumente entpackt wurde , funktioniert.

Falls Sie sich fragen, r>"">a>=bist die Abkürzung für r and a>=b.

Ruby, 76 64 (im Funktionskörper) Bytes

BEARBEITEN: verbesserte die Antwort durch Entfernen von 3 Bytes:

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

mit func (82 bytes):

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

mit Lambda (76 Bytes):

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}

der Lauf:

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

C #, 74 Zeichen innerhalb der Methode

Mein allererster Versuch auf dieser Seite ...

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

Oder besser lesbar:

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;

Ziemlich naiv, nicht allzu viele Tricks ... hauptsächlich, indem man davon profitiert, dass Zeichen eine Ordnungszahl und Zeichenfolgen eine Aufzählung sind. Speichern einiger Charaktere durch Schleifen, wenn der Spieler kein Geld mehr hat.

Golfscript, 51 41 36 35 Bytes

Innere Funktion

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

Dies setzt voraus, dass wir mit einem positiven Geldbetrag beginnen und dass die Gewinn-Verlust-Zeichenfolge nicht leer ist, sodass mindestens eine Wette ausgeführt werden kann.

Beispiel

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

gibt

[22 1 7 0]

Probieren Sie es online aus.

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;

Die .NET-Geige

Ein Blogbeitrag erklärt

Java, 95 Bytes (interne Funktion)

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;

Probieren Sie es online!

Ruby, 84 Zeichen

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

Gleicher Ansatz wie meine andere Antwort in C, aber ich wollte Ruby für Code-Golfing ausprobieren. Der Vorteil der C-Version ist, dass ich keine Wrapper-Funktion erstellen muss, sondern einfach die Standardwerte für Parameter verwenden kann.

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

Ich weiß, dass dies bei weitem nicht die kürzeste Lösung ist, aber ich wollte einen anderen Ansatz demonstrieren, bei dem Verluste und nicht einzelne Wetten durchlaufen werden. int(bin(a)[3:],2)gibt die Ganzzahl mit dem höchstwertigen Bit aus der binären Darstellung von agelöscht an. Dies ist der Geldbetrag, den die Person nach dem Verlust zunehmender Potenzen von 2 hat, bis sie nicht mehr wetten kann, da a derzeit 1 höher ist als ihr tatsächlicher Geldbetrag. In dieser Version wird davon ausgegangen, dass das Anfangskapital positiv ist.

C - 64 59 (Innenfunktion)

Noch eine C-Antwort. Es nutzt die Tatsache aus, dass der Wert der Variablen auf dem Stapel bleibt. Das scheiterte bei einigen Compilern, aber es funktionierte überall dort, wo ich es getestet habe. Außerdem habe ich die %2von tia genommen, um einen Charakter zu retten. Es tut uns leid!

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

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

Beispiel -

H:\uprof>bet.bat 15 LLLWLLLL
1

Japt , 38 Bytes

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

Versuch es

Benötigt wahrscheinlich etwas Golf :) Aber es scheint, korrekte Ergebnisse zu erzielen.

HINWEIS Dies ist ein vollständiges Programm, das durch Voranstellen in eine Funktion umgewandelt werden kann UV{. Die Anzahl der Bytes innerhalb der Funktion ist gleich.

Transpiled JS erklärt:

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

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

Probieren Sie es online!

Diese Herausforderung erfordert einige sehr umständliche Aufgaben, was bedeutet, dass ich ein großes Update nicht verketten konnte. Es wird die Tatsache verwendet, dass 'W' in ASCII 87 und 'L' 76 ist, sodass Sie durch Modifizieren um 2 auf einfache True / False-Werte zugreifen können.|% t*yDies ist die Standardverknüpfung zu CharArray, und die Aktualisierung des Einsatzes mithilfe der Division hat sich als die billigste Methode herausgestellt, die ich finden konnte (teilt ihn entweder durch die Hälfte eines Verlusts (verdoppelt ihn) oder teilt ihn bei einem Gewinn durch sich selbst (setzt ihn auf 1). ).

Plus viele Bytes, weil ich Einschränkung verpasst habe. Wird daran arbeiten, den Platz hinunter zu golfen

05AB1E , 19 Bytes

vDX@iy'WQiX+1UëXxU-

Port von @Howards GolfScript-Antwort , also stelle sicher, dass du ihn auch positiv bewertest!

Beachten Sie, dass 05AB1E keine Funktionen hat, es sich also stattdessen um ein vollständiges Programm handelt.
Nimmt zuerst die Zeichenfolge und dann die Ganzzahleingabe (Zeilenumbruch in STDIN).

Probieren Sie es online aus oder überprüfen Sie einige weitere Testfälle .

Erläuterung:

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)