Ispirazione

Questa domanda è ispirata alle carte Throne Room e King's Court del famoso gioco di carte per la costruzione di mazzi Dominion .

Come parte del proprio turno, si gioca una sequenza di azioni. Queste due azioni particolari fanno ripetere l'azione successiva per due o tre volte *. Altre azioni "generiche" causano effetti di gioco specifici, ma non saremo interessati ai dettagli, semplicemente etichettandoli con lettere.

Il caso interessante è quando una Throne Room o King's Court colpisce un'altra Throne Room di King's Court, facendo raddoppiare o triplicare l'effetto di raddoppiare o triplicare. Le lunghe catene di stanze del trono, re corti e azioni moltiplicate possono confondere anche i giocatori dominatori esperti.

Il tuo obiettivo è scrivere codice che risolva correttamente queste catene, usando il minor numero di byte possibile. Descriverò i requisiti del programma prima di spiegare come le catene si risolvono nelle regole del Dominio.

* Tecnicamente, scegli l'azione interessata come parte della risoluzione di Throne Room o King's Court, ma questa visione è più chiara per questa sfida.

Requisiti del programma

Scrivi un programma o una funzione denominata . Dovrebbe includere la catena di azioni eseguite (STDIN o input di funzione) e produrre o stampare la catena di azioni risultante dagli effetti del raddoppio e del triplo. Vince il minor numero di byte.

Ingresso

Una stringa che rappresenta la sequenza di azioni eseguite. Azioni generiche sono rappresentate da lettere maiuscole Aattraverso Z. La speciale azione di raddoppio Throne Room è rappresentata dal personaggio 2e l'azione tripla King's Court di 3,

Il numero di personaggi (azioni) sarà compreso tra 1 e 30, inclusi. Se lo desideri, potresti avere la fine dell'input in una riga.

Esempio di input: WA23G3GA

Produzione

Una stringa di lettere maiuscole Aa Z. Questa dovrebbe essere la sequenza di azioni generiche che risulta dalla risoluzione degli effetti di raddoppio e triplicazione, nell'ordine in cui si verificano.

Se lo desideri, potresti avere l'output in una nuova riga. Altrimenti non dovrebbero esserci caratteri aggiuntivi.

Uscita Esempio: WAGGGGGGAAA.

Come funziona il raddoppio e il triplo in Dominion

Qui, esaminerò il modo in cui le catene di stanze del trono 2e le corti del re 3funzionano secondo le regole del dominio.

Dopo aver giocato a 2, l'azione successiva da risolvere si verifica due volte. Quindi, se giochi per la prima volta 2, poi A, ti Aaccadranno due volte.

2A -> AA

Allo stesso modo,

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

Nota nell'ultimo esempio che la finale 2non aveva nulla da raddoppiare, quindi non ha avuto alcun effetto.

La cosa interessante accade quando gli effetti di raddoppio o triplicazione vengono raddoppiati o triplicati. Per esempio,

22AB -> AABB

Per prima cosa suoni 2. Quindi ne giochi un altro 2, che è raddoppiato rispetto al precedente 2. Di conseguenza, le due azioni successive vengono raddoppiate. Innanzitutto, le due copie di Arisoluzione. Quindi, le copie di Brisoluzione.

Si noti che Anon è quadruplicato: dopo la prima copia di 2atti sul primo A, la copia successiva agisce sull'azione successiva non risolta, che è B. Senza il B, avremmo

22A -> AA

dove la seconda copia di 2è in attesa che la prossima azione raddoppi, ma non arriva alcuna azione.

Infine, diamo un'occhiata a un esempio complesso.

223BCDE -> BBBCCCDDE

Come prima, la prima 2fa 2raddoppiare la seconda . Quindi, le prossime due azioni saranno raddoppiate. La prima copia di 2raddoppia l'azione successiva 3, che deve essere risolta completamente prima di risolvere la copia successiva di 2. La prima copia di 3triple Be la seconda copia di triple C. Ora, la seconda copia ancora in attesa di 2raddoppia la prossima azione ancora irrisolta, che è D. Dopo questo, non rimangono effetti di raddoppio o triplo e l'azione finale Esemplicemente accade.

Casi test

Questi sono dati come (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 byte)

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

Demo online

Dissezione

Ciò abusa leggermente della digitazione libera di GolfScript. La pila di quante volte ripetere azioni successive comincia come un array e turni successivi in una stringa - ma 1+aggiunge un 1 e (3&apre il primo valore e correttamente mette nella gamma 0a 3prescindere dal tipo cambiamento.

](         # 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 byte

minified:

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

Allargato:

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

Immagino che le lingue da golf basate sullo stack uccideranno su questo, dal momento che è fondamentalmente un esercizio di impilamento delle funzioni. : P

Output di esempio

F('3N2BC3XY2')
"NNNBBCXXXY"

F('WA23G3GA')
"WAGGGGGGAAA"

F('A2A323AB2CD2D2E3ABC')
"AAAAAABBBCCDDDDEEAAABBBC"

F('322322ABCDEFGHIJKLMN')
"AABBCCDDEEEFFGGHHIJKLMN"

F('FY')
"FY"

F('')
""

C, 115 111 byte

Utilizza input / output standard.

Salvato 4 usando memsete facendo andare la pila nella direzione opposta.

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è la pila di moltiplicatori (in alto se davanti). È inizializzato con abbastanza 1per gestire azioni non moltiplicate.

A seconda che l'azione corrente csia generica o meno, aggiungiamo il risultato moltiplicato all'output Ro alla pila di moltiplicatori S.

Tutto è rappresentato come una stringa anziché come un elenco di caratteri. Poiché le stringhe sono immutabili, purtroppo non possiamo usarle popo assegnarle elementi.