Несколько месяцев назад у меня был этот вопрос в качестве загадки перед собеседованием. Недавно, когда я размышлял о материалах блога, он показался мне хорошим примером для функционального решения проблемы. Я опубликую свое решение, как только я закончу писать в своем блоге.

ПРИМЕЧАНИЕ. Этот вопрос был задан в StackOverflow год назад и был отклонен после нескольких (неправильных) ответов. Я предполагаю, что это было понижено для того, чтобы быть очевидным интервью или домашним заданием. Наши ответы должны быть написаны достаточно глубоко, чтобы кто-то не задумывался об их использовании!

В гонке вы делаете ставки, используя следующую стратегию. Каждый раз, когда вы проигрываете ставку, вы удваиваете значение ставки для следующего раунда. Всякий раз, когда вы выигрываете, ставка на следующий раунд будет один доллар. Вы начинаете раунд, ставя один доллар.

Например, если вы начнете с 20 долларов и выиграете ставку в первом раунде, потеряете ставку в следующих двух раундах, а затем выиграете ставку в четвертом раунде, вы получите 20 + 1-1-2 +4 = 22 доллара.

Ожидается, что вы завершите функцию g, которая принимает два аргумента:

1. Первый аргумент - это целое число, aкоторое представляет собой начальные деньги, которые мы получаем, когда начинаем делать ставки.
2. Второй аргумент - это строка r. I-ый символ результата будет либо «W» (победа), либо «L» (проигрыш), обозначая результат i-го раунда.

Ваша функция должна возвращать сумму денег, которую вы будете иметь после всех раундов.

Если в какой-то момент на вашем счету недостаточно средств для покрытия стоимости ставки, вы должны остановиться и вернуть сумму, которая у вас есть на данный момент.

Пробный прогон

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

Функция возвращает 1в этом случае

Победитель определяется по наименьшему количеству символов ВНУТРИ определения подразумеваемой функции. Сотрудничайте по языку, если хотите. Я знаю, что мой может быть улучшен!

GolfScript, 33 символа

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

Примеры ( онлайн ):

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

Аннотированный код:

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 байта

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

Назовем это так: g(15,'LLLWLLLL').

Это просто перебирает строку, изменяя ценность денег, которые мы основали на персонаже.

Вот пример программы, которая запускает тесты для этой функции:

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)

Образец вывода:

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

С небольшими изменениями в тестере мы можем получить среднюю прибыль по многим прогонам:

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)

Пример вывода (это заняло довольно много времени, так как мы вызываем функцию 5000000раз):

-0.0156148

Редактировать: Спасибо Говарду и Дэнни за дальнейшую игру в гольф.

РЕДАКТИРОВАТЬ: теперь программа проверяет, достаточно ли денег, чтобы сделать ставку. Это на самом деле экономит байты.

R, 95 символов

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}

Отступ:

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
    }

Использование:

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

J - 63 55 символов

Теперь с добавленным бонусом неточность! Это даже точно так же долго, как и раньше.

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

Принимает начальную сумму денег в качестве левого аргумента и полосу выигрышей / проигрышей справа.

Объяснение: Программа распадается равномерно на что-то вроде композиции из двух функций, обе из которых подробно описаны ниже. Первый превращает полосу выигрыша / проигрыша в значения ставок с соответствующим знаком, а затем второй фактически вычисляет ответ с учетом начальных денег и этой преобразованной полосы выигрыша / проигрыша.

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

Обратите внимание, что мы добавляем деньги к ставкам, прежде чем принимать частичные суммы, но добавляем бесконечную ставку в конец списка значений ставок. Это то, что смещает значение превышения счета следующей ставки, а использование бесконечности позволяет нам всегда использовать последний элемент в качестве универсального.

Использование:

   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 символов (в теле функции)

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

Определяет рекурсивную функцию gс двумя аргументами:

• a- текущая сумма денег у вас есть; и
• r - череда побед / поражений.

И два необязательных аргумента:

• t- индекс текущего раунда торговли (изначально 0)
• b- сумма денег за текущую ставку (опять же изначально 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 символа (в теле функции)

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

Объяснение:

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

тесты

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 байта

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

Я определил функцию g, которая принимает (сумму денег, которую вы имеете на старте) и r (которая является результатом ставок). Она инициализирует сумму первой ставки на 1. Затем для каждого результата ставок, если он выигрыш («W» в r) вы получаете деньги, а ставка возвращается к 1. В противном случае вы теряете сумму ставки, а сумма следующей ставки удваивается. Наконец он возвращает деньги, которые у вас есть. Вы можете использовать это так:

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

Я думаю, что это может быть в дальнейшем.

C, 107 знаков

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

Я использую рекурсивную функцию здесь, потому что в большинстве случаев реализация короче. Но я не совсем уверен, так ли это, потому что мне нужно было создать дополнительную функцию-обертку, чтобы моя функция фактически принимала только 2 аргумента. Третий аргумент в функции fнеобходим для текущей ставки (аккумулятора).

Без функции-обертки это решение было бы длиной всего 73 символа, но вам нужно было бы передать дополнительный параметр со значением 1 (начальная ставка), чтобы получить правильный результат.

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

С, 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}

Образцы прогонов:

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

JSFiddle с ведением журнала

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 байт внутри функции

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}

Вариация: ( одинаковая длина )

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}

Контрольные примеры: ( взяты из решения планнапа )

g(15,'LLWLLLL'); // 1
g(20,'WLLW'); // 22
g(13,'LLWLLLLWWLWWWLWLWW'); // 7

Хаскелл, 62

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

или с именами обоих аргументов (65 символов):

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

Обратите внимание, что 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 байт

Сейчас побежден лучшим на сегодняшний день решением Python, но я не могу не поделиться им:

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

Как и некоторые другие решения Python, я использую аргументы функции для объявления bвне определения функции, но так как функция рекурсивна, это на самом деле служит не только игре в гольф.

Мне также нужно было изменить порядок аргументов функции, чтобы кортеж распаковывался в аргументы функции .

В случае, если вам интересно, r>"">a>=bэто сокращение от r and a>=b.

Ruby, 76 64 (в теле функции) байта

РЕДАКТИРОВАТЬ: улучшить ответ, удалив 3 байта:

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

используя func (82 байта):

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

используя лямбду (76 байт):

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}

бег :

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

C #, 74 символа внутри метода

Моя самая первая попытка на этом сайте ...

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

Или, более читабельно:

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;

Довольно наивно, не так уж много трюков ... в основном, используя преимущества порядковых чисел и числовых. Сохранение нескольких персонажей путем постороннего зацикливания, когда у игрока заканчиваются деньги.

Golfscript, 51 41 36 35 байт

Внутренняя функция

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

Это предполагает, что мы начинаем с положительной суммы денег и что строка выигрыша проигрыша будет непустой, чтобы можно было сделать хотя бы одну ставку.

пример

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

дает

[22 1 7 0]

Попробуйте онлайн.

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;

.NET Fiddle

Сообщение в блоге, объясняющее

Java, 95 байт (внутренняя функция)

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;

Попробуйте онлайн!

Рубин, 84 персонажа

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

Тот же подход, что и в моем другом ответе на C, но я хотел попробовать ruby ​​для Code-Golfing. Преимущество версии C в том, что мне не нужно создавать функцию-оболочку, я могу просто использовать значения по умолчанию для параметров.

К, 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

Питон, 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

Я знаю, что это далеко не самое короткое решение, но я хотел продемонстрировать другой подход, который повторяет серии потерь, а не отдельные ставки. int(bin(a)[3:],2)дает целое число с наиболее значимым битом в двоичном представлении aудаленного, которое представляет собой сумму денег, которую человек будет иметь после потери увеличивающихся способностей 2, пока он или она не сможет больше не делать ставки, потому что a в настоящее время на 1 выше, чем его или ее фактическая сумма денег. Эта версия предполагает, что начальный капитал положительный.

С - 64 59 (внутренняя функция)

Еще один С ответ. Он использует тот факт, что значение переменной остается в стеке. Так что это моя ошибка с некоторыми компиляторами, но она работала правильно везде, где я тестировал. Кроме того, я взял %2из TIA, чтобы спасти персонажа. Сожалею!

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

Партия - 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%

Пример -

H:\uprof>bet.bat 15 LLLWLLLL
1

Japt , 38 байт

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

Попытайся

Наверное, нужно немного поиграть в гольф :) Но похоже, чтобы получить правильные результаты.

НОТА Это полная программа, которую легко превратить в функцию путем добавления UV{. Количество байтов внутри функции будет одинаковым.

Transpiled 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 байт

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

Попробуйте онлайн!

Эта задача требует очень неловких заданий, а это означает, что я не смог собрать одно большое обновление. Он использует тот факт, что «W» равно 87 в ASCII, а «L» равно 76, так что изменение по 2 дает вам доступ к простым значениям true / false.|% t*yявляется стандартным ярлыком toCharArray, и обновление ставки с использованием деления оказалось самым дешевым способом, который я мог найти (делит его либо на половину при проигрыше (удваивая его), либо делит его сам на выигрыш (устанавливая его в 1) ).

Плюс много байтов, потому что я пропустил ограничение. Будет работать над игрой в гольф

05AB1E , 19 байтов

vDX@iy'WQiX+1UëXxU-

Port of @Howard 's GolfScript answer , так что не забудьте также поддержать его!

Обратите внимание, что 05AB1E не имеет функций, поэтому это полная программа.
Сначала берется строка ввода, а затем целочисленный (строка с новой строкой в ​​STDIN).

Попробуйте онлайн или проверьте еще несколько тестов .

Объяснение:

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)