Inspirasi

Pertanyaan ini terinspirasi oleh kartu Throne Room dan King's Court dari permainan kartu deck-building yang populer, Dominion .

Sebagai bagian dari giliran seseorang, seseorang memainkan serangkaian tindakan. Dua tindakan khusus ini menyebabkan tindakan yang dimainkan berikutnya mengulangi dua atau tiga kali *. Tindakan "umum" lainnya menyebabkan efek game tertentu, tetapi kami tidak akan tertarik dengan rinciannya, cukup memberi label dengan huruf.

Kasus yang menarik adalah ketika Ruang Singgasana atau Pengadilan Raja mempengaruhi Ruang Singgasana lain dari Pengadilan Raja, menyebabkan efek penggandaan atau tiga kali lipat itu sendiri menjadi dua kali lipat atau tiga kali lipat. Rantai panjang Ruang Singgasana, Pengadilan Raja, dan aksi berlipat ganda dapat membingungkan para pemain Dominion yang berpengalaman sekalipun.

Tujuan Anda adalah menulis kode yang menyelesaikan rantai ini dengan benar, menggunakan sesedikit mungkin byte. Saya akan menjelaskan persyaratan program sebelum menjelaskan bagaimana rantai diselesaikan dalam aturan Dominion.

* Secara teknis, Anda memilih tindakan yang terpengaruh sebagai bagian dari penyelesaian Throne Room atau King's Court, tetapi pandangan ini lebih bersih untuk tantangan ini.

Persyaratan Program

Tulis program atau nama fungsinya . Itu harus mengambil dalam rantai tindakan yang dimainkan (STDIN atau fungsi input), dan output atau mencetak rantai tindakan yang dihasilkan dari efek penggandaan dan tiga kali lipat. Bytes paling sedikit menang.

Memasukkan

String yang mewakili urutan aksi yang dimainkan. Tindakan umum diwakili oleh huruf kapital Amelalui Z. Ruang singgasana aksi ganda yang diwakili oleh karakter 2, dan aksi tiga kali lipat King's Court oleh 3,

Jumlah karakter (tindakan) akan antara 1 dan 30, inklusif. Anda mungkin memiliki input yang diakhiri di baris baru jika diinginkan.

Input contoh: WA23G3GA

Keluaran

Sederetan huruf kapital Auntuk Z. Ini harus menjadi urutan tindakan umum yang dihasilkan dari menyelesaikan efek penggandaan dan tiga kali lipat, dalam urutan daripada yang terjadi.

Anda mungkin memiliki output di baris baru jika Anda mau. Seharusnya tidak ada karakter tambahan.

Contoh output: WAGGGGGGAAA.

Cara menggandakan dan tiga kali lipat bekerja di Dominion

Di sini, saya akan membahas bagaimana rantai Kamar Tahta ( 2's) dan Pengadilan Raja ( 3' s) bekerja sesuai aturan Dominion.

Setelah Anda memainkan 2, tindakan selanjutnya yang harus diselesaikan terjadi dua kali. Jadi, jika Anda pertama kali bermain 2, maka A, Anda mendapatkan Aterjadi dua kali.

2A -> AA

Demikian pula,

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

Perhatikan dalam contoh terakhir bahwa final 2tidak memiliki dua kali lipat, sehingga tidak berpengaruh.

Hal yang menarik terjadi ketika efek dua kali lipat atau tiga kali lipat sendiri berlipat atau tiga kali lipat. Sebagai contoh,

22AB -> AABB

Pertama, kamu bermain 2. Kemudian, Anda memainkan yang lain 2, yang dua kali lipat dari sebelumnya 2. Akibatnya, dua tindakan selanjutnya menjadi dua kali lipat. Pertama, dua salinan Atekad. Kemudian, salinan Btekad.

Catatan yang Atidak empat kali lipat: setelah salinan pertama dari 2tindakan pada yang pertama A, salinan berikutnya bertindak pada tindakan yang tidak terselesaikan berikutnya, yaitu B. Tanpa itu B, kita punya

22A -> AA

di mana salinan kedua 2sedang menunggu tindakan berikutnya untuk menggandakan, tetapi tidak ada tindakan datang.

Akhirnya, mari kita lihat contoh yang kompleks.

223BCDE -> BBBCCCDDE

Seperti sebelumnya, yang pertama 2menyebabkan yang kedua 2menjadi dua kali lipat. Jadi, dua tindakan selanjutnya akan digandakan. Salinan pertama 2menggandakan tindakan berikutnya 3, yang harus diselesaikan sepenuhnya sebelum menyelesaikan salinan berikutnya 2. Salinan 3tiga kali lipat pertama B, dan salinan kedua lipat tiga C. Sekarang, salinan kedua yang masih menunggu akan 2menggandakan aksi selanjutnya yang masih belum terselesaikan, yaitu D. Setelah ini, tidak ada efek pengganda atau tiga kali lipat yang tersisa, dan tindakan terakhir Eterjadi begitu saja.

Uji kasus

Ini diberikan sebagai (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

Pembedahan

Ini sedikit menyalahgunakan pengetikan GolfScript yang longgar. Tumpukan berapa kali untuk mengulang tindakan selanjutnya dimulai sebagai array dan kemudian berubah menjadi string - tetapi 1+menambahkan 1 dan (3&muncul nilai pertama dan benar menempatkan itu dalam kisaran 0untuk 3terlepas dari perubahan jenis.

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

Diperkecil:

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

Diperluas:

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

Saya menduga bahasa golf berbasis stack akan mematikan yang satu ini, karena pada dasarnya ini adalah latihan dalam penumpukan fungsi. : P

Output Sampel

F('3N2BC3XY2')
"NNNBBCXXXY"

F('WA23G3GA')
"WAGGGGGGAAA"

F('A2A323AB2CD2D2E3ABC')
"AAAAAABBBCCDDDDEEAAABBBC"

F('322322ABCDEFGHIJKLMN')
"AABBCCDDEEEFFGGHHIJKLMN"

F('FY')
"FY"

F('')
""

C, 115 111 byte

Menggunakan input / output standar.

Disimpan 4 dengan menggunakan memsetdan membuat tumpukan pergi ke arah lain.

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

Tidak disatukan

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

Sadalah tumpukan pengganda (atas jika depan). Ini diinisialisasi dengan cukup 1untuk menangani tindakan yang tidak disalahgunakan.

Bergantung pada apakah tindakan saat cini generik atau tidak, kami menambahkan hasil yang dikalikan ke output Ratau ke tumpukan pengganda S.

Semuanya direpresentasikan sebagai string daripada daftar karakter. Karena string tidak dapat diubah, sayangnya kami tidak dapat menggunakan popatau menetapkan elemen pada mereka.