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!
Respuestas:
MATL ,
20161211 bytes3 bytes gracias a DJMcMayhem.
1 byte gracias a Luis Mendo.
Pruébalo en línea!
Explicación
fuente
Zc
lugar de35*c
y~
(lógico NO) en lugar de0=
Q
lugar de2<
!t*
a&*
. Este último significa "multiplicación de una entrada", que multiplica (por elementos) la entrada por su transposiciónBrain-Flak , 420 bytes
Pruébalo en línea!
No, el puntaje de 420 no fue intencional. Lo prometo. Versión legible:
fuente
6502 código máquina (C64),
5956 bytesDemostración en línea
Uso:
SYS49152,N
donde 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 :
fuente
Haskell , 43 bytes
Pruébalo en línea!
Emite una lista de cadenas.
fuente
Python 2 , 55 bytes
Pruébalo en línea!
Esto devuelve una lista 2D de caracteres.
Python 2 , 65 bytes
Pruébalo en línea!
Python 2 , 66 bytes
Pruébalo en línea!
fuente
f(i);
almacenar el resultado en una temperatura yprint
acceder a él.f(i)
impresiones yprint
en Python 2 agrega una nueva línea: PCarbó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.fuente
J, 22 bytes
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.
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,0
simplemente crea la matriz21 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 uno21
se reemplaza por1 0 1 0 1
lo esperado, pero cada uno0
se reemplaza por0 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 ser5 5
debido a las1 0 1 0 1
filas. Afortunadamente, para los números con los que se alinea0
, obtenemos la matriz resultante'# '{~
convierte cada uno1
en un espacio y0
en#
.{
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 se0
convierte en el elemento cero#
y cada uno se1
convierte 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
n
tiempos a lo largo de cada eje, hecho usandoel primero
#
(que forma parte de un gancho) y#~"1]
.#
copias a lo largo del eje horizontal y#"1
copias a lo largo del eje vertical.fuente
##"1&('# '{~#:5$21,0)
Guarda un byte.CJam,
272625 bytesPrué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:
fuente
Casco ,
1210 bytesPruébalo en línea! Tenga en cuenta el espacio final.
Explicación
fuente
J ,
2319 bytesGuardado 4 bytes gracias a @LeakyNun.
Pruébalo en línea!
Explicación
fuente
[:|:f
podría ser0|:f
' # '{~]#"1]#+./~@i:@2
guarda un bytef=:' #'{~1=]+./~@#i:@2
Jalea ,
141311 bytesGuardado 2 bytes gracias a @JonathanAllen
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
fuente
µ
(o el⁸
que podría haber tenido allí en su lugar) ...5ẋ€Ẏ&þ`ị⁾ #
5Ḷẋ€
requiere elµ
, pero no5ẋ€
?Ẏ
actuarn
y 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&
.Game Maker Language,
138108bytesDiseñado como un script (nombre de Game Maker para funciones definidas por el usuario), por lo tanto, el
n=argument0
yreturn s
. Se pueden reducir 20 bytes tomandon
directamente de la instancia actual y usandos
como resultado. (La instancia obtiene estas variables de todos modos porque no se declararon convar
).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.
fuente
Perl 5 , 49 + 1 (-p) = 50 bytes
Pruébalo en línea!
¿Cómo?
Almacene implícitamente la entrada en $ _ a través de la
-p
bandera. 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-p
bandera.fuente
05AB1E ,
252221 bytesPrué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.
fuente
5ôεS„# èJ¹F=
Guarda un byte.JavaScript (ES6), 79 bytes
Puerto del enfoque de mapa de bits que había utilizado para mi intento original de carbón.
fuente
Python 2 ,
124,116,113,112,98,9666 bytesNuevo (Crédito: HyperNeutrino):
Antiguo:
Pruébalo en línea!
Obviamente no es la solución más corta, pero creo que es decente. ¡Cualquier comentario sería apreciado!
fuente
a,b,c=input()," #"
debería guardar algunos bytes.a,b,c=input(),"#"," "
? Que no es más corto ... ¡Agradezco la ayuda!a,b="# "
funciona.a=input();b,c="# "
funcionará y ahorrará bytes(i==2)
y agregar un espacio al principio.Brain-Flak ,
338332 bytes6 bytes gracias a Riley.
Pruébalo en línea!
Más versión "legible"
Pruébalo en línea!
fuente
(({})<>)(())<>({}<>)
al principio puede ser reemplazado con(({}<>)<(())>)
SOGL (SOGLOnline commit 2940dbe) , 15 bytes
Para ejecutar esto, descargue esto y ejecute el código en el
index.html
archivo.Utiliza que en ese commit (y antes)
*
repitió cada carácter, no toda la cadena.Explicación:
Bonificación: ¡agregue 2 entradas para una longitud X e Y separada!
fuente
ø─Ζ┘Χ⁴‘
empuja eso?#
y los datos de base 2 necesarios para esa cadena.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:
Pruébalo en línea!
fuente
C (gcc) ,
9893 bytes5 bytes gracias a Felix Palmen.
Pruébalo en línea!
fuente
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
fuente
Befunge ,
105103 bytesPruébalo en línea!
fuente
Python,
888477 bytesPruébalo en línea!
Devuelve una lista 2D de caracteres.
fuente
PowerShell ,
72686360 bytesPruébalo en línea!
Toma entrada
$a
. Luego, hacemos un montón de cadenasmágicasy manipulación de matrices.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.
fuente
Haskell, 72 bytes
Devuelve una lista de cadenas. Pruébalo en línea!
Cómo funciona:
fuente
Mathematica, 63 bytes
Explicación
(1)
-##
analiza enTimes[-1, ##]
fuente
ArrayFlatten
es muy lindo.Python 2, 113 bytes
Como una serie de cadenas:
Como arte ASCII:
Python 3, 115 bytes
Python 3, 117 bytes
Como un conjunto de booleanosPython 2, 75 bytes
fuente
Java 8, 103 bytes
Lambda acepta
Integer
e imprime el octothorpe al estándar. Fundido aConsumer<Integer>
.Pruébalo en línea
Lambda sin golf
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
fuente
int s=5*n,x=0,y
bucle for para guardar un byte en el punto y coma.Pyth ,
2822 bytes-6 bytes gracias a @LeakyNun
Banco de pruebas.
fuente
R ,
878562 bytes2 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):
fuente