แรงบันดาลใจ

คำถามนี้เป็นแรงบันดาลใจด้วยบัตรห้องบัลลังก์กษัตริย์และศาลจากความนิยมดาดฟ้าอาคารเกมการ์ดปกครอง

ในฐานะที่เป็นส่วนหนึ่งของหนึ่งเราเล่นลำดับของการกระทำ การกระทำเฉพาะสองอย่างนี้ทำให้การกระทำถัดไปที่เล่นซ้ำสองหรือสามครั้ง * การกระทำ "ทั่วไป" อื่น ๆ ทำให้เกิดเอฟเฟกต์เกมเฉพาะ แต่เราจะไม่สนใจรายละเอียดใด ๆ เพียงแค่ติดป้ายกำกับด้วยตัวอักษร

กรณีที่น่าสนใจคือเมื่อห้องบัลลังก์หรือราชสำนักมีผลต่อห้องบัลลังก์อีกแห่งของศาลทำให้เกิดเอฟเฟกต์สองเท่าหรือสามเท่าให้ตัวเองเป็นสองเท่าหรือสามเท่า โซ่ยาวของห้องบัลลังก์กษัตริย์และการกระทำที่หลากหลายสามารถสร้างความสับสนให้กับผู้เล่นที่มีประสบการณ์

เป้าหมายของคุณคือการเขียนโค้ดที่สามารถแก้ไขเชนเหล่านี้ได้อย่างถูกต้องโดยใช้จำนวนไบต์น้อยที่สุด ฉันจะอธิบายข้อกำหนดของโปรแกรมก่อนที่จะอธิบายวิธีการแก้ไขปัญหาโซ่ในกฎ Dominion

* ในทางเทคนิคคุณเลือกการกระทำที่ได้รับผลกระทบซึ่งเป็นส่วนหนึ่งของการแก้ไข Throne Room หรือ King's Court แต่มุมมองนี้สะอาดกว่าสำหรับความท้าทายนี้

ข้อกำหนดของโปรแกรม

เขียนโปรแกรมหรือฟังก์ชั่นการตั้งชื่อ มันควรใช้ในห่วงโซ่ของการกระทำที่เล่น (STDIN หรือฟังก์ชั่นอินพุต) และเอาท์พุทหรือพิมพ์ห่วงโซ่ของการกระทำจากผลของการเสแสร้งและสามเท่า ไบต์ที่น้อยที่สุดจะเป็นผู้ชนะ

อินพุต

สตริงที่แทนลำดับของการดำเนินการที่เล่น การกระทำทั่วไปจะแทนด้วยตัวอักษรทุนผ่านA Zห้องบัลลังก์แอ็คชั่นสองเท่าเป็นพิเศษแสดงโดยตัวละคร2และแอ็คชั่นสามเท่าของคิงส์คอร์ต3 ,

จำนวนอักขระ (การกระทำ) จะอยู่ระหว่าง 1 ถึง 30 โดยรวม คุณอาจมีจุดสิ้นสุดการป้อนข้อมูลในบรรทัดใหม่หากคุณต้องการ

อินพุตตัวอย่าง: WA23G3GA

เอาท์พุต

สตริงตัวอักษรพิมพ์ใหญ่AถึงZที่จะนี่ควรเป็นลำดับของการกระทำทั่วไปที่เป็นผลมาจากการแก้ไขเอฟเฟกต์สองเท่าและสามเท่าตามลำดับที่เกิดขึ้น

คุณอาจมีผลลัพธ์สิ้นสุดในการขึ้นบรรทัดใหม่ถ้าคุณต้องการ ไม่ควรมีอักขระอื่นเพิ่มเติม

ตัวอย่างผลลัพธ์: WAGGGGGGAAA.

การเสแสร้งและสามเท่าทำงานอย่างไรใน Dominion

ที่นี่ฉันจะไปดูว่าเชนของบัลลังก์ (ห้อง2) และศาลของกษัตริย์3ทำงานอย่างไรตามกฎการปกครอง

หลังจากที่คุณเล่น a 2การกระทำต่อไปที่จะได้รับการแก้ไขจะเกิดขึ้นสองครั้ง ดังนั้นถ้าคุณเล่นครั้งแรก2แล้วAคุณจะได้รับAสิ่งที่เกิดขึ้นเป็นครั้งที่สอง

2A -> AA

ในทำนองเดียวกัน

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

โปรดสังเกตในตัวอย่างสุดท้ายว่าสุดท้าย2ไม่มีอะไรที่จะเพิ่มเป็นสองเท่าดังนั้นจึงไม่มีผลกระทบ

สิ่งที่น่าสนใจเกิดขึ้นเมื่อเพิ่มเอฟเฟกต์เป็นสองเท่าหรือสามเท่า ตัวอย่างเช่น,

22AB -> AABB

2ครั้งแรกที่คุณเล่น จากนั้นคุณเล่นอีกซึ่งเป็นสองเท่าจากก่อนหน้านี้2 2ด้วยเหตุนี้การกระทำสองอย่างถัดไปจึงเป็นสองเท่า ครั้งแรกที่ทั้งสองสำเนาของการAแก้ไข จากนั้นสำเนาของการBแก้ไข

โปรดทราบว่าAไม่ได้ปากต่อปาก: หลังจากที่คัดลอกแรกของ2การกระทำในครั้งแรกคัดลอกต่อไปทำหน้าที่เกี่ยวกับการดำเนินการยังไม่ได้แก้ไขต่อไปซึ่งเป็นA BหากปราศจากBเราก็จะมี

22A -> AA

โดยที่สำเนาที่สอง2กำลังรอการดำเนินการถัดไปเป็นสองเท่า แต่ไม่มีการกระทำใดเกิดขึ้น

สุดท้ายเรามาดูตัวอย่างที่ซับซ้อน

223BCDE -> BBBCCCDDE

อย่างที่เคยเป็นมาก่อน2สาเหตุที่สอง2จะเพิ่มเป็นสองเท่า ดังนั้นสองแอ็คชั่นถัดไปจะถูกเพิ่มเป็นสองเท่า สำเนาแรกของ2คู่ดำเนินการต่อไปซึ่งจะต้องได้รับการแก้ไขก่อนที่จะแก้ไขสำเนาต่อไปของ3 2สำเนาแรกของ3อเนกประสงค์และอเนกประสงค์สำเนาที่สองB Cตอนนี้สำเนาที่สองยังคงรอคอยของคู่การกระทำที่ยังคงได้รับการแก้ไขต่อไปซึ่งเป็น2 Dหลังจากนี้จะไม่มีเอฟเฟกต์เพิ่มขึ้นสองเท่าหรือสามเท่าและการกระทำขั้นสุดท้ายEก็เกิดขึ้น

กรณีทดสอบ

(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 ไบต์)

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

การสาธิตออนไลน์

การผ่า

นี่เป็นการละเมิดการพิมพ์ GolfScript ที่หลวมเล็กน้อย สแต็คของจำนวนครั้งที่จะทำซ้ำการกระทำที่ตามมาเริ่มต้นเป็นอาร์เรย์และต่อมากลายเป็นสตริง - แต่1+ผนวก 1 และ(3&ปรากฏค่าแรกและปรากฏอย่างถูกต้องในช่วง0ที่3ไม่คำนึงถึงการเปลี่ยนแปลงประเภท

](         # 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 ไบต์

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

ขยาย:

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

ฉันเดาว่าภาษากอล์ฟแบบสแต็กจะถูกฆ่าในภาษานี้เพราะโดยทั่วไปแล้วเป็นการออกกำลังกายในการซ้อนฟังก์ชั่น : P

ตัวอย่างผลลัพธ์

F('3N2BC3XY2')
"NNNBBCXXXY"

F('WA23G3GA')
"WAGGGGGGAAA"

F('A2A323AB2CD2D2E3ABC')
"AAAAAABBBCCDDDDEEAAABBBC"

F('322322ABCDEFGHIJKLMN')
"AABBCCDDEEEFFGGHHIJKLMN"

F('FY')
"FY"

F('')
""

C, 115 111 ไบต์

ใช้อินพุต / เอาต์พุตมาตรฐาน

บันทึก 4 โดยใช้memsetและทำให้สแตกไปในทิศทางอื่น

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คือสแต็คของตัวคูณ (ด้านบนถ้าด้านหน้า) มันเริ่มต้นได้ด้วยพอ1ที่จะจัดการกับการกระทำแบบไม่ จำกัด

ขึ้นอยู่กับว่าการกระทำในปัจจุบันcคือทั่วไปหรือไม่เราเพิ่มผลคูณของทั้งการส่งออกหรือสแต็คของตัวคูณRS

ทุกอย่างถูกแสดงเป็นสตริงแทนที่จะเป็นรายการของตัวอักษร เนื่องจากสตริงนั้นไม่เปลี่ยนรูปเราจึงไม่สามารถใช้popหรือกำหนดองค์ประกอบให้กับมันได้