Angenommen, eine unendliche Aneinanderreihung von Sechsecken, die aus |/\Zeichen bestehen.

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

Geben Sie bei gegebener Eingabe n > 0einen dreieckigen Teil der Kachelung aus, wie in den folgenden Beispielen dargestellt und mit einem _in der Mitte eines Sechsecks verankert :

n=1
\_/

n=2
\/ \/
 \_/

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

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

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

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

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

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

and so on

Regeln

• Führende / nachfolgende Zeilenumbrüche oder andere Leerzeichen sind optional, sofern die Zeichen richtig ausgerichtet sind.
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Die Ausgabe kann auf der Konsole erfolgen, als Bild gespeichert, als Liste von Zeichenfolgen usw. zurückgegeben werden.
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Python 2 , 86 Bytes

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

Probieren Sie es online!

Mit einem von Eriks Tricks konnte ich 3 Bytes Golf spielen! 3 Bytes dank Jonathan Allan gespeichert.

Wie das geht

Zunächst wird dies von STDIN eingegeben und zwei separaten Variablen iund zugewiesen k. Während die Variable iwahr ist, dekrementieren wir sie und generieren die Zeichenfolgen entsprechend. Dies ist eine Abkürzung für die Schleife von Eingang 1 bis 0.

Strings generieren

Ich werde dies in mehrere Teile aufteilen:

• Zunächst wird der führende Abstand mit erreicht " "*(k+~i). Da idurch den Bereich (Eingabe, 0] abgebildet wird , müssen wir ihn von subtrahierenk (unserer sicher gespeicherten ursprünglichen Eingabe) , dekrementieren und ein Leerzeichen so oft wiederholen.

• +"\\" - Fügt den Charakter hinzu "\" zu den oben stehenden Leerzeichen hinzu.

• ' / |\ '[i%2::2]- Erzeugt unsere beiden Zeichenfolgen, nämlich "/ \ "und" | " in der folgenden Art und Weise:

  • Wenn iungerade ist, i% 2 ist 1 , also [i%2::2]jeweils 2 Zeichen unserer größeren String zurückgibt, bei Index Start 1 (0-indexiert).

  • Wenn iselbst ist, 2i% ist 1 , so dass der Mechanismus über das gleiche tut , außer es bei Index beginnt 0 .

• +~-i*- Wiederholt die Zeichenfolge oben erzeugt, entweder "/ \ "oder " | ", i-1 - mal, und fügt sie zu den anderen Saiten. Der Vorteil des bitweisen Operators ( ~- Bitweises Komplement, äquivalent zu i, subtrahiert von -1 ) besteht darin, dass in diesem Kontext keine Klammern erforderlich sind.

• [:k-~i]- Ruft alle Zeichen der oben verketteten Zeichenfolgen ab, bis der Index k- ~ i = k - (-1 - i) = k + 1 + i .

• +"_/"[i>0:]- Dies wird nur hinzugefügt, "/"wenn i ≥ 1 ist , andernfalls wird es angehängt _/.

Vollständiges Beispiel / Ausführungsdetails

Schauen wir uns ein Beispiel an, wie die Eingabe von 4 funktioniert :

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.

Python 2 , 90 Bytes

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

Probieren Sie es online!

05AB1E , 33 Bytes

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

Probieren Sie es online!

Mathematica, 131 Bytes

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

gibt eine Liste von Zeichenketten zurück

Probieren Sie es online!

Retina , 129 119 112 Bytes

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

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

Probieren Sie es online!

Holzkohle , 26 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes.

Python 2 , 123 112 110 109 100 98 96 Bytes

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

Probieren Sie es online!

• Mit Eingabe- und Zeichenfolgenformatierung wie in Rods Antwort eine Reihe von Bytes gespeichert
• 2 Bytes gespart dank Mr. Xcoder

Python 2 , 103 Bytes

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

Probieren Sie es online!

APL (Dyalog) , 97 93 Bytes

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

Probieren Sie es online!

SOGL V0.12 , 28 27 Bytes

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

Probieren Sie es hier aus!

Haskell , 96 bis 95 Bytes

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

Probieren Sie es online!

0-indiziert und gibt eine Liste von Zeilen zurück.

Haskell, 101 bis 99 Bytes

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

Gibt eine Liste von Zeilen zurück.

Probieren Sie es online!

Wie es funktioniert:

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

Edit: @Laikoni hat zwei Bytes gespeichert. Vielen Dank!

Java (OpenJDK 8) , 315 306 Bytes

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;}

Probieren Sie es online!

Java (OpenJDK 8) , 198 Byte

Endlich unter 200 Bytes. Werde wahrscheinlich später eine Erklärung posten.

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?"_/":"/")));}

Probieren Sie es online!

JavaScript (ES6), 89-85 Byte

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

Demo

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))

CJam, 43

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

Probieren Sie es online aus

PHP, 89 + 1 Bytes

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

Laufen Sie als Pipe mit -nRoder versuchen Sie es online .

Pyth ,  46  44 Bytes

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

Probieren Sie es hier aus!