shCoc/NhN/zhNm>o_/zZSzdUz
इस उत्तर से प्रेरित सभी नए एल्गोरिथ्म का उपयोग करता है ।
(implicit) z = input()
(implicit) print
s combine list of strings into one string
h first list in
C matrix transpose of (e.g. first characters in first list, etc.)
o order_by(lambda N:
c float_div(
/NhN N.count(N[0]),
/zhN z.count(N[0])),
m map(lambda d:
> slice_head(
o order_by(lambda Z:
_/zZ -1*z.count(Z),
Sz sorted(z)),
d d),
Uz range(len(z))
क्रमशः:
सबसे पहले, हमने वर्णों को उनकी समानता के आधार पर क्रमबद्ध किया, संबंधों को वर्णानुक्रम से तोड़ा। यह वह जगह है o_/zZSz। oपाइथन के समान है sorted(<stuff>,key=<stuff>), कुंजी के लिए एक लैम्ब्डा अभिव्यक्ति के साथ, सिवाय इसके कि यह एक स्ट्रिंग के रूप में रखता है।
फिर हम उस स्ट्रिंग के उपसर्गों की एक सूची तैयार करते हैं, len(z)लंबाई 1 से लंबाई 1. >अजगर के बराबर है <stuff>[<int>:]।
फिर, हम भिन्नात्मक स्थान द्वारा उपसर्गों की इस सूची को फिर से व्यवस्थित करते हैं, 0 बाएं किनारे पर और 1 दाएं होने के कारण, प्रश्न में देखे गए आयताकार लेआउट पर उपसर्ग के पहले चरित्र का। /NhNगिनती करता है कि उपसर्ग में पहला वर्ण कितनी बार उपसर्ग में होता है, जबकि /zhNस्ट्रिंग में एक छेद के रूप में उपसर्ग में पहले वर्ण की घटनाओं की संख्या देता है। यह प्रत्येक उपसर्ग को एक समूह में प्रत्येक वर्ण द्वारा अलग-अलग अंश के लिए, 1/kउस वर्ण की दाईं सबसे अधिक घटना से बाईं ओर के लिए निर्दिष्ट करता है k/k। इस संख्या द्वारा उपसर्ग सूची को फिर से व्यवस्थित करना लेआउट में उपयुक्त स्थिति देता है। पूर्व आदेश के उपयोग से संबंध टूट जाते हैं, जो पहले गणना के बाद वर्णमाला के अनुसार वांछित था।
अंत में, हमें प्रत्येक उपसर्ग स्ट्रिंग से पहले चरित्र को निकालने की जरूरत है, उन्हें एक स्ट्रिंग में संयोजित करें, और उन्हें प्रिंट करें। पहला अक्षर निकालना है hC। Cसूची में मैट्रिक्स ट्रांसपोज़ करता है, वास्तव zip(*x)में पायथन 3. hपरिणामी मैट्रिक्स की पहली पंक्ति को निकालता है। यह वास्तव में एकमात्र पंक्ति है, क्योंकि 1 वर्ण उपसर्ग की उपस्थिति किसी भी अन्य पूर्ण पंक्तियों को बनने से रोकती है। sइस टपल में पात्रों को एक ही तार में गाता है। मुद्रण निहित है।
परीक्षा:
$ pyth -c 'shCoc/NhN/zhNm>o_/zZSzdUz' <<< 'oroybgrbbyrorypoprr'
rorbyroprbyorrobypg
वृद्धिशील कार्यक्रम के टुकड़े पर oroybgrbbyrorypoprr:
Sub-Piece Output
Sz bbbgoooopprrrrrryyy
o_/zNSz rrrrrroooobbbyyyppg (uses N because o uses N on first use.)
m>o_/zNSzdUz ['rrrrrroooobbbyyyppg', 'rrrrroooobbbyyyppg', 'rrrroooobbbyyyppg', 'rrroooobbbyyyppg', 'rroooobbbyyyppg', 'roooobbbyyyppg', 'oooobbbyyyppg', 'ooobbbyyyppg', 'oobbbyyyppg', 'obbbyyyppg', 'bbbyyyppg', 'bbyyyppg', 'byyyppg', 'yyyppg', 'yyppg', 'yppg', 'ppg', 'pg', 'g']
oc/NhN/zhNm>o_/zZSzdUz ['roooobbbyyyppg', 'obbbyyyppg', 'rroooobbbyyyppg', 'byyyppg', 'yppg', 'rrroooobbbyyyppg', 'oobbbyyyppg', 'pg', 'rrrroooobbbyyyppg', 'bbyyyppg', 'yyppg', 'ooobbbyyyppg', 'rrrrroooobbbyyyppg', 'rrrrrroooobbbyyyppg', 'oooobbbyyyppg', 'bbbyyyppg', 'yyyppg', 'ppg', 'g']
Coc/NhN/zhNm>o_/zZSzdUz [('r', 'o', 'r', 'b', 'y', 'r', 'o', 'p', 'r', 'b', 'y', 'o', 'r', 'r', 'o', 'b', 'y', 'p', 'g')]
shCoc/NhN/zhNm>o_/zZSzdUz rorbyroprbyorrobypg
पुराना उत्तर:
ssCm*+t*u*G/zHS{-zd1]kd/zdo_/zNS{z
यह प्रोग्राम एक निश्चित सबलिस्ट को दोहराने के लिए कितनी बार गणना करके काम करता है। उप-सूची जैसा दिखता है ['', '', '', '', ... , 'r']। इस उप-सूची की कुल लंबाई अन्य कैंडीज की घटनाओं की संख्या का उत्पाद है, जो है u*G/zHS{-zd1। पूर्ण स्ट्रिंग को खाली स्ट्रिंग की सूची का निर्माण करके बनाया गया है ]k, जो कि कई बार, फिर हटाने और तत्व के साथ tऔर कैंडी नाम को अंत तक जोड़ते हैं +d।
फिर, इस उप-सूची को कई बार दोहराया जाता है क्योंकि इनपुट में कैंडी पाई जाती है /zd, यह सुनिश्चित करते हुए कि प्रत्येक कैंडी की सूची समान लंबाई की है।
अब, इस फ़ंक्शन के साथ उचित क्रमबद्ध क्रम ( o_/zNS{z) में सभी अद्वितीय कैंडीज पर मैप किया गया है , हमारे पास प्रश्न कथन में एक के समान एक आयत है, लेकिन अवधि के बजाय खाली तार के साथ। मैट्रिक्स हस्तांतरण ( C) दो योगों ( ss) के बाद अंतिम स्ट्रिंग देता है।
सत्यापन:
$ pyth programs/candy.pyth <<< 'oroybgrbbyrorypoprr'
rorbyroprbyorrobypg