मुझे हनीकॉम्ब चाहिए

Question

सबसे छोटा प्रोग्राम लिखिए जो एक हेक्सागोनल टाइलिंग या हनीकॉम्ब के इस ASCII कला अनुभाग को प्रिंट करता है :

       __
    __/  \__
 __/  \__/  \__
/  \__/  \__/  \
\__/  \__/  \__/
/  \__/  \__/  \
\__/  \__/  \__/
/  \__/  \__/  \
\__/  \__/  \__/
   \__/  \__/
      \__/

• कोई इनपुट नहीं लिया जाना चाहिए।
• स्टडआउट या आपकी भाषा के निकटतम विकल्प के लिए आउटपुट।
• एक कार्यक्रम के बजाय, आप एक नामित फ़ंक्शन लिख सकते हैं जो कोई पैरामीटर नहीं लेता है और परिणाम को सामान्य रूप से प्रिंट करता है या इसे एक स्ट्रिंग के रूप में लौटाता है।
• आउटपुट में किसी भी संख्या में अग्रणी और / या नई अनुगामी हो सकती हैं और आउटपुट में प्रत्येक पंक्ति में अग्रणी और / या अनुगामी रिक्त स्थान की कोई संख्या हो सकती है (जब तक कि पैटर्न ठीक से ऊपर न हो जाए।)
• बाइट्स में सबसे छोटा कोड जीतता है।

Comments

क्या आप बहुत सारे केतन खेलते हैं?

— user3490

@ user3490 वास्तव में मैं ^ ^

— केल्विन के

पीसीजी पर अगले सप्ताह: एक केतन बोर्ड जनरेटर लिखें?

— user3490

इसमें एक इनपुट IMO होना चाहिए, आपके मामले में यह 3. होना चाहिए

— user3819867

@ user3819867 मैंने इस पर विचार किया, लेकिन इसे प्राथमिकता दी। बदलने के लिए बहुत देर हो चुकी है लेकिन किसी को भी संबंधित चुनौती देने में बहुत देर नहीं हुई है।

— केल्विन के शौक

Answer 1

CJam, 45 43 42 41 40 बाइट्स

741e8 36+Ab"\__/  "38*21/.{G2$-<\S*.e<N}

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

"\__/  "38*21/

\__/ 38 बार पैटर्न को दोहराता है और इसे 21 की लंबाई में विभाजित करता है । यदि चंक्स को लाइनफीड द्वारा अलग किया गया था, तो यह परिणाम होगा:

\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/  

इसमें स्पष्ट रूप से वांछित छत्ते शामिल हैं। बस इतना करना बाकी है कि कुछ पात्रों को रिक्त स्थान से बदल दिया जाए, कुछ को काट दिया जाए और वास्तव में लाइनफीड का परिचय दिया जाए।

741e8 36+Ab

पूर्णांक 74 100 000 036 उत्पन्न करता है और इसे सरणी में परिवर्तित करता है [7 4 1 0 0 0 0 0 0 3 6] । प्रत्येक सरणी तत्व, संबंधित पंक्ति के प्रमुख वर्णों की संख्या को एन्कोड करता है जिन्हें रिक्त स्थान के साथ बदलना पड़ता है। इस संख्या को 16 से घटाकर , हम इस रेखा के लिए सही लंबाई भी प्राप्त करते हैं।

.{            } e# Execute for each pair of a digit D and a line L:
  G2$-<         e#   Chop off L after 16 - D characters.
       \S*      e#   Push a string of D spaces.
          .e<   e#   Compute the vectorized minimum.
             N  e#   Push a linefeed.

चूँकि एक स्पेस में L के अन्य वर्णों की तुलना में एक कम कोड बिंदु होता है और सदिश संचालक लंबे स्ट्रिंग के वर्णों को छोड़ देते हैं जो किसी एक छोटे से अछूते के अनुरूप नहीं होते हैं, .e<जो पहले D अक्षर को रिक्त स्थान से बदल देता है ।

Comments

ये जबरदस्त है। अच्छा काम।

— एलेक्स ए

Answer 2

पायथन 2, 73

i=0
exec"k=max(7-i,i-24,0);print' '*k+('\__/  '*9)[i:][k:16-k];i+=3;"*11

इसे चलाकर देखें।

11 आउटपुट पंक्तियों में से प्रत्येक के लिए, प्रमुख रिक्त स्थान की संख्या को kअधिकतम तीन रैखिक कार्यों के रूप में गणना करता है जो हेक्सागोन के बाईं ओर का लिफाफा बनाते हैं। क्योंकि विकर्ण लाइनों में ढलान है 3और -3, पंक्ति संख्या को अनुक्रमित करना बेहतर है i=0,3,...30।

षट्भुज जाल बनाने के लिए, हम पहले इकाई के पर्याप्त टाइल करते हैं '\__/ '। फिर, [i:]इसे विषम पंक्तियों के लिए 3 से स्थानांतरित कर देता है। अंत में, हम इसके आवश्यक हिस्से [k:16-k]को लेते हैं , जिससे kबाईं और दाईं ओर एक मार्जिन होता है ।

Answer 3

CJam, 65 56 55 बाइट्स

"Ý6TNð*¯5"303b4b["/\_")"_ "4*S]f=sB/z{_W%"\/"_W%erN}/

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

विचार

प्रत्येक पंक्ति का दाहिना आधा बाईं ओर का आधा उलटा होता है जिसमें स्लैश और बैकस्लैश स्वैप होते हैं। इसलिए, यह मधुकोश के बाएं आधे हिस्से को एनकोड करने के लिए पर्याप्त है:

       _
    __/ 
 __/  \_
/  \__/ 
\__/  \_
/  \__/ 
\__/  \_
/  \__/ 
\__/  \_
   \__/ 
      \_

लाइन द्वारा इस पैटर्न लाइन का विश्लेषण करने के बजाय, हम इसे कॉलम द्वारा कॉलम का विश्लेषण कर सकते हैं:

   /\/\/\  
  _ _ _ _  
  _ _ _ _  
  /\/\/\/\ 
 _ _ _ _ _ 
 _ _ _ _ _ 
 /\/\/\/\/\
_ _ _ _ _ _

स्पष्ट पैटर्न उभर कर आते हैं:

• स्ट्रिंग _ _ _ _पांच बार होती है।
• हर /एक के बाद एक है \।

हर बदलकर /\, _, _ _ _ _0 से 3 करने के लिए एक नंबर के साथ और अंतरिक्ष, हम एक ऊंचे बेस के लिए एक आधार के 4 संख्या से उत्पन्न सरणी बदलने और एक कॉम्पैक्ट फैशन में पूरा पैटर्न स्टोर कर सकते हैं।

कोड

"Ý6TNð*¯5"303b4b  e# Convert the string from base 303 to base 4.
["/\_")"_ "4*S]f= e# Replace each resulting digit by the corresponding item of the array
                  e# ["/\" "_" "_ _ _ _ " " "].
sB/               e# Split into strings of length 11.
z                 e# Zip: transpose rows with columns.
{             }/  e# For each string:
 _W%              e#     Push a reversed copy.
    "\/"_W%er     e#     Swap slashes and backslashes.
             N    e#     Push a linefeed.

Answer 4

सी, 148 144 140 बाइट्स

k,r,c,d,p;f(){for(;k<187;k++){r=k/17;c=k%17;d=c+r%2*3;p=3*r+c-7<33u&3*r-c+8<33u;putchar(c==16?10:p&(d+5)%6<2?95:p&d%6==3?47:!p|d%6?32:92);}}

संकलक चेतावनी के बिना व्हाट्सएप के साथ, और कुछ बाइट्स को बचाने के लिए कुछ कोड से पहले:

#include <stdio.h>

int k, r, c, d, p;

void f() {
    for ( ; k < 187; k++) {
        r = k / 17;
        c = k % 17;
        d = c + 3 * (r % 2);
        p = 3 * r + c - 7 < 33u && 3 * r - c + 8 < 33u;
        putchar(
            c == 16 ? 10 :
            p && (d + 5) % 6 < 2 ? 95 :
            p && d % 6 == 3 ? 47 :
            p && d % 6 == 0 ? 92 :
            32);
    }
}

यह दृष्टिकोण किसी भी वर्ण / स्ट्रिंग तालिकाओं का उपयोग नहीं करता है। यह सभी 187 (11 पंक्तियों, 17 कॉलमों को शामिल करता है, जिसमें नई लाइनें शामिल हैं) और शर्तों के संयोजन के आधार पर प्रत्येक स्थिति के लिए किस वर्ण को प्रिंट करना है, यह तय करता है।

परिस्थितियों में 4 कोनों के अंदर / बाहर होने के लिए एक परीक्षण शामिल है, 4 लाइन समीकरणों का उपयोग करके, चर में संग्रहीत परिणाम के साथ p। बाकी तो हर 6 वर्णों को दोहरा रहा है, विषम पंक्तियों के साथ 3 पंक्तियों को भी समान पंक्तियों के सापेक्ष स्थानांतरित कर दिया।

Comments

गोल्फ वाले के लिए, आप निहित-इंट का उपयोग कर सकते हैं और ड्रॉप कर सकते हैं int ।

— लूजर ने

कुछ सूक्ष्म सुधार:k;f(r,c,d,p){for(;k<187;putchar(c>15?10:p&d<2&p?95:p&d<3?47:!p|d-5?32:92))r=k/17,c=k++%17,d=(5+c+r%2*3)%6,p=3*r+c-7<33u&3*r-c+8<33u;}

— डेनिस

Answer 5

रूबी - 78 बाइट्स

(-5..5).map{|i|puts' '*(j=[i.abs*3-i/6-9,0].max)+('/  \__'*4)[j+i%2*3,16-j*2]}

---

Xnor के समाधान का एक प्रतिलेखन (69 बाइट्स):

11.times{|i|puts' '*(j=[7-i*=3,i-24,0].max)+('\__/  '*9)[i+j,16-j*2]}

Comments

11.times2 बाइट्स बचाता है

— मिच श्वार्ट्ज

Answer 6

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

यह एक शुद्ध स्ट्रिंग की जगह है / प्रतिस्थापित / बदलें ... किसी भी ज्यामितीय संपत्ति का लाभ नहीं ले रहा है।

टेम्प्लेट स्ट्रिंग्स का उपयोग करते हुए, सभी न्यूलाइन्स महत्वपूर्ण और गिनती हैं।

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

f=_=>`70
405
 055
9992 3051
6301`[R='replace'](/9/g,`55123
30551
`)[R](/5/g,1230)[R](/\d/g,n=>['__','/',,'\\'][n]||' '.repeat(n))

// TEST

O.innerHTML = f()

<pre id=O></pre>

Answer 7

PHP - 139 137 107 101 91 87 बाइट्स

मुझे नहीं पता कि यह गोल्फ के लिए सबसे अच्छा तरीका है, लेकिन यहाँ मेरी कोशिश है:

30 36 46 -50 बाइट्स इस्माइल मिगुएल के लिए धन्यवाद

इसे यहाँ ऑनलाइन टेस्ट करें

<?='       __
    __',$a='/  \__',"
 __$a$a
",$c="$a$a/  \
\__$a$a/
","$c$c   \__$a/
      \__/";

<script src="http://ideone.com/e.js/WHWEZS" type="text/javascript" ></script>

पुराना कोड:

<?php $a="/  \\__";$c=$a.$a."/  \\\n\__".$a.$a."/\n";echo "       __\n    __".$a."\n __".$a,$a."\n".$c,$c,$c."   \\__".$a."/\n      \\__/";

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है। आपका PHP कोड बहुत अधिक घटाया जा सकता है। आप 3 बाइट्स को बचाने के <?बजाय उपयोग कर सकते हैं <?php। इसके बजाय $c=$a.$a."/ \\\n\__".$a.$a."/\n";, आप लिख सकते हैं $c="$a$a/ \\\n\__.$a$a/\n";(चूंकि PHP स्ट्रिंग्स में चर का विस्तार करता है)। आप echoइसकी लंबाई कम करने के लिए उसी तर्क को लागू कर सकते हैं । इसके अलावा, आपको echoऔर स्ट्रिंग के बीच उस स्थान की आवश्यकता नहीं है ।

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

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

— तिमो

आपका स्वागत है। यहाँ एक 99-बाइट लंबा समाधान है: ideone.com/WHWEZS । यह गड़बड़ दिखता है, लेकिन यह बहुत छोटा है। उपयोग करने के बजाय \n, आप एक वास्तविक न्यूलाइन डाल सकते हैं और प्रति पंक्ति 1 बाइट बचा सकते हैं।

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

इस बीच, मैंने इसे 2 बाइट्स घटा दिया है। अब इसमें 97 बाइट्स हैं।

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

यहाँ एक लाइनर है <?="\t __\n\t__",$a='/ \__',"\n __$a$a\n",$c="$a$a/ \\\n\__$a$a/\n","$c$c \__$a/\n\t \__/";:। \tटैब कैरेक्टर और \nअसली न्यूलाइन के साथ बदलना याद रखें ।

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

Answer 8

लुआ 146

T="       __\n    __/  \\__\n __/  \\__/  \\__\n"
S="/  \\__/  \\__/  \\\n\\__/  \\__/  \\__/\n"
B="   \\__/  \\__/\n      \\__/"
io.write(T,S,S,S,B)

(newlines स्पष्टता के लिए जोड़ा गया)

Comments

क्या यह कोड वांछित आउटपुट से अधिक लंबा नहीं है क्योंकि इसमें सिर्फ आउटपुट प्लस एस्केप और स्ट्रिंग हैंडलिंग सामान शामिल है?

— कालेब

@ कालेब: मुझे संदेह है कि आपने वास्तव में गिनती नहीं की है और केवल उस टिप्पणी को बनाने में अनुमान लगाया है। मेरे पाठ संपादक के अनुसार, जाली में 165 वर्ण हैं (शामिल नईं)। Sतीन बार दोहराने के कारण मेरे पास 19 कम पात्र हैं ।

— काइल कानोस

लेकिन आप सही हैं कि इस विशेष गेम में प्रतिस्पर्धा करने के लिए पलायन और नई सूचियाँ मेरे कोड की क्षमता को सीमित करती हैं। लेकिन जीतना यह भी नहीं है कि मैं ऐसा क्यों करता हूं, यह मजेदार और सीखने के लिए है।

— काइल कानोस १15

Answer 9

डार्ट - 113

main({r:"/  \\__"}){print("       __\n    __$r\n __$r$r\n${"$r$r/  \\\n\\__$r$r/\n"*3}   \\__$r/\n      \\__/");}

शुद्ध स्ट्रिंग-प्रक्षेप समाधान, कुछ भी नहीं फैंसी। अभ्यास में प्रतिस्पर्धा करने के लिए "सबस्ट्रिंग" जैसे स्ट्रिंग ऑपरेशन बहुत अधिक क्रियात्मक हैं।

इसे डार्टपैड पर चलाएं ।

Answer 10

जावास्क्रिप्ट ( ईएस 7 ड्राफ्ट ), 96 94 93 बाइट्स

यहां कुछ समाधानों से ली गई प्रेरणा ...

संपादित करें: -1 edc65 से

f=z=>[for(x of[741e6]+36)' '.repeat(x)+'/  \\__'.repeat(4,z^=3).slice(+x+z,16-x+z)].join(`
`)

// For snippet demo:
document.write('<pre>'+f()+'</pre>');

टिप्पणी की:

f=z=>[                                 
        for(x of [741e6] + 36)        // for each character "x" in "74100000036"
            ' '.repeat(x) +           // x spaces
            '/  \\__'.repeat(4,       // build pattern string
            z ^= 3).                  // toggle z offset (3) for even lines
            slice(+x + z, 16 - x + z) // get appropriate substring
    ].join(`                          // join with newlines
    `)

Comments

अच्छा है। .substr(+x+z,16-x-x)-> .slice(+x+z,16-x+z)-1

— edc65

@ edc65 अच्छी पकड़!

— शाम

त्वरित प्रश्न: यह +xसिर्फ के बजाय क्यों है x?

— निक हार्टले

@QPaysTaxes इसे xएक नंबर पर डालना है। इसके बिना, यह श्रेणीबद्ध हैंz

— nderscore

Answer 11

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

n=0x85208e08e08dd445
while n:l=n>>2&15;print(' '*(8-l)+('\__/  '*4)[n&3:n&3|l*2]);n>>=6

और नीचे दिए गए कोड का एक पठनीय संस्करण। विचार अंतराल को शुरू करने के लिए अंतराल (शुरुआत, लंबाई) और फिर पैड को सही मात्रा में रखने के लिए है।

hexagon_string = '\__/  ' * 4
for i in range(11):
    # Pick the begin and length of the i-th interval using hardcoded numbers
    b = (0x00030303111 >> 4*i) & 3   # n is a combination of these two numbers
    l = (0x25888888741 >> 4*i) & 15  #
    # Print the interval with appropriate whitespace in front of it
    spaces = ' ' * (8-l)
    print(spaces + hexagon_string[b : b+l*2])

Answer 12

रेटिना , 66 बाइट्स

<empty line>
sss __<LF>ssa__<LF> aa__<LF>lll dau<LF>ssdu
l
/daa<LF>\aau<LF>
a
ud
u
__/
d
s\
s

प्रत्येक पंक्ति को अपनी फ़ाइल में जाना चाहिए और फ़ाइल <LF>में वास्तविक नई लाइन का मतलब होना चाहिए । 1 बाइट प्रति अतिरिक्त फ़ाइल बाइट-काउंट में जोड़ी गई।

आप कोड को -sध्वज के साथ एक फ़ाइल के रूप में चला सकते हैं , <LF>मार्करों को रख सकते हैं और हो सकता है कि यदि आप चाहें तो उन्हें पठनीयता के लिए आउटपुट में नए सिरे से बदल दें।

एल्गोरिथ्म एक खाली इनपुट स्ट्रिंग से शुरू होने वाले 5 सरल स्थानापन्न चरण (विषम लाइन सामग्री को यहां तक ​​कि लाइन सामग्री तक बदलें) है। प्रत्येक चरण के बाद परिणाम (सीमांकित द्वारा सीमांकित =) हैं:

sss __
ssa__
 aa__
lll dau
ssdu
============
sss __
ssa__
 aa__
/daa
\aau
/daa
\aau
/daa
\aau
 dau
ssdu
============
sss __
ssud__
 udud__
/dudud
\ududu
/dudud
\ududu
/dudud
\ududu
 dudu
ssdu
============
sss __
ss__/d__
 __/d__/d__
/d__/d__/d
\__/d__/d__/
/d__/d__/d
\__/d__/d__/
/d__/d__/d
\__/d__/d__/
 d__/d__/
ssd__/
============
sss __
ss__/s\__
 __/s\__/s\__
/s\__/s\__/s\
\__/s\__/s\__/
/s\__/s\__/s\
\__/s\__/s\__/
/s\__/s\__/s\
\__/s\__/s\__/
 s\__/s\__/
sss\__/
============
       __
    __/  \__
 __/  \__/  \__
/  \__/  \__/  \
\__/  \__/  \__/
/  \__/  \__/  \
\__/  \__/  \__/
/  \__/  \__/  \
\__/  \__/  \__/
   \__/  \__/
      \__/

Answer 13

जावास्क्रिप्ट, 154 151 बाइट्स

b="\n",c="\t",d="/  \\",f="__",g="\\",h="/",a=f+d,j=a+a,i=d+j+b+g+j+f+h+b,k="   ";console.log(c+k+f+b+c+a+f+b+" "+j+f+b+i+i+i+k+g+a+f+h+b+c+"  "+g+f+h)