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

Question

आपका कार्य: साइड लंबाई के साथ एक हेक्सागोनल त्रिकोण बनाएं n, जहां nएक सकारात्मक पूरी संख्या या 0 है।

सबसे पहले, मुझे एक षट्भुज परिभाषित करें:

 / \
|   |
 \ /

(कमाल ASCII कला, सही?)

हेक्सागोन को पक्ष साझा करके एक साथ जोड़ा जा सकता है:

 / \ / \
|   |   |
 \ / \ /

   / \  
  |   |
 / \ /
|   |
 \ /

एक हेक्सागोनल त्रिकोण निम्नलिखित है:

   / \
  |   |
 / \ / \
|   |   |
 \ / \ /

उस हेक्सागोनल त्रिकोण की लंबाई 2-2 है - एक तरफ बनाने के लिए 2 हेक्सागोन्स की आवश्यकता होती है। साइड-लेंथ 1 के साथ एक हेक्सागोनल त्रिकोण सिर्फ एक हेक्सागोन है, और साइड-लेंथ 0 के साथ एक हेक्सागोन खाली है।

औपचारिक रूप से, एक षट्कोणीय त्रिभुज एक त्रिभुज है जो अपने पक्षों से जुड़े षट्भुज से बना होता है। शीर्ष षट्भुज इसके नीचे दो तरफ से नीचे की ओर दो लिंक करता है। नीचे वाले त्रिकोण में बाएँ से दाएं और ऊपर-दाएँ से लिंक होता है, और नीचे के दाएँ हिस्से में बाएँ और ऊपरी बाएँ से लिंक होता है। कोने वाले लोगों के बीच हेक्सागोन हैं, उनके विपरीत पक्षों द्वारा जुड़ा हुआ है, और उनकी संख्या है n-2। त्रिकोण नहीं भरे हैं।

और ज्यादा उदाहरण:

Side length 3:
     / \
    |   |
   / \ / \
  |   |   |
 / \ / \ / \
|   |   |   |
 \ / \ / \ /

Side length 4:
       / \
      |   |
     / \ / \
    |   |   |
   / \ / \ / \
  |   |   |   |
 / \ / \ / \ / \
|   |   |   |   |
 \ / \ / \ / \ /
(This triangle isn't really filled, the borders make it look like there is a hexagon in the middle, but there is not.)

Side length 5:
         / \
        |   |
       / \ / \
      |   |   |
     / \ / \ / \
    |   |   |   |
   / \ /     \ / \
  |   |       |   |
 / \ / \ / \ / \ / \
|   |   |   |   |   |
 \ / \ / \ / \ / \ /

Side length 6:
           / \
          |   |
         / \ / \
        |   |   |
       / \ / \ / \
      |   |   |   |
     / \ /     \ / \
    |   |       |   |
   / \ /         \ / \
  |   |           |   |
 / \ / \ / \ / \ / \ / \
|   |   |   |   |   |   |
 \ / \ / \ / \ / \ / \ /

Comments

यदि इसके लिए कोई हेक्सागोनी उत्तर नहीं है, तो मैं @MartinEnder पर सभी विश्वास खो दूंगा।

— caird coinheringaahing

@Soyoucanreplytomeincomments चलो कहते हैं कि अगर मैं यहाँ पर उपयोगकर्ताओं को आकर्षित कर सकता हूँ, तो वे सूची में होंगे।

— फेयरफॉक्स

@phyrfox आप कर सकते हैं, की तरह।

— डेनिस

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

— नील

@ पूरी तरह से नई प्रोग्रामिंग भाषा नहीं सीखने के लिए आपको माफ किया जाता है। लेकिन यह आपकी पहली चेतावनी है!

— caird coinheringaahing

Answer 1

चारकोल , 62 43 39 बाइट्स

ＮβＦ³«Ｆ⁻β‹ι²« / \¶|   |¶ \ /Ｍײι↑¿⁻¹ιＭ⁶←

इसे ऑनलाइन आज़माएं! संपादित करें: @ ASCII- केवल कुछ सटीक बाइट्स का धन्यवाद सहेजा गया (यह निश्चित रूप से नहीं कि कितने के रूप में मैंने एक और 6 10 बाइट्स बचाए लेकिन फिर एक बगफिक्स पर 4 बाइट्स खर्च करने की आवश्यकता थी)। अब नेस्टेड छोरों का उपयोग करना, जो कि यह सब साथ होना चाहिए था।

Comments

45 बाइट्स: Ａ / \¶| |¶ \ /αＮβＦβ«α←←»Ｆβ«α↖↖Ｍ⁶←»Ｆβ«αＭ⁴↑←←(btw लकड़ी का कोयला autocompletes किसी भी जरूरत »के अंत में)

— केवल

@ ASCII- केवल दुःख की बात है कि मैं चारकोल के दस्तावेज़ीकरण को और अधिक नहीं जान पाया, इसलिए मुझे नहीं पता कि आपका कोड क्या करता है।

— नील

कमांड यहां विकी पर हैं , मूल रूप से Assign(hexagon_with_space_to_left, a);InputNumber(b);for(b){Print(a);Move(:Left);Move(:Left);}for(b){Print(a);Move(:UpLeft);Move(:UpLeft);Move(6, :Left);}for(b){Print(a);Move(4, :Up);Move(:Left);Move(:Left);}, लूप के लिए प्रत्येक एक तरफ खींचता है

— केवल

इतना सुंदर कि आप क्या कर रहे थे लेकिन एक चर के रूप में सहेजे गए तार के साथ

— ASCII-only

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

— नील

Answer 2

पायथन 2, 184 177 174 164 बाइट्स

n=input();p='|   |';e=' \\ /'
for i in range(n):k=' '*(4*i-5);w='  '*~(i-n);print w+[' / \\'*-~i+'\n'+w+p[:4]*i+p,' /'+e+k[3:]+e+' \\\n'+w+p+k+p][2<i<n-1]
print e*n

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

-7 बाइट्स अर्जन जोहान्सन को धन्यवाद

Comments

आप |शीर्ष तीन और नीचे षट्भुज पंक्ति पर सबसे दायाँ भाग याद कर रहे हैं ।

— अर्जन जोहान्सन

p[:4]*(i+2)इसके बजाय p[:4]*(i+1)इसे ठीक करने के लिए लगता है।

— अर्जन जोहान्सन

आप केवल bएक ही स्थान पर उपयोग कर रहे हैं , इसलिए इसे अपनी ~चाल के साथ मिलाकर , w=' '*2*~(i-n)7 बाइट्स छोटे हैं।

— अर्जन जोहान्सन

@ WentrjanJohansen धन्यवाद, कोड बहुत सारे रिफलेक्टरिंग से गुजरा और मैं उन चीजों को बदलना भूल गया

— गणित दीवाने

Answer 3

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

f=n=>(n=n*2-2,a=[...Array(n+3)].map(_=>Array(n*2+5).fill` `),g=(y,x)=>(a[y+1][x]=a[y+1][x+4]=`|`,a[y][x+1]=a[y+2][x+3]=`/`,a[y][x+3]=a[y+2][x+1]=`\\`),[...Array(n+!n)].map((_,i)=>i%2||(g(n,i*2),g(i,i=n-i),g(i,n+i))),a.map(a=>a.join``).join`
`)

<input type=number oninput=o.textContent=f(this.value)><pre id=o>

Answer 4

जावास्क्रिप्ट (ईएस 6), 133 129 128 126 बाइट्स

दो के साथ चरित्र से उत्पादन चरित्र बनाता है के लिए छोरों।

n=>{for(s='',y=n*2,n*=4;~y--;s+=`
`)for(x=n;~x--;)s+=' \\ /|'[x>y-2&x<n-y&(k=x+y&3,x>n-y-6|x<y+4|y<2)?y&1?k:k+1&4:0];return s}

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

बाहरी लूप में, y n * 2-1 से -1 तक पुनरावृति करता है । आंतरिक लूप में, x n * 4-1 से -1 तक पुनरावृत्त होता है । हमने k = (x + y) और 3 सेट किया , जो कि अंतर्निहित पैटर्न है जिसका उपयोग हेक्सागोन्स उत्पन्न करने के लिए किया जाता है।

नीचे n = 4 के लिए परिणामी ग्रिड है :

     15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0 -1
   +---------------------------------------------------
 7 |  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2
 6 |  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1
 5 |  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0
 4 |  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3
 3 |  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2
 2 |  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1
 1 |  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0
 0 |  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3
-1 |  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2

यहां तक ​​कि पंक्तियों पर, एक सेल को पाइप वर्ण से भर दिया जाता है जब k = 3 , और अन्यथा एक स्थान। पाइप हमारे संदर्भ स्ट्रिंग में 5 वां वर्ण है " \ /|", इसलिए सही इंडेक्स (k + 1) और 4 द्वारा दिया गया है ।

विषम पंक्तियों पर, प्रत्येक सेल को संदर्भ स्ट्रिंग में संबंधित वर्ण के साथ सीधे भरा जाता है:

• k = 0 → स्थान
• k = 1 → "\"
• k = 2 → स्थान
• k = 3 → "/"

नीचे हमारा अद्यतन उदाहरण है (डॉट्स के साथ प्रतिस्थापित स्थान):

     15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0 -1
   +---------------------------------------------------
 7 |  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .
 6 |  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .
 5 |  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .
 4 |  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |
 3 |  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .
 2 |  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .
 1 |  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .
 0 |  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |
-1 |  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .

निम्नलिखित सूत्रों में, हम पठनीयता के लिए N = n * 4 को परिभाषित करते हैं (हालांकि कोड में एक ही चर का उपयोग किया जाता है)।

त्रिकोण आकार परीक्षण द्वारा प्राप्त किया जाता है:

• x> y - 2 → दायां कोना निकालता है
• AND x <N - y → बाएं कोने को हटाता है

और आंतरिक भाग परीक्षण द्वारा हटा दिया गया है:

• x> N - y - 6 → केवल बायें किनारे को रखता है
• या x <y + 4 → केवल सही बढ़त रखता है
• या y <2 → केवल नीचे का किनारा रखता है

डेमो

let f =

n=>{for(s='',y=n*2,n*=4;~y--;s+=`
`)for(x=n;~x--;)s+=' \\ /|'[x>y-2&x<n-y&(k=x+y&3,x>n-y-6|x<y+4|y<2)?y&1?k:k+1&4:0];return s}

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

Comments

[x>y-2&x<n-y&(x>n-y-6|x<y+4|y<2)&&y&1?x+y&3:x-~y&4]काम करता है ?

— नील

@ नील हम्म, मुझे ऐसा नहीं लगता। हमें टर्नरी अभिव्यक्ति के आसपास कोष्ठक की आवश्यकता होगी और (x+y+1)&4यह वैसा नहीं है (((x+y)&3)+1)&4।

— अरनौलद

नहीं, बेशक यह नहीं है। मैं क्या सोच रहा था ...

— नील

Answer 5

जेली ,  62  61 बाइट्स

वर्तमान में छह छक्के लगा रहा है।

_‘<×⁸>6
Rµ‘⁾| ẋ⁾/\ẋ⁸¤ż;/K€µ⁶ðMṀ_6r6ẋð¦"Jç¥
ḤḶUẋ@€⁶;"ǵ-ịṙ6ṭ⁸Y

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

कैसे?

_‘<×⁸>6 - Link 1, should we eat the praline? row number, triangle size
_       - row number minus triangle size
 ‘      - plus one
  <     - less than triangle size? (1 if one of the last rows else 0)
   ×⁸   - multiply by row number   (row number or 0)
     >6 - greater than 6?          (row number if between row 6 and last two rows)

Rµ‘⁾| ẋ⁾/\ẋ⁸¤ż;/K€µ⁶ðMṀ_6r6ẋð¦"Jç¥ - Link 2, build a solid triangle: triangle size
                                              (except the very bottom row)
R                                  - range: [1,2,...,size]
 µ                                 - monadic chain separation, call that r
  ‘                                - increment: [2,3,...,size+1]
   ⁾| <space                       - literal "| "
      ẋ                            - repeat: ["| | ","| | | ",...]
            ¤                      - nilad followed by link(s) as a nilad:
       ⁾/\                         -   literal "/\"
           ⁸                       -   link's left argument, r
          ẋ                        -   repeat (vectorises): ["/\","/\/\",...]
             ż                     - zip the two repeated lists together: [["/\","| | "],["/\/\","| | | "],...]
              ;/                   - reduce by concatenation: ["/\","| | ","/\/\","| | | ",...]
                K€                 - join with spaces for €ach: ["/ \","|   |  ","/ \ / \","|   |   |  ",...]
                  µ                - monadic chain separation call that s
                                 ¥ - last two links a a dyad:
                               J   -   range(length(s))  
                                ç  -   call the last (1) link as a dyad (left = result of J, right = size)
                              "    - zip with: (call those d)
                    ð       ð¦     -   apply to indexes:
                   ⁶               -   a literal space character
                     M             -     indexes of maximal elements in an element of s (a row)
                      Ṁ            -     maximum (this is the rightmost non-space index, MṀ working like length ignoring trailing spaces)
                       _6          -     subtract 6  (6 indexes back from the right)
                         r6        -     range from there to 6, i.e [l-6,l-7,...,6]
                           ẋ       -     repeat d times (1 or 0), thus applying to the middle rows but not the bottom and top ones.

ḤḶUẋ@€⁶;"ǵ-ịṙ6ṭ⁸Y - Main link: triangle size
Ḥ                  - double(size)
 Ḷ                 - unlength: [0,1,2,...,double(size)-1]
  U                - upend: [double(size)-1,...,2,1,0]
      ⁶            - literal space character
   ẋ@€             - repeat for €ach with reversed arguments ["  ...  ",...,"  "," ",""]
         Ç         - call the last link (2) as a monad(size)
       ;"          - zip with concatenation (zips the leading spaces with the solid triangle body)
          µ        - monadic chain separation, call that t
           -ị      - index -1 (last but one row of t)
             ṙ6    - rotate left by 6 (any number congruent to 2 mod 4 would do)
               ṭ⁸  - tack to t (add this new row on)
                 Y - join all the rows by new lines
                   - implicit print

Comments

>स्पष्टीकरण में एक मिसिंग है ( <space)

— रोमन ग्रैफ़

@ RomanGräf धन्यवाद मैंने स्पष्टीकरण संपादित किया! यदि आपको " ẋस्पष्टीकरण में अंतरिक्ष के नीचे गलत अर्थ है" से अधिक मतलब है , तो मुझे बताएं।

— जोनाथन एलन

Answer 6

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

jb+Rt_.rd"/\\"_.e<s[dd*dkb*dyQ)hyQ*,"|   |""/ \\ /"tQ*Q" / \\"+*Q"|   "\|*Q" \\ /"

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

Answer 7

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

""<>Table[If[i+j<d||i-j>d+1||i+j>d+5&&i-j<d-3&&j<d-1," ",Switch[Mod[i+d+{j,-j},4],{1,3},"/",{3,1},"\\",{1,1},"|",_," "]],{j,(d=2#)+1},{i,4#+1}]~Riffle~"\n"&

\nएक नई पंक्ति के साथ प्रतिस्थापित किया गया।

अधिक पठनीय:

"" <> Table[
    If[i+j < d || i-j > d+1 || 
      i+j > d+5 && i-j < d-3 && j < d-1, " ", 
     Switch[Mod[i+d+{j,-j}, 4], {1, 3}, "/", {3, 1}, 
      "\\", {1, 1}, "|", _, " "]], {j, (d=2#)+1}, {i, 4#+1}]~
   Riffle~"\n" &

पात्रों में से एक सरणी, द्वारा अनुक्रमित बनाता है मैं 1 से 4 से n + 1 क्षैतिज और जे 2 1 से n + 1 खड़ी। सबसे पहले, Switch[Mod[i+d+{j,-j},4],{1,3},"/",{3,1},"\\",{1,1},"|",_," "]एक हेक्सागोनल ग्रिड में भरता है:

 \ / \ / \ / \ / 
  |   |   |   |  
 / \ / \ / \ / \ 
|   |   |   |   |
 \ / \ / \ / \ / 
  |   |   |   |  
 / \ / \ / \ / \ 
|   |   |   |   |
 \ / \ / \ / \ / 

तब If[i+j<d||i-j>d+1||i+j>d+5&&i-j<d-3&&j<d-1," ",...]इसे " "बाहर के त्रिभुज के साथ बदल देता है ।