हेक्सागोन्स के त्रिकोण

Question

मान लीजिए कि |/\वर्णों से बना हेक्सागोन्स की एक अनंत टाइलिंग ।

 / \ / \ / \ / \
|   |   |   |   |
 \ / \ / \ / \ /  etc.
  |   |   |   |
   \ / \ / \ /

इनपुट को देखते हुए n > 0, उस टाइलिंग के एक त्रिकोणीय हिस्से को नीचे दिए गए उदाहरणों में दर्शाया गया है, _एक षट्भुज के बीच में एंकर किया गया है :

n=1
\_/

n=2
\/ \/
 \_/

n=3
\  |  /
 \/ \/
  \_/

n=4
\/ \ / \/
 \  |  /
  \/ \/
   \_/

n=5
\  |   |  /
 \/ \ / \/
  \  |  /
   \/ \/
    \_/

n=6
\/ \ / \ / \/
 \  |   |  /
  \/ \ / \/
   \  |  /
    \/ \/
     \_/

n=7
\  |   |   |  /
 \/ \ / \ / \/
  \  |   |  /
   \/ \ / \/
    \  |  /
     \/ \/
      \_/

n=8
\/ \ / \ / \ / \/
 \  |   |   |  /
  \/ \ / \ / \/
   \  |   |  /
    \/ \ / \/
     \  |  /
      \/ \/
       \_/

and so on

नियम

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

Comments

यदि आप परिणाम के शीर्ष के साथ अंतिम बिंदुओं की संख्या की गिनती करते हैं, तो आपको 4. 2 , 4 , 3 , 6 , 4 , 8 , 5 , 10 , 10 की ऑफसेट के साथ A029578 (सम संख्याओं के साथ समाहित प्राकृतिक संख्या) मिलता है। 6 , 12 , 7 , 14 , ...

— इंजीनियर टोस्ट

"एक छवि के रूप में सहेजा गया" का क्या अर्थ है? क्या यह एस्की-आर्ट टैग है?

— tsh

@tsh हाइपरकार्ड या कुछ और चीजों के लिए, जहां एक कैनवास पर आउटपुट उनके "स्टडआउट" आउटपुट के बराबर है। मैं कैसे उत्पादन प्रदर्शित किया जाता है पर picky नहीं हूँ ।

— AdmBorkBork

Answer 1

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

i=k=input()
while i:i-=1;print(" "*(k+~i)+"\\"+i*' /  |\  '[i%2::2])[:k-~i]+"_/"[i>0:]

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

एरिक की चाल में से एक ने मुझे 3 बाइट्स की अनुमति दी! जोनाथन एलन के लिए 3 बाइट्स को सहेजा गया।

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

सबसे पहले, यह STDIN से इनपुट प्राप्त करता है और इसे दो अलग-अलग वेरिएबल्स में असाइन करता है iऔर k। तब, जबकि चर iसत्य है, हम इसे घटाते हैं और तदनुसार तार उत्पन्न करते हैं; यह इनपुट से लूपिंग के लिए एक शॉर्टहैंड है - 1 सभी तरह से नीचे 0 पर।

स्ट्रिंग्स बनाना

मैं इसे और भागों में विभाजित करूँगा:

• सबसे पहले, अग्रणी रिक्ति प्राप्त करने के साथ प्राप्त किया जाता है " "*(k+~i)। चूंकि iरेंज (इनपुट, 0] के माध्यम से मैप किया जाता है , हमें इसे k(हमारे सुरक्षित रूप से संग्रहीत मूल इनपुट से) घटाना चाहिए , और कई बार एक स्थान को दोहराना चाहिए।

• +"\\"- चरित्र "\"को ऊपर के रिक्त स्थान में जोड़ता है।

• ' / |\ '[i%2::2]- निम्नलिखित तरीके से , हमारे दो तार उत्पन्न करता है, "/ \ "और " | ":

  • तो iअजीब है, मैं% 2 है 1 , इस प्रकार [i%2::2]हमारे बड़े स्ट्रिंग के प्रत्येक 2 वर्ण देता है, सूचकांक पर शुरू 1 (अनुक्रमित 0)।

  • तो iभी है, मैं% 2 है 1 , एक ही करता है इस प्रकार ऊपर तंत्र को छोड़कर यह सूचकांक पर शुरू होता है 0 ।

• +~-i*- से दोहराया जाएगा स्ट्रिंग ऊपर जेनरेट, या तो "/ \ "या " | ", i-1 बार, और अन्य तार करने के लिए इसे जोड़ देता है। बिटवाइज ऑपरेटर ( ~- बिटवाइज़ कॉम्प्लिमेंट, इक्वलेंट टू आई सबट्रेक्ट -1 ) का लाभ यह है कि इसके लिए इस संदर्भ में कोष्ठक की आवश्यकता नहीं है।

• [:k-~i]- अनुक्रमणिका k- ~ i = k - (-1 - i) = k + 1 + i तक उपरोक्त सभी वर्णों को मिलाया जाता है ।

• +"_/"[i>0:]- यह केवल "/"अगर मैं ≥ 1 जोड़ता है, अन्यथा यह जोड़ता है _/।

पूर्ण उदाहरण / निष्पादन विवरण

आइए एक उदाहरण को पकड़ो कि 4 के इनपुट के लिए चीजें कैसे काम करती हैं :

i=k=input()        # i and k are assigned to 4.
while i:           # Starts the loop. The initial value of i is 4.
i-=1;              # Decrement i. i is now 3.
" "*(k+~i)         # A space repeated k - 1 - i = 4 - 1 - 3 = 0 times.
+"\\"              # Plus the character "\". CS (Current string): "\".
' /  |\  '[i%2::2] # The string ' /  |\  '[3%2::2] = ' /  |\  '[1::2] = "/ \ ".
i*                 # ^ repeated i = 3 times: "/ \ / \ / \ ".
+                  # And concatenate. CS: "\/ \ / \ / \ "
[:k-~i]            # Get the characters of ^ up to index k + 1 + i = 4 + 1 + 3 = 8.
                   # CS: "\/ \ / \".
+"_/"[i>0:]        # Append "_/"[i>0:] = "_/"[3>0:] = "_/"[1:] = "/".
                   # CS: "\/ \ / \/".
print              # Output the result "\/ \ / \/".
while i:           # i is truthy (> 0), thus we loop again.
i-=1;              # Decrement i. i becomes 2.
" "*(k+~i)         # " " repeated 4 - 2 - 1 = 1 time. 
+"\\"              # Plus "\". CS: " \".
' /  |\  '[i%2::2] # ' /  |\  '[2%2::2] = ' /  |\  '[::2] = "  | ".
+i*                # Repeat i = 2 times and append: "  | ". CS: " \  |  |".
[:k-~i]            # CS up until k + 1 + i = 4 + 2 + 1 = 7. CS: " \  |  ".
+"_/"[i>0:]        # Append "/". CS: " \  |  /".
print              # Outputs the CS: " \  |  /".
while i:           # i is truthy (> 0), thus we loop again.
i-=1;              # Decrement i. i is now 1.
" "*(k+~i)         # " " repeated 4 - 1 - 1 = 2 times. 
+"\\"              # Plus "\". CS: "  \".
' /  |\  '[i%2::2] # ' /  |\  '[2%2::2] = ' /  |\  '[::2] = "/ \ ".
+i*                # Repeat i = 1 time and append: "/ \ ". CS: "  \/ \ ".
[:k-~i]            # CS up until k + i + 1 = 4 + 2 = 6. CS: "  \/ \".
+"_/"[i>0:]        # Append "/". CS: "  \/ \/".
print              # Outputs the CS: "  \/ \/".
while i:           # i is truthy (> 0), thus we loop again.
i-=1;              # Decrement i. i is now 0.
" "*(k+~i)         # " " repeated 4 - 1 - 0 = 3 times. 
+"\\"              # Plus "\". CS: "   \".
' /  |\  '[i%2::2] # ' /  |\  '[1%2::2] = ' /  |\  '[1::2] = "  | ".
+i*                # Repeat i = 0 times and append: "   \". CS: "   \".
[:k-~i]            # CS up until k + i + 1 = 4 + 0 + 1 = 5. CS: "   \".
+"_/"[i>0:]        # Append "_/" (because i > 0 is False since i == 0). CS: "  \_/".
print              # Outputs the CS: "  \_/".
while i:           # i == 0, hence the condition is falsy and the loop ends. 
                   # Program terminates.

Comments

i-=1लूप की शुरुआत में स्थानांतरित करें और 87 बाइट्स को नीचे लाने के लिए थोड़ा अलग दाहिने हाथ-साइड गठन का उपयोग करें ।

— जोनाथन एलन

... वास्तव में अपने दाहिने हाथ की ओर गठन की तरह कुछ का उपयोग कर 86 बाइट्स में बेहतर :) :)

— जोनाथन एलन

@JonathanAllan ... धन्यवाद! (हालांकि स्पष्टीकरण को फिर से

— परिभाषित करना

@JonathanAllan मुझे एक ऐसा विकल्प मिला , जो डिक्रीमेंट स्टेटमेंट के आदेश को उलट नहीं करता है।

— श्री एक्सकोडर

Answer 2

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

n=N=input()
while N:print' '*(n-N)+'\\'+(('/   \|  '[N%2::2]*n)[:N*2-1],'_')[N<2]+'/';N-=1

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

Answer 3

05AB1E , 33 बाइट्स

1ŸεÐi'_ë"/ \   | "4ôsès∍}'\ì.∞}.c

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

Comments

इसे ऑनलाइन आज़माएं! - "0300" और "2010" पैटर्न का फायदा उठाने की कोशिश की, इतना गर्म नहीं था।

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

@MagicOctopusUrn जो एक अंडरस्कोर को भी प्रिंट नहीं करता है: पी

— एरिक आउटगॉल्फर

Answer 4

गणितज्ञ, 131 बाइट्स

Join[Table[s=StringRiffle@Table[If[OddQ@i,"/ \\"," | "],⌈i/2⌉];""<>{"\\",If[!OddQ@i,{" ",s," "},s],"/"},{i,#-1,1,-1}],{"\_/"}]&   

तार की सूची देता है

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

Answer 5

रेटिना , 129 119 112 बाइट्स

\d+
$* 
 
¶$`a $'$' 
m`$
/
  /$
_/
^.¶

a(    )*/
a$#1/
\d+
$*
1
/ a  
 (    )*/
$#1/
\d+
$*
1
 |  
a /¶
a/¶
a
\

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

Answer 6

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

ＮθＧ↖→↓θ“ ″✂=ＡＬ«Q"η\`”←_↖θ‖Ｂ

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

Answer 7

पायथन 2 , 123 112 110 109 100 98 96 बाइट्स

i=n=input()
while i:a=i%2;print' '*(n-i)+'\%s/'%['_',((-~i/2)*'/   \  |'[a::2])[a:~a]][i>1];i-=1

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

• रॉड के उत्तर में इनपुट और स्ट्रिंग फॉर्मेटिंग का उपयोग करके बाइट्स का एक गुच्छा बचाया
• श्री एक्सकोडर के लिए 2 बाइट्स का धन्यवाद

Comments

आप की जगह 2 बाइट्स बचा सकता है -1-aके साथ ~a(के रूप में मैं अपने जवाब में किया था)।

— मिस्टर एक्सकोडर

@ Mr.Xcoder धन्यवाद :)

— TFeld

Answer 8

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

i=n=input()
while i:print' '*(n-i)+'\%s/'%' '.join(['/\\'*(-~i/2),['_',' '+'| '*(i/2)][i>1]][i%2]);i-=1

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

Answer 9

एपीएल (डायलॉग) , 97 93 बाइट्स

{⍵=1:1 3⍴'\_/'⋄x←' ',' ',⍨∇⍵-1⋄y←1+2×⍵-1⋄2|⍵:x⍪⍨'\','/',⍨y⍴'  | '⋄x⍪⍨'\/','\/',⍨(y-2)⍴' \ /'}

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

Answer 10

SOGL V0.12 , 28 27 बाइट्स

╔.H∫"C↕‽«‘4nwιF«Im}¹⌡¾\/¹№╚

यह कोशिश करो!

Answer 11

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

f n=[([1..n-x]>>" ")++'\\':take(2*x+1)(cycle$("_":a)!!x)++"/"|x<-[n,n-1..0]]
a="/ \\ ":"  | ":a

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

0-अनुक्रमित और लाइनों की एक सूची देता है।

Answer 12

हास्केल, 101 99 बाइट्स

j 1=["\\_/"]
j n|r<-([1,3..n-1]>>)=('\\':cycle[init$r"/ \\ ",' ':r" |  "]!!n++"/"):map(' ':)(j$n-1)

लाइनों की एक सूची देता है।

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

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

j 1=["\\_/"]               -- base case, n=1

j n                        -- for all other n
   |r<-([1,3..n-1]>>)      -- let r be the function that makes n/2 copies of
                           -- it's argument
   =                       -- the result is
      '\\':                --  a backslash, followed by
      cycle[  ]!!n         --  the inner part, which is
          init$r"/ \\ "    --    all but the last char of some copies of
                           --    "/ \ " for even line numbers, or
          ' ':r" |  "      --    some copies of " |  " prepended by a space
                           --    for odd line numbers
                           --    (chosen by indexing an infinite list of
                           --     both values alternating)   
      ++"/"                --  followed by a slash
    :                      --  and append a
               j$n-1        --  recursive call with n-1
      map(' ':)            --  where each line is prepended by a space

संपादित करें: @ लाईकोनी ने दो बाइट्स बचाए। धन्यवाद!

Comments

([1,3..n-1]>>)के बजाय इस्तेमाल किया जा सकता है ([1..div n 2]>>)।

— लकोनी

Answer 13

जावा (ओपनजेडके 8) , 315 306 बाइट्स

i->{String r="";int j=0,k,u=i*2;char[][]c=new char[i][u+1];c[i-1][i]=95;for(;j<i;r+="".valueOf(c[j++]).replace('\0',' ')+"\n")for(k=0;k<u+1;k++){if(k==j)c[j][k]=92;if(k==u-j)c[j][k]=47;if(k>j&k<u-j)if((i-j)%2<1)c[j][k]=(k-j-1)%2<1?(char)(47+((k-j-1)/2)%2*45):32;else if((k-j-1)%4==2)c[j][k]='|';}return r;}

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

Answer 14

जावा (ओपनजेडके 8) , 198 बाइट्स

अंत में इसे 200 बाइट्स से नीचे पाया गया। शायद बाद में एक स्पष्टीकरण पोस्ट करेंगे।

i->{for(int k=i+1;i>0;System.out.println(("".format("%"+(k-i)+"s","")+"\\"+(i<2?"":"".format("%"+(i-1)+"s","")).replace(" ","/ \\ ,  | ".split(",")[i%2])).substring(0,i<2?k:k+i)+(--i<1?"_/":"/")));}

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

Answer 15

जावास्क्रिप्ट (ईएस 6), 89 85 बाइट्स

f=(y,s='\\')=>--y?s+(y&1?' / \\':' |  ').repeat(y).slice(~y-y)+`/
`+f(y,' '+s):s+'_/'

डेमो

f=(y,s='\\')=>--y?s+(y&1?' / \\':' |  ').repeat(y).slice(~y-y)+`/
`+f(y,' '+s):s+'_/'

console.log(f(1))
console.log(f(2))
console.log(f(3))
console.log(f(4))
console.log(f(5))
console.log(f(6))
console.log(f(7))

Answer 16

CJam, 43

ri_{S*'\@(:X"  | / \ "4/=X*X2*)<'_e|'/NX}/;

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

Answer 17

PHP, 89 + 1 बाइट्स

while($k=$argn-$n)echo($p=str_pad)("",$n++),$p("\\",2*$k,$k>1?$k&1?"  | ":"/ \ ":_),"/
";

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

Answer 18

पायथ ,  46  44 बाइट्स

j_m+<++*;t-Qd\\*d%2>" /  |\  "%d2h+Qd>"_/"._

यहाँ कोशिश करो!