Hace varios meses tuve esta pregunta como un rompecabezas de preselección para una entrevista. Recientemente, cuando pensaba en el material del blog, apareció en mi cabeza como un buen ejemplo para resolver un problema funcionalmente. Publicaré mi solución a esto tan pronto como termine de escribir mi publicación de blog.

NOTA: Esta pregunta se hizo en StackOverflow hace un año y fue rechazada después de algunas respuestas (incorrectas). Supongo que fue rechazado por ser una entrevista obvia o una pregunta de tarea. ¡Nuestras respuestas aquí deben tener un código lo suficientemente profundo como para que alguien no piense en usarlas!

En una carrera, apuestas usando la siguiente estrategia. Cada vez que pierdes una apuesta, duplicas el valor de la apuesta para la próxima ronda. Siempre que gane, la apuesta para la próxima ronda será de un dólar. Comienzas la ronda apostando un dólar.

Por ejemplo, si comienza con 20 dólares y gana la apuesta en la primera ronda, pierde la apuesta en las siguientes dos rondas y luego gana la apuesta en la cuarta ronda, terminará con 20 + 1-1-2 +4 = 22 dólares.

Se espera que complete la función g, que toma dos argumentos:

1. El primer argumento es un número entero, aque es el dinero inicial que tenemos cuando comenzamos a apostar.
2. El segundo argumento es una cadena r. El i-ésimo carácter del resultado será 'W' (ganar) o 'L' (perder), denotando el resultado de la i-ésima ronda.

Su función debe devolver la cantidad de dinero que tendrá después de jugar todas las rondas.

Si en algún momento no tiene suficiente dinero en su cuenta para cubrir el valor de la apuesta, debe detenerse y devolver la suma que tiene en ese momento.

Ejecución de la muestra

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 función vuelve 1en este caso

El ganador se determina por el menor número de caracteres DENTRO de la definición de función implícita. Coopere por idioma si lo desea. ¡Sé que el mío se puede mejorar!

GolfScript, 33 caracteres

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

Ejemplos (en línea ):

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

Código anotado:

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

Llamarlo así: g(15,'LLLWLLLL').

Esto simplemente recorre la cadena, cambiando el valor del dinero que tenemos en función del personaje.

Aquí hay un programa de muestra que ejecuta pruebas en esta función:

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)

Salida de muestra:

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 un pequeño cambio en el probador, podemos obtener el beneficio promedio de muchas ejecuciones:

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)

Salida de muestra (tomó bastante tiempo, ya que estamos llamando a los 5000000tiempos de función )

-0.0156148

Editar: Gracias a Howard y Danny por seguir jugando al golf.

EDITAR: ahora el programa verifica si hay suficiente dinero para hacer la apuesta. Esto realmente ahorra bytes.

R, 95 caracteres

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}

Sangrado:

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

¡Ahora con la ventaja añadida de no ser incorrecto! Incluso es exactamente el mismo tiempo que antes.

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

Toma la cantidad inicial de dinero como argumento izquierdo y la racha de victorias / derrotas a la derecha.

Explicación: El programa se divide de manera uniforme en una composición de dos funciones, ambas detalladas a continuación. El primero convierte la racha de victorias / derrotas en los valores de las apuestas, con el signo correspondiente, y luego el segundo realmente determina la respuesta dado el dinero inicial y esta racha de victorias / derrotas transformada.

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

Tenga en cuenta que anteponemos el dinero a las apuestas antes de tomar las sumas parciales, pero agregamos la apuesta infinita al final de la lista de valores de apuesta. Esto es lo que cambia el valor del sobrepaso de la cuenta de la próxima apuesta, y el uso del infinito nos permite tener siempre el último elemento como un todo.

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 (borrador de ECMAScript 6) - 62 51 50 caracteres (en el cuerpo de la función)

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

Define una función recursiva gcon dos argumentos:

• a- la cantidad actual de dinero que tiene; y
• r - la cadena de victorias / derrotas.

Y dos argumentos opcionales:

• t- el índice de la ronda actual de apuestas (inicialmente 0)
• b- la cantidad de dinero para la apuesta actual (de nuevo inicialmente 1).

Sin 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 caracteres (en el cuerpo de la función)

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

Explicación:

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

Pruebas

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

Definí la función g, que toma a (la cantidad de dinero que tiene al inicio) yr (que es el resultado de las apuestas). Inicializa la cantidad de la primera apuesta en 1. Luego, para cada resultado de las apuestas, si es una ganancia ("W" en r) gana el dinero y la apuesta vuelve a 1. De lo contrario, pierde el monto de la apuesta, y el monto de la próxima apuesta se duplica. Finalmente te devuelve el dinero que tienes. Puedes usarlo así:

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

Creo que esto también se puede jugar al golf.

C, 107 caracteres

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

Estoy usando una función recursiva aquí, porque la mayoría de las veces la implementación es más corta. Pero no estoy muy seguro de si es el caso aquí, porque necesitaba hacer una función de contenedor adicional, de modo que mi función solo toma 2 argumentos. El tercer argumento en función fes necesario para la apuesta actual (el acumulador).

Sin la función de envoltura, esta solución solo tendría 73 caracteres, pero necesitaría pasar un parámetro adicional con el valor 1 (la apuesta inicial) para obtener el resultado adecuado.

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

Ejecuciones de muestra:

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

JSFiddle con registro

Sin 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 bytes dentro de la función

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}

Variación: ( misma longitud )

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}

Casos de prueba: ( tomado de la solución 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)

o con ambos argumentos nombrados (65 caracteres):

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

Tenga en cuenta 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 bytes

Ahora superado por la mejor solución actual de Python, pero no puedo compartirlo:

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

Como algunas otras soluciones de Python, utilizo los argumentos de la función para declarar bfuera de la definición de la función, pero como la función es recursiva, esto en realidad tiene un propósito diferente al golf aquí.

También necesitaba cambiar el orden de los argumentos de la función para que la tupla desempaquetada en argumentos de la función funcione.

Por si te lo preguntas, r>"">a>=bes la abreviatura de r and a>=b.

Ruby, 76 64 (en el cuerpo de la función) bytes

EDITAR: mejoró la respuesta al eliminar 3 bytes:

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

usando 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

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

la carrera :

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

C #, 74 caracteres dentro del método

Mi primer intento en este sitio ...

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, más legible:

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;

Bastante ingenuo, no tantos trucos ... principalmente aprovechando que char es ordinal y string es enumerable. Guardar algunos personajes mediante bucles extraños cuando el jugador se queda sin dinero.

Golfscript, 51 41 36 35 bytes

Función interior

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

Esto supone que comenzamos con una cantidad positiva de dinero y que la cadena de ganancias y pérdidas no estará vacía, por lo que se puede realizar al menos una apuesta.

Ejemplo

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

da

[22 1 7 0]

Pruébalo en línea.

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;

El violín .NET

Una publicación de blog que explica

Java, 95 bytes (función 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;

Pruébalo en línea!

Ruby, 84 caracteres

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

El mismo enfoque que mi otra respuesta en C, pero quería probar Ruby para Code-Golfing. La ventaja de la versión C es que no necesito crear una función de contenedor, simplemente puedo usar los valores predeterminados para los parámetros.

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

Sé que esto no está cerca de la solución más corta, pero quería demostrar un enfoque diferente, que repite las rachas de pérdidas en lugar de las apuestas individuales. int(bin(a)[3:],2)le da al número entero el bit más significativo de la representación binaria de aeliminado, que es la cantidad de dinero que tendrá la persona después de perder poderes crecientes de 2 hasta que ya no pueda apostar, porque a es actualmente 1 mayor que su cantidad real de dinero Esta versión supone que el capital inicial es positivo.

C - 64 59 (función interior)

Otra respuesta más de C. Aprovecha el hecho de que el valor de la variable permanece en la pila. Así que esto falla con algunos compiladores, pero funcionó correctamente donde sea que lo probé. Además, tomé el %2de tia para salvar a un personaje. ¡Lo siento!

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

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

Expample -

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

Intentalo

Probablemente necesita algo de golf :) Pero parece obtener resultados correctos.

NOTA Este es un programa completo que es trivial para convertirse en una función al anteponer UV{. El recuento de bytes dentro de la función será el mismo.

Transpiled JS explicado:

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

Pruébalo en línea!

Este desafío necesita algunas tareas muy incómodas, lo que significa que no podría encadenar una gran actualización. Utiliza el hecho de que 'W' es 87 en ASCII y 'L' es 76, por lo que modificar por 2 le da acceso a valores verdaderos / falsos fáciles. |% t*yes el atajo estándar de CharArray y la actualización de la apuesta usando la división resultó ser la forma más barata que pude encontrar (lo divide por la mitad en una pérdida (duplicándolo), o lo divide por sí mismo en una victoria (estableciéndolo en 1) )

Además de muchos bytes porque omití la restricción. Trabajará en jugar golf en el parche

05AB1E , 19 bytes

vDX@iy'WQiX+1UëXxU-

Puerto de @Howard 's GolfScript respuesta , así que asegúrese de que le Upvote así!

Tenga en cuenta que 05AB1E no tiene funciones, por lo que este es un programa completo.
Toma la entrada de cadena primero y la entrada de entero segunda (nueva línea delimitada en STDIN).

Pruébelo en línea o verifique algunos casos de prueba más .

Explicación:

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)