|/\문자 로 구성된 육각형의 무한 타일링을 가정하십시오 .

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

입력이 주어지면 n > 0아래 예제에 표시된 것처럼 타일링의 삼각형 부분을 _육각형의 중간에 앵커로 출력하십시오 .

n=1
\_/

n=2
\/ \/
 \_/

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

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

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

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

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

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

and so on

규칙

• 문자가 적절하게 정렬되는 경우 선행 / 후행 줄 바꿈 또는 기타 공백은 선택 사항입니다.
• 전체 프로그램 또는 기능이 허용됩니다. 함수 인 경우 출력하지 않고 출력을 반환 할 수 있습니다.
• 콘솔로 출력하고 이미지로 저장하거나 문자열 목록으로 반환 할 수 있습니다.
• 표준 허점 은 금지되어 있습니다.
• 이것은 코드 골프 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

파이썬 2 , 86 바이트

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

온라인으로 사용해보십시오!

Erik의 트릭 중 하나가 3 바이트의 골프를 허용했습니다! Jonathan Allan 덕분에 3 바이트를 절약했습니다.

작동 원리

먼저 STDIN에서 입력을 받아서 두 개의 개별 변수 i및에 할당합니다 k. 그런 다음 변수는i 가 진실한 를 줄이고 문자열을 적절하게 생성합니다. 이것은 입력에서 1-0까지 루핑하는 속기입니다.

문자열 생성

나는 이것을 더 많은 부분으로 나눌 것이다 :

• 우선, 띄어쓰기 간격은으로 달성됩니다 " "*(k+~i). i범위 (input, 0]을 통해 매핑 되기 때문에 k(안전하게 저장된 원래 입력에서) 빼고 공백을 여러 번 반복하고 반복해야합니다.

• +"\\"- "\"위의 공백에 문자 를 추가합니다 .

• ' / |\ '[i%2::2]- 즉 우리의 두 문자열을 생성 "/ \ "하고 " | "다음과 같은 방식으로, :

  • 경우 i홀수, 난 % 2 인 1 따라서, [i%2::2]인덱스부터 시작하여, 우리의 큰 문자열의 각 2 개 문자를 반환 1 (0 인덱스).

  • 경우 i에도이고, I는 2 % 인 1 은 인덱스에서 시작되는 것을 제외하고는 동일한 작업을 수행하므로기구보다도 0 .

• +~-i*- 문자열이 상기 생성 된 반복하거나 "/ \ "또는 " | ", I-1 번, 다른 문자열에 추가한다. 비트 연산자 ( -1 에서 빼는 i~ 와 동등한 비트 연산자)의 이점은 이 컨텍스트에서 괄호가 필요하지 않다는 것입니다.

• [:k-~i]-인덱스 k- ~ i = k-(-1-i) = k + 1 + i 까지 문자열이 연결된 모든 문자를 가져옵니다 .

• +"_/"[i>0:]-i가 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.

파이썬 2 , 90 바이트

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

온라인으로 사용해보십시오!

05AB1E , 33 바이트

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

온라인으로 사용해보십시오!

Mathematica, 131 바이트

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

문자열 목록을 반환

온라인으로 사용해보십시오!

망막 , 129 (119) 112 바이트

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

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

온라인으로 사용해보십시오!

숯 , 26 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다.

파이썬 (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

온라인으로 사용해보십시오!

• Rod의 답변 에서와 같이 입력 및 문자열 형식을 사용하여 많은 바이트를 절약했습니다.
• Mr. Xcoder 덕분에 2 바이트 절약

파이썬 2 , 103 바이트

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

온라인으로 사용해보십시오!

APL (Dyalog) , 97 93 바이트

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

온라인으로 사용해보십시오!

SOGL V0.12 , 28 27 바이트

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

여기 사용해보십시오!

하스켈 , 96 95 바이트

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

온라인으로 사용해보십시오!

0 색인화되어 행 목록을 리턴합니다.

하스켈, 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

편집 : @Laikoni는 2 바이트를 저장했습니다. 감사!

자바 (오픈 JDK 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;}

온라인으로 사용해보십시오!

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 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))

CJam, 43

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

온라인으로 사용해보십시오

PHP, 89 + 1 바이트

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

파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

Pyth ,  46  44 바이트

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

여기 사용해보십시오!