#OctothorpeAsciiArt

35

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!

DJMcMayhem
fuente
1
Relacionado
pppery

Respuestas:

21

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          ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  
                                   ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  
Monja permeable
fuente
1
Puede usar en Zclugar de 35*cy ~(lógico NO) en lugar de0=
DJMcMayhem
1
@DJMcMayhem @ _ @ ¿por qué es eso una
monja
1
En realidad, la razón por la que es una construcción es realmente interesante. Podría estar equivocado, pero creo que Conor lo sugirió, y Suever escribió un script que analiza todas las respuestas de MATL para ver qué funciones son más comunes para futuras mejoras. Zc acaba de agregarse
DJMcMayhem
Además, dado que cada celda tiene que ser distinta de cero, puede hacerlo en Qlugar de2<
DJMcMayhem
1
@LeakyNun Puede cambiar !t*a &*. Este último significa "multiplicación de una entrada", que multiplica (por elementos) la entrada por su transposición
Luis Mendo
14

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

>[()])}
DJMcMayhem
fuente
13

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)

Captura de pantalla

Felix Palmen
fuente
55
+1 para nostalgia (el ensamblaje 6502 en un c64 fue mi primera experiencia de programación ...)
Olivier Dulac
8

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!

Sr. Xcoder
fuente
Wat Witchkraft es tu pie de página
Leaky Nun
@LeakyNun A para loop :)
Sr. Xcoder
No, estoy hablando de f(i);almacenar el resultado en una temperatura y printacceder a él.
Leaky Nun
1
@LeakyNun Ya mal entendido: f(i)impresiones y printen Python 2 agrega una nueva línea: P
Sr. Xcoder
Oh, que estúpido de mi parte.
Leaky Nun
6

Carbón , 21 bytes

NθUOײθ#UOθ F²⟲OO²⁴⁶θ

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:

F⁵F⁵F&|ικ¹«J×ιIθ×κIθUOθ#

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.

Neil
fuente
¿El carbón realmente no tiene una forma de hashtag incorporada?
dzaima
¿Ate el carbón vegetal O_O?
Magic Octopus Urn
yay (hmm parece que necesito arreglar eso un poco)
solo ASCII
@ Solo ASCII ¿Qué necesita arreglarse?
Neil
Oblong no debería estar imprimiendo los pasos para el polígono que usa internamente jajaja
solo ASCII
6

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.

col
fuente
1
##"1&('# '{~#:5$21,0)Guarda un byte.
Zgarb
6

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#  "  ##  ##  "]
Fruta Esolanging
fuente
Alguien estaba preparado para este desafío: P
ETHproductions
@ETHproductions Era un CMC y se mudó a main ...
Esolanging Fruit
@ETHproductions Realmente no puedo culparlo por eso ...
Leaky Nun
6

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.
Zgarb
fuente
6

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
millas
fuente
Ratas! Estaba a punto de publicar una solución propia (4 bytes más). Estoy realmente impresionado por cómo puedes componer estas funciones sin mayúsculas y con pocas conjunciones.
cole
@cole Gracias. A veces se pueden evitar las mayúsculas usando un sustantivo y una diada. Por ejemplo, [:|:fpodría ser0|:f
millas
' # '{~]#"1]#+./~@i:@2guarda un byte
Conor O'Brien
repita antes de que la multiplicación le dé 19 bytes:f=:' #'{~1=]+./~@#i:@2
Leaky Nun
1
@hoosierEE Es una nueva característica que viene en J 8.06. Puede probar la versión beta jsoftware.com/download/j806/install
millas del
5

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.             "#####",
                                                              " # # ",
                                                              "#####",
                                                              " # # "]
ETHproducciones
fuente
Buena observación con respecto a bit a bit o - guardar dos bytes cambiando de o hacia y - eliminando la necesidad de bajar, permitiendo un rango implícito y eliminando la necesidad de µ(o el que podría haber tenido allí en su lugar) ...5ẋ€Ẏ&þ`ị⁾ #
Jonathan Allan
@ JonathanAllan Interesante: ¿por qué 5Ḷẋ€requiere el µ, pero no 5ẋ€?
ETHproductions
Pensé que la necesidad era simplemente dejar de actuar ny luego pasarlo a la derecha de ẋ€, ya que con una cadena líder de nilad-dyad llamada monádicamente no es necesario. Sin embargo, no estoy muy seguro de cómo `parece colocar 5 (o tal vez la lista de esa longitud) a la derecha de la tabla &.
Jonathan Allan
4

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.

Andrea
fuente
Creo que esta es la primera respuesta GML que he visto
Timothy Groote
@TimothyGroote Es una pena que no se use más, sus corchetes y puntos y comas opcionales son excelentes para jugar al golf :)
Andrea
4

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.

Xcali
fuente
Me gusta cómo tu respuesta es tan legible como la mía.
AdmBorkBork
Siempre han dicho que Perl es un lenguaje de solo escritura.
Xcali
3

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.

Urna de pulpo mágico
fuente
Reflexión ... no es la respuesta en 05AB1E, aunque parece que podría ser ...
Magic Octopus Urn
5ôεS„# èJ¹F=Guarda un byte.
Emigna
@Emigna, ¿el lienzo sería bueno para esto?
Urna de pulpo mágico
Posiblemente. Todavía no he probado el lienzo, así que no estoy muy seguro de sus capacidades. Parece algo para lo que está hecho.
Emigna
3

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.

Neil
fuente
3

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!

Braeden Smith
fuente
1
a,b,c=input()," #"debería guardar algunos bytes.
DJMcMayhem
@DJMcMayhem Eso me dio un error. Quiso decir a,b,c=input(),"#"," "? Que no es más corto ... ¡Agradezco la ayuda!
Braeden Smith
Oh, lo siento. Supuse que funcionaba porque a,b="# "funciona.
DJMcMayhem
a=input();b,c="# "funcionará y ahorrará bytes
Wheat Wizard
También puedes deshacerte de los padres (i==2)y agregar un espacio al principio.
Wheat Wizard
3

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!

Monja permeable
fuente
(({})<>)(())<>({}<>)al principio puede ser reemplazado con(({}<>)<(())>)
Riley
2

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!

dzaima
fuente
"commit 2940dbe" - Me gusta esa idea. ¿Puede explicar por qué ø─Ζ┘Χ⁴‘empuja eso?
Urna de pulpo mágico
1
@MagicOctopusUrn Esa es la compresión SOGL, que aquí almacena un diccionario de "" #y los datos de base 2 necesarios para esa cadena.
dzaima
Neat , ¿es lo suficientemente estable como para comenzar a usar :)?
Urna de pulpo mágico
1
@MagicOctopusUrn Bueno, es bastante estable ya que no ha habido cambios que rompan la respuesta desde SOGLOnline, pero si puedes usarlo (como lo entiendes) es otra pregunta. Sin embargo, puede intentar y hacer una pregunta en TNB
dzaima
Jaja ... Esperaré por la documentación entonces. Necesito un poco mimado.
Magic Octopus Urn
2

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!

Monja permeable
fuente
2

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!

Monja permeable
fuente
2

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
Gato de negocios
fuente
2

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!

Demur Rumed
fuente
¿Podría agregar un enlace a un intérprete en línea? tio.run/#befunge es un buen AFAIK.
DJMcMayhem
1

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.

Uriel
fuente
1

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.

AdmBorkBork
fuente
1

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 '#'
nimi
fuente
1

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

JungHwan Min
fuente
ArrayFlattenes muy lindo.
Mark S.
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

Python 2, 75 bytes

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]

Puertas de Zach
fuente
1
Mucho tiempo sin verte :-)
ETHproductions
¡Sí lo tiene! @ETHproductions
Zach Gates
1

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
Jakob
fuente
1
Puede colocar el int s=5*n,x=0,ybucle for para guardar un byte en el punto y coma.
Kevin Cruijssen
1

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             
usuario2390246
fuente
No funciona en TIO porque escanea la siguiente línea, que es un código.
Leaky Nun
1
85 bytes
Leaky Nun
78 bytes
Giuseppe