Octothorpe, (또한 숫자 기호, 해시 또는 해시 태그, 또는 파운드 기호는) 다음과 같은 ASCII 문자는 다음과 같습니다

#

재미 있지 않습니까? 더 큰 버전을 만들 수 있습니다! 여기 당신의 도전이 있습니다 :

정수 긍정적 감안할 때 N 크기의 출력 아스키 해시 태그, N .

예를 들어, 크기가 1 인 ASCII 해시 태그는 다음과 같습니다.

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

각 줄의 후행 공백은 허용되지만 필수는 아닙니다.

입력은 항상 유효한 양의 정수이므로 숫자가 아닌 수, 음수 또는 0을 처리 할 필요가 없습니다. 출력은 합리적인 형식 일 수 있으므로 STDOUT으로 출력하거나, 문자열 목록 또는 줄 바꿈, 2D 문자 매트릭스, 파일 쓰기 등은 모두 괜찮습니다.

테스트 사례

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

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

4:
    ####    ####    
    ####    ####    
    ####    ####    
    ####    ####    
####################
####################
####################
####################
    ####    ####    
    ####    ####    
    ####    ####    
    ####    ####    
####################
####################
####################
####################
    ####    ####    
    ####    ####    
    ####    ####    
    ####    ####    

5:
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
#########################
#########################
#########################
#########################
#########################
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
#########################
#########################
#########################
#########################
#########################
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     

이것은 코드 골프이기 때문에 가능한 한 가장 짧은 솔루션을 작성하고 무엇보다도 재미있게 보내십시오!

MATL , 20 16 12 11 바이트

DJMcMayhem 덕분에 3 바이트.

Luis Mendo 덕분에 1 바이트.

21BwY"&*~Zc

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

설명

    % stack starts with input e.g. 2
21  % push 21 to stack             2 21
B   % convert to binary            2 [1 0 1 0 1]
w   % swap                         [1 0 1 0 1] 2
Y"  % repeat                       [1 1 0 0 1 1 0 0 1 1]
&*  % one-input multiplication    [[1 1 0 0 1 1 0 0 1 1]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [1 1 0 0 1 1 0 0 1 1]]
~   % complement                  [[0 0 1 1 0 0 1 1 0 0]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [0 0 1 1 0 0 1 1 0 0]]
Zc  % convert 0 to spaces            ##  ##  
      1 to octothorpes               ##  ##  
      and join by newline          ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  
                                   ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  

Brain-Flak , 420 바이트

(()()()){({}<(({})){({}<<>(<>({})<>){({}<((((()()()()){}){}()){}())>[(
)])}{}(<>({})<>){({}<((((()()()()){}){}){})>[()])}{}(<>({})<>){({}<(((
(()()()()){}){}()){}())>[()])}{}(<>({})<>){({}<((((()()()()){}){}){})>
[()])}{}((()()()()()){})<>>[()])}{}((({}))<(({})(({}){}){})>){({}<<>(<
>({})<>){({}<((((()()()()){}){}()){}())>[()])}{}((()()()()()){})<>>[()
])}{}{}>[()])}{}({}<>)(({})((({({})({}[()])}{})){}){}{}){({}<{}>[()])}

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

아니요, 420 점은 의도적이지 않았습니다. 약속합니다. 읽을 수있는 버전 :

# 3 Times...
(()()())
{
({}<

    #Duplicate the input
    (({}))

    #Input times...
    {
        ({}<

        #Switch to the main stack
        <>

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            # Push a hash
            ((((()()()()){}){}()){}())

        >[()])}{}

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            #Push a space
            ((((()()()()){}){}){})

        >[()])}{}

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            # Push a hash
            ((((()()()()){}){}()){}())

        >[()])}{}

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            #Push a space
            ((((()()()()){}){}){})

        >[()])}{}

        #Push a newline
        ((()()()()()){})

        #Toggle back to the alternate stack
        <>

        #Decrement the (second) loop counter
        >[()])

    #Endwhile
    }

    #Pop the now zeroed loop counter
    {}

    #Turn [a] into [a, a*5, a]
    ((({}))<(({})(({}){}){})>)

    #A times....
    {
        ({}<

        #Toggle back over
        <>

        #Grab a*5
        (<>({})<>)

        #That many times...
        {({}<

            #Push a space
            ((((()()()()){}){}()){}())

        >[()])}{}

        #Push a newline
        ((()()()()()){})

        #Toggle back
        <>

        #Decrement the (second) loop counter
        >[()])

    }

    #Pop the loop counter and the a*5
    {}{}

#Decrement the outer loop counter
>[()])
}

#Pop the zeroed loop counter
{}

#Pop a over
({}<>)

#Pushes (a**2) * 5 + a
(({})((({({})({}[()])}{})){}){}{})

#That many times...
{({}<

    #Pop a character off the output stack
    {}

>[()])}

6502 머신 코드 (C64), 59 56 바이트

00 C0 20 9B B7 A9 06 85 FC 86 FE A6 FE 86 FD A9 03 4D 1F C0 8D 1F C0 C6 FC D0
01 60 A9 23 A0 05 49 00 20 D2 FF CA D0 FA A6 FE 88 D0 F3 A9 0D 20 D2 FF C6 FD
D0 E6 F0 D3

온라인 데모

사용법 : SYS49152,N여기서 N은 1에서 255 사이의 숫자입니다.

_{(4보다 큰 값은 이미 8부터 C64 화면에 비해 너무 커서 출력이 너무 넓습니다)}

설명 :

         00 C0       .WORD $C000    ; load address

.C:c000  20 9B B7    JSR $B79B      ; read N into X
.C:c003  A9 06       LDA #$06       ; number of "logical" lines plus 1 for hash
.C:c005  85 FC       STA $FC        ; store in counter variable for lines
.C:c007  86 FE       STX $FE        ; store N in counter variable for char repetitions
.C:c009  A6 FE       LDX $FE        ; load repetition counter
.C:c00b  86 FD       STX $FD        ; store in counter variable for line repetitions
.C:c00d  A9 03       LDA #$03       ; value to toggle the character toggle
.C:c00f  4D 1F C0    EOR $C01F      ; xor character bit toggle
.C:c012  8D 1F C0    STA $C01F      ; store character bit toggle
.C:c015  C6 FC       DEC $FC        ; decrement "logical" lines
.C:c017  D0 01       BNE $C01A      ; not 0 -> continue
.C:c019  60          RTS            ; program done
.C:c01a  A9 23       LDA #$23       ; load hash character
.C:c01c  A0 05       LDY #$05       ; load "logical" columns for hash
.C:c01e  49 00       EOR #$00       ; in each odd "logical" line, toggle character
.C:c020  20 D2 FF    JSR $FFD2      ; output one character
.C:c023  CA          DEX            ; decrement character repetition
.C:c024  D0 FA       BNE $C020      ; not 0 -> back to output
.C:c026  A6 FE       LDX $FE        ; reload character repetition
.C:c028  88          DEY            ; decrement "logical" columns
.C:c029  D0 F3       BNE $C01E      ; not 0 -> back to character toggle
.C:c02b  A9 0D       LDA #$0D       ; line done, load newline character
.C:c02d  20 D2 FF    JSR $FFD2      ; and output
.C:c030  C6 FD       DEC $FD        ; decrement line repetitions
.C:c032  D0 E6       BNE $C01A      ; not 0 -> back to character init
.C:c034  F0 D3       BEQ $C009      ; else back to main loop (toggle char toggling)

하스켈 , 43 바이트

l%n=l!!1:l++l<*[1..n]
f n=["##"%n,"# "%n]%n

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

문자열 목록을 출력합니다.

파이썬 2 , 55 바이트

def f(n):p=[(" "*n+"#"*n)*2]*n;print(p+["#"*n*5]*n)*2+p

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

2D 문자 목록을 반환합니다.

파이썬 2 , 65 바이트

def f(n):p=((" "*n+"#"*n)*2+"\n")*n;print(p+("#"*n*5+"\n")*n)*2+p

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

파이썬 2 , 66 바이트

def f(n):p=[(" "*n+"#"*n)*2]*n;print'\n'.join((p+["#"*n*5]*n)*2+p)

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

숯 , 21 바이트

ＮθＵＯײθ#ＵＯθ Ｆ²⟲ＯＯ²⁴⁶θ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 원래는 귀여운 비트 맵 방식을 시도했습니다.

Ｆ⁵Ｆ⁵Ｆ＆｜ικ¹«Ｊ×ιＩθ×κＩθＵＯθ#

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명 : 5x5 #제곱의 배열로 간주하여 작동합니다 . 홀수 행 또는 열에있는 사각형을 채워야합니다.

J, 22 바이트

#('# '{~#:5$21,0)#~"1]

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

다른 J 답변과 많은 유사점을 가지고 있지만 명사가 많은 기차를 이해하지 못하기 때문에 내 대답에는 3 개의 잠재적 바이트가 있습니다 (두 개의 parens 및 reflexive- ~).

설명

문어 생성

옥토 소프는 괄호 안의 모든 것으로 만들어지며 편의를 위해 아래에 재현됩니다.

'# '{~#:5$21,0

내가 옥토 프를 만드는 많은 방법은 J가 충분히 길지 않을 때 배열을 채우는 방식을 남용하는 것입니다.

21,0단순히 배열을 만듭니다 21 0.

5$해당 배열을 5 원자 배열로 재구성합니다 21 0 21 0 21.

#:각 원자를 이진수로 변환합니다. #:각 원자에서 작동 하기 때문에 출력은 행렬입니다. 각각 21은 1 0 1 0 1예상대로 대체 되지만 각각 0은 0 0 0 0 0! 로 대체됩니다 . 이는 J 패드 배열 5 5이 1 0 1 0 1행 때문에 발생 해야하는 결과 2D 배열의 모양과 일치하기에 충분히 길지 않기 때문입니다 . 다행스럽게도 숫자 0는로 채워 지므로 결과 행렬을 얻습니다.

1 0 1 0 1
0 0 0 0 0
1 0 1 0 1
0 0 0 0 0
1 0 1 0 1

'# '{~각각 1을 공백과 로 변환 0합니다 #. {"테이크"를 ~의미하고 "이항 인수를 전환하므로 J는 문자열의 인덱스로 각 요소를 찾습니다. '# '즉, 각 0요소는 0 번째 요소가 #되고 각 1요소는 첫 번째 요소, 공백이됩니다. 이는 1 옥토 프 크기를 나타냅니다.

문어 크기 조정

이것은 단순히 n각 축을 따라 시간 을 복사하는 문제입니다.

첫 번째 #(후크의 일부) 및 #~"1]. #가로 축을 #"1따라 복사하고 세로 축을 따라 복사합니다.

CJam, 27 26 25 바이트

{_[{S3*'#*'#5*}3*;]fe*e*}

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

재미있는 사실 : 이것은 원래 29 바이트에서 시작되었으며 이후 블록과 전체 프로그램 모드를 번갈아 가며 바이트가 하나씩 제거되었습니다.

설명:

{                          e# Stack:               | 2
 _                         e# Duplicate:           | 2 2
  [                        e# Begin array:         | 2 2 [
   {                       e# Do the following 3 times:
    S                      e#   Push a space       | 2 2 [" "
     3*                    e#   Repeat it 3 times: | 2 2 ["   "
       '#*                 e#   Join with '#':     | 2 2 [" # # "
          '#               e#   Push '#':          | 2 2 [" # # " '#
            5*             e#   Repeat it 5 times: | 2 2 [" # # " "#####"
              }3*          e# End:                 | 2 2 [" # # " "#####" " # # " "#####" " # # " "#####"
                 ;         e# Delete top of stack: | 2 2 [" # # " "#####" " # # " "#####" " # # "
                  ]        e# End array:           | 2 2 [" # # " "#####" " # # " "#####" " # # "]
                   fe*     e# Repeat characters:   | 2 ["  ##  ##  " "##########" "  ##  ##  " "##########" "  ##  ##  "]
                      e*   e# Repeat strings:      | ["  ##  ##  " "  ##  ##  " "##########" "##########" "  ##  ##  " "  ##  ##  " "##########" "##########" "  ##  ##  " "  ##  ##  "]
                        }  e# End
e# Result:
e# ["  ##  ##  "
e#  "  ##  ##  "
e#  "##########"
e#  "##########"
e#  "  ##  ##  "
e#  "  ##  ##  "
e#  "##########"
e#  "##########"
e#  "  ##  ##  "
e#  "  ##  ##  "]

껍질 , 12 10 바이트

´Ṫ▲Ṙ" # # 

온라인으로 사용해보십시오! 후행 공백에 유의하십시오.

설명

´Ṫ▲Ṙ" # #   Implicit input, e.g. n=2.
   Ṙ" # #   Repeat each character of the string n times: "  ##  ##  "
´Ṫ          Outer product with itself by
  ▲         maximum: ["  ##  ##  ","  ##  ##  ","##########","##########","  ##  ##  ","  ##  ##  ","##########","##########","  ##  ##  ","  ##  ##  "]
            Print implicitly, separated by newlines.

J , 23 19 바이트

' #'{~1=]+./~@#i:@2

@LeakyNun 덕분에 4 바이트가 절약되었습니다.

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

설명

' #'{~1=]+./~@#i:@2  Input: integer n
                  2  The constant 2
               i:@   Range [-2, -1, 0, 1, 2]
        ]            Get n
              #      Copy each n times
         +./~@       GCD table
      1=             Equals 1, forms the hashtag for input 1
' #'{~               Index and select the char

젤리 , 14 13 11 바이트

@JonathanAllen 덕분에 2 바이트 절약

5ẋ€Ẏ&þ`ị⁾ #

라인리스트를 리턴하는 모나드 링크. 후행 공백에 유의하십시오.

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

작동 원리

5ẋ€Ẏ&þ`ị⁾ #    Main link. Arguments: n (integer)            1
5              Yield 5.
 ẋ€            Create a range and repeat each item n times. [[1], [2], [3], [4], [5]]
   Ẏ           Tighten; dump all sublists into the main list.
                                                            [1, 2, 3, 4, 5]
     þ         Create a table of                            [[1, 0, 1, 0, 1],
    &          bitwise ANDs,                                 [0, 2, 2, 0, 0],
      `        reusing this list.                            [1, 2, 3, 0, 1],
                                                             [0, 0, 0, 4, 4],
                                                             [1, 0, 1, 4, 5]]
       ị⁾ #    Index into the string " #".                   [" # # ",
               0 -> "#", 1 -> " ", 2 -> "#", etc.             "#####",
                                                              " # # ",
                                                              "#####",
                                                              " # # "]

게임 메이커 언어, 138108 바이트

n=argument0 s=''for(j=0;j<5*n;j+=1){for(l=0;l<5*n;l+=1)if(j div n|l div n)&1s+='#'else s+=' 's+='
'}return s

스크립트 (사용자 정의 함수의 게임 제작자 이름)로 사용되므로 n=argument0및 return s. n현재 인스턴스에서 직접 가져 와서 s결과를 사용하여 20 바이트를 줄일 수 있습니다 . (이 인스턴스는로 선언되지 않았으므로 이러한 변수를 가져옵니다 var).

물론 #Game Maker의 그래픽 콘텐츠에서 대체 줄 바꿈 문자로 사용되므로 \화면에 출력하려는 ​​경우 접두사를 붙이고 싶을 수도 있습니다.

또한 여기서 Game Maker 8.0의 GML 버전을 사용하고 있습니다. 최신 GML 버전에는 추가 바이트를 절약 할 수있는 기능이있을 수 있습니다.

친구 wareya와 chordbug에 대한 일부 아이디어.

펄 5 , 49 + 1 (-p) = 50 바이트

$_=' # # 
'=~s/./$&x$_/gre x$_;$_.=(y/ /#/r.$_)x2

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

어떻게?

-p플래그 를 통해 $ _에 입력을 내재적으로 저장하십시오 . " # # "마지막 줄 바꿈으로 가장 기본적인 가능한 최상위 줄로 시작하십시오 . 각 문자를 입력 번호로 복제하십시오. 그런 다음 입력 번호로 복제하여 옥토 프의 상단 부분을 형성하고 모든 것을 $에 다시 저장합니다 . 그런 다음 모든 문자를 입력 번호의 '#'배로 바꾼 행을 추가하십시오. 그런 다음 상단 섹션을 추가하십시오. 마지막 두 문장을 총 두 번 수행하십시오. $의 출력은-p 플래그에 내재되어 있습니다.

05AB1E , 25 22 21 바이트

•LQ•bûε×}5ôεS„# èJ¹F=

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

-1 Emigna는 음역을 싫어하고 고맙게도 나에게도 이렇게 생각 나게합니다. : P.

비트 맵핑하는 것보다 더 나은 방법이 있어야합니다. 여전히 작동합니다.

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

f=
n=>[...Array(n*5)].map((_,i,a)=>a.map((_,j)=>` #`[(i/n|j/n)&1]).join``).join`
`

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

원래의 숯 시도에 사용한 비트 맵 접근 방식의 포트.

파이썬 2 , 124 , 116 , 113 , 112 , 98 , 96 66 바이트

새로운 (크레딧 : HyperNeutrino) :

def f(a):i='print(" "*a+"#"*a)*2;'*a;exec(i+'print"#"*a*5;'*a)*2+i

늙은:

a=input();b,c="# "
for i in"012":
	exec'print c*a+b*a+c*a+b*a;'*a
	if i<"2":exec'print b*a*5;'*a

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

분명히 가장 짧은 해결책은 아니지만 괜찮다고 생각합니다. 모든 의견을 부탁드립니다!

Brain-Flak , 338332 바이트

Riley 덕분에 6 바이트.

(({}<>)<(())>)(()()()()()){({}<(<>)<>{({}<<>({}<(((((()()()()())){})){}{}{})<>([({})]()){(<{}({}<((((({}))){}){}{}){({}<<>(({}))<>>[()])}{}>)>)}{}(({})<{{}(<(()()()()()){({}<<>(<([{}](((((()()){}){}){}){}()){}())>)<>{({}<<>({}<(({}))>())<>>[()])}<>({}<>{})>[()])}{}>)}>{})<>((()()()()()){})>())<>>[()])}<>({}<>{}<([{}]())>)>[()])}<>

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

더 "판독 가능한"버전

(({}<>)<(())>)(()()()()())
{({}<(<>)<>{({}<<>({}<(((((()()()()())){})){}{}{})<>
  ([({})]()){(<{}({}<
    ((((({}))){}){}{}){({}<<>(({}))<>>[()])}{}
  >)>)}{}(({})<{{}(<
    (()()()()()){({}<<>(<([{}](((((()()){}){}){}){}()){}())>)<>{({}<<>({}<(({}))>())<>>[()])}<>({}<>{})>[()])}{}
  >)}>{})
<>((()()()()()){})>())<>>[()])}<>({}<>{}<([{}]())>)>[()])}<>

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

SOGL (SOGLOnline commit 2940dbe) , 15 바이트

ø─Ζ┘Χ⁴‘5n{.∙.*T

이를 실행하려면 다운로드 이 과의 코드 실행 index.html파일을.

해당 커밋에서 (그리고 그 전에) *전체 문자열이 아닌 각 문자를 반복하여 사용합니다.

설명:

ø─Ζ┘Χ⁴‘          push " # # ##### # # ##### # # "
       5n        split into lines of length 5
         {       for each line do
          .∙       multiply vertically input times
            .*     multiply horizontally input times
              T    output in a new line

보너스 : 별도의 X 및 Y 길이에 2 개의 입력을 추가하십시오!

brainfuck , 224 바이트

,[->+>>>>+<<<<<]>>>+>+++++[-<<<[->+>>>>>+>+++++[-<<<[->+<<<[->>>>>>+<<[->>>+>---<<<<]<<<<]>>>>>>[-<<<<<<+>>>>>>]>[-<<<+>>>]+++++[->+++++++<]>.[-]<<<<<<]>[-<+>]>[-<->]<+[->+<]>>]<<++++++++++.[-]<<<<<]>[-<+>]>[-<->]<+[->+<]>>]

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

만들기

나는이 코드를 직접 작성하려고 노력했으며 꽤 많은 시간을 보냈으므로 파이썬으로 트랜스 필러를 만들기로 결정했습니다.

이 코드를 만들기 위해 입력 한 코드는 다음과 같습니다.

read(0)
copy(0,(1,1),(5,1))
add(3,1)
add(4,5)
loop(4)
loop(1)
add(2,1)

add(7,1)
add(8,5)
loop(8)
loop(5)
add(6,1)

loop(3)
add(9,1)
loop(7)
add(10,1)
add(11,-3)
end(7)
end(3)
copy(9,(3,1))
copy(10,(7,1))
add(10,5)
copy(10,(11,7))
write(11)
clear(11)

end(5)
copy(6,(5,1))
copy(7,(6,-1))
add(6,1)
copy(6,(7,1))
end(8)
add(6,10)
write(6)
clear(6)

end(1)
copy(2,(1,1))
copy(3,(2,-1))
add(2,1)
copy(2,(3,1))
end(4)

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

C (gcc) , 98 93 바이트

Felix Palmen 덕분에 5 바이트.

i,j;main(a){for(scanf("%d",&a);j<a*5||(j=!puts(""),++i<a*5);)putchar(i/a+1&j++/a+1&1?32:35);}

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

가이아 , 9 바이트

 # ”ṫ&:Ṁ‡

Zgarb의 위대한 답변의 항구

온라인으로 사용해보십시오! (바닥 글은 단지 인쇄하기 쉽고 프로그램 자체는 2D 문자 목록을 반환합니다)

설명

 # ”       Push the string " # "
    ṫ      Bounce, giving " # # "
     &     Repeat each character by input
      :    Copy
       Ṁ‡  Tabled maximum with itself

비 펀지 , (105) 103 바이트

p9p&5*08p>08g-   v
>,g1+:00p^v0:/5g8_p9g1+:09p08g-#v_@
gvg90\/\g0< # # ##### 0:/5g8,+55<
^>\/2%5*+92++2

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

파이썬, 88 84 77 바이트

lambda x:[[(' #'[i//x%2]+'#')[j//x%2]for j in range(5*x)]for i in range(5*x)]

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

2D 문자 목록을 반환합니다.

PowerShell , 72 68 63 60 바이트

param($a)(,($x=,((' '*$a+"#"*$a)*2)*$a)+,("#"*5*$a)*$a)*2;$x

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

입력을 $a받습니다. 그런 다음, 우리는 많은 마법 문자열과 배열 조작을 수행합니다.

(,($x=,((' '*$a+"#"*$a)*2)*$a)+,("#"*5*$a)*$a)*2;$x
         ' '*$a+"#"*$a                              # Construct a string of spaces and #
        (             )*2                           # Repeat it twice
      ,(                 )*$a                       # Repeat that $a times to get the top as an array
  ($x=                       )                      # Store that into $x and immediately output it
 ,                            +                     # Array concatenate that with ...
                               ,("#"*5*$a)          # another string, the middle bar ...
                                          *$a       # repeated $a times.
(                                            )*2;   # Do that twice
                                                 $x # Output $x again

아래에서 시작하여 설명의 일부를 벗겨 출력이 어떻게 구성되는지 확인할 수 있으므로 내 설명이 의미가 있기를 바랍니다.

하스켈, 72 바이트

a#b=a++b++a++b++a
c%l=((c<$l)#('#'<$l))<$l
f n=(' '%[1..n])#('#'%[1..n])

문자열 목록을 반환합니다. 온라인으로 사용해보십시오!

작동 방식 :

a#b=a++b++a++b++a          -- concatenate the strings a and b in the given pattern
c%l=                       -- take a char c and a list l (we only use the length
                           -- of l, the actual content doesn't matter)
    c<$l                   -- make length l copies of c
         '#'<$l            -- make length l copies of '#'
        #                  -- combine them via function #
               <$l         -- and make length l copies of that string
f n=                       -- main function
              #            -- make the "a b a b a" pattern with the strings
                           -- returned by the calls to function %                                
    ' '%[1..n]             --   one time with a space 
               '#'%[1..n]  --   one time with a '#'

수학, 63 바이트

ArrayFlatten@Array[x=#;Table[If[OddQ@-##," ","#"],x,x]&,{5,5}]&

설명

ArrayFlatten@Array[x=#;Table[If[OddQ@-##," ","#"],x,x]&,{5,5}]&  (* input N *)

                   x=#                                           (* Set x to N *)
                                                      &          (* A function that takes two inputs: *)
                             If[OddQ@-##," ","#"]                (* if both inputs are odd (1), " ". "#" otherwise *)
                       Table[                    ,x,x]           (* Make N x N array of that string *)
             Array[                                     ,{5,5}]  (* Make a 5 x 5 array, applying that function to each index *)
ArrayFlatten@                                                    (* Flatten into 2D array *)

_{(1) -##파싱Times[-1, ##]}

파이썬 2, 113 바이트

문자열 배열로 :

r=[1-1*(i%(2*n)<n)for i in range(5*n)]
print[''.join(' #'[r[k]+r[j]>0]for k in range(len(r)))for j in range(n*5)]

ASCII 아트로 :

파이썬 3, 115 바이트

r=[1-1*(i%(2*n)<n)for i in range(5*n)]
for j in range(n*5):print(*(' #'[r[k]+r[j]>0]for k in range(len(r))),sep='')

파이썬 3, 117 바이트

p=range(5*n)
for i,e in enumerate([j%(2*n)>=n for j in p]for k in p):print(*[' #'[i%(2*n)>=n or k]for k in e],sep='')

부울 배열로

p=range(5*n)
f=lambda o:o%(2*n)>=n
print[[f(j)or f(i)for j in p]for i in p]

자바 8, 103 바이트

Lambda는 Integer옥토 프를 받아 들여 표준 출력합니다. 캐스팅 Consumer<Integer>.

n->{for(int s=5*n,x=0,y;x<s;x++)for(y=0;y<s;)System.out.print((x/n%2+y++/n%2>0?'#':32)+(y<s?"":"\n"));}

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

언 골프 람다

n -> {
    for (
        int
            s = 5 * n,
            x = 0,
            y
        ;
        x < s;
        x++
    )
        for (y = 0; y < s; )
            System.out.print(
                (x / n % 2 + y++ / n % 2 > 0 ? '#' : 32)
                + (y < s ? "" : "\n")
            );
}

여기서 중요한 관찰은 n x n 셀 의 5 x 5 그리드 에서 행 또는 열 번호 (0부터 시작)가 홀수 인 곳에는 옥토 프가 나타납니다. 나는 이것이 가장 저렴한 일반적인 접근법이라고 확신하지만 더 골프 타는 것 같습니다.

감사의 말

• Kevin Cruijssen 덕분에 -1 바이트

Pyth , 28 22 바이트

@LeakyNun 덕분에 -6 바이트

JsC*]S5Qjmsm@"# "*kdJJ

테스트 스위트.

R , 87 85 62 바이트

m=matrix(" ",x<-scan()*5,x);m[s,]=m[,s<-rep(!1:0,e=x/5)]="#";m

LeakyNun 덕분에 c (F, T)를! 1 : 0으로 표시하여 2 바이트 절약

주세페 덕분에 23 바이트 절약

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

설명 (ungolfed) :

x=scan()*5              # Multiply input by 5 to get the required width/height of the matrix
m=matrix(" ",x,x)       # Create a matrix of the required dimensions
s=rep(!1:0,each=x/5)    # The sequence s consists of F repeated n times, followed by T repeated n times
m[s,]="#"               # Use s as logical indices to set those rows as "#" characters.
                        # R recycles the sequence to the height of the matrix.
m[,s]="#"               # Same, with columns
write(m,"",x,,"")       # Print out across the required number of columns