साइड लंबाई n का ASCII षट्भुज ड्रा करें
एक सकारात्मक पूर्णांक को देखते हुए \$n\$विकर्ण पक्ष लंबाई \ के साथ एक ASCII षट्भुज का उत्पादन$n\$, के रूप में चित्रित (नोट देखते हैं \$2n\$ _ शीर्ष किनारे पर अक्षर)
उदाहरण:
\ _$n = 1\$
__
/ \
\__/
\ _$n = 2\$
____
/ \
/ \
\ /
\____/
\ _$n = 5\$
__________
/ \
/ \
/ \
/ \
/ \
\ /
\ /
\ /
\ /
\__________/
आदि।
बाइट्स में सबसे छोटा कोड जीतता है। सामान्य इनपुट / आउटपुट विधियाँ लागू होती हैं।
जवाब
कैनवस , 15 9 बाइट्स
_；１＊⁸／∔╬
यहाँ कोशिश करो!
-6 बाइट्स प्रोग्राम फिक्स करने के बाद।
षट्कोण का एक चौथाई भाग खींचता है, और चतुष्कोण पलिंड्रोमाइज करता है।
पायथन 2 , 92 बाइट्स
k=n=input()
while 1:a=k^k>>n;print" "*a+"\/_"[k/n-2]+"_ "[-n<k<n]*2*(2*n+~a)+"\_/"[k/n];k-=1
इसे ऑनलाइन आज़माएं!
चारकोल , 14 बाइट्स
←×_θ↖θ→↗θ×_θ‖Ｍ
इसे ऑनलाइन आज़माएं!
ASCII- केवल से +1 बाइट ठीक करें।
षट्कोण का आधा भाग खींचता है, और उसे दर्पण करता है।
सी (जीसीसी) , 119 109 बाइट्स
a,i,j;f(n){for(i=a+=a=j=n*2;~j;)putchar(!i--?i=a,j--,13:i%(n*3)<n|j%(n*2)?(i-~j-n)%a?(i-j+n)%a?32:92:47:95);}
इसे ऑनलाइन आज़माएं!
- @ceilingcat को 2 धन्यवाद दिए गए
नीचे दी गई तालिका अपडेट नहीं की गई है ताकि मान भिन्न हो सकें, लेकिन अवधारणा यह है:
- हमारे पास समानांतर रेखाओं के 2 जोड़े हैं
। । _______.______.________ | / \ / | । । | / \ / | । | / \ / | | / \ / | | / / | | \ / | । । | \ / | __ | ___ \ ________ / ___ | ___ | । ।
हम x को yerate करते हैं, आकार से 0 तक और हम उन्हें यह जांचने के लिए जोड़ते हैं कि क्या ए / प्रिंट होना चाहिए, हम \ _ के लिए जांच करने के लिए घटाते हैं, हम दोनों समानताएं जांचने के लिए मोडुलो का उपयोग करते हैं।
i 65432109876543210. जे
i + jn ________ 8
13 + 7-4 => / \ 7
14 + 6-4 / \ 6
15 + 5-4 / \ 5
/ \ 4
\ 1 + 3-4 => / 3
\ 2 + 2-4 / 2
\ 3 + 1-4 / 1
\ ________ / ०
पर्ल 5 ( -p), 102 बाइट्स
s/_+/__$&/g,s/^|$/ /gm,s/^ *\S /$& /gm,s-( +)\\ -$&/ $1 \\ \\ $1 /
- for($\=' __ / \ \__/')x--$_}{
इसे ऑनलाइन आज़माएं!
-pऔर }{अंत में केवल आउटपुट रिकॉर्ड सेपरेटर $\को प्रिंट करने के लिए एक ट्रिक है । यह केवल एक इनपुट रिकॉर्ड के लिए काम करता है; हेडर का उपयोग सभी को एक टियो लिंक में प्रिंट करने के लिए किया जाता है।
$\=' __
/ \
\__/' # output record separator initialized with hexagon (size 1)
s/_+/__$&/g,s/^|$/ /gm,s/^ *\S /$& /gm,s-( +)\\ -$&/ $1 \\ \\ $1 /
- # regexes to increase the hexagon by 1
for .. --$_ # to repeat n-1 times where n is the input
हास्केल , 150 बाइट्स
r=reverse
m(o:c:k)=o:c:c:c:k++" "
f 1=[["\\ /","__ "],["/__\\"]]
f n|[w:i,j]<-map m<$>f(n-1),_:_:k<-r$m w=[r k:w:i,k:j]
h[i,j]=unlines$r<$>r i++j
h.f
इसे ऑनलाइन आज़माएं!
इस उत्तर का अधिक पुनरावर्ती संस्करण। इस चुनौती की मनमानी इस बहुत निराशा होती है।
स्पष्टीकरण
यह उत्तर समझाना थोड़ा कठिन है। चुनौती यह है, जैसा कि मैंने पहले ही कहा था, कुछ तरीकों से मनमाना, इसलिए कोड सिर्फ प्रतीकों का एक घोंसला है।
विचार
यहां कार्यक्रम का विचार दो हिस्सों का निर्माण करना है। जब nth षट्भुज की गणना करते समय हम n-1th षट्भुज के लिए दो हिस्सों को प्राप्त करते हैं और इसका उपयोग अगले सबसे बड़े को बनाने के लिए करते हैं।
हालांकि कुछ चेतावनी भी हैं। हम शीर्ष आधा ऊपर-नीचे बनाते हैं और हम बाएं से दाएं दोनों हिस्सों का निर्माण करते हैं। हम ऐसा करते हैं क्योंकि यह इस तरह से करना सुविधाजनक है। कोई गहरी वजह नहीं कि यह चीजों को थोड़ा कम कर दे, भले ही यह चीजों को थोड़ा समझ में न आए।
विवरण
पहली पंक्ति बहुत आगे rकी ओर एक उर्फ है reverse। दूसरी पंक्ति इतनी सीधी नहीं है। mएक बकवास कार्य है, यह मौजूद है क्योंकि इसे या इसी तरह के ऑपरेशन को कुछ स्थानों पर करने की आवश्यकता है। इसका वास्तव में अर्थ अर्थ नहीं है। यह यहाँ क्या करता है का सबसे अच्छा स्पष्टीकरण कोड है।
m(o:c:k)=o:c:c:c:k++" "
यहाँ से हम शुरू करते हैं fजो मूल रूप से सभी तर्क को संभालता है। fआधार मामले के लिए पहला मामला है, यह बहुत मानक है
f 1=[["\\ /","__ "],["/__\\"]]
ध्यान दें कि हम एक टपल के बजाय दो वस्तुओं की सूची लौटाते हैं। किसी भी साने प्रोग्राम में हम एक ट्यूपल का उपयोग कर रहे होंगे क्योंकि यह 2 तत्वों पर तय किया गया है। हालाँकि बाद में हम इसी फ़ंक्शन के साथ दोनों तर्कों पर विचार करेंगे। ऐसा करना कठिन है, लेकिन एक सूची के साथ एक आसान लेकिन आसान है, और इस सूची में कोई भी कमी नहीं है, इसलिए हम इसका उपयोग करते हैं।
फिर हमारे पास आगमनात्मक मामला है। पहले हम पिछले मामले को लाते हैं, और mउस पर हमारा दोहरा नक्शा बनाते हैं। यह षट्भुज 1 इकाई को व्यापक (2 वर्ण) बनाता है और इसे आधी इकाई (1 वर्ण) को दाईं ओर ले जाता है (हालाँकि जब से यह पूरी चीज पीछे की ओर है, अंतरिक्ष वर्ण दाईं ओर जुड़ जाते हैं )। हम पैटर्न इस से मेल खाते हैं [w:i,j]क्योंकि हम wबाद में नई पंक्तियाँ बनाने के लिए उपयोग करना चाहते हैं । जिसके आगे हम पंक्तियों को बनाते हैं। हम एक पैटर्न मैच के साथ ऐसा करते हैं:
_:_:k<-r$m w
यह बकवास कोड की तरह है। यह केवल उन चीजों को एक साथ थप्पड़ मारता है जो हमें पहले से ही सही आउटपुट का उत्पादन करना था। kऔर इसके उलट नई पंक्तियों के रूप में तो हम उन्हें जोड़ने और वापस कि।
बाद fहमारे पास hजो के उत्पादन में बदल जाता है fएक स्ट्रिंग में। यह निर्माण के दौरान हमारे द्वारा उपयोग किए गए सभी निराला परिवर्तनों को मिटा देता है और इसका उपयोग करने के लिए पैकेज करता है।
उन सभी के साथ, जो हम अभी fऔर hअंतिम कार्य के लिए रचना करते हैं।
हास्केल , 100 बाइट्स
f n=unlines[q<$>[1..3*n]++[1-n..0]|y<-[-n..n],let q x|abs y==n,x>n='_'|x==y='\\'|x+y==1='/'|1>0=' ']
इसे ऑनलाइन आज़माएं!
गोल्फ AZTECCO के जवाब प्लस कुछ नई तकनीकों।
मुख्य विचार यह है कि यदि हम पहले nकॉलम को अंत तक ट्रांसप्लांट करते हैं तो षट्भुज सरल है ।
|-|
______
/ \
/ \
/ \
\ /
\ /
\______/
|-|
______
\ /
\ /
\/
/\
/ \
______/ \
अब सभी /और \एक ही पंक्ति में हैं, और _उन में से छोड़ दिया करने के लिए सभी कर रहे हैं। यह AZTECCO की समन्वय से चरित्र का निर्धारण करने की रणनीति को करना बहुत आसान बनाता है। इन रिलेटेड निर्देशांक को लागू करने के लिए, हम x-coordinates [1..4*n]को एक चक्रीय और स्थानांतरित संस्करण के साथ बदलते हैं [1..3*n]++[1-n..0]।
रेटिना 0.8.2 , 94 बाइट्स
.+
$* ¶$&$* \G ¶$%'/$`$%_$%_$`\
r` \G
$%`\$'$%_$%_$%'/¶ ^¶( *) $1 $.&$*_$.&$*_$& T` `\_` +/$
इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। स्पष्टीकरण:
.+
$* ¶$&$*
nरिक्त स्थान की दो पंक्तियाँ डालें ।
\G
¶$%'/$`$%_$%_$`\
पहली पंक्ति को षट्भुज के शीर्ष पक्षों में परिवर्तित करें।
r` \G
$%`\$'$%_$%_$%'/¶
दूसरी पंक्ति को षट्भुज के नीचे की भुजाओं में परिवर्तित करें।
^¶( *)
$1 $.&$*_$.&$*_$&
शीर्ष पंक्ति डालें।
T` `\_` +/$
नीचे की पंक्ति बदलें।
पायथन 2 , 119 114 बाइट्स
i=n=input()
d=0
exec"k=i/n|d;print' '*i+'\_/'[~k]+'_ '[i-d<n]*2*(2*n+~i)+'\_/'[k]\nif i==d:d=i=-1\ni-=d|1;"*(n-~n)
इसे ऑनलाइन आज़माएं!
जावास्क्रिप्ट (ईएस 6), 109 107 बाइट्स
w=>(x=0,W=w*4,i=g=y=>~y?`
/\\_`[x++-W?y*!i|w/x|x>w*3?(x+~y+w)%W?(x+y)%W-w?1:3:2:4:x=i=0&y--]+g(y):'')(w*2)
इसे ऑनलाइन आज़माएं!
टिप्पणी की
w => ( // w = input
x = 0, // initialize x to 0
W = w * 4, // W = total width
i = // initialize i to a non-zero value
g = y => // g is a recursive function taking y
~y ? // if y is not equal to -1:
`\n /\\_`[ // list of characters
x++ - W ? // if this is not the end of the row:
y * !i | // if this is neither the first nor the last row
w / x | // or x is less than or equal to w
x > w * 3 ? // or x is greater than w * 3:
(x + ~y + w) % W ? // if (x - y - 1 + w) mod W is not equal to 0:
(x + y) % W - w ? // if (x + y) mod W is not equal to w:
1 // draw a space
: // else:
3 // draw a '\'
: // else:
2 // draw a '/'
: // else:
4 // draw a '_'
: // else:
x = i = 0 & y-- // decrement y, set x and i to 0 and draw a linefeed
] + g(y) // append the result of a recursive call
: // else:
'' // stop the recursion
)(w * 2) // initial call to g with y = w * 2
सी (जीसीसी) , 194 \ _$\cdots\$ 149 144 बाइट्स
सहेजा गया 13 14 19 बाइट सीक्रेट के लिए धन्यवाद !!!
p(n,c){for(;n--;)printf(L"/\\ _\n"+c);}i;t;f(n){p(n,2);for(i=t=p(2*n,3);i>=p(1,4);t=i/n?--i,1:t)i+=!p(!p(n+i<<!p(!p(n+~i,2),t),t&!i|2),!t)-2*t;}
इसे ऑनलाइन आज़माएं!
स्पष्टीकरण (कुछ गोल्फ से पहले)
p(n,c){for(;n--;) // Helper function to print
putchar("/\\ _\n"[c]);} // one of '/', '\', ' ', '_' , or
// newline n times, this function
// also returns 0
i;t;f(n){ // Main function prints an n hexagon
p(n,2); // Print n leading spaces for the 1st
// line
for( // Main loop
i=t=p(2*n,3); // Set i and t to 0,
// and print 2*n '_'s for the 1st line
i>=p(1,4); // Loop until i goes below 0, and
// print a newline
// At the end of each loop:
i+=1-2*t, // increment i for the 1st half
// and then decrement i in the 2nd
t=i/n?--i,1:t) // keep t as t unless i equals n,
// then make t 1 and decrement i
// In the main loop:
p(n+~i,2), // print n-i-1 leading spaces
p(1,t), // print a '/' in the 1st half and a
// '\' in the 2nd
p(n+i<<1,t&!i|2), // print the 2*(n+i) middle spaces
// unless at the bottom print '_'s
p(1,!t); // print a '\' in the 1st half and a
// '/' in the 2nd
}
05AB1E , 33 29 25 बाइट्स
-4 ( 7 ) बाइट्स केविन क्रूज़सेन को धन्यवाद !
L+<'/úíºI·'_ך»∊¶¡`ðs‡).c
इसे ऑनलाइन आज़माएं!
05AB1E यह सिर्फ दर्पण builtins है एक कैनवास निर्मित जो उपयोगी हो सकता है है, लेकिन काम कर पाने के लिए काफी मुश्किल है, ºऔर ∊और केंद्रीय builtin .c।
जे , 50 47 बाइट्स
-3 योना के लिए धन्यवाद!
' \/_'{~]|."1((0,]+2*|.)@=@i.,.3,3,~0$~<:,])@+:
इसे ऑनलाइन आज़माएं!
((0,]+2*|.)@=@i. ,. 3,3,~0$~<:,])@+:
0 0 0 0 3 3 3 3
1 0 0 2 0 0 0 0
0 1 2 0 0 0 0 0
0 2 1 0 0 0 0 0
2 0 0 1 3 3 3 3
]|."1
0 0 3 3 3 3 0 0
0 2 0 0 0 0 1 0
2 0 0 0 0 0 0 1
1 0 0 0 0 0 0 2
0 1 3 3 3 3 2 0
' \/_'{~
____
/ \
/ \
\ /
\____/
पायथन 3.8 (पूर्व-रिलीज़) , 174 बाइट्स
n=int(input())
b,a,s="\/ "
z,f=range(n),lambda c,d,t:((n-1-i)*s+c+2*(n+i)*s+d for i in t)
print(f"{'_'*2*n:^{4*n}}",*f(a,b,z),*f(b,a,z[:0:-1]),f"{b:>{n}}{'_'*2*n}/",sep="\n")
इसे ऑनलाइन आज़माएं!
-1 बाइट @ डंकन को धन्यवाद
-8 बाइट्स @ धन्यवाद के लिए धन्यवाद
हास्केल , 129 120 बाइट्स
g=mod
f n|a<-n*4=[c|y<-[-n..n],x<-[0..a],let c|x<1='\n'|g x(n*3+1)>n,abs y==n='_'|g(x+y)a==1='/'|g(x-y)a<1='\\'|1>0=' ']
इसे ऑनलाइन आज़माएं!
@hheat जादूगर और @xnor को 9 धन्यवाद दिए।
समस्या के दृष्टिकोण पर @xnor उत्तर और इसके बड़े सुधार की जाँच करें (मॉडुलो और समानांतर रेखाओं से बचते हुए)!
मेरे सी उत्तर के बराबर
हम सूची समझ का उपयोग करके कार्टेशियन निर्देशांक बनाते हैं। y <- [0..n * 2], x <- [0..a]
[सी | ..., चलो सी | ... | ... | ...] और हम लाइनों को खींचने के लिए xy या x + y के आधार पर आवश्यक चरित्र को वेल्ड करते हैं ..
हम कई लाइनों को खींचने के लिए modulo का उपयोग करते हैं (2)
विशेष मामला है _जिसके लिए ax / y अनुपात की आवश्यकता नहीं है, लेकिन एक सीमा, हम >एक> x> b जैसे के बजाय सिर्फ एक तुलना करने के लिए modulo का उपयोग किया
रूबी , 141 बाइट्स
->(n,g=->c,d{(1..n).map{|i|" "*(n-i)+d+" "*2*(n+i-1)+c}},l=g[?/,e=?\\].reverse){[" "*n+?_*n*2,g[e,?/],l[0..-2],l[-1].sub(/ +(?=\/)/,?_*n*2)]}
इसे ऑनलाइन आज़माएं!
यदि एक ऊपरी अंडरस्कोर की अनुमति है, तो यह थोड़ा कम बाइट्स लेगा, जबकि हेक्सागोन उतना ही सुंदर है जितना पहले था; ;-)
रूबी , 114 बाइट्स
->n{[" "*n+?_*2*n,(g=->c,d{(1..n).map{|i|" "*(n-i)+c+" "*2*(n+i-1)+d}})[?/,e=?\\],g[e,?/].reverse," "*n+?‾*n*2]}
इसे ऑनलाइन आज़माएं!
05AB1E , 70 बाइट्स
ðש'_¹·×«©¶«©¹'/1Λ¹·Ì'.2Λ¹'\3.Λ«©„./`.;©¶¡Â‚€»`s'.ð:,¹3*>(£„._`:„/\‡,
इसे ऑनलाइन आज़माएं!
पर्ल 5 , 143 बाइट्स
sub f{$n=pop;@b=map{join'',$"x($n-$_),'/',' 'x($n+$_-1),'\\',$/}1..$n;join('',$"x$n,$u=__ x$n,$/,@b,map y|/\\|\\/|r,reverse@b)=~s| +/$|$u/|sr}
इसे ऑनलाइन आज़माएं!
sub f{
$n=pop; #n = input
@b=map{ #set array @b to line 2 - n+1
join'', #join parts into a line string
$" x ($n-$_), #space times n-1 '/', #char / ' ' x ($n+$_-1), #space times n+iterator minus 1 '\\', #char \ $/ #char newline
} 1..$n; #n lines join('', #return string of these joined: $" x $n, #n spaces $u = __ x$n, #n*2 underscores $/, #char newline
@b, #lines 2 to n+1 constructed above
map y|/\\|\\/|r, #and bottom part which is the same
reverse@b #as top part reversed and /\ rotated
)=~s| +/$|$u/|sr #and change last spaces of last line to _'s
}
हास्केल ,
186
168 बाइट्स
अंतिम लाइन पर xnor के फिक्स और अनावश्यक स्थानों को हटाने के साथ -18 बाइट्स
s=' '
(!)=replicate
e=reverse
h n=unlines$(\m->(n!s++(2*n)!'_'++n!s):e(e<$>m)++init m++[(n-1)!s++'\\':(2*n)!'_'++"/"])$(\i->i!s++'\\':(4*n-2*i-2)!s++'/':i!s)<$>[0..n-1]
इसे ऑनलाइन आज़माएं!
अधूरा:
hex :: Int -> String
hex n = unlines $ first: middle ++ (init $ reverse (map reverse middle)) ++ [last]
where
first = replicate n ' ' ++ replicate (2*n) '_' ++ replicate n ' '
f i = replicate i ' ' ++ "/" ++ replicate (n-i + 2*n + n-i -2) ' ' ++ "\\" ++ replicate i ' '
middle = map f [n-1,n-2..0]
last = replicate (n-1) ' ' ++ "\\" ++ replicate (2*n) '_' ++ "/" ++ replicate (n-2) ' '