डोमिनियन में दोहरीकरण और ट्रिपलिंग क्रियाओं को हल करें

Question

प्रेरणा स्त्रोत

यह प्रश्न कार्डों के सिंहासन कक्ष और किंग्स कोर्ट द्वारा लोकप्रिय डेक-बिल्डिंग कार्ड गेम डोमिनियन से प्रेरित है ।

अपनी बारी के हिस्से के रूप में, एक क्रिया का क्रम निभाता है। ये दो विशेष क्रियाएं दो-तीन बार * दोहराने वाली अगली-क्रिया का कारण बनती हैं। अन्य "जेनेरिक" कार्यों के कारण विशिष्ट खेल प्रभाव होते हैं, लेकिन हम विशेष रूप से पत्रों के साथ उन्हें लेबल करने में दिलचस्पी नहीं लेंगे।

दिलचस्प मामला यह है कि जब एक सिंहासन कक्ष या राजा का दरबार राजा के दरबार के एक अन्य सिंहासन कक्ष को प्रभावित करता है, जिससे दोहरीकरण या ट्रिपलिंग का प्रभाव स्वयं दोगुना या तिगुना हो जाता है। सिंहासन कक्ष, किंग कोर्ट्स और गुणा कार्यों की लंबी श्रृंखला भी अनुभवी डोमिनियन खिलाड़ियों को भ्रमित कर सकती है।

आपका लक्ष्य कोड लिखना है जो इन जंजीरों को सही ढंग से हल करता है, संभव के रूप में कुछ बाइट्स का उपयोग करके। डोमिनियन नियमों में चेन कैसे हल करते हैं, यह समझाने से पहले मैं कार्यक्रम की आवश्यकताओं का वर्णन करूँगा।

* तकनीकी रूप से, आप थ्रोन रूम या किंग्स कोर्ट के समाधान के हिस्से के रूप में प्रभावित कार्रवाई का चयन करते हैं, लेकिन यह दृश्य इस चुनौती के लिए क्लीनर है।

कार्यक्रम की आवश्यकताएँ

कोई प्रोग्राम या नामांकित फ़ंक्शन लिखें । इसे खेले जाने वाले कार्यों (एसटीडीआईएन या फ़ंक्शन इनपुट) की श्रृंखला में ले जाना चाहिए, और दोहरीकरण और ट्रिपलिंग के प्रभावों से परिणामी श्रृंखला को प्रिंट करना चाहिए। सबसे कम बाइट्स जीतता है।

इनपुट

निभाई जाने वाली क्रियाओं के अनुक्रम का प्रतिनिधित्व करने वाला एक तार। सामान्य क्रियाओं का प्रतिनिधित्व बड़े अक्षरों द्वारा किया Aजाता है Z। विशेष दोहरीकरण कार्रवाई सिंहासन कक्ष को चरित्र द्वारा दर्शाया गया है 2, और राजा की अदालत द्वारा ट्रिपलिंग कार्रवाई 3,

वर्णों (क्रियाओं) की संख्या 1 और 30 के बीच होगी, समावेशी। यदि आप चाहें तो एक नई पंक्ति में इनपुट अंत हो सकता है।

उदाहरण इनपुट: WA23G3GA

उत्पादन

बड़े अक्षरों का एक स्ट्रिंग Aके लिए Z। यह सामान्य क्रियाओं का अनुक्रम होना चाहिए, जो कि होने वाले क्रम में दोहरीकरण और ट्रिपलिंग प्रभावों को हल करने के परिणामस्वरूप होता है।

यदि आप चाहें तो आउटपुट का अंत एक नई पंक्ति में हो सकता है। अन्यथा कोई अतिरिक्त वर्ण नहीं होना चाहिए।

उदाहरण आउटपुट: WAGGGGGGAAA।

डोमिनियन में दोहरीकरण और ट्रिपलिंग कैसे काम करता है

यहाँ, मैं सिंहासन के नियमों के अनुसार सिंहासन कक्ष ( 2's' और 'किंग्स कोर्ट्स 3') की श्रृंखलाओं के माध्यम से जाऊँगा ।

आपके द्वारा खेलने के बाद 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)

Answer 1

GolfScript ( 29 26 बाइट्स)

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

ऑनलाइन डेमो

विच्छेदन

यह गोल्फस्क्रिप्ट की ढीली टाइपिंग को थोड़ा गाली देता है। बाद के कार्यों को दोहराने के लिए कितनी बार एक सरणी के रूप में शुरू होता है और बाद में एक स्ट्रिंग में बदल जाता है - लेकिन 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

Comments

मैं 1ढेर के नीचे धकेलने की अपनी चाल को अन-गुणा क्रियाओं के समान गुणा गुणकों के समान मानता हूं । क्या आप कृपया इस बारे में अधिक बता सकते हैं कि आपने विभिन्न ढेरों को कैसे किया? विशेष रूप से, \ "रेप स्टैक को शीर्ष पर लाने" के लिए क्या करता है?

— xnor

@ xnor, यहाँ बिल्टर्स संदर्भ है । स्टैक पर शीर्ष दो आइटम स्वैप करता है।

— पीटर टेलर

धन्यवाद, मुझे समझ नहीं आया था कि प्रत्येक स्टैक तत्व का अपना स्टैक था; मैं एक अकेले समतल की कल्पना कर रहा था।

— xnor

@ xnor, ऐसा नहीं है कि प्रत्येक स्टैक आइटम का अपना स्टैक है; यह है कि पुनरावृत्ति स्टैक को एक सरणी या एक स्ट्रिंग (जो अभी भी एक सरणी है, लेकिन कुछ बिल्डरों द्वारा अलग तरह से व्यवहार किया जाता है) के रूप में संग्रहीत किया जाता है। डीबग डेमो जो मुख्य लूप के अंत से पहले जीएस स्टैक सामग्री को प्रिंट करता है।

— पीटर टेलर

Answer 2

जावास्क्रिप्ट - 162 152 बाइट्स

न्यूनतम किया गया:

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

मुझे लगता है कि स्टैक-आधारित गोल्फ भाषाओं को इस पर मार देंगे, क्योंकि यह मूल रूप से फ़ंक्शन स्टैकिंग में एक अभ्यास है। : पी

नमूना आउटपुट

F('3N2BC3XY2')
"NNNBBCXXXY"

F('WA23G3GA')
"WAGGGGGGAAA"

F('A2A323AB2CD2D2E3ABC')
"AAAAAABBBCCDDDDEEAAABBBC"

F('322322ABCDEFGHIJKLMN')
"AABBCCDDEEEFFGGHHIJKLMN"

F('FY')
"FY"

F('')
""

Comments

मुझे आश्चर्य है कि कार्यों के रूप में कार्डों की आपकी व्याख्या कितनी सटीक है। मैं एक स्टैक की उम्मीद करता हूं, लेकिन कार्यों का एक शाब्दिक कॉल स्टैक नहीं! क्या कई बार किसी फ़ंक्शन को कॉल करने का अधिक संक्षिप्त तरीका नहीं है? एक 2/3साथ मामलों को संभालने के लिए बेहतर समय की एक परिवर्तनीय संख्या ?

— xnor

@xnor: मैंने सोचा कि यह चतुर था। ;) आपके सुझाव के अनुसार, आपका अंतर्ज्ञान सही था। मैंने 10 बाइट की बचत के लिए दो मामलों को संयुक्त किया है। यह आदर्श रूप से 18 साल का होगा, लेकिन मुझे लगता है कि फ़ायरफ़ॉक्स में एक बग है पर मैंने ठोकर खाई है। मैं xसीधे पहले bलैम्ब्डा के लिए स्कूप किए गए एक चर में कॉपी किए बिना सीधे हेरफेर करने में सक्षम होना चाहिए , लेकिन फ़ायरफ़ॉक्स लूप स्थिति का ठीक से मूल्यांकन नहीं करता है। विशेष रूप से, xनकारात्मक हो जाता है और ब्राउज़र हैंग हो जाता है। इनपुट के , b = x; b--;साथ बदलने ; x--;और चलाने का प्रयास करें A2A323AB2CD2D2E3ABC। अगर इसे पढ़ने वाला कोई भी समझ सकता है कि क्यों, ...

— COTO

... मुझे जानने में बहुत दिलचस्पी होगी। शायद मुझे कुछ याद आ रहा है कि क्लोजर कैसे काम करना चाहिए।

— सीओटीओ

Answer 3

सी, 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;
}

Answer 4

पायथन (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सामान्य है या नहीं, इस पर निर्भर करते हुए , हम इसके गुणा परिणाम को आउटपुट में Rया गुणक के ढेर में जोड़ते हैं S।

सब कुछ वर्णों की सूची के बजाय एक स्ट्रिंग के रूप में दर्शाया गया है। क्योंकि तार अपरिवर्तनीय हैं, हम दुर्भाग्य से उन popपर काम या तत्व असाइनमेंट का उपयोग नहीं कर सकते हैं।