एक यादृच्छिक ASCII कला रजाई ड्रा

Question

इस चुनौती के लिए, ASCII कला रजाई एक अक्षर के 24 खंडों वाली चौड़ी और 18 पंक्तियों वाली एक खंड होगी, जिसमें पात्र =-<>/\रजाई की तरह पैटर्न होते हैं जो क्षैतिज और लंबवत सममित होते हैं।

उदाहरण रजाई:

========================
------------------------
//\\//\\\//\/\\///\\//\\
<<><<>>>>><<>><<<<<>><>>
/\\/\\\\/\/\/\/\////\//\
------------------------
/\/////\\///\\\//\\\\\/\
\///\/\/\\\\////\/\/\\\/
\///\/\/\\\\////\/\/\\\/
/\\\/\/\////\\\\/\/\///\
/\\\/\/\////\\\\/\/\///\
\/\\\\\//\\\///\\/////\/
------------------------
\//\////\/\/\/\/\\\\/\\/
<<><<>>>>><<>><<<<<>><>>
\\//\\///\\/\//\\\//\\//
------------------------
========================

सभी रजाई का एक ही रूप है:

• वे हमेशा 18 से 24 के होते हैं।
• शीर्ष रेखा (रेखा 1) और निचला रेखा (रेखा 18) =सभी आरपार हैं।
• लाइनें 2, 6, 13 और 17 -पूरे रास्ते हैं।
• लाइन्स 4 और 15 एक ही यादृच्छिक हैं क्षैतिज सममित के पैटर्न <और >।
• अन्य सभी लाइनें (3, 5, 7, 8, 9, 10, 11, 12, 14, 16) पूरी तरह से /और \पूरी तरह से यादृच्छिक तरीके से भरी हुई हैं ताकि पूरी रजाई क्षैतिज और लंबवत सममित रूप से बनी रहे ।

ध्यान दें कि जब रजाई को बिल्कुल आधे में मोड़ते हैं, या तो लंबवत या क्षैतिज रूप से, वर्णों के आकार बिल्कुल मेल खाते हैं। वर्णों के मेल से खुद को भ्रमित न करें। उदाहरण के लिए लाइन 3 और लाइन 16 समान नहीं हैं, वे ऊर्ध्वाधर दर्पण छवियां हैं।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एक यादृच्छिक ASCII कला रजाई को प्रिंट या वापस करेगा।

कई हार्डकोड लाइनों और समरूपता के कारण, एकमात्र वास्तविक यादृच्छिकता लाइनों 3, 4, 5, 7, 8, 9 पर पहले 12 अक्षरों से आती है:

• लाइन 4 पर पहले 12 अक्षर किसी भी लम्बाई के 12 स्ट्रिंग के पात्र होने चाहिए <और >।
• लाइनों 3, 5, 7, 8, 9 पर पहले 12 अक्षर किसी भी लम्बाई के 12 स्ट्रिंग वर्ण /और \(एक दूसरे से स्वतंत्र) होने में सक्षम होना चाहिए ।
• इन यादृच्छिक तारों को फिर से पूरी रजाई बनाने के लिए मिरर किया जाता है।

बाइट्स जीत में सबसे छोटा जवाब। टाईब्रेकर पहले की पोस्ट है।

आप छद्म आयामी संख्या जनरेटर का उपयोग कर सकते हैं। (नहीं, आप साबित होता है कि जरूरत नहीं है सब के 12 चार स्ट्रिंग <>या /\के साथ भाषा की PRNG उत्पन्न किया जा सकता।)

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

Comments

क्या हम एक यादृच्छिक बीज के रूप में इनपुट ले सकते हैं?

— विनाशकारी नींबू

Answer 1

सीजाम, 61 60 58 55 54 52 51 बाइट्स

Sp3000 और ऑप्टिमाइज़र की कुछ मदद से थोड़ा छोटा हुआ।

"=-/</-///"{C*1{"<\/>"%1$W%\_W%er}:F~+mrC<1FN}%s3F(

इसका परीक्षण यहां करें।

व्याख्या

हमेशा की तरह इन सममित ASCII कला चुनौतियों के साथ, मैं एक चतुर्थांश पैदा कर रहा हूं और फिर दो उपयुक्त मिररिंग ऑपरेशंस द्वारा इसे पूरी चीज तक विस्तारित कर रहा हूं।

इस स्पष्टीकरण के लिए मुझे फ़ंक्शन से शुरू करना चाहिए F, जिसे मैं रास्ते में कहीं भी परिभाषित कर रहा हूं, क्योंकि यह तीन स्थानों पर तीन अलग-अलग चीजों के लिए उपयोग किया जाता है:

{"<\/>"%1$W%\_W%er}:F

यह स्टैक के शीर्ष पर एक पूर्णांक, और उसके नीचे एक स्ट्रिंग की अपेक्षा करता है। इसका उद्देश्य स्ट्रिंग को उल्टा करना है और कुछ पात्रों को स्वैप करना है, ताकि मिररिंग सही हो सके। पूर्णांक 1या तो है या 3इंगित करता है कि क्या ( 1) कोष्ठक और स्लैश दोनों को स्वैप किया जाना चाहिए या ()3 ) केवल ब्रैकेट को स्वैप किया जाना चाहिए। यहाँ दिया गया है कि यह कैसे काम करता है:

"<\/>"            "Push a string with all four relevant characters.";
      %           "% applied to a string and an integer N (in any order) selects every
                   Nth character, starting from the first. So with N = 1 this just
                   leaves the string unchanged, but with N = 3 it returns a string
                   containing only < and >.";
       1$         "Copy the string we want to mirror.";
         W%       "% also takes negative arguments. Giving it -1 reverses the string.";
           \_     "Swap the two strings and duplicate the <\/> or <> string.";
             W%   "Reverse that one. Due to the symmetry of this string, we'll now
                   have the characters to be swapped at corresponding indices.";
               er "Perform element-wise transliteration on the reversed input string
                   to complete the mirroring operation.";

अब बाकी कोड के लिए:

"=-/</-///"                            "This string encodes the 9 different line types.
                                        Note that for the /\ and <> lines we only use
                                        one of the characters. This idea is due to
                                        Sp3000. Thanks! :)";
           {                   }%      "Map this block onto the characters.";
            C*                         "Repeat the character 12 times, turning it into
                                        a string.";
              1{...}:F~                "Define and call F on the resulting string. The
                                        reversal doesn't do anything, but the character
                                        swapping creates strings containing both \/ and
                                        <>.";
                       +mr             "Add the two halves together and shuffle them.";
                          C<           "Truncate to 12 characters. We've now got our
                                        random half-lines.";
                            1F         "Call F again to mirror the half-line.";
                              N        "Push a newline.";
                                 s     "Join all those separate strings together by
                                        converting the array to a string.";
                                  3F   "Perform one more mirroring operation on the
                                        half-quilt, but this time only swap < and >.
                                        This yields the correct full quilt, except
                                        there are two newlines in the centre.";
                                    (  "This slices the leading newline off the second
                                        half and pushes it onto the stack.";

कार्यक्रम के अंत में दो हिस्सों और उस एक नई पंक्ति को स्वचालित रूप से मुद्रित किया जाता है।

Answer 2

पायथन 3, 257 229 192 185 176 149 143 बाइट्स

from random import*
k,*L=80703,
while k:s=eval("''"+".join(sample('--==<>\/'[k%4*2:][:2],2))"*12);L=[s]+L+[s[::(-1)**k]];k//=4
*_,=map(print,L)

@Xnor की मदद से, हमने आखिरकार JS को पकड़ लिया है!

नमूना उत्पादन:

========================
------------------------
///////////\/\\\\\\\\\\\
>><<<>><<<><><>>><<>>><<
/\/\\/\/\\/\/\//\/\//\/\
------------------------
//\\////\\/\/\//\\\\//\\
/////\\\/\/\/\/\///\\\\\
/\\//\\/////\\\\\//\\//\
\//\\//\\\\\/////\\//\\/
\\\\\///\/\/\/\/\\\/////
\\//\\\\//\/\/\\////\\//
------------------------
\/\//\/\//\/\/\\/\/\\/\/
>><<<>><<<><><>>><<>>><<
\\\\\\\\\\\/\///////////
------------------------
========================

व्याख्या

(थोड़ा पुराना है, बाद में अपडेट होगा)

"444046402"प्रत्येक 2-चार विकल्प के आरंभिक सूचकांक के संदर्भ में, प्रत्येक अंक के साथ पंक्तियों को कूटबद्ध करता है '--==\/<>'। प्रत्येक व्यक्तिगत पंक्ति को दो वर्णों के बार-बार फेरबदल के माध्यम से अंदर-बाहर बनाया जाता है (उपयोग करने sample(...,2)के बाद सेrandom.shuffle दुर्भाग्य से यथा-स्थान है) और स्ट्रिंग में शामिल होने।

चौथी पंक्ति के लिए विस्तार कैसा दिख सकता है, इसका एक सरल उदाहरण है:

''.join(['<','>']).join(['>','<']).join(['>','<']).join(['<','>']).join(['>','<'])

जो उपज होगा ><>><><<><:

               ''
    <>         .join(['<','>'])
   >  <        .join(['>','<'])
  >    <       .join(['>','<'])
 <      >      .join(['<','>'])
>        <     .join(['>','<'])

समग्र रजाई भी अंदर-बाहर निर्मित होती है, क्योंकि निर्माण 9 वीं / 10 वीं पंक्तियों के साथ शुरू होता है, बाहर की ओर काम करता है। ऐसा करने के लिए हम एक खाली सूची के साथ शुरू करते हैं L, जिसे हम आगे और पीछे की पंक्तियों को जोड़ते हैं जैसे हम गुजरते हैं

L=[s]+L+[[s,s[::-1]][n<"5"]]

यह n<"5"स्थिति यह जांचने के लिए है कि क्या हमारे पास एक पंक्ति है ><, जिस स्थिति में हम एक समान पंक्ति को पीछे की ओर जोड़ते हैं, अन्यथा इसके विपरीत।

अंत में, मुद्रण *_,=के मूल्यांकन को बाध्य करने के लिए mapहोता है, और ऐसा करने का एक छोटा तरीका है print("\n".join(L))।

लंबे समय तक मेरे पास फंक्शन था

g=lambda s:s.translate({60:62,62:60,92:47,47:92})

जो एक स्ट्रिंग लेता है और क्रमशः परिवर्तित करता /\><है \/<>, लेकिन मैं अंततः इससे छुटकारा पाने में कामयाब रहा हूं :)

Comments

युक्ति कहती है कि जब तक यह सभी संभव कालीनों को उत्पन्न कर सकता है , यह ठीक है।

Answer 3

पायथन 2, 300 बाइट्स

यह कार्यक्रम join, lambda, replace, sample, importअन्य क्रिया कार्यों का उपयोग करता है , इसलिए यह किसी भी गोल्फ पुरस्कार को नहीं जीता जाएगा।

from random import*
f=lambda a,b,t:t.replace(a,'*').replace(b,a).replace('*',b)
k=lambda a:''.join(sample(a*12,12))
c='-'*24
e=k('<>')
h=e+f('<','>',e[::-1])
j=[d+f('/','\\',d[::-1])for d in[k('\\/')for i in'quilt']]
g=['='*24,c,j[0],h,j[1],c]+j[2:]
print'\n'.join(g+[f('/','\\',d)for d in g[::-1]])

ऑटो-गोल्फर से पहले कोड को पकड़ लिया:

from random import *

change = lambda a,b,t: t.replace(a,'*').replace(b,a).replace('*',b)
pick = lambda a: ''.join(sample(a*12, 12))

innerline = '-' * 24
line4h = pick('<>')
line4 = line4h + change('<', '>', line4h[::-1])
diag = [d + change('/', '\\', d[::-1]) for d in [pick('\\/') for i in 'quilt']]

quilt = ['='*24, innerline, diag[0], line4, diag[1], innerline] + diag[2:]
print '\n'.join(quilt + [change('/', '\\', d) for d in quilt[::-1]])

एक नमूना उत्पादन:

========================
------------------------
\\\\/\////\\//\\\\/\////
<><<>>>><><><><><<<<>><>
/\\\\////\\\///\\\\////\
------------------------
\\\\//\///\\//\\\/\\////
//\//\\\\/\/\/\////\\/\\
\/\\\\/\//\/\/\\/\////\/
/\////\/\\/\/\//\/\\\\/\
\\/\\////\/\/\/\\\\//\//
////\\/\\\//\\///\//\\\\
------------------------
\////\\\\///\\\////\\\\/
<><<>>>><><><><><<<<>><>
////\/\\\\//\\////\/\\\\
------------------------
========================

Comments

कम से कम नहीं, लेकिन हे, 7 और बाइट्स के साथ आपको अपने नाम के योग्य एक कार्यक्रम मिला है : डी

— केल्विन के

आपने वहां क्या किया वह मैने देखा।

— लॉजिक नाइट

ऑटो गोल्फ खिलाड़ी? क्या किसी को हाथ से गोल्फ खेलने का समय नहीं मिला?

— लार्स एबर्ट

आप हमें हैकर्स जानते हैं। यदि मुझे एक से अधिक बार 3 मिनट का कार्य करना है, तो मैं इसे स्वचालित करने के लिए एक कार्यक्रम लिखने में 10 घंटे खर्च करूंगा। मैं दक्षता के बारे में सब;;

— तर्क नाइट

Answer 4

एपीएल ( 53 58)

यह बिल्कुल सममित नहीं है जैसा कि मैंने सोचा था कि दुर्भाग्य से। फिक्स ने मुझे 5 अक्षर दिए और अब मैं चल रहा हूं।

L←+,3-⌽⋄'==--/\<><'[↑(732451451260688⊤⍨18/8)+L{L?12⍴2}¨⍳9]

स्पष्टीकरण:

• L←+,3-⌽: L एक फ़ंक्शन है जो 3 के बाद अपने तर्क को लौटाता है - इसके तर्क का उलटा
• L{L?12⍴2}¨⍳9: [१,२] से १२ यादृच्छिक मानों की ९ पंक्तियाँ उत्पन्न करें, साथ ही साथ उनकी ९ पंक्तियों को उल्टा करें
• 732451451260688⊤⍨18/8: सूची बनाएँ 0 2 4 6 4 2 4 4 4 4 4 4 2 4 _7_ 4 2 0(यह है कि लानत विषमता कहाँ है)
• +: प्रत्येक पंक्ति के लिए, प्रत्येक मान में संबंधित संख्या जोड़ें
• ↑: मैट्रिक्स के रूप में प्रारूपित करें
• '==--/\<><'[... ]: मैट्रिक्स में प्रत्येक संख्या के लिए, उस स्थिति में स्ट्रिंग से वर्ण का चयन करें

आउटपुट:

========================
------------------------
///////\\///\\\//\\\\\\\
<<><<><><<<<>>>><><>><>>
\\\\\//\/\\\///\/\\/////
------------------------
/\///\\/\/\/\/\/\//\\\/\
\////////\//\\/\\\\\\\\/
\\/\\\//\///\\\/\\///\//
//\///\\/\\\///\//\\\/\\
/\\\\\\\\/\\//\////////\
\/\\\//\/\/\/\/\/\\///\/
------------------------
/////\\/\///\\\/\//\\\\\
<<><<><><<<<>>>><><>><>>
\\\\\\\//\\\///\\///////
------------------------
========================

Comments

मेरे पास + 1ed था क्योंकि आपके द्वारा पोस्ट किया गया एल्गोरिथम दिलचस्प और मौलिक था, लेकिन मैंने अभी देखा है कि आपकी <>रेखाएँ लंबवत सममित नहीं हैं क्योंकि आप ऊर्ध्वाधर दर्पण बनाते समय अपनी स्वैप टेबल का उपयोग करते हैं। (उत्पादन btw पोस्ट करने के लिए धन्यवाद, अगर एपीएल बहुत आसान काम करता है पता लगाना? पी)

— FryAmTheEggman

@FryAmTheEggman: बकवास, ध्यान नहीं दिया। मुझे शायद अब पूरे एल्गोरिथ्म को स्क्रैप करना होगा, क्योंकि एक लाइन है जो दूसरों की तरह नहीं है। खैर, मुझे केवल नीचा दिखाने के बजाय धन्यवाद देने के लिए।

— मेरीस

@FryAmTheEggman: ठीक है, यह तय हो गया है ( <स्ट्रिंग के अंत में एक और जोड़कर , और दूसरी पंक्ति को एक बार और बढ़ा दिया गया, जिससे इसे दो बार स्वैप किया गया)। यहां तक ​​कि पूरी चीज को स्क्रैप नहीं करना था, हालांकि यह अब और नहीं जीतेगा। (शायद अगली बार मुझे आउटपुट पोस्ट नहीं करना चाहिए: P)

— marinus

यह समाधान काफी चतुर है, आप +1 :)

— FryAmTheEggman

@ केल्विन के शौक: एक चीज को ठीक करो, दूसरे को तोड़ो। अब यह वास्तव में तय हो गया है।

— मारिनस

Answer 5

PHP, 408 , 407 , 402 , 387 , 379 बाइट्स

मैं एक अच्छा गोल्फर नहीं हूं, लेकिन यह समस्या मजेदार लग रही थी इसलिए मैंने इसे आजमाया।

<?$a=str_replace;$b=str_repeat;function a($l,$a,$b){while(strlen($s)<$l){$s.=rand(0,1)?$a:$b;}return$s;}$c=[$b('=',12),$b('-',12),a(12,'/','\\'),a(12,'<','>'),a(12,'/','\\'),$b('-',12)];while(count($c)<9){$c[]=a(12,'/','\\');}for($d=9;$d--;){$c[$d].=strrev($a(['/','<','\\','>',1,2],[1,2,'/','<','\\','>'],$c[$d]));$c[]=$a(['/','\\',1],[1,'/','\\'],$c[$d]);}echo implode("
",$c);

अघोषित कोड

<?php

    function randomString($length, $a, $b) {
        $string = '';
        while(strlen($string) < $length) {
            $string .= rand(0, 1) ? $a : $b;
        }
        return $string;
    }

    if(isset($argv[1])) {
        srand(intval($argv[1]));
    }

    $lines = [
        str_repeat('=', 12),
        str_repeat('-', 12),
        randomString(12, '/', '\\'),
        randomString(12, '<', '>'),
        randomString(12, '/', '\\'),
        str_repeat('-', 12)
    ];
    while(count($lines) < 9) {
        $lines[] = randomString(12, '/', '\\');
    }

    for($index = count($lines); $index--;) {
        $lines[$index] .= strrev(str_replace(['/', '<', '\\', '>', 1, 2], [1, 2, '/', '<', '\\', '>'], $lines[$index]));
        $lines[] = str_replace(['/', '\\', 1], [1, '/', '\\'], $lines[$index]);
    }

    echo implode("\n", $lines) . "\n";

?>

Ungolfed संस्करण में थोड़ा बोनस है: आप इसे बीज के लिए पूर्णांक पास कर सकते हैं rand()और बीज के लिए हर बार एक ही रजाई प्राप्त कर सकते हैं:

php quilt.php 48937

यह परिणाम, उदाहरण के लिए, इस सुंदर, हाथ से बुने हुए रजाई में:

========================
------------------------
/\\\////\\\/\///\\\\///\
><>><>><<<><><>>><<><<><
/\\\///\//\/\/\\/\\\///\
------------------------
/\\/\\\/\\/\/\//\///\//\
/\\\\/\//\\/\//\\/\////\
\/\\/\/\////\\\\/\/\//\/
/\//\/\/\\\\////\/\/\\/\
\////\/\\//\/\\//\/\\\\/
\//\///\//\/\/\\/\\\/\\/
------------------------
\///\\\/\\/\/\//\///\\\/
><>><>><<<><><>>><<><<><
\///\\\\///\/\\\////\\\/
------------------------
========================

संपादित करें : मेरा पहला संस्करण सही रजाई नहीं लौटाता है। इसलिए मैंने इसे ठीक किया। काफी मजेदार, फिक्स भी कम है।

Comments

आप इसे गोल्फ के लिए कई चीजें कर सकते हैं: के ['/','<','\\','>','a','b']साथ प्रतिस्थापित किया जा सकता है['/','<','\\','>',a,b] ( में गायब कोट्स को नोटिस कर सकते हैं ) aऔर उसके साथ प्रतिस्थापित किया जा सकता है , आप स्टोर कर सकते हैं और वैश्विक चर / स्थिरांक में बदल सकते हैं , और दोहराया कार्यों को छोटा करके दिया जा सकता है उनका नाम एक वैश्विक चर (जैसे :) और newlines ( ) को बहु-पंक्ति स्ट्रिंग द्वारा प्रतिस्थापित किया जा सकता है। b@$s$sstr_repeat('-',12)str_repeat('=',12)for($b=8;$b>=0;$b--)for($b=9;$b--;)str_repeatglobal$R,$V;$R=str_repeat;$V=strrev;$V($R('=',12))\n

— इस्माईल मिगुएल

यहाँ एक छोटा संस्करण है: pastebin.com/2TabUqbA (373 बाइट्स)। मैंने कुछ सुझाव बदले हैं: वैश्विक चर हटा दिए गए strrevहैं, 1 स्थान और कुछ छोटे परिवर्तन हटा दिए गए हैं।

— इस्माइल मिगुएल

मुझे लगता है कि आपको <>><><एक ही होने के लिए लाइन 4 और लाइन 15 ( लाइनें) की आवश्यकता है।

— लॉजिक नाइट

क्षमा करें, यहां एक 357-बाइट्स लंबा समाधान है: pastebin.com/TugNDjjL मैं कुछ चीजों को कम करना भूल गया।

— इस्माइल मिगुएल

@IsmaelMiguel आपकी मदद के लिए धन्यवाद। मैंने आपकी कुछ सलाह ली, लेकिन इसका कुछ परिणाम नोटिस में आया।

— लार्स एबर्ट

Answer 6

जावास्क्रिप्ट (ईएस 6) 169 195 201

6 बाइट्स संपादित करें thx @nderscore को बचाया। खबरदार, backquotes के अंदर newline महत्वपूर्ण और गिना जाता है।

Edit2 सरलीकृत पंक्ति निर्माण, की कोई आवश्यकता नहीं है reverseऔरconcat

F=(o='')=>[...z='/\\/-/<\\-='].map((c,i,_,y=[z,'\\/\\-\\>/-='],q=[for(_ of-z+z)Math.random(Q=k=>q.map(v=>r=y[v^!k][i]+r+y[v^k][i],r='')&&r+`
`)*2])=>o=Q()+o+Q(i!=5))&&o

परीक्षण करने के लिए स्निपेट चलाएँ (फ़ायरफ़ॉक्स में)

F=(o='')=>[...z='/\\/-/<\\-='].map((c,i,_,y=[z,'\\/\\-\\>/-='],q=[for(_ of-z+z)Math.random(Q=k=>q.map(v=>r=y[v^!k][i]+r+y[v^k][i],r='')&&r+`
`)*2])=>o=Q()+o+Q(i!=5))&&o

Q.innerHTML=F()

<pre id=Q style='font-size:9px;line-height:9px'>

Comments

-6 बाइट्स: की परिभाषा के आसपास कोष्ठक निकालें z। कॉल के Qअंदर की परिभाषा को स्थानांतरित Math.randomकरें। Newline '\n'के टेम्पलेट स्ट्रिंग के साथ बदलें । |0पूर्णांक कास्टिंग की आवश्यकता नहीं है, क्योंकि मूल्य बाद में xor-ed होंगे।

— अंडरस्कोर

इसका क्या for(_ of-z+z)मतलब है?

— डेरेक 會 朕

@ डेरेक को मुझे 12 बार पुनरावृत्त करना होगा और मेरे पास सबसे अच्छा 9 चर स्ट्रिंग है। zक्या संख्यात्मक नहीं है -z NaN (संख्या नहीं है) NaN को स्ट्रिंग में परिवर्तित किया जाता है "NaN" और 3 वर्ण + 9 वर्ण हैं 12.

— edc65

Answer 7

रूबी, 162 155

मुझे यह पसंद है क्योंकि इसने मुझे स्ट्रिंग स्ट्रिंगल्स और दोनों में बैकस्लैश का दुरुपयोग करना सीखा String#tr। कोड बहुत चालाक है अन्यथा, बस कॉम्पैक्ट नहीं है।

a='/\\'
b='\\\/'
t=Array.new(9){x=''
12.times{x+=a[rand(2)]}
x+x.reverse.tr(a,b)}
t[0]=?=*24
t[1]=t[5]=?-*24
t[3].tr!a,'<>'
puts t,((t.reverse*'
').tr a,b)

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ स्टैक एक्सचेंज में आपका स्वागत है! यहाँ रूबी-विशिष्ट युक्तियों के एक जोड़े हैं: मुझे नहीं लगता कि आपको /अंदर aऔर बाहर भागने की आवश्यकता है b। पहली trशायद कोष्ठक के बिना भी कर सकते हैं। जैसे एकल-वर्ण तार '='लिखे जा सकते हैं ?=। और .joinद्वारा प्रतिस्थापित किया जा सकता है *।

— मार्टिन एंडर

@ MartinBüttner स्वागत और सुझावों के लिए धन्यवाद! चरित्र शाब्दिक और joinसमानार्थक शब्द मुझे 6 बाइट बचाते हैं। मैं कोष्ठकों को अंदर नहीं निकाल सकताx+x.reverse.tr(a,b) क्योंकि इसमें +पूर्वता लेता है ,। मैं भी वास्तव में मेरे तार में होने वाले स्लैश से बच नहीं रहा हूं - मैं प्रत्येक में एक बैकस्लैश से बचने में विफल रहा हूं । एक दूसरे \के लिए आवश्यक है bक्योंकि जिस तरह से tr, काम करता है, हालांकि मैं अब एहसास पहले \में aज़रूरत से ज़्यादा है, इसलिए वहाँ एक और बाइट है।

— 3

Answer 8

पायथ, ५ Py ५ ९ ६१

J"\<>/"K"\/"L+b_mXdK_Kbjbym+d_XdJ_JmsmOk12[\=\-K-JKK\-KKK

J"\<>/"K"\/"jbu++HGXHK_Km+d_XdJ_JmsmOk12[KKK\-K-JKK\-\=)Y

इन 57 बाइट संस्करणों के साथ आने के लिए @Jakube को बहुत धन्यवाद।

मार्टिन के समान ही एल्गोरिदम। (संशोधित) आने के लिए स्पष्टीकरण।

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

स्पष्टीकरण:

=G"\<>/"                            : Set G to be the string "\<>/"
K"\/"                               : Set K to be the string "\/"
Jm+d_XdG_GmsmOk12[\=\-K"<>"K\-KKK;  : Set J to be the top half of the carpet
                 [\=\-K"<>"K\-KKK;  : Make a list of possible chars for each row
          msmOk12                   : for each element of that list,
                                    : make a list of 12 randomly chosen characters
                                    : from it, then join them
Jm+d_XdG_G                          : for each element of that list,
                                    : make a new list with the old element,
                                    : and its horizontal reflection
jb+J_mXdK_KJ                        : Print the whole carpet
     mXdK_KJ                        : For each element of J make its vertical reflection

Comments

बहुत अच्छा। तौलिया में नहीं फेंकना चाहिए था। 1 char जगह बचाने के "<>"साथ-GK

— Jakube

और लैम्ब्डा का उपयोग करके J"\<>/"K"\/"L+b_mXdK_Kbjbym+d_XdJ_JmsmOk12[\=\-K-JKK\-KKKया घटाकर एक और एकJ"\<>/"K"\/"jbu++HGXHK_Km+d_XdJ_JmsmOk12[KKK\-K-JKK\-\=)Y

— जेक्यूब

@Jakube धन्यवाद! वे दोनों ही काफी चतुर आशावादी हैं। मुझे वास्तव में पसंद है कि लैम्ब्डा आपको सूची को आखिर में कैसे रखने देता है।

— फ्राइअमईएग्गमैन

Answer 9

जे, ५६ ५४ बाइट्स

'=/\<>--></\'{~(-,|.)0,(3(2})8$5,3#1)+(,1-|.)"1?8 12$2

उपयोग:

   '=/\<>--></\'{~(-,|.)0,(3(2})8$5,3#1)+(,1-|.)"1?8 12$2
========================
------------------------
///\\\\/\///\\\/\////\\\
><<><><>><>><<><<><><>><
\\/\//\\/\//\\/\//\\/\//
------------------------
\/\/\//////\/\\\\\\/\/\/
/\/\\//\//\\//\\/\\//\/\
//\\\\/////\/\\\\\////\\
\\////\\\\\/\/////\\\\//
\/\//\\/\\//\\//\//\\/\/
/\/\/\\\\\\/\//////\/\/\
------------------------
//\/\\//\/\\//\/\\//\/\\
><<><><>><>><<><<><><>><
\\\////\/\\\///\/\\\\///
------------------------
========================

1 बाइट @FUZxxl की बदौलत।

स्पष्टीकरण जल्द ही आ रहा है।

इसे यहाँ ऑनलाइन आज़माएँ।

Comments

एक चरित्र को बचाओ: बदलें 5 1 3 1 5 1 1 1साथ (3(2})8$5,3#1)।

— फूज़लक्ल

@FUZxxl बढ़िया! मैं विकल्पों में से एक टन की कोशिश की, लेकिन यह नहीं मिला है। (सीजेएम रातोंरात स्कोर में दूर हो गया इसलिए जे उन तक नहीं पहुंचेगा।: पी)

— यादृच्छिक

Answer 10

पायथन 295 287 227 बाइट्स

यह महान नहीं है, लेकिन मैं इसे वैसे भी पोस्ट करूंगा:

from random import*
m,d=[],dict(zip("\/<>=-","/\><=-"))
v=lambda w:[d[x]for x in w]
for e in '=-/>/-///':f=[choice([e,d[e]])for x in[0]*12];t=''.join(f+v(f[::-1]));print t;m+=''.join(e=='/'and v(t)or t),
print'\n'.join(m[::-1])

यदि आप स्पष्टीकरण चाहते हैं तो मुझसे पूछें।

Comments

@ Sp3000 इसे इंगित करने के लिए धन्यवाद, मैंने इसे ठीक कर दिया। शर्म की बात यह है कि अगर अब भी आया ...

— Def

यहाँ गोल्फ का एक समूह है जो एक टिप्पणी में फिट होने के लिए बहुत लंबा है। आप इसे और भी नीचे लाने में सक्षम हो सकते हैं यदि आप डालते हैं =और -अंदर d।

— Sp3000

@ Sp3000 सभी सलाह के लिए बहुत बहुत धन्यवाद। यह बहुत स्पष्ट था (रिक्त स्थान को हटाते हुए), जैसा कि मैं सबसे बड़ा गोल्फर (कोड और irl दोनों) नहीं हूं, लेकिन मैंने कुछ नए अजगर भी सीखे (इसलिए फिर से धन्यवाद)। यदि = और - में दिए गए कथन को हटाकर, एक बहुत अच्छा विचार है। PS क्या आप बताएंगे कि कैसे एक पुनरावर्ती रजाई को इतने कम कोड (डिक्रिप्टिंग ट्रांसलेशन चूस) में बनाया जाता है

— Def

Answer 11

जावास्क्रिप्ट ( ईएस 7 ड्राफ्ट ) 174 168 146

@ Edc65 से ली गई कुछ प्रेरणा

संपादित करें: पंक्तियों के निर्माण का अनुकूलन करने के लिए कुछ विचारों के लिए edc65 के लिए धन्यवाद।

F=(o='')=>[for(i of'555357531')(z=[for(_ of c='==--/\\<>golf')Math.random(r=x=>z.reduce((s,y)=>c[w=i^y^x]+s+c[w^1],'')+`
`)*2],o=r()+o+r(i<7))]&&o

---

प्रदर्शन: ( केवल फ़ायरफ़ॉक्स )

F=(o='')=>[for(i of'555357531')(z=[for(_ of c='==--/\\<>golf')Math.random(r=x=>z.reduce((s,y)=>c[w=i^y^x]+s+c[w^1],'')+`
`)*2],o=r()+o+r(i<7))]&&o

document.write('<pre>' + F() + '</pre>');

---

टिप्पणी की:

// define function, initialize output to ''
F = (o = '') =>
    // loop through character indexes of first 9 lines
    [
        for (i of '555357531')(
            // build array of 12 random 0/1's, initialize character list
            z = [
                for (_ of c = '==--/\\<>golf')
                    Math.random(
                        // define function for generating lines
                        // if x is true, opposite line is generated
                        r = x =>
                            z.reduce(
                                (s, y) => 
                                    c[w = i ^ y ^ x] + s + c[w ^ 1],
                                ''
                            ) + `\n`
                    ) * 2
            ],
            // build new lines and wrap output in them
            // x true in the second line for indexes < 7 (not character '>')
            o = r() + o + r(i < 7)
        )
    ]
    // return output
    && o

Comments

मेरा संपादन देखें, यह आपके समाधान के लिए भी अच्छा है

— edc65

@ edc65 अच्छा विचार! मैंने अब कुछ इसी तरह से लागू किया है।

— अंडरकोर

Answer 12

चरण 4, 236

|s i f v h|s:='====----/\/\/<><<>'.f:=[:c|s at:(s indexOf:c)+i].v:=#(),'=-/</-///'collect:[:c|h:=(String new:12)collect:[:x|i:=2atRandom.f value:c].i:=1.h,(h reverse collect:f)].i:=3.String cr join:v,(v reverse collect:[:k|k collect:f])

या स्वरूपित सामान्य:

|s i f v h|
s:='====----/\/\/<><<>'.
f:=[:c|s at:(s indexOf:c)+i].
v:=#() , '=-/</-///'
  collect:[:c|
    h:=(String new:12)collect:[:x|i:=2atRandom.f value:c].
    i:=1.
    h,(h reverse collect:f)].
i:=3.
String cr join:v,(v reverse collect:[:k|k collect:f])

स्पष्टीकरण:

s:='====----/\/\/<><<>'ब्लॉक के साथ एक साथ तार f:=[:c|s at:(s indexOf:c)+i]यहाँ हैं दोनों पात्रों को उछालने और पैटर्न को उलटने के लिए ...

• I = 1 के लिए, यह क्षैतिज प्रत्यावर्तन ( /<-> \, <<-> >) करता है।

• I = 3 के लिए, यह लंबवत प्रत्यावर्तन ( /<-> \) करता है

• I = 1 या 2 atRandom के लिए, यह के बीच टॉस /या \, <या>

'=-/</-///'वर्ण प्रकार एन्कोड करता है जो cब्लॉक को फीड करेगाf 9 पहली लाइनों के लिए ।

#() , '=-/</-///' स्ट्रिंग को एक सरणी में बदलने और इस प्रकार एक सरणी में एकत्रित करने के लिए एक स्थानापन्न चाल है।

बाकी क्षैतिज / ऊर्ध्वाधर समरूपता को लागू करने के बाद सरल संयोजन है।

========================
------------------------
\\/\/\\\\/\/\/\////\/\//
>>>><><><>><><<><><><<<<
\/\/\//\///\/\\\/\\/\/\/
------------------------
/\//\/\/////\\\\\/\/\\/\
\\//\//\\\/\/\///\\/\\//
////\\/\/\//\\/\/\//\\\\
\\\\//\/\/\\//\/\/\\////
//\\/\\///\/\/\\\//\//\\
\/\\/\/\\\\\/////\/\//\/
------------------------
/\/\/\\/\\\/\///\//\/\/\
>>>><><><>><><<><><><<<<
//\/\////\/\/\/\\\\/\/\\
------------------------
========================

Answer 13

स्क्वीक 4.X, 247

|r s h m n p|s:='==--/\<>'.r:=(1<<108)atRandom.h:=''.m:=0.(16to:0by:-2),(0to:16by:2)do:[:i|n:=3bitAnd:28266>>i.p:=0.(11to:0by:-1),(0to:11)do:[:j|h:=h,(s at:n*2+1+(r-1>>(6*i+j)+(101>>(3-n*4+m+p))bitAnd:1)).j=0and:[p:=1]].i=0and:[m:=2].h:=h,#[13]].h

या स्वरूपित:

|r s h m n p|
s:='==--/\<>'.
r:=(1<<108)atRandom.
h:=''.
m:=0.
(16to:0by:-2),(0to:16by:2) do:[:i|
  n:=3 bitAnd: 28266>>i.
  p:=0.
  (11to:0 by:-1),(0to:11) do:[:j|
    "h:=h,(s at:n*2+1+((r-1bitAt:6*i+j+1)bitXor:(101bitAt:3-n*4+m+p))). <- originally"
    h:=h,(s at:n*2+1+(r-1>>(6*i+j)+(101>>(3-n*4+m+p))bitAnd:1)).
    j=0and:[p:=1]].
  i=0and:[m:=2].
  h:=h,#[13]].
h

स्पष्टीकरण:

s:='==--/\<>'. स्पष्ट रूप से चार पॉसिबल जोड़े को एनकोड करता है।

r:=(1<<108)atRandom. 9 पंक्तियों के लिए 108 बिट्स (एक लार्जइन्टेगर में) टॉस करें * 12 कॉलम (हम == और - टॉस करें लेकिन प्रदर्शन हमारी समस्या नहीं है)।

h:=''वह स्ट्रिंग है जहां हम संक्षिप्त करेंगे (स्लेमियल चित्रकार क्योंकि एक स्ट्रीम पात्रों में बहुत महंगा होगा)।

(16to:0by:-2),(0to:16by:2)do:[:i| पंक्तियों पर चलने वाला है (* 2)

(11to:0by:-1),(0to:11) do:[:j| स्तंभों पर पुनरावृति कर रहा है

28266एक जादुई संख्या है जो पहले 9 लाइनों पर जोड़ी जाने वाली जोड़ी को एन्कोडिंग करती है।
यह बिट पैटर्न है 00 01 10 11 10 01 10 10 10, जहां 00 एनकोडिंग '==', 01 '-', 10 '/ \' और 11 '<>' है।

101एक जादुई संख्या है जो क्षैतिज और ऊर्ध्वाधर उलट को कूटबद्ध करती है।
यह थोड़ा पैटर्न है0000 0000 0110 1010 , एन्कोडिंग जब (1) या नहीं (0) पहली (0) या दूसरी (1) प्रत्येक जोड़ी का वर्ण '==' '-' '/ \' और '<>' है। ऊर्ध्वाधर समरूपता और क्षैतिज समरूपता के लिए।

n:=3 bitAnd: 28266>>i पंक्ति i / 2 के लिए वर्ण युग्म की एन्कोडिंग देता है (0 = '==' के लिए, '-' के लिए 1, '/ \' के लिए 2 और '<>' के लिए 3)।

(r-1 bitAt: 6*i+j+1) पंक्ति I / 2 कॉलम j के लिए यादृच्छिक बिट चुनें (1 सबसे कम बिट का रैंक है, इस प्रकार हमारे पास +1 में, कश्मीर atRandom टॉस है [1, k] इस प्रकार हमारे पास -1 है)।

(101 bitAt: 3-n*4+m+p) उत्क्रमण बिट उठाओ: (3-एन) * 4 जोड़ी कोड n के अनुरूप 4 बिट्स के समूह के लिए ऑफसेट है, मी ऊर्ध्वाधर उलट ऑफसेट है (पहले 9 के लिए 0, अंतिम 9 पंक्तियों के लिए 2), पी है क्षैतिज प्रत्यावर्तन ऑफसेट (पहले 12 के लिए 0, अंतिम 12 कॉलम के लिए 1) +1 क्योंकि कम बिट रैंक 1 है।

bitXor: प्रत्यावर्तन करता है (यह एक ऑफसेट 0 या 1 का उत्तर देता है), और s at:2*n+1+bitXor_offset सही वर्ण को एस में चुनता है।

लेकिन की (A>>a)+(B>>b) bitAnd: 1तुलना में कम बाइट्स का खर्च आता है(A bitAt:a+1)bitXor:(B bitAt:b+1) इस तरह और बिटक्वाटर को फिर से लिखा जाता है और पी पर ऑफसेट +1 चला जाता है ...

h,#[13] एक बदसूरत चीख़ है, हम एक बाइट के साथ एक स्ट्रिंग को व्यवस्थित कर सकते हैं (कैरिज वापसी के लिए कोड युक्त)।

========================
------------------------
/\/\\\/\//\/\/\\/\///\/\
><>><<>>>><<>><<<<>><<><
////\\////\\//\\\\//\\\\
------------------------
/\\\/\\/\\//\\//\//\///\
\/\\/\//////\\\\\\/\//\/
\\\//\\\////\\\\///\\///
///\\///\\\\////\\\//\\\
/\//\/\\\\\\//////\/\\/\
\///\//\//\\//\\/\\/\\\/
------------------------
\\\\//\\\\//\\////\\////
><>><<>>>><<>><<<<>><<><
\/\///\/\\/\/\//\/\\\/\/
------------------------
========================