도전

크기가 주어지면 해시 기호 ( #)와 공백 ( )으로 구성된 해당 크기의 큐브 그물을 인쇄하십시오 .

예 :

1:
  #
# # #    
  #
  #

2:
    # #
    # #
# # # # # #
# # # # # #
    # #
    # #
    # #
    # #

3:
      # # #
      # # #
      # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
      # # #
      # # #
      # # #
      # # #
      # # #
      # # #

그물은 실제로 큐브로 접을 수있는 유효한 큐브 그물 일 수 있습니다. 예를 들면 다음과 같습니다.

    # #
    # #
# # # # # # # #
# # # # # # # #
    # #
    # #

    # # # #
    # # # #
    # #
    # #
    # #
    # #
# # # #
# # # #

규칙

• 결과 그물은 기하학적으로 유효해야합니다 (입방체로 접을 수 있음)
• 금지 된 표준 허점
• 규칙을주의 깊게 읽으십시오
• 이것은 code-golf , 최단 답변 승리이지만 선택되지는 않습니다.

파이썬 2, 47 바이트

n=input()
for c in 1,4,1:exec"print'# '*c*n;"*n

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

왼쪽 정렬을 위해 선택된이 그물을 인쇄합니다.

# # 
# # 
# # # # # # # # 
# # # # # # # # 
# # 
# # 

행에 n또는의 4*n사본이 '# '있습니다. 각각에 대해 1,4,1, 우리 n는 많은 사본 n을 한 n줄에 인쇄 한 횟수를 인쇄 합니다. exec루프 내부에 for루프가 있으면 낭비되는 것처럼 보이지만 더 잘 보이지 않았습니다.

내가 테스트 한 대안 :

lambda n:('# '*n*3+'\n')*n+('  '*n+'# '*n+'\n')*3*n

lambda n:('# '*n*3+'\n')*n+(' '*4*n+'# '*n*3+'\n')*n

def f(n):
 for c in[3]*n+[1]*3*n:print('# '*c*n).center(6*n)

def f(n):
 for c in[4]*n+[0]*n:print' '*c*n+'# '*n*3

def f(n):
 for c in[1]*n+[4]*n+[1]*n:print'# '*c*n

def f(n):
 c=1;exec("print'# '*c*n;"*n+"c^=5;"*n)*3

def f(n):
 for i in range(3*n):print'# '*[1,4,1][i/n]*n

def f(n):
 for c in 1,4,1:print('# '*c*n+'\n')*n,

def f(n):
 for c in 1,4,1:exec"print'# '*c*n;"*n

( def기능은 프로그램으로서 하나 더 짧을 수 있습니다.)

옥타브, 58 44 42 32 바이트

@(n)[z=repmat('# ',n);z,z,z,z;z]

@xnor의 python answer에서 부분적으로 영감을 얻었습니다.

z=repmat('# ',n);

입력 2에 대해 '#'의 squre 패턴을 작성하면 다음 패턴이 나타납니다.

# #             
# # 

y=[z,z,z,z];

4 개가 z가로로 연결됩니다.

# # # # # # # # 
# # # # # # # # 

[z;y;z]

z및 y및 z수직으로 연결된다

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

# #             
# #             
# # # # # # # # 
# # # # # # # # 
# #             
# #             

이전 답변 :

@(n){h(1:n,1:2:n*6)=1;h(1:n*4,n*2+1:2:4*n)=1;' #'(h+1)}{3}

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

T 자형을 생성합니다

# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
      # # #      
      # # #      
      # # #      
      # # #      
      # # #      
      # # #      
      # # #      
      # # #      
      # # #      

Mathematica, 77 60 52 바이트

8 바이트 떨어진 골프를 해주신 Martin Ender에게 감사드립니다!

{±s_:=s~Table~#;b=±{a=±"# ","
"},±{a,a,a,a,"
"}}<>b&

명명되지 않은 함수는 양의 정수 인수를 취하고 #개행 (후행 개행 포함)이 포함 된 문자열을 반환합니다. 각 줄에는 후행 공간이 있습니다. 먼저 ±입력 #시간 을 반복하는 함수로 정의 합니다 . 다음 a과 같이 정의된다 ±"# "(이것은 #문자가 아니라 입력!)에서 그 b집합으로 정의되는 #반면, 짧은 라인 ±{a,a,a,a}<>n세트이며 #긴 라인. (두 경우 모두 일치하는 따옴표 사이에 리터럴 줄 바꿈이 있습니다.) 마지막 <>b문자열은 결과 문자열 목록을 짧은 줄 집합의 두 번째 복사본과 연결합니다. #=2( xnor의 답변 이이 방향이 골퍼임을 가르쳐주었습니다) 의 출력 예 :

# #     
# #     
# # # # # # # # 
# # # # # # # # 
# #     
# #     

이 구현의 이전 버전 :

""<>(±s_:=s&~Array~#;{b=±{a=±"# ",n="\n"},±{a,a,a,a}<>n,b})&

원본 제출 :

""<>If[(m=n~Mod~t)==0,"\n",If[n<t#||#<m<=2#,"# ","  "]]~Table~{n,4(t=3#+1)#}&

캐릭터의 아웃 구축 4*(3#+1)되는 각각의 하나이고, 조각 "# ", " "또는 "\n"; 단순히 인덱스를 기반으로 사용할 조각을 계산합니다 n. 다음의 경우 출력 예 #=2:

# # # # # # 
# # # # # # 
    # #     
    # #     
    # #     
    # #     
    # #     
    # #     

자바 스크립트 (ES6), 59 바이트

f=
n=>`141`.replace(/./g,m=>`${`# `.repeat(n*m)}\n`.repeat(n))

<input type=number oninput=o.textContent=f(this.value)><pre id=o>

출력에는 각 줄의 끝에 후행 공백과 후행 줄 바꿈이 포함됩니다.

루비, 36 바이트

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}

용법:

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}
f[3]
# # #
# # #
# # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # #
# # #
# # #

루비, 38 바이트

이 모양은 Ruby에서 더 길지만 더 짧은 언어가있을 것으로 예상합니다.

->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}

용법:

g=->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}
g[3]
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #

문자열 배열 또는 (바람직하지 않은) 단일 문자열을 반환하는 대신 (바람직하게는) 반환하는 것이 허용되면 두 답변이 더 짧을 수 있습니다.

스칼라, 56 바이트

(n:Int)=>Seq(1,4,1)map("# "*_*n+"\n")map(_*n)mkString ""

자바 스크립트 (ES6), 71

n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

테스트

f=
n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

function update() {
  O.textContent=f(I.value)
}

update()

<input id=I type=number value=3 oninput='update()'><pre id=O></pre>

자바 8, 99 바이트

l->{for(int i=-1,j;++i<3*l;)for(j=-1,k=(i/l==2)?4*l:l;++j<k;)System.out.print("# "+j>k-2?"\n":"");}

V , 24 23 20 18 20 바이트

Ài# ddÀpLyGïp3PGïp

숨겨진 모든 문자가 표시된 상태

Ài# ^[ddÀp^VLyGïp3PGoïp

^[is 0x1b(문자 이스케이프)이고 ^Vis 0x16( C-v)

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

Ä이 새로운 V 풀에서 명령이 버그 이기 때문에 바이트 수를 늘려야했습니다.

이 형식의 출력 :

# 
# # # # 
# 

주요 개행

16 진 덤프 :

00000000: c069 2320 1b64 64c0 7016 4c79 47ef 7033  .i# .dd.p.LyG.p3
00000010: 5047 ef70                                PG.p

설명

Ài# ^[              " Argument times insert "# "
ddÀp                " Argument times duplicate line

그물의 한면이 완성되었으므로 그물을 만들어야합니다

^VLy                " Copy the face
Gïp                 " Paste it at the end of buffer
3P                  " Paste 3 times (these form the line)
Gïp                 " Paste at end of buffer again

공백을 출력하지 않으면 대체 솔루션 :

21 20 18 16 18 바이트

Àé#ddÀpLyGïp3pGïp

(최상의 솔루션과 동일한 이유로이 TIO 링크가 수정 됨)

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

V , 14 바이트 (비경쟁)

Ài# 5Ù4JjòÀÄk

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

00000000: c069 2320 1b35 d934 4a6a f2c0 c46b       .i# .5.4Jj...k

어떤 이유로 든이 도전은 수많은 버그를 발견했습니다. 모두 수정되었으므로이 버전은 불행히도 경쟁이되지 않지만, 난잡한 코딩을 처리하기 위해 많은 양의 바이트를 추가 할 필요가없는 경우이 문제에 대한 V 답변의 모양을 보는 것이 좋습니다.

설명:

À                   " Arg 1 times:
 i# <esc>           "   Insert the string "# "
         5Ù         " Make 5 copies of this line, and put the cursor on the second copy
           4J       " Join four of these lines together
             j      " Move down to the last line
              ò     " Recursively:
               ÀÄ   "   Make Arg 1 copies of this line
                 k  "   And move up a line

젤리 , 20 19 바이트

”#xẋ³Wẋ³K€Y
141DÇ€Y

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

44874 (steenbergh)에게 -1 감사합니다.

^{머드 피쉬 도움말을 아웃 고프 할 수 없습니다!}

이것이 골프입니까? 20 19 바이트는 Link 1을 보면 너무 많이 보입니다 .

설명:

”#xẋ³Wẋ³K€Y Helper link. Arguments: z
”#          Character #.
            y (implicit)
  x         Repeat each element of y x times.
    ³       1st command-line argument.
   ẋ        Repeat x y times.
     W      Wrap z.
       ³    1st command-line argument.
      ẋ     Repeat x y times.
        K   Join z on spaces.
         €  Map this link on x.
          Y Join z on newlines.

141DÇ€Y Main link. Arguments: 0
141     Integer 141.
   D    Convert z to base 10.
    Ç   The above link as a monad.
     €  Map this link on x.
      Y Join z on newlines.

숯 , 20 바이트

ＮλＧ↑λ←×⁶λ↓λ# ＤＭ×⁴λ← 

코드는 공백으로 끝납니다. 온라인으로 사용해보십시오!

설명

숯은 ASCII 아트를 전문으로하는 언어입니다. 또한 불완전하고 버그가 많으며 문서화가 부족합니다. 말하자면, 예상했던 일을하기 전에 상당한 양의 시행 착오가 필요했습니다.

• Ｎλ에 숫자를 입력합니다 λ.
• Ｇ여기에 사각형을 그리는 데 사용할 다각형 명령이 있습니다. ↑λ←×⁶λ↓λ다각형의 경계를 지정합니다 (위쪽 λ단계, 왼쪽 6 배 λ단계 및 아래쪽 λ단계). (즉, 세이다 λ의해 λ사각형의 하단 유추 나란히이. 블록). 그런 다음 다각형이 문자열로 채워집니다 # .
• Ｄ 현재 캔버스를 stdout에 덤프하여 다음과 같은 결과를 얻습니다.

 # # # # # # # # #
 # # # # # # # # #
 # # # # # # # # #

• Ｇ명령 후 커서는 캔버스의 왼쪽 하단에 있습니다. Ｍ×⁴λ←4 배씩 왼쪽으로 이동 λ합니다 ( 블록 당 2 개 λ에 해당 λ).
• 공간을 출력하여 캔버스를 왼쪽으로 올바른 양만큼 확장합니다.
• 프로그램이 끝나면 캔버스는 다시 stdout으로 보내집니다.

             # # # # # # # # #
             # # # # # # # # #
             # # # # # # # # #

그들을 합치면 큐브 그물이 생겼습니다.

Bash / Unix 유틸리티, 72 69 68 66 바이트

b()(yes `dc<<<2o4d$n^$1^3/p`|tr 01 ' #'|head -$n);n=$1;b 1;b 4;b 1

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

이것은 기본 2로 쓰여질 때 [4 ^ k / 3]이 10101010 ... 01이고 k 1과 함께 있다는 사실을 사용하여 작동합니다. (여기에서 대괄호는 바닥 기능을 나타냅니다.)

파이크, 16 바이트

uAD,sXF**"# 

여기 사용해보십시오!

에 해당

1 4 1]3AD,sXF**"# 

인쇄 할 수없는 요소로 인해

바이트 수를 낮추기 위해 몇 가지 트릭을 사용합니다.

• 일부 인쇄 할 수없는 것을 사용하여 목록을 나타냅니다. [1, 4, 1]
• XF 출력을 스택에 자동 덤프
• "#끝에 있는 문자열 은 마지막으로 교체 *되므로 닫을 "필요가 없습니다. 이것은 마지막 토큰이 문자열 일 때 암시 적으로 발생합니다.

u                -      [1, 4, 1]
     AD          -     apply(*, ^, input)
       ,         -    zip(^)
        s        -   sum(^)
          F**"#  -  for i in ^:
           *     -    ^ * input
            *    -   ^ * v
             "#  -    "# "
         X       - splat(^)

파이썬 2 , 68 71 65 바이트

@sagiksp 덕분에 -6

def f(i,c=1):
 print(' '*i*4,'')[c>i]+'# '*i*3
 if i*2>c:f(i,c+1)

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

@xnor를 이길 방법을 찾지 못하면 대체 대안으로 내 재귀 함수를 게시합니다. f (5) 인쇄

                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 

이 패턴은 다른 패턴과 달리 두 부분으로 나눌 수 있기 때문에 간단하게 선택되었습니다.

PHP, 64 62 바이트

Christoph 덕분에 2 바이트가 절약되었습니다 .

while($a="282"[$i++/$s=$argv[1]]*$s)echo str_pad("
",$a,"# ");

다음과 같이 그물을 인쇄합니다.

# #
# #
# # # # # # # #
# # # # # # # #
# #
# #

(가는 줄 바꿈)

배치, 111 바이트

@set s=
@set i=@for /l %%i in (1,1,%1)do @
%i%call set s=%%s%% #
%i%echo%s%
%i%echo%s%%s%%s%%s%
%i%echo%s%

Pushy , 32 29 28 바이트

정사각형을 왼쪽 정렬하여 인쇄합니다. 이것은 골프하기가 어려웠다 ...

&V:`# `;{:";N^:4:";T'.;TD^:"

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

망막 , 39 37 바이트

레티 나를 사용한 것은 이번이 처음이지만 여전히 어떻게해야하는지 이해하려고 노력하고 있습니다.

.+
$*#
#
# 
\`# 
$_¶
G`.
)*%`^
$_$_$_

(4 번째와 5 번째 줄 다음에 2 개의 후행 공백이 있음)

2 바이트 골프를 한 Martin Ender에게 감사합니다!

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

QBIC , 52 67 40 바이트

다시 쓰기 완료 :

:[a*3|G=G+@#`][a*2|G=G+@ `][a|?G][a|?_fG

이제이 패턴을 사용합니다.

###--
--###

-공백으로 채워진 곳 .

:        Read 'a' from the command line        > Assume 3
[a*3|    Create 3 segments times 'a' filling   > 3*3 = 9
G=G+@#`] Define A$ to be '#' and add this to G > G = "#########" 
[a*2|    Create 2 segments times 'a' spacer
G=G+@ `] Define B$ to be ' ' and add this to G > G = "#########       " 
[a|      FOR d == 1; d <= a; d++
?G]      Display G$:
            "#########       " 
            "#########       " 
            "#########       " 
[a|      FOR e == 1; e <= a; e++
?_fG     Display G$ in reverse (_f...|):
            "      #########" 
            "      #########" 
            "      #########" 
         (For loop and function call to Flip impicitly closed by QBIC)

핍 , 28 17 16 바이트

15 바이트의 코드, -n플래그의 경우 +1

"# "Xa*_RLaM141

크기를 명령 행 인수로 사용합니다. 온라인으로 사용해보십시오!

설명

                 a is 1st cmdline arg
       _         Build a lambda function
     a*          (a) times argument
"# "X            Repeat string "# " that many times
        RLa      Wrap in a list and repeat list (a) times
           M141  Map that function to the characters of 141
                 Autoprint (-n flag separating list items with newlines)

다음은 데이터가 정확히 어떻게 수정되는지는 아니지만 기본적인 아이디어를 제공합니다 ( a=2).

141

[1;4;1]

[2;8;2]

["# # ";"# # # # # # # # ";"# # "]

[["# # ";"# # "];["# # # # # # # # ";"# # # # # # # # "];["# # ";"# # "]]

# # 
# # 
# # # # # # # # 
# # # # # # # # 
# # 
# # 

05AB1E , 13 바이트

D141S×S*„# ×»

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

설명

입력 예 n=2

D              # duplicate input
               # STACK: 2, 2
 141S          # push the list [1,4,1]
               # STACK: 2, 2, [1,4,1]
     ×         # repeat each item in the list input_no times
               # STACK: 2, [11, 44, 11]
      S        # split into list of digits
               # STACK: 2, [1, 1, 4, 4, 1, 1]
       *       # multiply each digit with input
               # STACK: [2, 2, 8, 8, 2, 2]
        „# ×   # repeat the string "# " for each item in the list
               # STACK: ['# # ','# # ','# # # # # # # # ','# # # # # # # # ','# # ','# # ']
            »  # join by newlines
               # OUTPUT: # # 
                         # # 
                         # # # # # # # # 
                         # # # # # # # # 
                         # # 
                         # # 

C #, 152 바이트

n=>{var m="";foreach(int c in new[]{1,4,1})for(int i=0,j;i++<n;){for(j=0;j++<c;)m+=new System.Text.StringBuilder().Insert(0,"# ",n);m+="\n";}return m;};

SmileBASIC, 57 50 바이트

INPUT S
E$=("#"*S*3+CHR$(10))*S?E$SCROLL-S*2,-1?E$

설명 :

INPUT SIZE
PART$=("#"*SIZE*3+CHR$(10))*S 'generate half of the pattern
PRINT PART$ 'print half the pattern
SCROLL SIZE*-2,-1 'scroll the text 2 squares right (and 1 character down)
PRINT PART$ 'print half the pattern again

첫 번째 PRINT 이후 (size = 2, @는 커서 위치) :

######
######

@ 

스크롤 후 :

    ######
    ######
@

두 번째 인쇄 후 :

    ######
    ######
######
######
@

공통 리스프, 83 81 79 바이트

(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))

용법:

(funcall #'(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))2)

산출:

# # # # # #
# # # # # #
    # # 
    # # 
    # # 
    # #       
    # # 
    # #           

어떻게 작동합니까?

in format there is control string (inside "") and arguments after it
certain commands in string can use arguments (for example ~a displays argument)
~v{~} - takes argument and does commends inside {~} number of times 
                                      (number is given by argument)
       we can write text in loop body - it'll get displayed. Even if
       in loop body there are none commends to use arguments loop itself                 
       will consume one argument (it doesn't matter what it'll be -
       it doesn't seem to affect output)
~% - newline
~n* - jump n arguments forward (relative)
~n:* - jump n arguments backwards (relative)
~n@* - jump to argument n (global, counting from 0)

~v@{~v{# ~}~%~1@*~} <--- we make x rowns, 3x columns of string "# ". 
                         ~1@* is used during looping, it also means we end on argument 1. 
                         (second argument: (* x 3))
~v@{~vt~0@*~v{# ~}~%~} <--- we now make 3x rows, x columns of "(spaces)# "
                         ~vt - is used to move to accurate column. 
                         Here it takes argument (* x 2) - this is 
                         minimal number of columns to display. It uses
                         space as default character for missing characters
                         (when string inside <~> is shorter than min 
                         number of columns). I use it to make (* x 2) spaces, 
                         by giving it no text.
      ~0@* <--- after making spaces we have no new arguments, we go back to
                argument number zero - it is used to determine number of columns in our block

개선을위한 아이디어를 환영합니다.