मुझे एक कंबल बनाओ!

Question

मुझे एक कंबल चाहिए जो इस तरह दिखता है। प्रत्येक पट्टी ऊपर, नीचे, ऊपर, नीचे जाती है। क्या आप इसे प्रिंट कर सकते हैं?

\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\

प्रत्येक पंक्ति के अंत में अनुगामी रिक्त स्थान और अनुगामी न्यूलाइन्स स्वीकार्य हैं।

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

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई दे रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप अलग से झंडा लगाने वाले दंड को सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक स्कोर अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=99023,OVERRIDE_USER=12537;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Comments

दायें किनारे पर गलत लिखा हुआ लगता है।

— मैजिक ऑक्टोपस Urn

क्या बायाँ छोर अतिव्यापी नहीं है?

— xnor

@xnor क्षमा करें, मेरा बुरा।

— ओलिवर नी

@carusocomputing फिक्स्ड।

— ओलिवर नी

यदि आपने सैंडबॉक्स का उपयोग किया था, तो मुख्य मुद्दे पर जाने से पहले उन मुद्दों से बचा जा सकता था।

— मेगो

Answer 1

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

R=range(24)
for i in R:print''.join(" \// \/\\"[i+~j>>2&1^i+j>>1&2^i&4]for j in R*2)

अंकगणित संचालन को बिटवाइज़ में बदलने से 6 बाइट्स के लिए Sp3000 के लिए धन्यवाद।

Comments

वाह ... कैसे ????

— ओलिवर नी

i+~j>>2&1^i+j>>1&2^i&4, शायद?

— Sp3000

@ Sp3000 यह कुछ अच्छी बिटवाइज़ मिसाल है। मुझे यह याद रखना होगा कि अंकगणित से व्युत्पन्न बूलियन को एक सूचकांक में संयोजित करते समय।

— xnor

Answer 2

पायथ, 36 बाइट्स

V24sm@" \// \/\\"im<3%k8++BNdt-NdT48

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

हम 3 शर्तों की जाँच करके प्रतीक का निर्धारण कर सकते हैं:

A := row % 8 > 3
B := (row + column) % 8 > 3
C := (row - column - 1) % 8 > 3

यदि हम [A,B,C]एक बाइनरी संख्या के रूप में व्याख्या करते हैं, तो हमें निम्नलिखित मानचित्रण प्राप्त होते हैं:

01234567
 \// \/\

हम [A,B,C]दशमलव संख्या के रूप में भी व्याख्या कर सकते हैं और स्ट्रिंग में एक मॉड्यूलर अनुक्रमित लुकअप कर सकते हैं । इसका कारण यह है कोई फर्क नहीं पड़ता 10 mod 8 = 2।

अब कोड के लिए:

V24iterates N(पंक्ति-आईडीएक्स) पर [0, 1, ..., 23]।

sm...48संख्याओं d(कॉलम-आइडीएक्स) को चार्ट्स में मैप करता है [0, 1, ..., 47]और संयुक्त स्ट्रिंग प्रिंट करता है।

++BNdसूची बनाता है [N, N+d], +...t-Ndजोड़ता है N-d-1। इसलिए हमें सूची मिल गई है [N, N+d, N-d-1]। m<3%k8प्रत्येक गणना की गई संख्या के लिए चेक k, यदि 3 < k % 8, तो यह शर्तों के साथ सूची देता है [A, B, C]।

i...Tइसे एक दशमलव संख्या में बदल देता है और फिर @" \// \/\\"स्ट्रिंग में लुकअप करता है।

पायथन 2: 98 बाइट्स में कमोबेश समान कोड :

R=range(8)
for r in R*3:print''.join(" \// \/\\"[4*(r>3)+2*((r+c)%8>3)+((r-c-1)%8>3)]for c in R*6)

Comments

बस पाइथ के साथ पकड़ बनाने की कोशिश कर रहा है तो एक अच्छी व्याख्या के साथ किसी भी सभ्य जवाब से मुझे उत्थान मिलता है। मेरे बेस 3 प्रयोग के बाद Pyth को आज़माने जा रहा था :)

— ElPedro

आपको Python2 उत्तर को भी पोस्ट करना चाहिए ...

— जेरी यिर्मयाह

Answer 3

पर्ल, 209 + 17 = 226 बाइट्स

साथ चलाएं -mList::Util=max -M5.010(दूसरा झंडा स्वतंत्र है)। यह किसी भी बाइट गिनती प्रतियोगिताओं को नहीं जीत रहा है, लेकिन यहां मेरा समाधान है।

for(0..7){@b=(1)x8;@b[$_+3..$_+7]=(3)x4;@b[7-$_..10-$_]=(2)x4;for$c(0..2){$b[$c+8]=max$b[$c+8],$b[$c];$b[5-$c]=max$b[5-$c],$b[13-$c];}push@a,sprintf("%-8s",join("",@b[3..10])=~tr[123][ /\\]r)x6;}say for@a,@a,@a

पठनीय:

for(0..7){
    @b=(1)x8;
    @b[$_+3..$_+7]=(3)x4;
    @b[7-$_..10-$_]=(2)x4;
    for$c(0..2){
        $b[$c+8]=max$b[$c+8],$b[$c];
        $b[5-$c]=max$b[5-$c],$b[13-$c];
    }
    push@a,sprintf("%-8s",join("",@b[3..10])=~tr[123][ /\\]r)x6
}
say for@a,@a,@a

प्रक्रियात्मक रूप से प्रत्येक खंड उत्पन्न करता है, फिर पैटर्न को 6 बार दोहराता है, फिर कुल परिणाम 3 बार आउटपुट करता है।

Comments

वाह, मैं किसी भी अधिक लंबे समय तक answe नहीं हूँ :) +1 वैसे भी पर्ल में करने के लिए।

— एलपेड्रो

मैं इसे उसी तरह कर सकता था जैसे बाकी सब (बस लाइनों का एक गुच्छा छाप रहे हैं), लेकिन मैंने चीजों को स्पष्ट रूप से करने के बजाय एल्गोरिदम से करने का फैसला किया क्योंकि मुझे लगा कि यह कूलर था।

— गैब्रियल बेनामी

मेरे मानकों से कूल। मैंने एक दृष्टिकोण लिया है कि मैंने पहले कभी कोशिश नहीं की है क्योंकि यह एक दिलचस्प चुनौती थी। जैसा कि मैंने कहा, +1। मेरी टिप्पणी से कोई अपमान नहीं हुआ। इसलिए मैंने उत्थान किया।

— एलपेड्रो

Answer 4

पायथन 3, 174 172 138 बाइट्स

print("\n".join(o*6for o in("bbbb////"," bb//// ","  ////  "," ////bb ","////bbbb","b//  bbb","bb    bb","bbb  //b")*3).replace("b","\\"))

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

2 बाइट्स बंद करने के लिए ओलिवर का धन्यवाद!

पैटर्न को बदलकर 34 बाइट्स ले लिया - कंबल के लिए पूरा पैटर्न अब एक ही सूची में है, इसलिए पैटर्न को खोलना आवश्यक है।

Comments

PPCG में आपका स्वागत है! अच्छी पहली पोस्ट! आप अजगर 2 में एक बाइट दाढ़ी कर सकते हैं मुझे लगता है, आपको प्रिंट के लिए पेंडेंट की आवश्यकता नहीं है।

— 15

धन्यवाद ईस्टर इरक, मैं अब बहुत लंबे समय से कोड गोल्फ में घूम रहा हूं, इसलिए मैंने भाग लेने का फैसला किया। :)

— TheCrazyInventor

आप बाद में अंतरिक्ष को हटाकर दो बाइट बचा सकते हैं 0*6औरu*6

— ओलिवर नी

आप डबल बैकस्लैश के लिए "बी" का उपयोग करके 4 बाइट्स बचा सकते हैं और कहीं भी आपको एक ही बैकस्लैश की जरूरत है बस भागने का उपयोग करें:print((("\n".join(o*6 for o in("bb////"," b//// "," //// "," ////b ",""))+"\n".join(u*6 for u in("////bb","\\// b\\","b b","b\\ //\\","")))*3).replace("b","\\\\"))

— dzima

dzaima: आपका कोड एक मान्य कंबल उत्पन्न नहीं करता है।

— TheCrazyInventor 8:10 बजे

Answer 5

पायथन 2, 171 170 168 बाइट्स

a,b,c=r"\\","/"*4," "
f,g=c*2,c+a+b+c
d=(a*2+b)*6,g*6,(f+b+f)*6,g[::-1]*6,(b+a*2)*6,('\\//'+f+a+"\\")*6,(a+f*2+a)*6,(a+"\\"+f+'//\\')*6
for e in 0,1,2:print'\n'.join(d)

न सुंदर और न चतुर। बस तार के सबसे अधिक बार उपयोग किए जाने वाले समूहों के लिए चर सेट करता है और फिर उन्हें जोड़ती है और परिणाम 3 बार प्रिंट करता है। अगर मुझे एक बेहतर तरीका नहीं मिलता है, तो मैं इसे और बाद में आज़मा सकता हूँ।

1 बाइट एक असाइनमेंट पर कच्चे इनपुट का उपयोग करके सहेजा गया। धन्यवाद @ nedla2004

-2 चर के एक जोड़े को असाइन करके लेकिन अभी भी एक गंभीर प्रतियोगी नहीं है

Comments

आप

— nedla2004

धन्यवाद @ nedla2004 अच्छी बात। यह एक साथ बहुत जल्दी फेंक दिया और बाद में इसे देखने जा रहा था। यह एक अच्छी शुरुआत है :)

— एलपेड्रो

*6हालांकि प्रत्येक टपल तत्व पर एक रास्ता खोजने में सबसे अधिक दिलचस्पी है । कोई विचार?

— एलपेड्रो

मुझे नहीं पता कि आप ऐसा कैसे कर सकते हैं, लेकिन अंतिम पंक्ति क्या हो सकती है exec r"print'\n'.join(d);"*3।

— nedla2004

मैंने अभी-अभी आउट ऑफ इंटरेस्ट पोस्ट किया है। उस पर भी अपनी टिप्पणी मानेंगे

— ElPedro

Answer 6

एसओएमएल , 106 बाइट्स

3{"\\\\////”6*p" \\//// ”6*p"  ////  ”6*p" ////\\ ”6*p"////\\\\”6*p"\//  \\\”6*p"\\    \\”6*p"\\\  //\”6*p

एक गैर-प्रतिस्पर्धी संस्करण का उपयोग करके एक फ़ंक्शन जिसे मैंने हाल ही में जोड़ा है: ( 83) 67 66 बाइट्स)

स्पष्टीकरण:

  →$\\→#////→@”6*p"→~3{"##@~ #@ ~$@$~ @# ~@##~\//$#\~#$$#~#\$//\~”
  →$                                                                in the further code replace "$" with "  "
    \\→#                                                            replace "#" with "\\"
        ////→@                                                      replace "@" with "////"
              ”6*p"→~3{"##@~ #@ ~$@$~ @# ~@##~\//$#\~#$$#~#\$//\~” the code to exchange stuff in

so that results in:
”6*p"→~3{"\\\\////~ \\//// ~  ////  ~ ////\\ ~////\\\\~\//  \\\~\\    \\~\\\  //\~”
”6*p"→~3{"A~B~C~D~E~F~G~H~”  modified version of the program (removing "/","\" and " " and replaced with A,B,C,ect.)
”6*p"→~                      replace in the further program "~" with ”6*p" which is:
”                            end string
 6*                          repeat the last thing in stack 6 times
   p                         output the result
    "                        start a string
resulting program: 
3{"A”6*p"B”6*p"C”6*p"D”6*p"E”6*p"F”6*p"G”6*p"H”6*p"”
shortened example:
3{"A”6*p"B”6*p"H”6*p"”
3{                      repeat 3 times
  "A”                   push "A" (original: "\\\\////")
     6*p                output it multiplied by 6
        "B”             push "B" (original: " \\//// ")
           6*p          output it multiplied by 6
              "H”       push "H" (original: "\\\  //\")
                 6*p    output it multiplied by 6
                    "”  push an empty string (shorter to do ~” than ”6*p)

Answer 7

रूबी, 75 बाइट्स

1152.times{|i|$><<"\\/ /\\\\ /"[(i+j=i/48)/4&1|(i-j)/2&2|j&4]+$/*(i%48/47)}

बेहतर गोल्फर, एक एकल 8-बाइट स्ट्रिंग लुकअप का उपयोग करके अन्य मापदंडों के अलावा जम्मू और 4 द्वारा अनुक्रमित किया गया था, न कि 4-बाइट स्ट्रिंग के बजाय।

रूबी, 81 बाइट्स

1152.times{|i|j=i/48%8;$><<"\\#{'/\\'[j/4]} /"[(i+j)/4&1|(i-j)/2&2]+$/*(i%48/47)}

विकर्ण धारियों को चरित्र द्वारा मुद्रित करता है। प्रत्येक वर्ण की उपस्थिति / अनुपस्थिति के आधार पर 4 वर्णों की एक स्ट्रिंग से सही वर्ण का चयन किया जाता है। ओवरलैप चरित्र विविध है जिसके आधार पर स्ट्रैंड शीर्ष पर है।

टिप्पणी की गई

1152.times{|i|j=i/48%8;        #Iterate through all printable chars. j is line number.
  $><<"\\#{'/\\'[j/4]} /"[     #Print a char from "\/ /" if j/4 even or "\\ /" if odd. character changes depending which strand on top.
   (i+j)/4&1|(i-j)/2&2]+       #Print \ if (i+j)/4==0, / if (i-j)/2&2 >0, space if both false. As above if both true. 
   $/*(i%48/47)                #If on column 47, print a newline.
}

Answer 8

पर्ल, 132 131 113 बाइट्स

@a=((0)x4,1..4);map{say+(map$a[7-$_]?$a[$_]*$r?'/':'\\':$a[$_]?'/':$",0..7)x6;push@a,shift@a;$_%4||($r=!$r)}0..23

Ungolfed:

use strict;
use warnings;
use feature 'say';

my @a = ((1) x 4, (0) x 4);  # print '\' if true
my @b = ((0) x 4, (1) x 4);  # print '/' if true
my $r = 0;                   # print '\' over '/' if true

for (0 .. 23) {
    say((map { $a[$_] ? ($b[$_] * $r ? '/' : '\\') : ($b[$_] ? '/' : ' ') } 0 .. 7) x 6);
    unshift(@a, pop(@a));    # circular shift to left
    push(@b, shift(@b));     # circular shift to right
    $r = !$r if !($_ % 4);   # change print priority
}

Answer 9

05AB1E , 37 बाइट्स

CP-1252 एन्कोडिंग का उपयोग करता है ।

24FNU48FXXN+XN-<)8%3›J" \// \/\"è?}¶?

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

व्याख्या

मॉड -8 ट्रिक का उपयोग जकुबे के अजगर जवाब में स्पष्ट रूप से समझाया गया है ।

24F                                    # for N in [0 ... 23] do:
   NU                                  # save N in X
     48F                               # for N in [0 ... 48] do:
        XXN+XN-<)                      # push [X,X+N,X-N-1]
                 8%                    # mod each by 8
                   3›                  # compare with 3
                     J                 # join
                      " \// \/\"è?     # index into string and print
                                  }    # end inner loop
                                   ¶?  # print newline

Answer 10

पायथन, 245 236 234 233 230 216 212 198 195 बाइट्स

ठीक है, मेरे अंतिम (और किसी भी अन्य) उत्तर से अधिक है, लेकिन दृष्टिकोण पर प्रतिक्रिया में दिलचस्पी होगी।

for a in(40,4496,6200,5456,3240,1188,720,228)*3:print((`a%6561/2178`+`a%2178/729`+`a%729/243`+`a%243/81`+`a%81/27`+`a%27/9`+`a%9/3`+`a%3/1`)*6).replace('0','\\').replace('1','/').replace('2',' ')

संपादित करें

-9 की वजह से @ nedla2004 मुझसे ज्यादा बॉल पर है

-2 लण्ड को लूप के बाहर ले जाकर और 2 इंडेंट स्पेस को खो कर

के in' '*3बजाय का उपयोग करके -1 के in 0,1,2बाद से मैं उपयोग नहीं करतेh वैसे भी । यह सिर्फ एक काउंटर है।

-3 क्यों, क्यों, क्यों मैंने दूसरी और प्रिंट के बीच एक नई लाइन और 2 इंडेंट छोड़ दिए ??? उसे देर हो गई है। कल फिर करेंगे।

-14 वास्तव में लैम्ब्डा को पूरी तरह से खो सकता है और प्रिंट स्टेटमेंट के बाद सीधे बेस 3 डिकोडर को शामिल कर सकता है। गन्दा लगता है लेकिन आखिरकार, यह कोड गोल्फ है :)

-4 पूर्णांक सूची के लिए एक चर सेट करने वाला कोई बिंदु नहीं। बस इसे सीधे लूप के लिए दूसरे में उपयोग करें।

-14 और बाहरी लूप का उपयोग करके कोई बिंदु नहीं। बस पूर्णांक के गुच्छे को 3 से गुणा करें (200 के तहत प्राप्त करने के लिए @ nedla2004 से बेशर्मी से चुराया गया)

-3 सेव्ड 3 को \ _ 0, / = 1 और स्पेस = 2 बनाकर। यह पूर्णांक सूची को आधार 3 में से तीन के रूप में छोटा करता है, जिसमें अब 0 की अग्रणी संख्या है

यह कैसे काम करता है (और यह करता है)

चूंकि केवल 3 वर्णों का उपयोग किया जाता है:

1. l उनके आधार 3 प्रतिनिधित्व के पूर्णांक समकक्षों के रूप में 8 दोहराए जाने वाले पैटर्न की एक सूची है जो यह मानते हुए कि "" = 0, "\" = 1 और "/" = 2

2. लैम्ब्डा प्रिंट स्टेटमेंट के बाद पहला कोड पूर्णांक से आधार 3 स्ट्रिंग में एक हल्का कनवर्टर है

3. पहला लूप 3 बार लूप करता है और दूसरा हर लाइन को बेस 3 कैरेक्टर के साथ 6 से गुणा करके /, \ या स्पेस से रिप्लेस किया जाता है।

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

Comments

आप बेस 3 रूपांतरण में पहले डिवीजन को हटा सकते हैं।

— nedla2004

किसी कारण से जो मुझे पहले से परेशान कर रहा था लेकिन अभी कोशिश की और यह अब काम करता है। मुझसे अधिक जागृत होने के लिए बहुत धन्यवाद। मैं अपने उत्तर को फिर से संपादित करूँगा (और आपने अभी मुझे 9 बाइट्स बचाए हैं :))

— ElPedro

मैंने आधार 3 रूपांतरण को फिर से लिखा है, यह अब लंबोदर नहीं है, मुझे इसे एक समारोह बनाना था, लेकिन यह एक मेमने में परिवर्तित हो सकता है। आप यहां फंक्शन पा सकते हैं ।

— nedla2004

धन्यवाद। मुझे लगता है कि दोनों का संयोजन काम कर सकता है लेकिन शायद कल शाम के लिए एक काम है :) आपकी टिप्पणियों के लिए फिर से धन्यवाद।

— एल्पेड्रो

मैं इसे नीचे 169 तक ले गया, यहाँ ।

— nedla2004

Answer 11

रूबी, 135 बाइट्स

puts [3320,1212,720,2172,6520,4144,2920,3184].map{|e|(e.to_s(3).rjust(8,"0").gsub("0"," ").gsub("1","\\").gsub("2","/"))*6+"\n"}.join*3

संख्या सरणी प्रत्येक पंक्ति के प्रत्येक घटक से मेल खाती है, जिसका अनुवाद आधार 3: = 0 से किया गया है,\ = 1 है।/ = 2 से किया जाता है, फिर दशमलव में परिवर्तित किया जाता है। Gsub () कॉल बहुत बड़ी हैं, हालांकि।

और, अभी-अभी, मैंने @ ElPedro का उत्तर देखा। :-( सिर्फ संयोग।

Comments

e.to_s(3).rjust(8,"0")→ ("%8s"%e.to_s(3)); gsub("0"," ").gsub("1","\\")..gsub("2","/")→ tr("013"," \\/"); "\n"→ $/; .join→ *""। आप सरणी में सभी संख्याओं को 4 से विभाजित करके और के eसाथ प्रतिस्थापित करके एक बाइट को भी बचा सकते हैं (e*4)।

— जॉर्डन

उफ़, मुझे लगता है कि होना चाहिए tr("021"," /\\")।

— जॉर्डन

90 बाइट्स: tio.run/##ccjNDkUwEEDhV5FJJG0zl6mhauG@CHJDws5PlMUNnr26Ol/Ofg5-…

— जॉर्डन

Answer 12

PHP 157 126 बाइट्स

बदलावों को देखते हुए @ टिट्स लिस्ट कमेंट्स में ... मुझे गुस्सा आ रहा है कि मैं 1 अंक से चूक गया था जिसे मुझे पकड़ा जाना चाहिए था, लेकिन मुझे पता नहीं था कि स्ट्रेट () मौजूद था जो कि ज्यादातर बचत आती है - अच्छा काम टाइटस!

नया:

while($i<32)echo$b=strtr([3322,' 322 ','0220',' 223 ',2233,12013,3003,13021][$i++%8],['  ','\\','//','\\\\']),"$b$b$b$b$b\n";

पुराना:

<?$a=[zzyy,' zyy ',syys,' yyz ',yyzz,xysxz,zssz,xzsyx];while($i<32){$b=$a[$i++%8];$b=str_replace([z,x,y,s],['\\\\','\\','//','  '],$b);echo"$b$b$b$b$b$b
";}

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

Comments

यदि आप उपयोग करते हैं तो आप खुले टैग को हटा सकते हैं -r। एक और 30 बाइट को बचाने के लिए इन पांच चरणों का उपयोग करें: ideone.com/wt4HGB 1) इसे असाइन करने के बजाय $a[...]सीधे str_replaceपैरामीटर के रूप में उपयोग करें । 2) के strtrबजाय str_replace। 3) अक्षरों के बजाय अंकों का उपयोग करें। 4) इको में असाइनमेंट शामिल करें। 5) असाइन न करें $a, बस इसका उपयोग करें।

— टाइटस

Answer 13

अजगर 2, 169 161 165 160 155 154 152

छोटे सुधार के साथ @ एलपेड्रो के उत्तर पर आधारित। स्पष्टीकरण देखने के लिए, उनका उत्तर देखें । यह पायथन 2 है, भले ही पास में कोष्ठक लगता है print।

के लिए एक चर का उपयोग करके 8 बाइट्स सहेजे गए replace।यह केवल तार के लिए काम करता है, और इसके लिए एक फ़ंक्शन का उपयोग करना अधिक लंबा होगा।

@ElPedro ने महसूस किया कि उन्हें l की जरूरत नहीं है, और मुझे भी नहीं लगा, देखकर 4 बाइट्स बचाए।

5 बाइट्स को फ़्लिप न करके सहेजा range(8), और +=आर के लिए उपयोग करने के बजाय , नए अंक के अंत में आर जोड़कर। Repl.it का उपयोग करके इसे आज़माएं

@ ElPedro के मूल्यों की नई सूची चोरी करके 5 बाइट्स सहेजे गए।

inऔर के बीच की जगह को हटाकर 1 बाइट को बचाया (।

चर को हटाकर 2 बाइट्स सहेजे गए।

for x in(40,4496,6200,5456,3240,1188,720,228)*3:
 r=''
 for i in range(8):r=`x/3**i%3`+r
 print(r*6).replace('0','\\').replace('1','/').replace('2',' ')

Comments

आप के बीच की जगह को हटाने के द्वारा 1 बचा सकता है inऔर (के लिए पहली में

— ElPedro

इसके अलावा मैंने तीन बाइट्स खो दिए हैं, जो क्रम को क्रमबद्ध करके आधार 3 सूची में प्रत्येक वर्ण का प्रतिनिधित्व करते हैं। स्पष्टीकरण के लिए मेरा जवाब देखें। नकल करने के लिए स्वतंत्र महसूस करें। जहां तक ​​मेरा सवाल है यह एक संयुक्त प्रयास है और मुझे यह देखकर खुशी हुई कि मेरे मूल विचार में कम से कम कुछ संभावनाएं

— थीं

आप की जरूरत नहीं है a=3**i। बस एक जोड़े को बचाने के लिए for i in range(8):r=x / 3 ** i% 3 +rका उपयोग करें । ऑपरेटर पूर्वता बाकी की देखभाल करता है :)

— ElPedro

सुनिश्चित नहीं है कि स्ट्रिंग रूपांतरण वर्णों का परिसीमन कैसे किया जाए। पार्सर ने उन्हें मेरी पिछली टिप्पणी में हटा दिया ताकि मेरे सुझाव से केवल कॉपी और पेस्ट न करें या यह टूट जाएगा :)

— ElPedro

अच्छी बात है, मैं समझ गया।

— nedla2004

Answer 14

PHP, 184 बाइट्स

<?$p=['1111////',' 11//// ','  ////  ',' ////11 ','////1111','1//  111','11    11','111  //1'];for($j=0;$j<3;$j++)for($i=0;$i<8;$i++)echo str_replace(1,'\\',str_repeat($p[$i],6))."\n";

आउटपुट:

C:\PHP>php make-me-a-blanket.php
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\

Answer 15

बैच, 152 बाइट्स

@call:l
@call:l
:l
@for %%s in (\\\\//// " \\//// " "  ////  " " ////\\ " ////\\\\ "\//  \\\" "\\    \\" "\\\  //\")do @echo %%~s%%~s%%~s%%~s%%~s%%~s

बैच बेकार में स्ट्रिंग प्रसंस्करण, तो यह शायद सबसे अच्छा तरीका है। कॉल-एंड-फ़ॉल-थ्रू नेस्टेड forलूप की तुलना में बहुत कम है । कम से कम मुझे अपने बैकस्लैश को उद्धृत करने की आवश्यकता नहीं है!

Answer 16

एपीएल, 110 बाइट्स

मैं एपीएल के लिए नया हूं, इसलिए यह एक सरलीकृत समाधान है।

A←48⍴'\\\\////'⋄B←48⍴' \\//// '⋄C←48⍴'  ////  '⋄F←48⍴'\//  \\\'⋄G←48⍴'\\    \\'⋄24 48⍴A,B,C,(⊖B),(⊖A),F,G,⊖F  

यहां मेरा दृष्टिकोण है: ध्यान दें कि कंबल की पहली 8 पंक्तियों के बाद, पैटर्न खुद को दोहराता है। इसलिए मुझे केवल पहले 8 लाइनों को परिभाषित करने की आवश्यकता है, और फिर मैं उन्हें 3 बार दोहरा सकता हूं। यह भी ध्यान दें कि प्रत्येक पंक्ति पहले 8 अक्षरों के बाद खुद को दोहराती है। इसलिए एक एकल पंक्ति को परिभाषित करने के लिए मुझे केवल पहले 8 वर्णों को परिभाषित करने की आवश्यकता है और फिर उन्हें 8 बार दोहराएं।

यहाँ एक ungolfed समाधान है:

A←48⍴'\\\\////'⋄ ⍝ set A to a 48 element vector (48⍴) of repeated '\\\\////'s
B←48⍴' \\//// '⋄ ⍝ set B to a 48 element vector (48⍴) of repeated ' \\//// 's
C←48⍴'  ////  '⋄ ⍝ ...
D←48⍴' ////\\ '⋄ ⍝ Note that this is actually the reverse of vector B
E←48⍴'////\\\\'⋄ ⍝ Note that this is actually the reverse of vector A
F←48⍴'\//  \\\'⋄
G←48⍴'\\    \\'⋄
H←48⍴'\\\  //\'⋄ ⍝ Note that this is actually the reverse of vector F

24 48 ⍴ A,B,C,D,E,F,G,H ⍝ Make a 24 by 48 character matrix (24 48⍴) by concatenating A,B...H
                        ⍝ and repeating the string until the matrix is full

मैंने ऊपर उल्लेख किया है कि D, B का उल्टा है, E, A का उलटा है और H, F का उल्टा है। मेरे वास्तविक कोड में, मैं इसका लाभ D, F, या H को परिभाषित न करके और रिवर्स फ़ंक्शन का उपयोग करके लेता हूं। ⊖:

24 48⍴A,B,C,(⊖B),(⊖A),F,G,⊖F

Answer 17

रूबी, 132 बाइट्स

puts Zlib.inflate Base64.decode64 "eJzt0bENADAMAsGeKdggC/3+cyQRC+A2ipuT3RgJgHWGUjm6VXb2Vjn/3KpJ/qtIPlp1v+XSKZKPVk3y/x5+D6/3sAEUXQ+Q"

बहुत ही सरल जवाब।

Answer 18

हास्केल, 96 बाइट्स

f n=n`mod`8`div`4
putStr$unlines[["\\ //\\ \\/"!!(f(x-y)+2*f(x+y)+4*f y)|x<-[0..47]]|y<-[0..23]]