Um Octothorpe (também chamado de sinal numérico, hash ou hashtag ou sinal de libra) é o seguinte caractere ASCII:

#

Não é uma forma divertida? Vamos fazer versões maiores dele! Então, aqui está o seu desafio:

Dado um número inteiro positivo N , uma saída hashtag ASCII de tamanho N .

Por exemplo, uma hashtag ASCII de tamanho 1 se parece com isso:

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

O espaço em branco à direita em cada linha é permitido, mas não obrigatório.

A entrada sempre será um número inteiro positivo válido; portanto, você não precisa manipular números não negativos, ou 0. Sua saída pode estar em qualquer formato razoável; portanto, envie para STDOUT, retornando uma lista de cadeias ou cadeias com novas linhas, uma matriz 2D de caracteres, gravar em um arquivo etc. estão bem.

Casos de teste

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

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

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

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

Como este é um código de golfe, tente escrever a solução mais curta possível e, acima de tudo, divirta-se!

MATL , 20 16 12 11 bytes

3 bytes graças a DJMcMayhem.

1 byte graças a Luis Mendo.

21BwY"&*~Zc

Experimente online!

Explicação

    % 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          ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  
                                   ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  

Flak cerebral , 420 bytes

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

Experimente online!

Não, a pontuação de 420 não foi intencional. Eu prometo. Versão legível:

# 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
    {}

>[()])}

Código da máquina 6502 (C64), 59 56 bytes

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

Demonstração online

Uso: SYS49152,Nonde N é um número entre 1 e 255.

_{(valores maiores que 4 já serão muito grandes para a tela C64, a partir de 8, a saída é muito ampla)}

Explicação :

         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)

Haskell , 43 bytes

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

Experimente online!

Produz uma lista de strings.

Python 2 , 55 bytes

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

Experimente online!

Isso retorna uma lista 2D de caracteres.

Python 2 , 65 bytes

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

Experimente online!

Python 2 , 66 bytes

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

Experimente online!

Carvão , 21 bytes

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

Experimente online! Link é a versão detalhada do código. Originalmente, eu tentei uma abordagem de bitmap atraente:

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

Experimente online! Link é a versão detalhada do código. Explicação: Funciona considerando-o #como uma matriz de 5 × 5 quadrados. Os quadrados que estão em linhas ou colunas ímpares precisam ser preenchidos.

J, 22 bytes

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

Experimente online!

Muita semelhança com a outra resposta J, embora eu não entenda bem os trens com muitos substantivos, então minha resposta tem três bytes em potencial a serem cortados (dois parênteses e um reflexivo ~).

Explicação

Gerando o octothorpe

O octothorpe é feito por tudo entre parênteses, reproduzido abaixo por conveniência.

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

Na maior parte das vezes eu faço o octothorpe é um abuso da maneira como J aperta suas matrizes quando elas não são longas o suficiente.

21,0simplesmente cria a matriz 21 0.

5$remodela essa matriz em uma matriz de 5-omo: 21 0 21 0 21.

#:converte cada átomo em um número binário. Como #:opera em cada átomo, a saída é uma matriz. Cada um 21é substituído por 1 0 1 0 1conforme o esperado, mas cada um 0é substituído por 0 0 0 0 0! Isso ocorre porque os J pads não são longos o suficiente para corresponder ao formato da matriz 2D resultante, o que é forçado a ocorrer 5 5devido às 1 0 1 0 1linhas. Felizmente, para números com os quais ele se encaixa 0, obtemos a matriz resultante

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

'# '{~converte cada 1um em um espaço e 0em #. {significa "pegar" e ~significa "alternar os argumentos diádicos, então J olha para cada elemento da matriz como índices para a cadeia de caracteres, o que '# 'significa que cada um 0se torna o elemento zeroth #e cada um 1se torna o primeiro elemento, um espaço. Isso gera o tamanho de um oitavo.

Redimensionando o octothorpe

Isso é simplesmente uma questão de ntempos de cópia ao longo de cada eixo, feito usando

o primeiro #(que faz parte de um gancho) e #~"1]. #copia ao longo do eixo horizontal e #"1copia ao longo do eixo vertical.

CJam, 27 26 25 bytes

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

Experimente online!

Curiosidade: Originalmente, isso começou com 29 bytes e os bytes foram removidos um a um desde então, alternando entre o modo de bloco e o programa completo.

Explicação:

{                          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#  "  ##  ##  "]

Casca , 12 10 bytes

´Ṫ▲Ṙ" # # 

Experimente online! Observe o espaço à direita.

Explicação

´Ṫ▲Ṙ" # #   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 bytes

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

Guardado 4 bytes graças a @LeakyNun.

Experimente online!

Explicação

' #'{~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

Geléia , 14 13 11 bytes

Guardado 2 bytes graças a @JonathanAllen

5ẋ€Ẏ&þ`ị⁾ #

Um link monádico retornando uma lista de linhas. Observe o espaço à direita.

Experimente online!

Como funciona

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.             "#####",
                                                              " # # ",
                                                              "#####",
                                                              " # # "]

Linguagem do Game Maker, 138 108 bytes

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

Pretendido como um script (nome do Game Maker para funções definidas pelo usuário), portanto, o n=argument0e return s. 20 bytes podem ser raspados pegando ndiretamente da instância atual e usando scomo resultado. (A instância obtém essas variáveis ​​de qualquer maneira porque elas não foram declaradas com var).

Cuidado, #é claro, que é usado pelo material gráfico do Game Maker como um caractere de nova linha alternativa; portanto, você pode prefixá-lo \se quiser exibir na tela;)

Observe também que estou usando a versão GML do Game Maker 8.0 aqui; versões modernas de GML podem ter recursos que podem salvar bytes adicionais.

Algumas idéias são cortesia dos amigos wareya e chordbug.

Perl 5 , 49 + 1 (-p) = 50 bytes

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

Experimente online!

Quão?

Armazene implicitamente a entrada em $ _ através do -psinalizador. Comece com a linha superior mais básica possível " # # "com sua nova linha à direita. Replicar cada um desses caracteres pelo número de entrada. Em seguida, replique isso pelo número de entrada para formar a parte superior do octothorpe, armazenando tudo isso em $ . Em seguida, acrescente a linha com todos os caracteres substituídos por '#' vezes o número de entrada. Em seguida, acrescente a seção superior. Faça essas duas últimas frases no total duas vezes. A saída do $ está implícita no -psinalizador.

05AB1E , 25 22 21 bytes

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

Experimente online!

-1 porque Emigna odeia transliterar e, felizmente, me lembra que eu também deveria: P.

Tem que ser uma maneira melhor do que bitmap, ainda trabalhando.

JavaScript (ES6), 79 bytes

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>

Porta da abordagem de bitmap que eu usei para minha tentativa original de carvão.

Python 2 , 124 , 116 , 113 , 112 , 98 , 96 66 bytes

Novo (Crédito: HyperNeutrino):

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

Velho:

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

Experimente online!

Obviamente, não é a solução mais curta, mas acho que é decente. Qualquer opinião será apreciada!

Flak cerebral , 338 332 bytes

6 bytes graças a Riley.

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

Experimente online!

Versão mais "legível"

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

Experimente online!

SOGL (confirmação SOGLOnline 2940dbe) , 15 bytes

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

Para executar isso, baixe este e executar o código no index.htmlarquivo.

Usa que naquele commit (e antes dele) *repetiu cada caractere, não a string inteira.

Explicação:

ø─Ζ┘Χ⁴‘          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

Bônus: adicione 2 entradas para o comprimento X e Y separado!

brainfuck , 224 bytes

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

Experimente online!

Realização de

Eu tentei criar esse código manualmente e passei algumas horas, então decidi fazer um transpiler em Python.

Aqui está o código que inseri para criar esse código:

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)

Experimente online!

C (gcc) , 98 93 bytes

5 bytes graças a Felix Palmen.

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

Experimente online!

Gaia , 9 bytes

 # ”ṫ&:Ṁ‡

Praticamente um porto da grande resposta de Zgarb

Experimente online! (o rodapé é apenas para imprimir, o próprio programa retorna uma lista 2D de caracteres)

Explicação

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

Befunge , 105 103 bytes

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

Experimente online!

Python, 88 84 77 bytes

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

Experimente online!

Retorna uma lista 2D de caracteres.

PowerShell , 72 68 63 60 bytes

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

Experimente online!

Recebe entrada $a. Em seguida, fazemos um monte de manipulação de string e array mágicos .

(,($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

Você pode separar as partes da explicação começando de baixo para ver como a saída é construída, por isso espero que minha explicação faça sentido.

Haskell, 72 bytes

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

Retorna uma lista de strings. Experimente online!

Como funciona:

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

Mathematica, 63 bytes

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

Explicação

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) -##analisa emTimes[-1, ##]}

Python 2, 113 bytes

Como uma matriz de strings:

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

Como arte ASCII:

Python 3, 115 bytes

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

Python 3, 117 bytes

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

Como uma matriz de booleanos

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]

Java 8, 103 bytes

O Lambda aceita Integere imprime o octothorpe na saída padrão. Transmitir para 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"));}

Experimente Online

Lambda ungolfed

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

A observação principal aqui é que, em uma grade de 5 por 5 de n por n células, os octotorpes aparecem sempre que o número da linha ou coluna (baseado em 0) é ímpar. Tenho certeza de que essa é a abordagem geral mais barata, mas parece ainda mais jogável.

Agradecimentos

• -1 byte graças a Kevin Cruijssen

Pitão , 28 22 bytes

-6 bytes graças a @LeakyNun

JsC*]S5Qjmsm@"# "*kdJJ

Suíte de teste.

R , 87 85 62 bytes

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

2 bytes salvos representando c (F, T) como! 1: 0, graças a LeakyNun

23 bytes salvos graças a Giuseppe

Experimente online!

Explicação (não destruída):

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