측면 길이 n의 ASCII 육각형 그리기

Jan 06 2021

양의 정수 \$n\$대각선 길이의 ASCII 육각형 출력 \$n\$, 그림과 같이 ( \$2n\$ _ 상단 가장자리의 문자)

예 :

\$n = 1\$

 __
/  \
\__/

\$n = 2\$

  ____
 /    \
/      \
\      /
 \____/

\$n = 5\$

     __________
    /          \
   /            \
  /              \
 /                \
/                  \
\                  /
 \                /
  \              /
   \            /
    \__________/

기타

바이트 단위의 가장 짧은 코드가 이깁니다. 일반적인 입력 / 출력 방법이 적용됩니다.

답변

11 Razetime Jan 06 2021 at 16:01

캔버스 , 15 9 바이트

 _;1*⁸/∔╬

여기에서 시도하십시오!

프로그램 수정 후 -6 바이트.

육각형의 1/4을 그리고 4 개의 회문을 그립니다.

9 xnor Jan 06 2021 at 17:16

Python 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

온라인으로 시도하십시오!

6 Razetime Jan 06 2021 at 15:54

목탄 , 14 바이트

←×_θ↖θ→↗θ×_θ‖M

온라인으로 시도하십시오!

ASCII 전용에서 1 바이트 수정.

육각형의 절반을 그리고 미러링합니다.

6 AZTECCO Jan 07 2021 at 15:50

C (gcc) , 119109 바이트

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, y를 크기에서 0으로 반복하고 합산하여 /가 인쇄되어야하는지 확인하고 빼서 \를 확인하고 모듈로를 사용하여 두 병렬을 확인합니다.

    나는 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
5 NahuelFouilleul Jan 07 2021 at 03:22

Perl 5 ( -p), 102 바이트

s/_+/__$&/g,s/^|$/ /gm,s/^ *\S /$& /gm,s-( +)\\ -$&/ $1 \\ \\ $1 /
- for($\=' __ / \ \__/')x--$_}{

온라인으로 시도하십시오!

-p}{끝에 만 출력 레코드 분리를 인쇄하는 트릭 $\끝이. 하나의 입력 레코드에 대해서만 작동합니다. 헤더는 하나의 tio 링크에서 모두 인쇄하는 데 사용됩니다.

$\=' __ 
/  \
\__/'   # 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
5 WheatWizard Jan 08 2021 at 23:56

Haskell , 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

온라인으로 시도하십시오!

이 답변의 더 재귀 버전입니다. 이 도전의 임의성은 이것을 매우 실망스럽게 만듭니다.

설명

이 대답은 설명하기가 조금 어렵습니다. 내가 이미 말했듯이 문제는 몇 가지 방법에서 임의적이기 때문에 코드는 일종의 기호의 둥지 일뿐입니다.

생각

여기서 프로그램의 아이디어는 두 부분을 구성하는 것입니다. 그것은 n 번째 육각형을 계산할 때 우리는 n-1 번째 육각형에 대한 두 개의 반쪽을 얻고 그것을 다음으로 큰 육각형을 만드는 데 사용합니다.

그래도 몇 가지주의 사항이 있습니다. 우리는 위쪽 절반을 거꾸로 만들고 왼쪽에서 오른쪽으로 미러링 된 양쪽 절반을 만듭니다. 이렇게하는 것이 편리하기 때문입니다. 이해하기 어렵게 만들더라도 길이가 짧아지는 이유는 없습니다.

세부

첫 번째 줄은 꽤 정직 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최종 기능을 위해.

5 xnor Jan 11 2021 at 00:58

Haskell , 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].

4 Neil Jan 06 2021 at 17:08

Retina 0.8.2 , 94 바이트

.+
$* ¶$&$* \G ¶$%'/$`$%_$%_$`\
r` \G
$%`\$'$%_$%_$%'/¶ ^¶( *) $1 $.&$*_$.&$*_$& T` `\_` +/$

온라인으로 시도하십시오! 링크에는 테스트 케이스가 포함됩니다. 설명:

.+
$* ¶$&$* 

두 행의 n공백을 삽입 하십시오.

\G 
¶$%'/$`$%_$%_$`\

첫 번째 행을 육각형의 윗면으로 변환하십시오.

r` \G
$%`\$'$%_$%_$%'/¶

두 번째 행을 육각형의 아래쪽으로 변환하십시오.

^¶( *)
$1 $.&$*_$.&$*_$&

맨 윗줄을 삽입합니다.

T` `\_` +/$

결론을 바꿉니다.

4 ovs Jan 06 2021 at 16:32

Python 2 , 119114 바이트

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)

온라인으로 시도하십시오!

4 Arnauld Jan 07 2021 at 03:27

자바 스크립트 (ES6)  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
4 Noodle9 Jan 06 2021 at 21:18

C (gcc) , 194 \$\cdots\$ 149144 바이트

저장 (13) (14) (19)는 덕분에 바이트 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;}

온라인으로 시도하십시오!

설명 (일부 골프 전)

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    
   }  
 
4 ovs Jan 07 2021 at 05:12

05AB1E , 33 29 25 바이트

Kevin Cruijssen 덕분에 -4 ( 7 ) 바이트 !

L+<'/úíºI·'_ך»∊¶¡`ðs‡).c

온라인으로 시도하십시오!

05AB1E 에는 유용 ​​할 수있는 캔버스 내장 기능이 있지만 작업하기가 매우 까다 롭습니다. 이것은 미러 내장 기능 º중앙 집중화 내장 기능 .c입니다.

4 xash Jan 07 2021 at 01:26

J , 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

' \/_'{~ 
  ____
 /    \    
/      \    
\      /  
 \____/  
4 Anakhand Jan 06 2021 at 17:25

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

온라인으로 시도하십시오!

-@Duncan 덕분에 1 바이트

@Danis 덕분에 -8 바이트

4 AZTECCO Jan 10 2021 at 18:02

Haskell , 129120 바이트

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=' ']

온라인으로 시도하십시오!

  • @Wheat Wizard와 @xnor 덕분에 9 명이 절약되었습니다.

  • @xnor 답변과 문제에 대한 접근 방식에 대한 큰 개선 사항을 확인하십시오 (모듈로 및 병렬 라인 방지)!

  • 내 C 답변과 동일

목록 이해력 | y <-[0..n * 2], x <-[0..a]를 사용하여 데카르트 좌표를 만듭니다.

[c | ..., let c | ... | ... | ...] 그리고 우리는 xy 또는 x + y를 기준으로 필요한 문자를 소리내어 선을 그립니다 ..
우리는 모듈로를 사용하여 여러 선을 그립니다 (2)
특별한 경우는 _x / y 비율이 필요하지 않고 범위가 필요합니다. >a> x> b 대신 하나의 비교를 수행하기 위해 모듈로 사용

2 vrintle Jan 06 2021 at 15:15

Ruby , 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)]}

온라인으로 시도하십시오!

위쪽 밑줄이 허용되면 조금 더 적은 바이트를 사용하고 육각형은 이전처럼 예쁘다 ;-)

Ruby , 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]}

온라인으로 시도하십시오!

2 Makonede Jan 07 2021 at 00:45

05AB1E , 70 바이트

ðש'_¹·×«©¶«©¹'/1Λ¹·Ì'.2Λ¹'\3.Λ«©„./`.;©¶¡Â‚€»`s'.ð:,¹3*>(£„._`:„/\‡,

온라인으로 시도하십시오!

2 KjetilS. Jan 07 2021 at 00:54

Perl 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
}
2 StevenFontanella Jan 07 2021 at 12:31

Haskell , 186168 바이트

-18 바이트 (xnor의 수정 사항 포함) 및 마지막 줄에서 불필요한 공간 제거

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