Кілька місяців тому у мене виникло це питання як головоломка для попереднього екранізації для інтерв'ю. Нещодавно, коли замислювався над матеріалами блогів, він з’явився мені в голові як гарний приклад, який можна використовувати для вирішення проблеми функціонально. Я опублікую своє рішення щодо цього питання, як тільки закінчу написання своєї публікації в блозі.

ПРИМІТКА. Це питання було задано в StackOverflow рік тому , і воно було відхилене після кількох (невірних) відповідей. Я припускаю, що це було сприйнято тим, що явне питання інтерв'ю чи домашнє завдання. Наші відповіді повинні бути зашифровані кодом досить глибоко, щоб хтось не думав про їх використання!

У гонці ви робите ставку, використовуючи наступну стратегію. Щоразу, коли ви програєте ставку, ви подвоюєте вартість ставки для наступного раунду. Щоразу, коли ви виграєте, ставка на наступний раунд складе один долар. Ви починаєте раунд, роблячи ставку на один долар.

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

Від вас очікується виконання функції g, яка бере два аргументи:

1. Перший аргумент - це ціле число, aяке є початковими грошима, які ми маємо, коли починаємо робити ставки.
2. Другий аргумент - рядок r. Перший характер результату буде або "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

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

EDIT: тепер програма перевіряє, чи достатньо грошей, щоб зробити ставку. Це фактично економить байти.

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 char

Тепер з додатковим бонусом за неправильність! Це навіть рівно, як раніше.

((+/\@,(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) - 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).

Безголівки:

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

Пітон, 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 (початкова ставка), щоб отримати належний результат.

неозорений:

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 w / ведення журналів

Безголівки:

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.

Рубі, 76 64 (у функції функції) байт

EDIT: покращили відповідь, видаливши 3 байти:

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

використовуючи функцію (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;

Досить наївно, не так вже й багато хитрощів ... головним чином, скориставшись тим, що чарівність є порядковою, а струнна - незліченною. Збереження кількох символів шляхом стороннього циклу, коли у гравця не вистачає грошей.

Гольфскрипт, 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

Повідомлення в блозі з поясненням

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

Той самий підхід, як і в моїй іншій відповіді на С, але я хотів спробувати рубін для 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, поки він / вона більше не зможе робити ставку, тому що на даний момент на 1 вище, ніж його фактична сума грошей. Ця версія передбачає, що початковий капітал є позитивним.

С - 64 59 (внутрішня функція)

Ще одна відповідь С. Користується тим, що значення змінної залишається на стеку. Отже, це не вдається з деякими компіляторами, але воно справно працювало там, де я тестував. Крім того, я взяв %2з Тіа, щоб зберегти персонажа. Вибачте!

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{ . Кількість байтів всередині функції буде однаковою.

Транспільований 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 дає доступ до простих істинних / хибних значень. |% t*yє стандартним ярликом toCharArray і оновлення ставок за допомогою поділу виявилося найдешевшим способом, який я міг знайти (ділить його або на половину на збиток (подвоєння), або ділить його самостійно на виграш (встановивши його на 1) ).

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

05AB1E , 19 байт

vDX@iy'WQiX+1UëXxU-

Порт відповіді GolfScript @Howard 's , тому обов'язково підтримайте його також!

Зауважте, що 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)