Un Octothorpe, (también llamado signo de número, hash o hashtag, o signo de libra) es el siguiente carácter ASCII:

#

¿No es esa una forma divertida? ¡Hagamos versiones más grandes! Así que aquí está tu desafío:

Dado un número entero positivo N , la salida de un hashtag ASCII de tamaño N .

Por ejemplo, un hashtag ASCII de tamaño 1 se ve así:

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

El espacio en blanco al final de cada línea está permitido, pero no es obligatorio.

La entrada siempre será un entero positivo válido, por lo que no tiene que manejar números que no sean números, negativos o 0. Su salida puede estar en cualquier formato razonable, por lo que se envía a STDOUT, devolviendo una lista de cadenas o cadenas con líneas nuevas, una matriz 2D de caracteres, escribir en un archivo, etc. están bien.

Casos de prueba

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

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

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

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

Como se trata de un código de golf, intente escribir la solución más corta posible y, sobre todo, ¡diviértase!

MATL , 20 16 12 11 bytes

3 bytes gracias a DJMcMayhem.

1 byte gracias a Luis Mendo.

21BwY"&*~Zc

Pruébalo en línea!

Explicación

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

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

Pruébalo en línea!

No, el puntaje de 420 no fue intencional. Lo prometo. Versión legible:

# 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 código máquina (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

Demostración en línea

Uso: SYS49152,Ndonde N es un número entre 1 y 255.

_{(los valores superiores a 4 ya serán demasiado grandes para la pantalla C64, a partir de 8, la salida es incluso demasiado amplia)}

Explicacion :

         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

Pruébalo en línea!

Emite una lista de cadenas.

Python 2 , 55 bytes

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

Pruébalo en línea!

Esto devuelve una 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

Pruébalo en línea!

Python 2 , 66 bytes

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

Pruébalo en línea!

Carbón , 21 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Originalmente probé un lindo enfoque de mapa de bits:

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación: Funciona considerando el #como una matriz de cuadrados 5 × 5. Los cuadrados que están en filas o columnas impares deben completarse.

J, 22 bytes

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

Pruébalo en línea!

Mucha similitud con la otra respuesta J, aunque no entiendo bien los trenes con muchos sustantivos, por lo que mi respuesta tiene tres bytes potenciales para cortar (dos parens y un reflexivo ~).

Explicación

Generando el octothorpe

El octothorpe está hecho por todo lo que está entre paréntesis, reproducido a continuación para mayor comodidad.

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

Gran parte de la forma en que hago el octothorpe es el abuso de la forma en que J rellena sus matrices cuando no son lo suficientemente largas.

21,0simplemente crea la matriz 21 0.

5$remodela esa matriz en una matriz de 5-átomo de: 21 0 21 0 21.

#:Convierte cada átomo en un número binario. Como #:opera en cada átomo, la salida es una matriz. Cada uno 21se reemplaza por 1 0 1 0 1lo esperado, pero cada uno 0se reemplaza por 0 0 0 0 0! Esto se debe a que las matrices de almohadillas J no son lo suficientemente largas para coincidir con la forma de la matriz 2D resultante, que se ve obligada a ser 5 5debido a las 1 0 1 0 1filas. Afortunadamente, para los números con los que se alinea 0, obtenemos la 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

'# '{~convierte cada uno 1en un espacio y 0en #. {significa "tomar" y ~significa "cambiar los argumentos diádicos, por lo que J mira a cada elemento en la matriz como índices para la cadena, lo que '# 'significa que cada uno se 0convierte en el elemento cero #y cada uno se 1convierte en el primer elemento, un espacio. Esto produce el tamaño de un octotorpo".

Cambiar el tamaño del octothorpe

Esto es simplemente una cuestión de copiar ntiempos a lo largo de cada eje, hecho usando

el primero #(que forma parte de un gancho) y #~"1]. #copias a lo largo del eje horizontal y #"1copias a lo largo del eje vertical.

CJam, 27 26 25 bytes

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

Pruébalo en línea!

Dato curioso: esto originalmente comenzó en 29 bytes, y los bytes se han eliminado uno por uno desde entonces, alternando entre el modo bloque y el programa completo.

Explicación:

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

Casco , 12 10 bytes

´Ṫ▲Ṙ" # # 

Pruébalo en línea! Tenga en cuenta el espacio final.

Explicación

´Ṫ▲Ṙ" # #   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 gracias a @LeakyNun.

Pruébalo en línea!

Explicación

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

Jalea , 14 13 11 bytes

Guardado 2 bytes gracias a @JonathanAllen

5ẋ€Ẏ&þ`ị⁾ #

Un enlace monádico que devuelve una lista de líneas. Tenga en cuenta el espacio final.

Pruébalo en línea!

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

Game Maker Language, 138108 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

Diseñado como un script (nombre de Game Maker para funciones definidas por el usuario), por lo tanto, el n=argument0y return s. Se pueden reducir 20 bytes tomando ndirectamente de la instancia actual y usando scomo resultado. (La instancia obtiene estas variables de todos modos porque no se declararon con var).

Tenga cuidado, por supuesto, con el #uso de los gráficos de Game Maker como un personaje alternativo de nueva línea, por lo que es posible que desee prefijarlo \si desea que aparezca en la pantalla;)

También tenga en cuenta que estoy usando la versión de GML de Game Maker 8.0 aquí; Las versiones modernas de GML pueden tener características que podrían ahorrar bytes adicionales.

Algunas ideas son cortesía de amigos Wareya y Chordbug.

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

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

Pruébalo en línea!

¿Cómo?

Almacene implícitamente la entrada en $ _ a través de la -pbandera. Comience con la línea superior más básica posible " # # "con su nueva línea final. Replica cada uno de esos caracteres por el número de entrada. Luego, repítalo por el número de entrada para formar la parte superior del octothorpe, almacenando todo eso nuevamente en $ . Luego agregue la línea con todos los caracteres reemplazados por '#' veces el número de entrada. Luego agregue la sección superior. Haz esas dos últimas oraciones un total de dos veces. La salida de $ está implícita en la -pbandera.

05AB1E , 25 22 21 bytes

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

Pruébalo en línea!

-1 porque Emigna odia la transliteración y, afortunadamente, me recuerda que yo también debería: P.

Tiene que ser una mejor manera que mapearlo ... Sigue funcionando.

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>

Puerto del enfoque de mapa de bits que había utilizado para mi intento original de carbón.

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

Nuevo (Crédito: HyperNeutrino):

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

Antiguo:

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

Pruébalo en línea!

Obviamente no es la solución más corta, pero creo que es decente. ¡Cualquier comentario sería apreciado!

Brain-Flak , 338 332 bytes

6 bytes gracias a Riley.

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

Pruébalo en línea!

Más versión "legible"

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

Pruébalo en línea!

SOGL (SOGLOnline commit 2940dbe) , 15 bytes

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

Para ejecutar esto, descargue esto y ejecute el código en el index.htmlarchivo.

Utiliza que en ese commit (y antes) *repitió cada carácter, no toda la cadena.

Explicación:

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

Bonificación: ¡agregue 2 entradas para una longitud X e Y separada!

brainfuck , 224 bytes

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

Pruébalo en línea!

Making-of

Traté de construir este código a mano y pasé algunas horas, así que decidí hacer un transpilador en Python.

Aquí está el código que ingresé para hacer este 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)

Pruébalo en línea!

C (gcc) , 98 93 bytes

5 bytes gracias 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);}

Pruébalo en línea!

Gaia , 9 bytes

 # ”ṫ&:Ṁ‡

Casi un puerto de la gran respuesta de Zgarb

Pruébalo en línea! (el pie de página es solo una impresión bonita, el programa en sí mismo devuelve una lista 2D de caracteres)

Explicación

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

Pruébalo en línea!

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

Pruébalo en línea!

Devuelve una lista 2D de caracteres.

PowerShell , 72 68 63 60 bytes

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

Pruébalo en línea!

Toma entrada $a. Luego, hacemos un montón de cadenas mágicas y manipulación de matrices.

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

Puede despegar las partes de la explicación comenzando desde abajo para ver cómo se construye la salida, así que espero que mi explicación tenga sentido.

Haskell, 72 bytes

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

Devuelve una lista de cadenas. Pruébalo en línea!

Cómo 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}]&

Explicación

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) -##analiza enTimes[-1, ##]}

Python 2, 113 bytes

Como una serie de cadenas:

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 un conjunto 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

Lambda acepta Integere imprime el octothorpe al estándar. Fundido a 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"));}

Pruébalo en línea

Lambda sin golf

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

La observación clave aquí es que, en una cuadrícula de 5 por 5 de n por n celdas, los octothorpes aparecen donde el número de fila o columna (basado en 0) es impar. Estoy bastante seguro de que este es el enfoque general más barato, pero parece más difícil de jugar.

Expresiones de gratitud

• -1 byte gracias a Kevin Cruijssen

Pyth , 28 22 bytes

-6 bytes gracias a @LeakyNun

JsC*]S5Qjmsm@"# "*kdJJ

Banco de pruebas.

R , 87 85 62 bytes

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

2 bytes guardados al representar c (F, T) como! 1: 0, gracias a LeakyNun

23 bytes guardados gracias a Giuseppe

Pruébalo en línea!

Explicación (sin golf):

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