Inspiração

Essa pergunta é inspirada nas cartas Throne Room e King's Court do popular jogo de cartas Dominion .

Como parte de sua vez, desempenha-se uma sequência de ações. Essas duas ações específicas fazem com que a próxima ação seja repetida duas ou três vezes *. Outras ações "genéricas" causam efeitos específicos no jogo, mas não estaremos interessados ​​nos detalhes, simplesmente rotulá-los com letras.

O caso interessante é quando uma Sala do Trono ou Corte do Rei afeta outra Sala do Trono da Corte do Rei, fazendo com que o efeito de duplicação ou triplicação seja duplicado ou triplicado. Longas cadeias de salas do trono, cortes do rei e ações multiplicadas podem confundir até jogadores experientes do Dominion.

Seu objetivo é escrever um código que resolva corretamente essas cadeias, usando o mínimo de bytes possível. Descreverei os requisitos do programa antes de explicar como as cadeias se resolvem nas regras de domínio.

* Tecnicamente, você escolhe a ação afetada como parte da resolução da Sala do Trono ou da Corte do Rei, mas essa visão é mais limpa para esse desafio.

Requisitos do programa

Escreva um programa ou função nomeada . Ele deve incluir a cadeia de ações executadas (STDIN ou entrada de função) e gerar ou imprimir a cadeia de ações resultante a partir dos efeitos da duplicação e triplicação. Menos bytes ganha.

Entrada

Uma sequência que representa a sequência de ações executadas. Ações genéricos são representados por letras maiúsculas Aatravés Z. A ação especial de duplicação, Throne Room, é representada pelo personagem 2, e a ação triplicadora de King's Court por 3,

O número de caracteres (ações) estará entre 1 e 30, inclusive. Você pode ter a entrada final em uma nova linha, se desejar.

Exemplo de entrada: WA23G3GA

Resultado

Uma sequência de letras maiúsculas Apara Z. Essa deve ser a sequência de ações genéricas que resultam da resolução dos efeitos de duplicação e triplicação, na ordem em que ocorrem.

Você pode ter a saída final em uma nova linha, se desejar. Caso contrário, não deve haver caracteres adicionais.

Exemplo de saída: WAGGGGGGAAA.

Como duplicar e triplicar funciona em Dominion

Aqui, mostrarei como as cadeias de salas do trono 2e as cortes do rei 3funcionam de acordo com as regras do domínio.

Depois de jogar a 2, a próxima ação a ser resolvida acontece duas vezes. Então, se você primeiro jogar 2, então A, você começa Aa acontecer duas vezes.

2A -> AA

Similarmente,

A2BC -> ABBC
3DE -> DDDE
3N2BC3XY2 -> NNNBBCXXXY

Observe no último exemplo que a final 2não teve nada para dobrar, por isso não teve efeito.

O interessante acontece quando os efeitos de duplicação ou triplicação são eles mesmos duplicados ou triplicados. Por exemplo,

22AB -> AABB

Primeiro você joga 2. Então, você joga outro 2, que é duplicado do anterior 2. Como resultado, as próximas duas ações são duplicadas. Primeiro, as duas cópias da Aresolução. Então, as cópias da Bresolução.

Observe que Anão é quadruplicado: após a primeira cópia dos 2atos no primeiro A, a próxima cópia atua na próxima ação não resolvida, que é B. Sem o B, teríamos

22A -> AA

onde a segunda cópia de 2está aguardando a próxima ação dobrar, mas nenhuma ação ocorre.

Finalmente, vejamos um exemplo complexo.

223BCDE -> BBBCCCDDE

Como antes, o primeiro 2faz com que o segundo 2seja dobrado. Portanto, as próximas duas ações serão duplicadas. A primeira cópia de 2duplica a próxima ação 3, que deve ser resolvida completamente antes de resolver a próxima cópia de 2. A primeira cópia de 3triplos Be a segunda cópia triplica C. Agora, a segunda cópia ainda em espera 2dobra a próxima ação ainda não resolvida, que é D. Depois disso, nenhum efeito de duplicação ou triplicação permanece, e a ação final Esimplesmente acontece.

Casos de teste

Estes são dados como (input,output).

(FY, FY)
(A2BC, ABBC)
(3DE, DDDE)
(3N2BC3XY2, NNNBBCXXXY)
(WA23G3GA, WAGGGGGGAAA)
(32, )
(33RST, RRRSSSTTT)
(2A32B2CDEFG, AABBCCDDEEFG)
(A2A323AB2CD2D2E3ABC, AAAAAABBBCCDDDDEEAAABBBC)
(P22LL3Q2Q22T, PLLLLQQQQQTT)
(322322ABCDEFGHIJKLMN, AABBCCDDEEEFFGGHHIJKLMN)

GolfScript ( 29 26 bytes)

](1/{\1+(3&@*.23-\1$-@+}/;

Demonstração online

Dissecação

Isso abusa um pouco da digitação solta do GolfScript. A pilha de quantas vezes a repetir ações subseqüentes começa como um array e voltas mais tarde em uma string - mas 1+acrescenta um 1 e (3&aparece o primeiro valor e corretamente coloca na gama 0de 3, independentemente da mudança de tipo.

](         # Push an empty array under the input string to serve as rep stack
1/{        # Loop over the input string as a series of 1-char strings
           #   Stack is ... reps ch
           #   where the ... covers zero or more strings which will be output
  \        #   Bring the rep stack to the top
  1+(      #   Push a `1` on the bottom of it to avoid underflow and then pop
  3&       #   Coerce to correct range, because if rep stack is a string then
           #   we just got an ASCII value
  @*       #   Apply repetition to the 1-char string: it's now an n-char string
  .23-     #   Duplicate it and remove chars '2' and '3': this becomes output
  \1$-     #   Get the original copy and remove the output string's chars
           #   So the stack is now ... reps output non-output
           #   where non-output is either an empty string or a string of '2's
           #   or '3's
  @+       #   Push non-output onto the repetition stack
}/         # Loop
;          # Pop whatever's left of the repetition stack

Javascript - 162 152 bytes

Minificado:

F=I=>{L=c=>S.length;p=c=>L()?S.shift():d=>{};S=[(x=>/\d/.test(x)?(c,b)=>{for(c=p(),b=x;b--;)c();}:c=>s+=x)(m)for(m of I)];for(s='';L();)p()();return s;}

Expandido:

F = I => {
    L = c => S.length;
    p = c => L() ? S.shift() : d => {};
    S = [ (x => /\d/.test( x ) ?
        (c,b) => {
            for( c = p(), b = x; b--; )
                c();
        } : c =>
            s += x
        )(m) for( m of I ) ];

    for( s = ''; L(); )
        p()();

    return s;
}

Suponho que as linguagens de golfe baseadas em pilha serão eliminadas nesta, pois é basicamente um exercício de empilhamento de funções. : P

Saídas de amostra

F('3N2BC3XY2')
"NNNBBCXXXY"

F('WA23G3GA')
"WAGGGGGGAAA"

F('A2A323AB2CD2D2E3ABC')
"AAAAAABBBCCDDDDEEAAABBBC"

F('322322ABCDEFGHIJKLMN')
"AABBCCDDEEEFFGGHHIJKLMN"

F('FY')
"FY"

F('')
""

C, 115 111 bytes

Usa entrada / saída padrão.

Salvo 4, usando memsete fazendo a pilha ir na outra direção.

char*i,X[222],*s=X+99;main(){for(gets(i=X);*i;i++)*i<55?s=memset(s-*s,*i-49,*s+1):putchar(*i)**s?--*s,--i:++s;}

Ungolfed

#include <stdio.h>
#include <stdlib.h>
char I[99], S[99], *i = I, *s = S+66;
int n;
int main()
{
    gets(I);
    for(;*i;)
    {
        if(*i < '5') {
            n = *s;
            s[0] = s[1] = s[2] = *i - '1';
            s += n;
            i++;
        } else {
            putchar(*i);
            if(*s)
                --*s;
            else
                --s, ++i;
        }
    }
    return 0;
}

Python (84)

S='1'*99
R=''
for c in input():q=int(S[0])*c;S=q*(c<'A')+S[1:];R+=q*(c>'3')
print(R)

Sé a pilha de multiplicadores (superior se frontal). É inicializado com o suficiente 1para lidar com ações não multiplicadas.

Dependendo se a ação atual cé genérica ou não, adicionamos seu resultado multiplicado à saída Rou à pilha de multiplicadores S.

Tudo é representado como uma string, e não como uma lista de caracteres. Como as strings são imutáveis, infelizmente não podemos usar popou atribuir elementos a elas.