Zeichnen Sie ein ASCII-Sechseck mit der Seitenlänge n
Bei einer positiven ganzen Zahl \$n\$Ausgabe eines ASCII-Sechsecks mit diagonaler Seitenlänge \$n\$, wie abgebildet (beachten Sie, dass es \ gibt$2n\$ _ Zeichen am oberen Rand)
Beispiele:
\.$n = 1\$
__
/ \
\__/
\.$n = 2\$
____
/ \
/ \
\ /
\____/
\.$n = 5\$
__________
/ \
/ \
/ \
/ \
/ \
\ /
\ /
\ /
\ /
\__________/
usw.
Der kürzeste Code in Bytes gewinnt. Es gelten die üblichen Eingabe- / Ausgabemethoden .
Antworten
Leinwand , 15 9 Bytes
_；１＊⁸／∔╬
Probieren Sie es hier aus!
-6 Bytes nach dem Fixieren des Programms.
Zeichnet ein Viertel des Sechsecks und Quad palindromisiert.
Python 2 , 92 Bytes
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
Probieren Sie es online aus!
Holzkohle , 14 Bytes
←×_θ↖θ→↗θ×_θ‖Ｍ
Probieren Sie es online aus!
+1 Byte Fix von ASCII-Only.
Zeichnet die Hälfte des Sechsecks und spiegelt es.
C (gcc) , 119 109 Bytes
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);}
Probieren Sie es online aus!
- 2 dank @ceilingcat gespeichert
Die folgende Tabelle wird nicht aktualisiert, sodass die Werte abweichen können. Das Konzept lautet jedoch:
- Wir haben 2 Paare paralleler Linien
. . _______.______.________ | / \ | . . | / \ | . . | / \ |. | / \ | | \ / |. . | \ / | . . | \ / | __ | ___ \ ________ / ___ | ___ | . .
Wir iterieren x, y von Größe bis 0 und addieren sie, um zu prüfen, ob ein / gedruckt werden soll. Wir subtrahieren, um nach \ zu suchen. Wir verwenden Modulo, um beide Parallelen zu überprüfen.
i 65432109876543210. j
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
\ ________ / 0
Perl 5 ( -p), 102 Bytes
s/_+/__$&/g,s/^|$/ /gm,s/^ *\S /$& /gm,s-( +)\\ -$&/ $1 \\ \\ $1 /
- for($\=' __ / \ \__/')x--$_}{
Probieren Sie es online aus!
-pund }{am Ende ist ein Trick, um das Ausgabedatensatztrennzeichen nur am Ende zu drucken $\. Es funktioniert nur für einen Eingabedatensatz. Der Header wird verwendet, um alles in einem Link zu drucken.
$\=' __
/ \
\__/' # 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
Haskell , 150 Bytes
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
Probieren Sie es online aus!
Eine rekursivere Version dieser Antwort. Die Willkür dieser Herausforderung macht dies ziemlich frustrierend.
Erläuterung
Diese Antwort ist etwas schwer zu erklären. Die Herausforderung ist, wie ich bereits sagte, in einigen Punkten willkürlich, so dass der Code nur eine Art Nest von Symbolen ist.
Idee
Die Idee des Programms hier ist es, die beiden Hälften aufzubauen. Das heißt, wenn wir das n-te Sechseck berechnen, erhalten wir die beiden Hälften für das n-1-Sechseck und verwenden diese, um das nächstgrößere zu machen.
Es gibt jedoch einige Einschränkungen. Wir bauen die obere Hälfte auf den Kopf und beide Hälften, die von links nach rechts gespiegelt sind. Wir machen das, weil es bequem ist, es so zu machen. Kein tiefer Grund, es macht die Dinge nur kürzer, auch wenn es die Dinge ein wenig unverständlich macht.
Einzelheiten
Die erste Zeile ist ziemlich einfach rist ein Alias für reverse. Die zweite Zeile ist nicht so einfach. mist eine Unsinnsfunktion, sie existiert, weil sie oder eine ähnliche Operation an einigen Stellen durchgeführt werden muss. Es hat nicht wirklich eine semantische Bedeutung. Die beste Erklärung dafür ist der Code.
m(o:c:k)=o:c:c:c:k++" "
Von hier aus kommen wir zu fdem Punkt, der im Grunde die gesamte Logik handhabt. Der erste Fall für fist der Basisfall, es ist ziemlich Standard
f 1=[["\\ /","__ "],["/__\\"]]
Beachten Sie, dass wir anstelle eines Tupels eine Liste mit zwei Elementen zurückgeben. In jedem vernünftigen Programm würden wir ein Tupel verwenden, da es auf 2 Elemente festgelegt ist. Später werden wir jedoch beide Argumente mit derselben Funktion abbilden. Es ist schwer, das mit einem Tupel zu tun, aber einfach mit einer Liste, und die Liste weist keine Nachteile auf, also verwenden wir sie.
Dann haben wir den induktiven Fall. Zuerst holen wir den vorherigen Fall und ordnen mihn doppelt zu . Dadurch wird das Sechseck um 1 Einheit breiter (2 Zeichen) und um eine halbe Einheit (1 Zeichen) nach rechts verschoben (obwohl die Leerzeichen rechts hinzugefügt werden, da das Ganze rückwärts ist ). Wir passen dieses Muster an, [w:i,j]weil wir wspäter neue Zeilen erstellen möchten . Apropos, als nächstes machen wir die Reihen. Wir machen das mit einem Pattern Match:
_:_:k<-r$m w
Dies ist eine Art Unsinncode. Es schlägt nur Dinge zusammen, die wir bereits hatten, um die richtige Ausgabe zu produzieren. kund seine Umkehrung bilden die neuen Zeilen, also fügen wir sie hinzu. und geben das zurück.
Nachdem fwir haben h, verwandelt sich die Ausgabe von fin einen String. Es macht alle verrückten Transformationen rückgängig, die wir während des Aufbaus verwendet haben, und verpackt sie für die Verwendung.
Mit all dem komponieren wir nur fund hfür die endgültige Funktion.
Haskell , 100 Bytes
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=' ']
Probieren Sie es online aus!
Golf Antwort von AZTECCO sowie einige neue Techniken.
Die Hauptidee ist, dass das Sechseck einfacher ist, wenn wir die ersten nSpalten bis zum Ende verpflanzen .
|-|
______
/ \
/ \
/ \
\ /
\ /
\______/
|-|
______
\ /
\ /
\/
/\
/ \
______/ \
Jetzt sind alle /und \in einer einzigen Zeile, und die _sind alle links von denen. Dies erleichtert die Strategie von AZTECCO zur Bestimmung des Zeichens anhand der Koordinate erheblich. Um diese neu beschrifteten Koordinaten zu implementieren, ersetzen wir die x-koordinaten [1..4*n]durch eine getaktete und verschobene Version [1..3*n]++[1-n..0].
Retina 0,8,2 , 94 Bytes
.+
$* ¶$&$* \G ¶$%'/$`$%_$%_$`\
r` \G
$%`\$'$%_$%_$%'/¶ ^¶( *) $1 $.&$*_$.&$*_$& T` `\_` +/$
Probieren Sie es online aus! Link enthält Testfälle. Erläuterung:
.+
$* ¶$&$*
Fügen Sie zwei Zeilen mit nLeerzeichen ein.
\G
¶$%'/$`$%_$%_$`\
Wandle die erste Reihe in die Oberseite des Sechsecks um.
r` \G
$%`\$'$%_$%_$%'/¶
Wandle die zweite Reihe in die Unterseite des Sechsecks um.
^¶( *)
$1 $.&$*_$.&$*_$&
Fügen Sie die oberste Zeile ein.
T` `\_` +/$
Ersetzen Sie die unterste Zeile.
Python 2 , 119 114 Bytes
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)
Probieren Sie es online aus!
JavaScript (ES6), 109 107 Bytes
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)
Probieren Sie es online aus!
Kommentiert
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
C (gcc) , 194 \$\cdots\$ 149 144 Bytes
Gespeichert 13 14 19 Bytes dank Ceilingcat !!!
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;}
Probieren Sie es online aus!
Erklärung (vor einigen Golfspielen)
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 Bytes
-4 ( 7 ) Bytes dank Kevin Cruijssen !
L+<'/úíºI·'_ך»∊¶¡`ðs‡).c
Probieren Sie es online aus!
05AB1E hat eine Leinwand builtin , die nützlich sein könnte, aber es ist ziemlich schwierig , zum Laufen zu bringen, das ist nur der Spiegel builtins ist ºund ∊und die zentralisieren builtin .c.
J , 50 47 Bytes
-3 danke an Jonah!
' \/_'{~]|."1((0,]+2*|.)@=@i.,.3,3,~0$~<:,])@+:
Probieren Sie es online aus!
((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
' \/_'{~
____
/ \
/ \
\ /
\____/
Python 3.8 (Vorabversion) , 174 Bytes
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")
Probieren Sie es online aus!
-1 Byte dank @Duncan
-8 Bytes dank @Danis
Haskell , 129 120 Bytes
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=' ']
Probieren Sie es online aus!
9 dank @Wheat Wizard und @xnor gespeichert.
Überprüfen Sie die @ xnor-Antwort und ihre große Verbesserung bei der Herangehensweise an das Problem (Vermeidung von Modulo und parallelen Linien)!
Entspricht meiner C-Antwort
Wir erstellen kartesische Koordinaten mit dem Listenverständnis | y <- [0..n * 2], x <- [0..a]
[c | ..., lass c | ... | ... | ...] und wir schreien das Zeichen, das basierend auf xy oder x + y benötigt wird, um Linien zu zeichnen.
Wir verwenden Modulo, um mehrere Linien zu zeichnen. (2) Ein
Sonderfall ist, für _den kein Ax / Y-Verhältnis, sondern ein Bereich erforderlich ist hat modulo verwendet, um nur einen Vergleich >anstelle eines a> x> b wie durchzuführen
Ruby , 141 Bytes
->(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)]}
Probieren Sie es online aus!
Wenn ein oberer Unterstrich erlaubt ist, würde es etwas weniger Bytes dauern, während das Sechseck so hübsch ist wie früher ;-)
Ruby , 114 Bytes
->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]}
Probieren Sie es online aus!
05AB1E , 70 Bytes
ðש'_¹·×«©¶«©¹'/1Λ¹·Ì'.2Λ¹'\3.Λ«©„./`.;©¶¡Â‚€»`s'.ð:,¹3*>(£„._`:„/\‡,
Probieren Sie es online aus!
Perl 5 , 143 Bytes
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}
Probieren Sie es online aus!
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
}
Haskell ,
186
168 Bytes
-18 Bytes mit xnors Korrekturen und Entfernen nicht benötigter Leerzeichen in der letzten Zeile
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]
Probieren Sie es online aus!
Ungolfed:
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) ' '