ऐलिस की पहली कोड की समीक्षा

Question

ऐलिस एक कंपनी में इंटर्न है जो क्लाइंट-साइड और सर्वर-साइड विकास दोनों के लिए एक प्राथमिक भाषा के रूप में ब्रेनफक का उपयोग करता है। ऐलिस ने सिर्फ अपना पहला कोड लिखा है और वह थोड़ा घबरा गई है क्योंकि वह अपने पहले कोड की समीक्षा के लिए तैयार हो रही है।

ऐलिस अपने कोड को अच्छी तरह से स्वरूपित करना और अच्छी दिखना चाहती है, लेकिन उसके पास 328 पृष्ठों की कंपनी कोड स्टाइल गाइड पढ़ने का समय नहीं है, इसलिए उसने इसे एक आदर्श वर्ग के रूप में प्रारूपित करने का फैसला किया । काश, कोड की लंबाई एक वर्ग बनाने के लिए अपर्याप्त हो सकती है, इसलिए उसने बीच में एक आयताकार अंतर छोड़ने का फैसला किया । अंतराल पूरी तरह से केंद्रित होना चाहिए और जितना संभव हो सके वर्ग के करीब होना चाहिए ।

उदाहरण

++++++         +++++         +++++         +++++         +++++         +++++
++++++         +++++         +++++         +  ++         ++ ++         +++++
++++++         ++ ++         +   +         +  ++         +   +
++++++         +++++         +++++         +++++         ++ ++         +++++
++++++         +++++         +++++         +++++         +++++         +++++

Perfect         OK         Acceptable   Unacceptable    No way!        Nope.

ऐलिस की मदद करने के लिए एक कार्यक्रम या एक समारोह लिखें। ऐलिस कोड को एक इनपुट स्ट्रिंग के रूप में देखते हुए, आउटपुट ठीक से स्वरूपित कोड के रूप में यदि संभव हो तो नीचे वर्णित है। यदि स्वरूपण असंभव है, तो आउटपुट इमोजी रोता है :~(।

यह कोड-गोल्फ है इसलिए उत्तर बाइट्स में कम बाइट्स के साथ गोल किए जाते हैं।

प्रतिबन्ध

1. आपके प्रोग्राम या फ़ंक्शन को इनपुट के रूप में एक स्ट्रिंग लेना चाहिए और पाठ की एक या अधिक पंक्तियों को आउटपुट करना चाहिए (या यदि आप किसी फ़ंक्शन को लागू करते हैं, तो बहु-पंक्ति स्ट्रिंग या स्ट्रिंग के सरणी लौटाएं)।
2. इनपुट स्ट्रिंग में व्हॉट्सएप सहित कोई भी ASCII वर्ण हो सकते हैं।
3. इनपुट में सभी व्हाट्सएप को नजरअंदाज करना चाहिए। उन्हें कोड की लंबाई की गणना नहीं करनी चाहिए और उनका उपयोग आउटपुट में नहीं किया जाना चाहिए।
4. इनपुट स्ट्रिंग में कम से कम एक गैर-व्हाट्सएप चरित्र होता है।
5. प्रारूपित कोड में उसी गैर-व्हाट्सएप वर्ण के समान होना चाहिए जैसा इनपुट कोड में होता है।
6. स्वरूपित कोड एक पूर्ण वर्ग होना चाहिए, अर्थात सभी लाइनों की लंबाई समान होनी चाहिए, और लाइनों की संख्या लाइनों की लंबाई के बराबर होनी चाहिए।
7. प्रारूपित कोड में बीच में अंतराल हो सकता है।
8. अंतराल में केवल अंतरिक्ष वर्ण (ASCII कोड 32) का उपयोग किया जा सकता है।
9. गैप (यदि मौजूद है) आयताकार होना चाहिए।
10. स्वरूपित कोड की प्रत्येक पंक्ति में कम से कम एक गैर-व्हाट्सएप चरित्र होना चाहिए, अर्थात गैप की चौड़ाई वर्ग की चौड़ाई से कम होनी चाहिए (अंतर 5x1 5x5 वर्ग के लिए अस्वीकार्य है)।
11. गैप क्षैतिज होना चाहिए, यानी गैप की चौड़ाई गैप ऊंचाई से अधिक या बराबर होनी चाहिए।
12. गैप पूरी तरह से केंद्रित होना चाहिए।
13. नतीजतन अंतराल चौड़ाई और ऊंचाई समता वर्ग चौड़ाई समता के समान होनी चाहिए (उदाहरण के लिए 5x5 वर्ग अंतराल 1x1, 3x1 या 3x3 हो सकती है)।
14. यदि संभव हो तो, आउटपुट स्क्वायर बिना किसी अंतराल के।
15. कई समाधानों के मामले में, वर्ग के निकटतम अंतर वाले एक को चुनें, यानी गैप चौड़ाई और गैप ऊंचाई के बीच अंतर न्यूनतम है (उदाहरण के लिए: गैप 10x10 8x6 से अधिक बेहतर है, और 8x6 6x2 से अधिक बेहतर है)।
16. यदि अभी भी एक टाई है, तो न्यूनतम अंतराल क्षेत्र के साथ समाधान चुनें (उदाहरण के लिए 2x2 4x4 की तुलना में अधिक बेहतर है)।
17. यदि यह कोड को प्रारूपित करना असंभव है, तो आउटपुट :~(।
18. अंतिम पंक्ति के बाद की नई लाइन वैकल्पिक है।
19. [नया] आप सुरक्षित रूप से मान सकते हैं कि ३३ से नीचे के कोड वाला कोई भी वर्ण सफेद-स्थान है। मुझे उम्मीद है कि यह गोल्फ के लिए आपकी मदद करेगा।

टेस्ट

Input           Output      Code length     Comment

+++++++++       +++                   9     Alice is lucky, 
                +++                         her code perfectly fits a square. 
                +++


++++++++        +++                   8     Though code length isn't enough for a square, 
                + +                         a small gap fixes it.
                +++


++++++          :~(                   6     No luck, code cannot be formatted.


Hello,          Hell                 12     Input may contain any ASCII characters, 
World!          o  ,                        but whitespaces in input should be ignored.
                W  o
                rld!


+++++ + +++++   +++++                22     Gap is not required to be a square, 
+++++ + +++++   +++++                       it can be a rectangle.
                +   +
                +++++
                +++++

+++ + +++       ++++++++             28     There exists another solution: 
+++ + +++       +      +                    6x6 square with 4x2 gap, 
+++ + +++       +      +                    but in Alice's opinion square gap 
+++ + +++       +      +                    makes code more readable.
                +      +
                +      +
                +      +
                ++++++++

मुश्किल परीक्षण

This must be    Thism                24     7x7 with 5x5 gap looks good,
5x5 with 1x1    ustbe                       but 5x5 with 1x1 gap is better,
gap.            5x 5w                       because gap area is smaller.
                ith1x
                1gap.

+++ +++ +++     :~(                  18     In case you tried 5x5 square
+++ +++ +++                                 with 7x1 gap ;)

साधन

अंतरिक्ष को बचाने के लिए आप tio.run पर नमूना कोड और अतिरिक्त परीक्षण के मामले पा सकते हैं

[नया] आप १०० अक्षरों तक के इनपुट के लिए स्वीकृत समाधानों की तालिका देख सकते हैं । मैंने चौड़ाई और ऊँचाई की अदला-बदली की, क्योंकि यह अधिक इंट्रूव्यू लगता है।

से प्रेरित: पाठ का एक वर्ग

परिवर्तन

• नमूना कोड में 2 परीक्षण, फिक्स्ड बग जोड़ा गया।

• 100 तक के समाधानों की तालिका को जोड़ा गया, सफेद-स्थान स्पष्टीकरण जोड़ा गया।

Comments

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

— जोनाथन एलन

@JonathanAllan, इससे भी बेहतर यह गारंटी होगी कि फ़ॉर्मेटिंग हमेशा संभव है। Boo-urns इनपुट सत्यापन के लिए!

— झबरा

@ जोनाथन एलन, कोई भी आउटपुट बहुत व्यापक है और कमियों के प्रति संवेदनशील हो सकता है। मैंने किसी भी झूठे मूल्यों का उपयोग करने देने के बारे में सोचा, लेकिन यह विभिन्न भाषाओं के बीच असंगत बना देगा। मैंने खाली स्ट्रिंग का उपयोग करने पर भी विचार किया, लेकिन यह चल रहे मामलों को कम दृश्य बनाता है। मैंने "एरर" जैसे कुछ अन्य संदेशों के बारे में भी सोचा, लेकिन दुनिया भर में ब्रेनफक डेवलपर्स का समर्थन करने के लिए इसे और भी छोटा बनाने का फैसला किया।

— डेनियल टुटुबलिन

@ शैगी, यह केवल इनपुट सत्यापन नहीं है। यह पता लगाने के लिए कि कोई हल नहीं है पहेली का महत्वपूर्ण हिस्सा है: आपको यह पता लगाना है कि खोज कब बंद करनी है।

— डेनियल तूतुबलिन

@DaniilTutubalin यह आश्वस्त करने के लिए बहुत ही आम है कि यहां केवल कुछ इनपुट दिए जाएंगे। ऐसे "अमान्य" इनपुट पर किसी भी आउटपुट की अनुमति देना भी एक सामान्य दृष्टिकोण है, और बॉयलरप्लेट कोड से बचा जाता है जिसका चुनौती के मूल से कोई लेना-देना नहीं है। यदि आप वास्तव में ऐसे मामलों में आउटपुट के रूप में कुछ unvarying चाहते हैं तो मैं स्वयं इनपुट का सुझाव दूंगा। मैं सुझाव नहीं दे रहा हूँ कि आप इसे अभी बदल दें ... लेकिन यह भी एक बहुत अच्छी चुनौती है!

— जोनाथन एलन

Answer 1

सी (जीसीसी) , 354 बाइट्स

h,i,j,k,l,m;g,v,w,d;f(char*s){for(i=l=0;s[i];l+=!isspace(s[i++]));d=g=l;for(i=0;i++<l;)if(h=i*i-l)for(j=0;j<i-++j;h>0&h%k<1&k<=m&m<i&m+~k&&m-k<g|m==k+g&(d-2*v)*(d-2*w)>h?w=(i-m)/2,v=j,g=m-k,d=i:j)k=i-2*j,m=h/k;else g=0,v=w=d=i;if(g-l)for(i=j=1;*s;j+=!i++,k=0,i%=d+1)for(putchar(i?v>=j|j>d-v|w>=i|i>d-w?k=1,*s:32:10);k;k*=isspace(*++s));else puts(":~(");}

इसे ऑनलाइन आज़माएं!

Comments

मुझे लगता है कि एक टैब "व्हाइट-स्पेस" है, हालांकि मैंने इस पर स्पष्टीकरण मांगा कि वास्तव में क्या मायने रखता है।

— जोनाथन एलन

मैंने पोस्ट अपडेट की है। आप के isspace(x)साथ बदल सकते हैं x<33।

— डेनियल टुटुबलिन

349

— सीलिंगकॉट

Answer 2

जावास्क्रिप्ट (ईएस 6),  284 ... 274  270 बाइट्स

@ बग्घी के लिए 4 बाइट्स को सहेजा गया

स्ट्रिंग्स की एक सरणी देता है।

s=>(s=s.replace(/\s/g,''),n=s.length,o=[':~('],W=d=g=(x,w=0,h=p=0)=>4*~-x>n?o:h>w?++w>x-2?g(-~x):g(x,w):g(x,w,h+1,o=n-x*x+w*h|(w^x|h^x)&!!(w|h)|w-h>d|w-h==d&w>W?o:[...Array(x)].map((_,Y,a)=>a.map((_,X)=>2*X>=x-w&2*X<x+w&2*Y>=x-h&2*Y<x+h?' ':s[p++]).join``,d=w-h,W=w)))``

इसे ऑनलाइन आज़माएं!

Comments

बहुत बढ़िया! हालांकि इस परीक्षण की कोशिश करें: This must be 5x5 with 1x1 gap.(24 अक्षर)

— डेनियल टूटूबलिन

@DaniilTutubalin यही कारण है कि मैंने अपनी प्रारंभिक पोस्ट को हटा दिया (और इस तरह के एक परीक्षण मामले का सुझाव दिया), लेकिन यह अब सही ढंग से समर्थित है।

— अरनुलद

[\s\n]बस नहीं हो सकता \s?

— झबरा

++w>x-2w++>=x-2w++>=x$42$\s

Answer 3

स्टैक्स , 80 बाइट्स

ö╦Çc▀╕╡ëé╓]µiÖ9♪`W|╣▐↑╖D┘↕♫╗╔äƒ■úφ■U`ÿ⌠%é┴☼vAú)☺@ı◄¬¶¢(îÉ┼6⌠D~♀└lfæA.I@º╤∟òîü╦(

इसे चलाएं और डीबग करें

यह कैसे काम करता है?

• आयताकार कटआउट के साथ सभी वर्गों पर विचार करें।
• प्रोग्राम आकार फ़िल्टर करें जो सही आकार नहीं हैं।
• प्रोग्राम आकार फ़िल्टर करें जिसमें मिलान समता नहीं है।
• प्रोग्राम आकृतियों को फ़िल्टर करें जहां कटआउट वर्ग के लिए बहुत बड़ा है।
• यदि कोई नहीं पाया जाता है, तो आउटपुट विफलता और छोड़ दिया जाता है।
• उस आकृति को ढूंढें जो कटआउट की "आयताकारता" को कम करता है, फिर कटआउट आकार के द्वारा।
• प्रोग्राम इनपुट में संबंधित वर्ण के साथ प्रोग्राम आकार में प्रत्येक वर्ण को बदलें।

अनपैक्ड, अनगोल्डेड और टिप्पणी की गई यह इस तरह दिखता है।

                input e.g. "big socks"
L$j$            remove whitespace from input e.g. "bigsocks"
cr{~F           copy push each remaining character to input stack in reverse order
%c              get length L of flattened input and copy e.g. 8
^r3:$           create triples [a,b,c] in range 0..n e.g. [[0,0,0], [0,0,1], ... [8,8,8]]
{E*NsJ+n=f      filter triples: require a*a-b*c=L e.g. [[3,1,1], [4,1,8], ...]
{ET>f           filter triples: a>b and a>c e.g. [[3,1,1]]
{{2%m:u_0#+f    filter triples: a%2=b%2=c%2 or b*c=0 e.g. [[3,1,1]]
":~("s|c        if there are no triples, output ":~(" and terminate
{D:s_D:*\oh     sort by [abs(b-c),b*c]; keep the first e.g. [3,1,1]
X               store the chosen triple in the X register
E               explode onto stack e.g. 3, 1, 1
z)]*            using last two values, make a rectangle of zeroes e.g. 3, [[0]]
~               this will be the cutout, push it to the input stack
c'X*]*          make a square of "X" e.g. ["XXX", "XXX", "XXX"]
xEd-h           given the dimensions in x register, calculate the centered cutout coordinates
xEsd-h          e.g. ["XXX", "XXX", "XXX"], 1, 1
,||             embed the cutout grid at the specified coordinates e.g. ["XXX", "X X", "XXX"]
m'X{,]}R        for each line, regex replace "X" with a character from the input stack

इसको चलाओ

Comments

क्या आप कृपया अनपैक्ड संस्करण भी प्रदान कर सकते हैं?

— डेनियल तूतुबलिन

@DaniilTutubalin मैंने एक स्पष्टीकरण जोड़ा है।

— पुनरावर्ती

धन्यवाद! बहुत बढ़िया!

— डेनियल तूतुबलिन

Answer 4

चारकोल , 120 बाइट्स

≔Ｅ⮌⪫⪪Ｓ ωιθ≔⁰ηＦ⊕Ｌθ¿⁼Ｌθ×ιι«≔ιη≔ιζ≔ιε»Ｆ⊘ιＦ⊕κＦ∧⁼Ｌθ⁻×ιι×⁻ι⊗⊕κ⁻ι⊗⊕λ∨¬η›⁻ζε⁻κλ«≔ιη≔⊕κζ≔⊕λε»¿η«ＵＯη#ＪεζＦ›η⊗ζＵＯ⁻η⊗ε⁻η⊗ζψＵＭＫＡ⊟θ»:~(

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔Ｅ⮌⪫⪪Ｓ ωιθ

इनपुट से रिक्त स्थान को स्ट्रिप करें, फिर इसे रिवर्स करें और वर्णों में विभाजित करें, ताकि हम बाद में पात्रों पर अधिक आसानी से लूप कर सकें।

≔⁰η

शून्य के आकार के साथ प्रारंभ करें, कोई परिणाम नहीं मिला (अभी तक) का संकेत।

Ｆ⊕Ｌθ

स्ट्रिंग की लंबाई तक सभी साइड लंबाई की जाँच करें। (एक डिवीजन को फेंकना बेशक कोड को तेज़ कर देगा।)

¿⁼Ｌθ×ιι«≔ιη≔ιζ≔ιε»

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

Ｆ⊘ιＦ⊕κ

संभावित सीमा ऊँचाई और चौड़ाई पर लूप (सीमा चौड़ाई सीमा ऊँचाई से अधिक नहीं है, जिससे अंतराल की ऊँचाई अंतराल की चौड़ाई से अधिक नहीं है।)

Ｆ∧⁼Ｌθ⁻×ιι×⁻ι⊗⊕κ⁻ι⊗⊕λ∨¬η›⁻ζε⁻κλ«≔ιη≔⊕κζ≔⊕λε»

यदि सीमा का आकार वांछित लंबाई है और हमारे पास अभी तक कोई समाधान नहीं है या यह इस वर्ग के समान नहीं है, तो इस वर्ग और सीमा आकारों के साथ समाधान को अपडेट करें।

¿η«

अगर हमारे पास कोई हल है ...

ＵＯη#

दिए गए चौकोर आकार के मनमाने चरित्र का एक आयत बनाएँ।

ＪεζＦ›η⊗ζＵＯ⁻η⊗ε⁻η⊗ζψ

यदि सीमा एक अंतर छोड़ने के लिए काफी छोटी है तो अंतराल को मिटा दें। (ड्रॉइंग कमांड नकारात्मक मानों के लिए ऊपर और बाईं ओर खींचेगा और शून्य मान बिल्कुल पसंद नहीं करता है।)

ＵＭＫＡ⊟θ

सभी (शेष) वर्णों को इनपुट से वर्णों से बदलें।

»:~(

अन्यथा उत्पादन :~(।

Answer 5

जेली , 91 85 बाइट्स

ÆDżU$<Ạa;ḂEɗʋƇṢƑƇ;€€
ḟ⁶ḟ⁷;©⁶L’²<¥Ðḟ²_ç;,`Wɗ¹?⁸ʋ€$Ẏạ/ÞḢµIH+""Rp"/ḟ@/ŒṬ€ĖP€Sị®Yµ“:~(”¹?

इसे ऑनलाइन आज़माएं!

एक मौद्रिक लिंक जो इनपुट स्ट्रिंग को अपने तर्क के रूप में लेता है और एक स्ट्रिंग को स्वरूपित आउटपुट या के साथ वापस करता है :~(।

Answer 6

पायथन 2, 287 281 279 बाइट्स

c=list("".join(input().split()))
l=len(c)
p=[]
for q in range(l*l):x=q%l;y=q/l;s=(l+x*y)**.5;p+=[(abs(x-y)/2,int(s),-x)]*(s%1==0)*(x<s-1>y>=s%2==x%2==y%2or x<1)
if p:d,s,x=min(p);b=(s+x)/2;Y=0;exec"c[b:b]=' '*-x*(b+d<=Y<s-b-d);print''.join(c[:s]);c=c[s:];Y+=1;"*s
else:print':~('

इसे ऑनलाइन आज़माएं!

एक समाधान चुनने और इसे प्रिंट करने दोनों के लिए समान मूल्यों का उपयोग करके पायथन की लेक्सोग्राफ़िक सूची की तुलना करता है। मुझे पूरा यकीन है कि 10 4 2 या बाइट्स अभी भी मुंडा जा सकता है।

व्याख्या

c=list("".join(input().split()))
l=len(c)
p=[]

व्हॉट्सएप को व्हाट्सएप से अलग करके और ""उसके साथ जुड़कर व्हाट्सएप को हटा दें , फिर बाद के लिए इनपुट को सूची में परिवर्तित करें। lवास्तविक कोड की लंबाई और pमान्य संभावनाओं की सूची के लिए भी प्रारंभिक ।

for q in range(l*l):x=q%l;y=q/l;s=(l+x*y)**.5;

से खाई आकार के सभी संभावनाओं के माध्यम से लूप 0*0करने के लिए l*l। lकोड चार्ट और x*yरिक्त स्थान के साथ वर्ग की बढ़त लंबाई की गणना करें s।

p+=[(abs(x-y)/2,int(s),-x)]*(s%1==0)*(x<s-1>y>=s%2==x%2==y%2or x<1)

जाँच करें कि क्या निम्न स्थितियाँ मेल खाती हैं:

• s % 1 == 0, यानी एक आदर्श वर्ग का निर्माण होगा
• x < s-1 > y, यानी xऔर yअधिक से अधिक s-2और वर्ग के अंदर फिट हैं
• s % 2 == x % 2 == y % 2, यानी दोनों xऔर yकिनारे की समानता से मेल खाते हैं और इसे केंद्रित किया जा सकता है
• लेकिन x < 1, अगर , यानी x == 0, लेकिन सभी वर्ग की आवश्यकता को अनदेखा करें

यदि परिस्थितियाँ मेल खाती हैं, pतो इष्टतम को खोजने के लिए एक टपल में निम्नलिखित आइटम जोड़ें :

• abs(x-y)/2; पहले की न्यूनतम अंतर मिल xऔर yसबसे वर्ग के अंतर को प्राप्त करने के लिए। यह हमेशा होता है इसलिए हम 2 से भाग देते हैं।
• int(s); अगली न्यूनतम लंबाई ज्ञात करें। चूंकि sएक पूर्णांक है और अंतराल क्षेत्र के रूप में बढ़ता है x*y, इसलिए यह अंतराल क्षेत्र द्वारा भिन्न होता है।
• -x; अगले क्षैतिज अंतराल पसंद करने के लिए अधिकतम चौड़ाई पाते हैं। यह क्षेत्र के कारण आता है कि इसे कैसे विकसित किया गया था, लेकिन यह क्षेत्र उसी के लिए समान है x*yऔर y*xइसलिए यह काम करता है।

if p:d,s,x=min(p);b=(s+x)/2;Y=0

अगर हमें कोई मान्य लेआउट मिला, तो ऊपर बताए अनुसार इष्टतम को खोजें। क्षैतिज सीमा की गणना करें bऔर लाइन नंबर Yको 0 से प्रारंभ करें ।

exec"c[b:b]=' '*-x*(b+d<=Y<s-b-d);print''.join(c[:s]);c=c[s:];Y+=1;"*s

यदि पंक्ति संख्या Yगैप के अंदर है (ऊर्ध्वाधर सीमा है b+d, dटपल से), तो क्षैतिज बॉर्डर के बाद रिक्त स्थान की चौड़ाई का मान जोड़ें c। (संशोधन cइसीलिए है कि हमें इसकी एक सूची बनाने की आवश्यकता है।) फिर वर्ग की एक रेखा को प्रिंट करें और इसे हटा दें c। दोहराएँ sबार, लाइन नंबर बढ़ाने।

else:print':~('

यदि कोई लेआउट नहीं मिला, तो विफल रहें।

Comments

बहुत बढ़िया! काश, यह मल्टीलाइन इनपुट के साथ अच्छी तरह से काम नहीं करता। यह भी लगता है कि यह आयताकार अंतराल का समर्थन नहीं करता है (लंबाई 22 के साथ परीक्षण देखें)।

— डेनियल टुटुबलिन

@DaniilTutubalin आपको पायथन स्ट्रिंग के रूप में इनपुट की आपूर्ति करने की आवश्यकता है, बहुपरत का शाब्दिक "some\ntext"रूप से सीमांकक होगा। ( input()पायथन कोड के रूप में इनपुट की एक पंक्ति का मूल्यांकन करता है।) यदि यह स्वीकार्य नहीं है, तो कृपया मुझे बताएं। लंबाई 22 मेरे लिए भी काम करती है।

— पुरकाकूदरी

ouch, क्षमा करें। संभवतः मैंने इनपुट में कुछ गलत किया है।

— डेनियल टुटुबलिन

Answer 7

पायथ , 99 98 बाइट्स

#JscQ)=QshKh|oaFtNSf!|%hT1&eT|t{%R2TgeStThT+L@+lJ*Fd2^UJ2
":~("Am/-Qd2tKW=W}~hZrG-QGJj*eKdcJ]H<~>J

इसे ऑनलाइन आज़माएं!

यह मेरे पाइथन उत्तर के समान एल्गोरिथ्म का उपयोग करता है, लेकिन पाइथ में छोटे होने के लिए कई विवरणों को महत्वपूर्ण रूप से बदल दिया जाता है।

पाइथ यहां अपनी उम्र दिखाता है, क्योंकि यह उम्र में अद्यतन नहीं हुआ है और केवल मुद्रण योग्य ASCII वर्ण (कोड के लिए, डेटा नहीं) का उपयोग करता है, बहुत सारे स्थान को बर्बाद कर रहा है।

दिलचस्प बात यह है कि अगर स्टैक्स के रूप में पायथ ने एक ही तरह की बेस-256 पैकिंग का इस्तेमाल किया है, तो यह प्रोग्राम log98 लॉग ₂₅₆ 95tes = 81 बाइट्स लंबा हो सकता है, ठीक स्टेक्स (80 बाइट्स) और जेली (85 बाइट्स) के बगल में। मुझे लगता है कि यह अच्छी तरह से दिखाता है कि कैसे गोल्फ की भाषाएं उनके बेहद अलग प्रतिमानों के साथ भी हैं।

स्पष्टीकरण (केवल कोड से थोड़ा कम अपठनीय)

# एक में सब कुछ लपेटता है while True: संदेश और संदेश को दबा देता है और त्रुटि पर छोड़ देता है।

JscQ) cव्हाट्सप पर इनपुट ( Q),s भागों को एक साथ ums और परिणाम में बचाता है J।

^UJ2सूचकांकों की सूची बनाता है ( U) की Jऔर उसके लेता 2nd कार्तीय शक्ति ( ^सभी जोड़ों में जिसके परिणामस्वरूप), [h,w]के साथ 0<=h<len(J)और0<=w<len(J) ।

+L@+lJ*Fd: सभी के लिए ( L) इस तरह के जोड़े d, जोड़ता है ( +) वर्गमूल ( @… 2) का ( प्लस का lउत्कीर्ण ) ( ) जोड़ी का उत्पाद ( )J+*Fd ) जोड़ी के बाईं तरफ, एक त्रिक बनाने [side length, gap height, gap width]।

f!|%hT1&eT|t{%R2TgeStThT: fT जहां तीनों के लिए ilter

• न तो ( !|):
  • साइड लंबाई ( hT) मोडुलो 1 (% … 1) नॉनजरो है
  • दोनों (& ):
    • अंतर ऊंचाई (eT हाइट ) नॉनजरो है
    • दोनों में से कोई (| ):
      • तीन प्रतियों में प्रत्येक संख्या ( R) मोडुलो 2 ( %… 2), डुप्लिकेट के साथ ( {) और पहला अनोखा (t ) हटाए गए के नॉनम खाली है
      • बड़ा ( eS) की खाई ऊंचाई खाई चौड़ाई (की tT) है gओर लंबाई से reater या बराबर ( hT)

Sत्रिकोणीय को लेक्सोग्राफिक रूप से (साइड की लम्बाई से, फिर गैप ऊँचाई से) सॉर्ट करें। oaFtNफिर अंतर ऊंचाई और अंतर चौड़ाई के बीच के अंतर oसे तीन aगुना अंतर करता है (tN ) के ।

इस बिंदु पर, अगर हमारे पास कोई वैध समाधान नहीं है, तो |इसके दूसरे तर्क का मूल्यांकन करता है \n":~(", जो प्रिंट और रिटर्न करता है :~(। hइष्टतम समाधान (या ":"यदि कोई नहीं) लेता है और इसे इसमें सहेजा जाता है K। फिर hइसकी साइड की लंबाई (या ":"यदि कोई नहीं) लेता है , तो sइसे पूर्णांक में डाल देता है (या विफल हो जाता है और यदि कोई नहीं छोड़ता है) और इसे सहेज लिया जाता है (= ) में है Q।

साइड लंबाई ( ) और 2 ( … ) द्वारा विभाजित परिणाम से प्रत्येक ( m) [gap height, gap width]( tK) तब घटाया जाता है । परिणाम और करने के लिए ssign कर रहे हैं-Q/2AGH ।

अंत में, हम एक Wहाइल लूप दर्ज करते हैं । Z0 से शुरू होता है और प्रत्येक पुनरावृत्ति हम इसे बढ़ाते हैं लेकिन पुराने मूल्य ( ~hZ, Z++सी में सोचते हैं ) का उपयोग करते हैं।

• अगर ( W) पुराना मान ( {) rएनज Gटू (साइड लेंथ - G) ( -QG), असाइन ( =) टू Jद निम्‍न: cहॉप Jऑन पोजीशन ( ]) है Hऔर jहफ़्फ़्स विथ गैप चौड़ाई eKटाइम ( *) स्पेसd )। यदि मान सीमा में नहीं था, तो वापस लौटें J। यदि यह परिणाम खाली है, तो लूप बंद करें।
• >पहले Qवर्णों को निकालें Jऔर ( ~) परिणाम को असाइन करें ( ) J। के पुराने मान से J, <पहले Qअक्षर लें और उन्हें प्रिंट करें।

अंत में, #लूप फिर से शुरू होता है, त्रुटियों और क्विट करता है क्योंकि एक नंबर युक्त के cQ)साथ Qअमान्य है।

Comments

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

— डेनियल टुटुबलिन

@DaniilTutubalin भले ही तुलना आमतौर पर की जाती हो, फिर भी एक और गोल्फलैंग को हराना अच्छा लगता है;)

— PurkkaKoodari

Answer 8

05AB1E , 95 89 बाइट्स

… 
    мDg©Ý3ãʒćnsP-®Q}ʒć‹P}ʒÈËyß_~}Dg_i…:~(ëΣ¦DÆÄsP‚}н©¤_iнë¬Uć᤮Ås<иs;R`X*+šXnª£®θð×ýX}ô»

यहाँ कुछ बाइट्स और निश्चित रूप से गोल्फ हो सकता है।

कार्यक्रम के पहले तीन चरण @recursive के स्टैक्स उत्तर से प्रेरित हैं , इसलिए उसे सुनिश्चित करें!

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

चरण 1: सभी सफेद रिक्त स्थान निकालें:

… 
                   # Push string " \n\t"
    м              # And remove those from the (implicit) input-string

$[a,b,c]$$a$$a×a$$b×c$$[0,a]$

• $a^2-b×c=L$$L$
• $(a\gt b)\text{ and }(a\gt c)$
• $(a\pmod2=b\pmod2=c\pmod2)\text{ or }(min(a,b)\neq0)$

$L=28$[[6,2,4],[6,4,2],[8,6,6]]

Dg                 # Get the length of this string (without popping by duplicating first)
  ©                # Store this length in variable `®` (without popping)
   Ý               # Create a list in the range [0,®]
    3ã             # Create all possible triplets by repeating the cartesian product 3 times
ʒ                  # Filter these triplets by:
 ć                 #  Extract head; pop and push remainder-list and head to the stack
  n                #  Square the head
   sP-             #  Take the product of the remainder, and subtract it from the squared head
      ®Q           #  And check if it's equal to the string length in variable `®`
}ʒ                 # Filter the remaining triplets further by:
  ć‹P              #  Where the first integer is larger than the other two
}ʒ      }          # And filter it a third time by:
  ÈË               #  Where all three are either odd or even
       ~           #  Or
    yß_            #  It does not contain any 0s

चरण 3: जांचें कि क्या हमारे पास अभी भी कोई ट्रिपल बचा है। यदि नहीं, तो आउटपुट ":~("; यदि हम करते हैं, तो निर्धारित करें कि किसको छाँटकर उपयोग करना है और केवल पहला छोड़ना है। हम इसे ट्यूपल्स आधार पर सॉर्ट करते हैं।$(abs(b-c),b×c)$ ।

उदाहरण के लिए: त्रिगुणों [[6,2,4],[6,4,2],[8,6,6]]को क्रमबद्ध किया जाएगा [[8,6,6],[6,2,4],[6,4,2]], जिसके बाद केवल [8,6,6]अवशेष रह जाएंगे ।

Dg_i               # If this completely filtered list is now empty:
    …:~(           #  Push string ":~("
ë                  # Else:
 Σ                 #  Sort the triplets by:
  ¦                #   Remove the first character
   DÆÄ             #   Get the absolute difference between the remaining two integers
   sP‚             #   And pair it with the product of the remaining two integers
      }н           #  After we're done sorting: only leave the first triplet

चरण 4: रिक्त स्थान सम्मिलित करने के लिए हमें स्ट्रिंग कैसे विभाजित करनी चाहिए, इस पर एक सूची बनाएं। यह इस प्रकार किया जाता है:

$[a,b,c]$

• $\frac{a-b}{2}×a + \frac{a-c}{2}$
• $b-1$${a-c}$
• $a^2$

उदाहरण के लिए: [7,3,5]सूची में परिणाम ट्रिपल होगा [15,2,2,35]।

©                  #  Store this triplet in variable `®` (without popping)
 ¤_i               #  If the last value is 0 (which means the string is a square without gap):
    н              #   Simply keep the first value of the triplet
   ë               #  Else:
    ¬U             #   Store the first value in variable `X` (without popping)
      ć            #   Extract the first value; pop and push remainder-list and head to the stack
       α           #   Get the absolute difference of this head with the other two values
        ¤          #   Push the last value (without popping the pair itself)
         ®Ås<и     #   And repeat it the middle element or `®` minus 1 amount of times
       s           #   Swap to get the difference pair again
        ;          #   Halve both values
         R`        #   Push them reversed to the stack
           X*      #   Multiple the first value by `X`
             +     #   And then add it to the second value
              š    #   Prepend this in front of the repeated list
               Xnª #   And also append the square of `X`

$c$$c$

"Alongtesttoseeifitworksasintended."[15,2,2,35]["Alongtesttoseei","fi","tw","orksasintended."]$c=5$"Alongtesttoseei fi tw orksasintended."$a=7$["Alongte","sttosee","i f","i t","w o","rksasin","tended."]

    £              #   Then split the string into parts based on this list
     ®θð×          #   Push a string consisting of the last value of `®` amount of spaces
         ý         #   Join the list of substrings by this
          X        #   Push variable `X`
   }ô              #  After the if-else: split the string into parts of that size
     »             #  And then join these by newlines
                   # (after which the top of the stack is output implicitly as result)