एक विनिर्देश से एक आयत बनाएँ

Question

परिचय

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

इनपुट

आपका इनपुट एक स्ट्रिंग है जिसमें लोअरकेस ASCII अक्षर और प्रतीक |और हैं -। सादगी के लिए, इनपुट में बार-बार लोअरकेस वर्ण नहीं होते हैं। स्ट्रिंग वर्णों के आयताकार ग्रिड के एक वर्ग के लिए एक विनिर्देश है, और इसे एक स्टैक का उपयोग करके बाएं से दाएं तक पार्स किया गया है।

• किसी लोअरकेस वर्ण को देखते हुए , किसी भी वर्ण के ग्रिड cको स्टैक पर धकेलें ।m×ncm, n ≥ 1
• पाइप को देखते हुए |, दो ग्रिड Aऔर Bस्टैक से ( Bशीर्ष पर) पॉप था, और के दाईं ओर ABसमतल करके प्राप्त ग्रिड को धक्का दें । इसके लिए इसकी आवश्यकता है और समान ऊंचाई है।BAAB
• एक हाइफन को देखते हुए -, दो ग्रिड Aऔर Bस्टैक से ( Bशीर्ष पर) पॉप था, और नीचे के लिए A/Bकंक्रीटिंग द्वारा प्राप्त ग्रिड को धक्का दें । इसके लिए इसकी आवश्यकता है और समान चौड़ाई है।BAAB

यह गारंटी है कि के लिए है कुछ के विकल्पों mऔर nबनाया पार्स प्रक्रिया के दौरान (जो प्रत्येक अक्षर के लिए अलग हो सकता है), इनपुट विनिर्देश सही ढंग से कुछ आयत है, जो अंत में ढेर पर छोड़ दिया जाता है वर्णन करता है।

उत्पादन

आपका आउटपुट इनपुट द्वारा निर्दिष्ट वर्णों का एक आयताकार ग्रिड है। ग्रिड इस मायने में न्यूनतम होना चाहिए कि किसी भी पंक्ति या स्तंभ को हटाने से यह अमान्य हो जाए। आप एक नई पंक्ति-अलग स्ट्रिंग (एक अनुगामी न्यूलाइन के साथ या बिना), वर्णों की 2 डी सरणी या स्ट्रिंग की एक सरणी वापस कर सकते हैं, जो भी सबसे सुविधाजनक प्रारूप है।

ध्यान दें कि आपको इनपुट को संसाधित करने की आवश्यकता नहीं है जैसा कि ऊपर वर्णित है; एकमात्र महत्वपूर्ण बात यह है कि आपका आउटपुट सही है।

उदाहरण

विनिर्देश पर विचार करें

par-s||e-

सबसे पहले, हम एक पुश करने के लिए चुनते हैं 1×2की आयत p, और 1×1की आयतों aऔर r(इस का कारण यह बाद में स्पष्ट हो जाएगा)। फिर, हम पॉप aऔर rआयताकारों को पॉप करते हैं , और उनके ऊर्ध्वाधर संयोजन को धक्का देते हैं

a
r

अगला, हम एक 1×2आयत को धक्का देते हैं s, इसे और ऊपर की आयत को पॉप करते हैं, और उनके क्षैतिज संघटन को धक्का देते हैं

as
rs

फिर हम उस आयत और आयत को पॉप करते हैं p, और उनके संघटन को धक्का देते हैं

pas
prs

अंत में, हम एक 3×1आयत को धक्का देते हैं e, इसे और ऊपर की आयत को पॉप करते हैं, और ऊर्ध्वाधर संघनन को धक्का देते हैं

pas
prs
eee

यह प्रोग्राम का आउटपुट है, या कम से कम संभावनाओं में से एक है। ध्यान दें कि भले ही

ppas
ppas
pprs
eeee

विनिर्देश द्वारा भी उत्पन्न होता है, यह एक मान्य आउटपुट नहीं है, क्योंकि कई पंक्तियों और स्तंभों को हटाया जा सकता है।

अधिक सूक्ष्म उदाहरण के रूप में, विचार करें

co|m|p|il|e|r|-

यह विनिर्देश आयत उत्पन्न करता है

comp
iler

जो एक मान्य आउटपुट है। हालाँकि, यह भी उत्पन्न करता है

commp
iiler

जो मान्य है, क्योंकि कोई भी पंक्ति या स्तंभ बिना अमान्य किए नहीं हटाया जा सकता है।

नियम

आप एक पूर्ण कार्यक्रम या एक समारोह दे सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

अतिरिक्त परीक्षण मामले

आप अपने कार्यक्रम का परीक्षण करने के लिए इनका उपयोग कर सकते हैं।

Input:
a
Output:
a

Input:
co|mp|l|-ex|i|f|-y|
Example output:
cccoy
mplly
exify

Input:
ja-r|g-o|ni-|ze|d-|
Example output:
jronze
arondd
ggoidd

Input:
un|co|p-yr|i|gh-t-ab|-|le-||-
Example output:
unnnnnnn
coyriggl
ppyrihhe
ppyritte
ppyriabe

Comments

N और m कहाँ से आते हैं?

— १

स्थिर हो सकता है या इनपुट का कोई रूप होना चाहिए?

— १

@ सीग nऔर mगैर-निर्धारक रूप से चुने जाते हैं। यह गारंटी है कि उनके लिए उपयुक्त मूल्य मौजूद हैं, लेकिन उन्हें ढूंढना आपके कार्यक्रम का काम है।

— जर्बर्ग

आप वास्तव में परिभाषित नहीं करते हैं कि वे क्या हैं।

— देखिए

un|co|p-|yr|i|gh--t-ab|-|le-||-वैध होना असंभव है। अंतिम -में 2 की एक समता है, जबकि स्टैक पर केवल 1 तत्व है।

— orlp

Answer 1

के, 123 110 बाइट्स

मैंने कार्डबोर्ड_बॉक्स के समाधान के लिए एक समान दृष्टिकोण का उपयोग किया।

r:{y,x#,*|y};h:{t:(#x)|#y;r[t-#x;x],'r[t-#y]y};a:{(,x .|2#y),2_ y};*(){(a[{+h[+x;+y]}]x;a[h]x;(,,y),x)"-|"?y}/

यह कार्यक्रम सहायक परिभाषाओं की एक श्रृंखला है जिसके बाद एक टैसिट फ़ंक्शन होता है जो एक स्ट्रिंग को एक सही तर्क के रूप में लेता है। पठनीयता के लिए सुधार और अंतिम कार्य के रूप में असाइन करना f:

r: {y,x#,*|y};                           / repeat last row x times
h: {t:(#x)|#y;r[t-#x;x],'r[t-#y;y]};     / append horizontal
v: {+h[+x;+y]};                          / append vertical
a: {(,x[y@1;y@0]),2_ y};                 / pop two values, concat

f: *(){:[y="-";a[v;x]; y="|";a[h;x]; (,,y),x]}/;

उदाहरण का उपयोग करें:

  f "ja-r|g-o|ni-|ze|d-|"
("jronze"
 "aroidd"
 "ggoidd")

Kona का उपयोग कर परीक्षण किया गया, लेकिन यह भी में काम करेंगे ठीक है अगर आप को बदलने :की परिभाषा में fएक साथ $- K5 "cond" की वाक्य रचना बदल दिया है।

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

संपादित करें:

इस प्रविष्टि के शीर्ष पर प्रोग्राम अपडेट किया गया। Ungolfed संस्करण:

r: {y,x#,*|y};                           / repeat row x times
h: {t:(#x)|#y;r[t-#x;x],'r[t-#y;y]};     / append horizontal
v: {+h[+x;+y]};                          / append vertical
a: {(,x .|2#y),2_ y};                    / apply a concat
f: *(){(a[v]x;a[h]x;(,,y),x)"-|"?y}/;

उल्लेखनीय लंबाई ऑप्टिमाइज़ेशन में "डॉट लागू" का उपयोग शामिल है a, सूची में अनुक्रमण के साथ "कॉन्ड" की जगह f(कम कुशल, लेकिन कम) और समूह की अनुमति के रूप a[b;c]में फ़ॉर्म की शर्तों को प्रतिस्थापित करना a[b]c। चूंकि मैं अब "कॉन्ड" या किसी भी आदिम का उपयोग नहीं कर रहा हूं, जो k3 और k5 के बीच भिन्न हैं, यह संस्करण अब संशोधन के बिना ओके में काम करता है।

Comments

इनाम जीतने पर बधाई!

— ज़र्गब

धन्यवाद! यह एक दिलचस्प समस्या थी जो K के लिए बहुत अच्छी थी। तुलना के लिए J या APL में प्रयासों को देखना दिलचस्प होगा।

— जॉनई

Answer 2

प्रोलॉग, 539 बाइट्स

:-lib(ic).
:-lib(util).
b(A,B,C):-between(A,B,C).
g(S):-string_list(S,L),p(L,[]).
w(h(L,R):_:_,I,J):-w(L,I,J);L=_:W:_,X is I-W,w(R,X,J).
w(v(U,D):_:_,I,J):-w(U,I,J);U=_:_:H,Y is J-H,w(D,I,Y).
w(f(C):W:H,I,J):-b(1,W,I),b(1,H,J),char_code(S,C),put_char(S).
p([],[S]):-term_variables(S,V),S=_:X:Y,labeling(V),!,b(1,Y,J),(b(1,X,I),w(S,I,J);nl),fail.
p([124|T],[Q,Z|R]):-!,Q=_:WA:H,Z=_:WB:H,W #= WA+WB,p(T,[h(Z,Q):W:H|R]).
p([45|T],[Q,Z|R]):-!,Q=_:W:HA,Z=_:W:HB,H #= HA+HB,p(T,[v(Z,Q):W:H|R]).
p([C|T],R):-!,[H,W] #:: 1..100,p(T,[f(C):W:H|R]).

व्याख्या

हम विधेय के साथ शुरू करते हैं g, जो एक स्ट्रिंग लेता है, इसे वर्णों की सूची के रूप में परिवर्तित करता है और pएक दूसरे तर्क के रूप में एक खाली स्टैक के साथ विधेय को (पार्स) कहता है।

विधेय pएक उचित रूप से संशोधित ढेर (के लिए देखो के साथ रिकर्सिवली ही कॉल [H|T]destructuring और निर्माता पैटर्न)। बेस केस पर बुलाया जाता है, जहां इनपुट सूची खाली होती है, pस्टैक के अनूठे तत्व को प्रिंट करता है। यदि इस बिंदु पर स्टैक कम या अधिक एक तत्व है, तो इसका मतलब है कि हमारे पास एक खाली इनपुट स्ट्रिंग, एक खराब इनपुट स्ट्रिंग या एक बग (एक एमटीपी स्ट्रिंग के साथ, विधेय विफल रहता है (प्रोलॉग कहता है No), लेकिन कुछ भी मुद्रित नहीं है, जो ठीक है, क्योंकि हमें खाली तारों के लिए कुछ भी नहीं छापना चाहिए)।

हल

स्टैक में निर्मित आयतों का विवरण होता है, जिसे चिह्नित किया जाता है S:W:H, जहां आयत Sका एक प्रतीकात्मक प्रतिनिधित्व होता है, Wइसकी चौड़ाई और Hइसकी ऊंचाई (नोट, A:Bटपरल के लिए सिंटैक्टिक शुगर है :(A,B)जिसका नाम एक फ़नकार है :; यह केवल एक टपल होने से लिखने के लिए छोटा है; उपसर्ग संकेतन के साथ)।

साथ Aऔर Bउप आयत विनिर्देशों, Sया तो हो सकता है:

• h(A,B) : ए और बी के क्षैतिज अवतल
• v(A,B) : A और B का लंबवत अवतल
• f(C) : C के साथ भरें, जहां C एक वर्ण कोड है

ग्रिड की चौड़ाई और ऊँचाई बाधा-प्रोग्रामिंग चर हैं: ऊर्ध्वाधर (सम्मानीय क्षैतिज) के दौरान, हेरफेर किए गए आयतों की चौड़ाई (प्रतिक्रिया। ऊंचाई) एकीकृत होती है, जबकि परिणामी ऊंचाई (सम्मान चौड़ाई) योग होने का योग है। प्रत्येक सबग्रिड की ऊँचाई (सम्मान चौड़ाई)।

प्रक्रिया के अंत में लेबलिंग चरण बाधाओं का सम्मान करते हुए, कम से कम संभव मानों का उपयोग करते हुए चर को प्रेरित करता है (यह उस क्रम की एक संपत्ति है जिसके द्वारा समाधान की कोशिश की जाती है)।

मैंने उसी तर्क का उपयोग करके एक छोटा जवाब प्राप्त किया हो सकता है जो अन्य उत्तरों में किया जाता है, बिना किसी बाधा के, लेकिन अब बहुत देर हो चुकी है।

ध्यान दें कि क्योंकि चरों के लिए डिफ़ॉल्ट डोमेन सेट है 1..100, ग्रिड के संभावित आकारों पर एक सीमा है। जरूरत पड़ने पर ऊपरी-बाउंड को बदला जा सकता है। इसका प्रदर्शन निहितार्थ यह है कि यह निर्धारित करने में बहुत समय लग सकता है कि कोई विशेष समाधान कोई समाधान नहीं मानता है। मैंने कहा " हो सकता है " क्योंकि बाधाएं घातीय खोज को काफी कम करने की संभावना है। यदि आपको एक इनपुट स्ट्रिंग मिलती है जिसे अस्वीकार करना कठिन / महंगा है, तो कृपया साझा करें।

मुद्रण

मुद्रण भाग दिलचस्प है क्योंकि संरचना पर एक प्रकार की किरण-कास्टिंग एल्गोरिथ्म है: मैं परिणामस्वरूप ग्रिड के प्रत्येक सेल पर पुनरावृत्ति करता हूं, बिंदु (1,1)से बिंदु तक (W,H)और wमुख्य पेड़ में ग्रिड की सामग्री को प्रिंट करने के लिए विधेय को कॉल करता हूं यह स्थान (निश्चित रूप से, प्रत्येक पंक्ति को संसाधित करने के बाद एक नई रेखा मुद्रित की जाती है)।

wवर्तमान स्थिति में , ग्रिड वर्तमान ग्रिड के सापेक्ष हैं (रूट ग्रिड निरपेक्ष निर्देशांक को परिभाषित करता है)।

h(A,B)बिंदु पर एक संरचना को (X,Y)प्रिंट करते समय , मैं दोनों शाखाओं में बिना शर्त प्रिंट करता हूं:

• Aबिंदु पर ग्रिड में (X,Y), और
• Bबिंदु पर ग्रिड में (H,Y), जहां की चौड़ाई शून्य Hसे Xकम है A।

ग्रिड-ट्री की पत्ती शाखाएं f(C), अंत में या तो चरित्र को प्रिंट करती हैं C, यदि सापेक्ष स्थान ग्रिड के अंदर है, या कुछ भी नहीं। इस तरह से मैं आउटपुट स्ट्रीम से ग्रिड की सामग्री को ऊपर से नीचे, बाएं से दाएं तक प्रिंट कर सकता हूं। कोई वास्तविक सरणियों का उत्पादन नहीं किया जाता है।

टेस्ट

t("ja-r|g-o|ni-|ze|d-|").
t("un|co|p-yr|i|gh-t-ab|-|le-||-").
t("co|mp|l|-ex|i|f|-y|").
t("a").

tt :- t(X),nl,g(X).
tt.

परीक्षण चल रहा है:

[eclipse] tt.

jronze
aronze
ggoidd

uuuuuuun
coyriggl
coyrihhl
coyrittl
ppyriabe

cccoy
mmply
exify

a

Yes (0.00s cpu)

Comments

+1 No actual arrays are produced.यह है कि यह कैसे किया जाना चाहिए। इस मामले में ओवरकिल, क्योंकि व्याकरण इतना सरल है और शॉर्टकट हैं।

— edc65

@ edc65 हां, यह ओवरकिल है। लेकिन चूंकि यह कोडगॉल्फ है, इसलिए मैंने आकार को कम करने की कोशिश की, और सरणियों में हेरफेर भी बहुत ही क्रियात्मक रहा होगा।

— coredump

Answer 3

पायथन 2.7, 259

z=zip
def p(a,b):
 s,l=sorted([a,b],key=len)
 s+=([s[-1]]*(len(l)-len(s)))
 return z(*(z(*a)+z(*b)))
g=lambda s,t=[]:s and(s[0]=='-'and g(s[1:],t[:-2]+[z(*p(z(*t[-2]),z(*t[-1])))])or(s[0]=='|'and g(s[1:],t[:-2]+[p(t[-2],t[-1])])or g(s[1:],t+[[s[0]]])))or t[0]

gएक फ़ंक्शन है जो एक विनिर्देश लेता है और वर्णों का 2 डी सरणी देता है। यदि आप अधिक उपयोगकर्ता-अनुकूल संस्करण चाहते हैं, तो इस पंक्ति को जोड़कर स्टडिन से विनिर्देश लें और ग्रिड का प्रिंट आउट लें:

print'\n'.join(''.join(s)for s in g(raw_input()))

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

Input:
a
Output:
a
==========
Input:
co|mp|l|-ex|i|f|-y|
Output:
coooy
mplly
exify
==========
Input:
ja-r|g-o|ni-|ze|d-|
Output:
jronze
aroidd
ggoidd
==========
Input:
un|co|p-yr|i|gh-t-ab|-|le-||-
Output:
unnnnnnn
coyriggl
ppyrihhe
ppyritte
ppyriabe

व्याख्या

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

Answer 4

हास्केल, 388 367 352 बाइट्स

data C=L{c::Char}|N{t::Int,w::Int,h::Int,l::C,r::C}
q=replicate
[]#[x]=x
(c:i)#(b:a:s)|c=='-'=i#(N 1(max(w a)$w b)(h a+h b)a b:s)|c=='|'=i#(N 2(w a+w b)(max(h a)$h b)a b:s)
(c:i)#s=i#(N 0 1 1(L c)(L c):s)
p i|t i==0=q(h i)$q(w i)$c$l i|t i==2=zipWith(++)(p(l i){h=h i})$p(r i){h=h i,w=w i-w(l i)}|1<2=p(l i){w=w i}++p(r i){w=w i,h=h i-h(l i)}
f=p.(#[])

उपयोग: f "par-s||e-"->["pas","prs","eee"]

सुंदर मुद्रण के साथ टेस्ट रन:

> putStr $ unlines $ f "par-s||e-"
pas
prs
eee

> putStr $ unlines $ f "co|m|p|il|e|r|-"
comp
iler

> putStr $ unlines $ f "a"
a

> putStr $ unlines $ f "co|mp|l|-ex|i|f|-y|"
coooy
mplly
exify

> putStr $ unlines $ f "ja-r|g-o|ni-|ze|d-|"
jronze
aroidd
ggoidd

> putStr $ unlines $ f "un|co|p-yr|i|gh-t-ab|-|le-||-"
unnnnnnn
coyriggl
ppyrihhe
ppyritte
ppyriabe

यह कैसे काम करता है: फ़ंक्शन #ट्री संरचना में इनपुट स्ट्रिंग को पार्स करता है Cजो या तो एक पत्ती को Lपकड़ने या नोड को पकड़ने के लिए एक पत्ती है N। Na) साइड-बाय-साइड जॉइन ( t==2), b) टॉप-बॉटम जॉइन ( t==1) या c) सिंगल लेटर स्क्वायर ( t==0) हो सकता है। सभी नोड्स में एक चौड़ाई और ऊंचाई क्षेत्र और एक बाएं और दाएं बच्चे हैं। पार्स करने के बाद, pशेष रूट नोड को पुनरावर्ती रूप से आकार (चौड़ाई x ऊँचाई) पर समायोजित करके इसे बच्चे के नोड्स से जोड़ते हैं और उन्हें जोड़ते हैं।

संपादित करें: सुंदर छपाई के बजाय लाइनों की सूची के रूप में आउटपुट

Answer 5

जावास्क्रिप्ट (ईएस 6), 283 295

संपादित करें अब यह (भारी गोल्फ) जेएस समाधान संदर्भ (काफी गोल्फ) पायथन समाधान की तुलना में कम से कम छोटा है।

कार्डबोर्ड_बॉक्स के समान, केवल सबसे बाएं कॉलम या सबसे ऊपरी पंक्ति को दोहराते हुए।

F=w=>(
s=[t=1,l='length'],
[for(c of w)(
  b=s[t],a=s[--t],
  c>'z'?
    s[t]=(G=(a,b,m=b[l]-a[l])=>m?m>0?G([a[0],...a],b):G(a,[b[0],...b]):a.map((r,i)=>r+b[i]))(a,b)
  :c<'a'?
    s[t]=a.map(r=>r[m=b[0][l]-r[l],0].repeat(m>0&&m)+r).concat(b.map(r=>r[0].repeat(m<0&&-m)+r))
  :s[t+=2]=[c]
)],
s[t].join('\n'))

Ungolfed यह मेरा पहला, ungolfed समाधान है।

F=sp=>{
  s=[]
  for(c of sp){
    a=s.pop(b=s.pop())
    if (c > 'z')
    {
      l = a.length
      m = b.length
      for(; l-m ;)
        l < m ? l = a.unshift(a[0]) : m = b.unshift(b[0])
      s.push(a.map((r,i) => r + b[i]))
    }
    else if (c < 'a')
    {
      l = a[0].length
      m = b[0].length
      s.push(
        a.map(r => r[0].repeat(l < m ? m-l : 0) + r)
        .concat(b.map( r => r[0].repeat( l > m ? l-m : 0) + r))
      )
    }
    else 
    {
      s.push(a,b,[c])
    }
  }
  return s.pop().join('\n')
}

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

;['par-s||e-','co|m|p|il|e|r|-','co|mp|l|-ex|i|f|-y|',
 'ja-r|g-o|ni-|ze|d-|','un|co|p-yr|i|gh-t-ab|-|le-||-']
.forEach(w=>console.log(F(w)))

उत्पादन

pas
prs
eee

comp
iler

cccoy
mmply
exify

jronze
aronze
ggoidd

uuuuuuun
coyriggl
coyrihhl
coyrittl
ppyriabe

Answer 6

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

यहाँ संदर्भ उत्तर मैंने वादा किया था, थोड़ा और आगे बढ़ा।

T=lambda m:list(map(list,zip(*m)))
E=lambda a,b:a[:1]*(len(b)-len(a))+a
H=lambda a,b:[d+c for c,d in zip(E(a,b),E(b,a))]
s=[]
for k in input():s=k>"z"and[H(*s[:2])]+s[2:]or k<"a"and[T(H(*map(T,s[:2])))]+s[2:]or[[[k]]]+s
for r in s[0]:print("".join(r))

यह एक पूर्ण कार्यक्रम है जो STDIN से स्ट्रिंग लेता है और STDOUT को प्रिंट करता है। यह दृष्टिकोण कार्डबोर्ड_बॉक्स के समान है: एक वर्ण के लिए 1x1 सरणी को धक्का दें, और यदि तालमेल के लिए आवश्यक हो तो पंक्तियों की नकल करें।

$ echo "par-s||e-" | python3 gr.py
pas
prs
eee

विस्तृत विवरण

• Tदी गई सूचियों की सूची को स्थानांतरित करता है। अधिकांश कार्य उस कार्य द्वारा किया जाता है zip(*m)जिसके द्वारा पंक्तियों को स्तंभों पर स्वैप किया जाता है , बाकी परिणाम को सूचियों की सूची में परिवर्तित कर रहा है, क्योंकि zipटुपल्स का एक जनरेटर लौटाता है।
• E(a,b)रिटर्न aअपनी पहली तत्व के साथ की लंबाई से मेल करने के लिए पर्याप्त बार दोहराया b। ध्यान दें कि किसी सूची को ऋणात्मक संख्या से गुणा करने से रिक्त सूची मिलती है, इसलिए यदि bयह इससे छोटी है a, तो यह वापस आ जाती है a।
• H(a,b)रिटर्न की क्षैतिज संयोजन aऔर b, द्वारा लम्बे जा रहा है कम एक Eयदि आवश्यक हो तो।
• s स्टैक है।
• में forपाश, हम पुनरावृति इनपुट स्ट्रिंग से अधिक है, और की जगह sएक नया मान द्वारा: अगर यह की |(बड़ा है z), हम दो मानों पॉप और उनके धक्का Hहै, अगर यह के -(से कम a), हम दो मानों, पक्षांतरित, करने के लिए फ़ीड पॉप H, फिर से स्थानांतरित करें और परिणाम को धक्का दें, और अन्यथा पत्र के साथ 1x1 सरणी को धक्का दें।
• अंत में, हम के पहले तत्व को प्रिंट करते हैं s।