몇 달 전에 저는이 질문을 면접을위한 사전 심사 퍼즐로 사용했습니다. 최근 블로그 자료에 대해 생각할 때 기능적으로 문제를 해결하는 데 사용하기에 좋은 예가되었습니다. 내 블로그 게시물 작성을 마치 자마자 이에 대한 솔루션을 게시하겠습니다.

참고 : 이 질문은 1 년 전 StackOverflow에서 질문되었으며 몇 가지 (부정확 한) 답변 후 하향 투표되었습니다. 나는 그것이 명백한 면접이나 숙제 질문으로 다운 투표되었다고 가정합니다. 여기에 우리의 대답은 누군가가 그것들을 사용하는 것에 대해 생각할 수 없을 정도로 깊게 코드 골프되어야합니다!

레이스에서는 다음 전략을 사용합니다. 베팅을 잃을 때마다 다음 라운드에 대한 베팅 가치가 두 배가됩니다. 당신이 이길 때마다 다음 라운드에 대한 내기는 1 달러가 될 것입니다. 1 달러를 베팅하여 라운드를 시작합니다.

예를 들어, 20 달러로 시작하여 첫 번째 라운드에서 베팅에서 이기고 다음 두 라운드에서 베팅을 잃은 후 네 번째 라운드에서 내기면 20 + 1-1-2로 끝납니다. +4 = 22 달러

g두 개의 인수를 사용 하는 함수를 완료해야합니다 .

1. 첫 번째 인수는 정수 a이며, 우리가 베팅을 시작할 때 우리가 처음 지불하는 금액입니다.
2. 두 번째 인수는 문자열 r입니다. 결과의 i 번째 특성은 i 번째 라운드의 결과를 나타내는 'W'(승리) 또는 'L'(손실)입니다.

당신의 함수는 모든 라운드가 플레이 된 후에 가질 금액을 반환해야합니다.

어떤 시점에서 내기의 가치를 충당하기에 충분한 돈이 계정에 없으면 그 시점에 가지고있는 금액을 중지하고 반환해야합니다.

샘플 런

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

파이썬 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

편집 : 추가 골프를위한 Howard와 Danny에게 감사드립니다.

편집 : 이제 프로그램은 내기를하기에 충분한 돈이 있는지 확인합니다. 이것은 실제로 바이트를 절약합니다.

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 초안) -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

나는 (시작시 돈의 금액)과 r (베팅 결과)을 취하는 함수 g를 정의했습니다. 첫 베팅 금액을 1에서 초기화합니다. 그러면 베팅의 각 결과에 대해 승리 (r에서 "W")를하면 돈을 받고 베팅이 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);
}

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

자바 스크립트, 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

언 골프 드 :

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
}

함수 내 자바 스크립트 ( 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}

테스트 사례 : ( plannapus의 솔루션에서 가져옴 )

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

파이썬 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

다른 파이썬 솔루션으로 b함수 정의 외부에서 선언하기 위해 함수 인수를 사용 하지만 함수가 재귀 적이므로 실제로 골프 이외의 다른 용도로 사용됩니다.

또한 튜플의 함수 인수 로 압축을 풀기 위해 함수 인수의 순서를 변경 해야했습니다.

궁금하신 분 r>"">a>=b은의 약자입니다 r and a>=b.

루비, 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;

많은 순진한 것이 아니라 꽤 순진합니다. 주로 문자가 서수이고 문자열이 열거 가능하다는 장점이 있습니다. 플레이어가 돈을 잃을 때 불필요한 반복으로 문자를 절약합니다.

골프 스크립트, 51 41 36 35 바이트

내부 기능

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

이것은 우리가 양의 돈으로 시작하고 win-loss 문자열이 비어 있지 않다고 가정하여 적어도 하나의 베팅을 수행 할 수 있습니다.

예

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

C의 다른 대답과 같은 접근법이지만 코드 골프를 위해 루비를 시험 해보고 싶었습니다. C 버전의 장점은 래퍼 함수를 ​​만들 필요가 없으며 매개 변수의 기본값을 간단히 사용할 수 있다는 것입니다.

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

파이썬, 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. 이것은 현재 자신보다 1이 높기 때문에 더 이상 내기를 할 수 없을 때까지 2의 증가하는 힘을 잃은 후에 가질 돈입니다. 실제 금액 이 버전은 초기 자본이 양수라고 가정합니다.

C- 64 59 (내부 기능)

또 다른 C 답변. 변수의 값이 스택에 남아 있다는 사실을 이용합니다. 그래서 이것은 일부 컴파일러에서 실패하지만 테스트 한 곳에서는 제대로 작동했습니다. 또한 나는 %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

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

온라인으로 사용해보십시오!

이 과제에는 하나의 큰 업데이트를 함께 연결할 수 없다는 매우 어색한 과제가 필요합니다. ASCII에서 'W'가 87이고 'L'이 76이라는 사실을 사용하므로 2로 모딩하면 쉽게 참 / 거짓 값에 액세스 할 수 있습니다.|% t*y는 표준 toCharArray 바로 가기이며 나눗셈을 사용하여 베팅을 업데이트하면 내가 찾을 수있는 가장 저렴한 방법으로 판명되었습니다 (손실로 절반으로 나누거나 (두 배로) 또는 승리로 나눕니다 (1로 설정) ).

제약 조건을 놓 쳤기 때문에 많은 바이트가 추가되었습니다. 패치 아래로 골프를 칠 것입니다

05AB1E , 19 바이트

vDX@iy'WQiX+1UëXxU-

@Howard 의 GolfScript 답변 포트 때문에 그 해야합니다!

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)