एक स्टैक स्टेट डायग्राम को हल करें

स्टैक स्थिति आरेख दिखाता है कि एक स्टैक पर मौजूद मान दूसरे में कैसे बदले जाते हैं। उदाहरण के लिए, यह एक स्टैक स्टेट आरेख है:

3 0 2 1 0

इसका मतलब यह है कि शुरू में 3 मान ( 3भाग) युक्त एक स्टैक है । ये मान 0 से 2 तक अनुक्रमित हैं, शीर्ष पर 0 के साथ 2 1 0:। अगले भाग 0 2 1 0में स्टैक की अंतिम स्थिति का वर्णन किया गया है: स्टैक के शीर्ष पर मूल रूप से मान को पीछे की ओर कॉपी किया गया है।

ये परिवर्तन एक स्टैक पर होते हैं जिसमें कई डेटा प्रकारों के लिए समर्थन होता है:

"मान" प्रकार, जो मूल रूप से स्टैक पर है। यह एक स्ट्रिंग, पूर्णांक, आदि हो सकता है, लेकिन इसके मूल्य को जानने की आवश्यकता नहीं है।
"सूची" प्रकार, जो किसी भी डेटा प्रकार के मूल्यों से युक्त एक सूची है।

इस परिवर्तन को मॉडल करने के लिए, निम्नलिखित कार्यों की अनुमति है:

S: स्टैक के शीर्ष पर दो मान स्वैप करें: 2 1 0→2 0 1
D: स्टैक के शीर्ष पर मूल्य डुप्लिकेट करें: 1 0→1 0 0
R: स्टैक पर शीर्ष मान निकालें। 2 1 0→2 1
L: शीर्ष मान को उस मान वाले एक-तत्व सूची में बदल दें: 2 1 0→2 1 (0)
C: स्टैक पर शीर्ष दो सूचियों को सम्‍मिलित करें: 2 (1) (0)→2 (1 0)
U: स्टैक पर एक सूची से सभी मान रखें: 2 (1 0)→2 1 0

ये अंडरलोड कमांड के बराबर हैं ~ : ! a * ^, बशर्ते कि कोई अन्य कमांड का उपयोग न किया जाए।

S, D, R, और Lढेर के शीर्ष पर किसी भी मूल्यों के साथ इस्तेमाल किया जा सकता है, लेकिन Cऔर Uकार्य करने के लिए ढेर के शीर्ष पर सूचियों होना आवश्यक है। एक ऐसा सबमिशन, जिसके जेनरेट किए गए सीक्वेंस अमान्य ऑपरेशंस (जैसे Dखाली स्टैक Uपर या नॉन-लिस्ट) को प्रीफॉर्म करने का प्रयास करते हैं , गलत है और इसे निश्चित रूप से ~~दंडित किया~~ जाना चाहिए ।

स्टैक स्थिति आरेख को हल करने के लिए, एक क्रम का क्रम खोजें जो प्रारंभिक स्टैक स्थिति को सही रूप से नए में बदल देगा। उदाहरण के लिए, इसका एक समाधान 3: 0 2 1 0है LSLCSLCULSLCLSLDCSC USLCU:

   2 1 0
L  2 1 (0)
S  2 (0) 1
L  2 (0) (1)
C  2 (0 1)
S  (0 1) 2
L  (0 1) (2)
C  (0 1 2)
U  0 1 2
L  0 1 (2)
S  0 (2) 1
L  0 (2) (1)
C  0 (2 1)
L  0 ((2 1))
S  ((2 1)) 0
L  ((2 1)) (0)
D  ((2 1)) (0) (0)
C  ((2 1)) (0 0)
S  (0 0) ((2 1))
C  (0 0 (2 1))
U  0 0 (2 1)
S  0 (2 1) 0
L  0 (2 1) (0)
C  0 (2 1 0)
U  0 2 1 0

आपका कार्य एक कार्यक्रम लिखना है जो एक स्टैक स्टेट आरेख लेता है और एक समाधान को आउटपुट करता है।

परीक्षण के मामलों

2 1 0       ->

3 2 0       -> SR

9           -> RRRRRRRRR

2 0 1 0     -> LSLCDCUR

2 0 1 1     -> SD

6 2         -> RRSRSRSR

5 0 1 2 3 4 -> LSLCSLCSLCSLCU

4 2 0 1 3 2 -> LSLCSLSCSLCULSLSCSLSCLSLDCSCUSLCU

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर (बाइट्स में) जीतता है।

code-golf code-generation stack

— फल तोड़ना
स्रोत

क्या आपके पास सूची वाली कोई सूची हो सकती है? संपादित करें: कोई बात नहीं, आप कर सकते हैं, यह उदाहरण में है।

— orlp

क्या Cस्टैक के शीर्ष और दूसरे स्थान पर आवश्यकता सूची है? या दूसरी स्थिति में तत्व शीर्ष पर एक सूची में जोड़ा जा सकता है?

— edc65

Cदोनों पदों पर सूची की जरूरत है। यह एक मूल्य और एक सूची को समझने के लिए कोई मतलब नहीं है।

— फल तोड़ना

जवाबों:

पायथन 3, 84 बाइट्स

lambda n,*s:"DLL"+"L".join(i*"SLSC"+"LSLSCDURLCULCULSC"for i in s[::-1])+n*"SR"+"UR"

उपयोग:

# Example: 4 2 0 1 3 2 -> LSLCSLSCSLCULSLSCSLSCLSLDCSCUSLCU
>>> f = lambda ...
>>> f(4, 2, 0, 1, 3, 2)
'DLLSLSCSLSCLSLSCDURLCULCULSCLSLSCSLSCSLSCLSLSCDURLCULCULSCLSLSCLSLSCDURLCULCULSCLLSLSCDURLCULCULSCLSLSCSLSCLSLSCDURLCULCULSCSRSRSRSRUR'

स्पष्टीकरण: हम शून्य को डुप्लिकेट करने के लिए शुरू करते हैं और इसे सूची में लपेटते हैं:

DL -> 3 2 1 0 (0)

यह हमारा आधार है। अब मैं एक सामान्य एल्गोरिथ्म समझा जाएगा कि बदल जाता है ... 1 0 (x)में ... 1 0 (i x)मनमाने ढंग से पूर्णांक के लिए i। मैं एक उदाहरण के रूप में उपयोग करूंगा i = 2, और हमारी कुछ मनमानी सूची है (x)। हम अपनी वर्तमान सूची (x)को दूसरी सूची में लपेटकर शुरू करते हैं:

L -> 3 2 1 0 ((x))

अब हम निम्नलिखित अनुक्रम iबार दोहराते हैं :

SLSC -> 3 2 1 (0 (x))
SLSC -> 3 2 (1 0 (x))

अब हम सूची में 2 सम्मिलित करने के लिए तैयार हैं (x)। यह इस प्रकार है:

LSLSC -> 3 (2 (1 0 (x)))
DU -> 3 (2 (1 0 (x))) 2 (1 0 (x))
RLCU -> 3 2 (1 0 (x)) 2
LCU -> 3 2 1 0 (x) 2
LSC -> 3 2 1 0 (2 x)

ध्यान दें कि हम नए पूर्णांक को बाईं ओर धकेलते रहते हैं। इसलिए सबसे पहले (0)हमने दाईं ओर बने रहने की शुरुआत की।

हमने प्रत्येक पूर्णांक सम्मिलित करने के बाद हमें उस सूची में शामिल किया है जिसे हम स्वैप करके शेष समय को हटाते हैं और n समय ( SR) हटाते हैं । अंत में हम अपनी सूची को अनपैक करते हैं और अपनी सूची 0को शुरू करने के लिए हमने जो पहले डाला है उसे हटाते हैं ( UR)।

— orlp
स्रोत

क्या आपको sइसके बजाय टाइप करने का मतलब था l?

— ज़ाचरी

@ZacharyT उफ़, हाँ। यह lमेरे REPL पर परिभाषित किया गया था, क्योंकि चारों ओर चीजों फेरबदल करते हुए काम किया ।

— orlp

दिखाया गया उदाहरण काम नहीं करता है ... (

DLLSLSCSLSCSLSCSLSCLSLSCDURLCULCULSCLSLSCSLSCSLSCLSLSCDURLCULCULSCLSLSCSLSCLSLSCDURLCULCULSCLSLSCLSLSCDURLCULCULSCLLSLSCDURLCULCULSCSRSRSRSRUR

)। यह Sस्टैक पर केवल 1 मान होने पर एक निर्देश निष्पादित करने का प्रयास करता है ।

— फल तोड़ना

@ चैलेंजर 5 और मैं भी उदाहरण को अद्यतन करने के लिए भूल गया ... अब तय किया जाना चाहिए।

— orlp

हाँ, अब अच्छा लग रहा है!

— २२:१५

CJam, 54 बाइट्स

सीजेएम में ऑर्लप के पायथन समाधान से सिर्फ एक अनुवाद। यहां कुछ नया नहीं है।

"DLL"q~("SR"*\W%{"SLSC"*"LSLSCDURLCULCULSC"+}%'L*\"UR"

स्पष्टीकरण:

"DLL"                  e# Push string
q~                     e# Read input and evaluate
(                      e# Pop the first value
"SR"                   e# Push string
*                      e# Repeat string n times
\                      e# Swap (bring s to front)
W%                     e# Reverse
{                      e# For each:
  "SLSC"               e#   Push string
  *                    e#   Repeat i times
  "LSLSCDURLCULCULSC"+ e#   Append string to end
}%                     e# End
'L*                    e# Join with 'L'
\                      e# Swap (bring "SR"*n to front)
"UR"                   e# Push string
                       e# [Stack is implicitly output.]

— फल तोड़ना
स्रोत