Para cualquier número entero positivo k
, d(k)
denote el número de divisores de k
. Por ejemplo, d(6)
es 4
, porque 6
tiene 4
divisores (es decir 1
, 2
, 3
, 6
).
Dado un número entero positivo N
, muestre un "horizonte" en el arte ASCII utilizando un carácter fijo, de modo que la altura del "edificio" ubicado en posición horizontal k
sea d(k)
adecuada k = 1, ..., N
. Ver casos de prueba a continuación.
Reglas
- Cualquier carácter que no sea un espacio en blanco puede usarse de manera consistente, no necesariamente
#
como se muestra en los casos de prueba. - El algoritmo debería funcionar teóricamente para arbitrariamente alto
N
. En la práctica, es aceptable si el programa está limitado por el tiempo, la memoria, el tamaño del tipo de datos o el tamaño de la pantalla. - Se permiten espacios iniciales o finales horizontales o verticales o líneas nuevas.
- La entrada y la salida se pueden tomar por cualquier medio razonable .
- Se permiten programas o funciones , en cualquier lenguaje de programación . Las lagunas estándar están prohibidas.
- El código más corto en bytes gana.
Casos de prueba
N = 10
:
# # #
# # ###
#########
##########
N = 50
:
#
# #
# # # # # #
# # # # # #
# # # # # # # # # # ## # #
# # # # # # # # # # # ## # #
# # # # ### # ### # ### # ##### ### # ### # #
# # ### # ### # ### ##### # ##### ### # ### ###
#################################################
##################################################
N = 200
:
#
#
# # #
# # # #
# # # # #
# # # # #
# # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # ## # # # # # # # # # ## # # # # # # # # # # # # # # # # # # ## # ## # #
# # # # # # # # # # # # # # # # # # # # # ## # # # # # # # # # ## # # # # # # # # # # # # # # # # # # ## # ## # #
# # # # # # # # # # ## # # # # # # ## # # # # ## # # # # # # # ### # ## # # # # ## # # # # # # ## # # # ## # ### # # # ## # ### ### # # # # ### # ## # #
# # # # # # # # # # # ## # # # # # # ## # # # # ## # ## # # # # # ### # ## # # # # ## # # # # # # ## # # # ## # ### # # # ## # ### ### # # # # ### # ## # #
# # # # ### # ### # ### # ##### ### # ### # ### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ####### ##### ### ##### # ######### # ##### ##### ### # ### ##### # ######### # ### # #
# # ### # ### # ### ##### # ##### ### # ### ##### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ############# ### ##### # ######### # ##### ##### ### ##### ##### # ######### # ### # #
#######################################################################################################################################################################################################
########################################################################################################################################################################################################
C,
9995929190 bytesVéalo funcionar aquí .
fuente
Octava,
414032 bytesGracias a @StewieGriffin ahorró 8 bytes.
Pruébalo en línea!
Respuestas anteriores:
Pruébalo en línea!
Pruébalo en línea!
Explicación:
fuente
@(N)" #"(sort(~mod(k=1:N,k')+1))
ahorra unos pocos bytes :) Sin embargo, obtiene un montón de nuevas líneas principales, no estoy seguro de cuáles son las reglas al respecto.@(N)['',35*sort(~mod(k=1:N,k'))]
.mod(1:N,(1:N).')
aceptable en MATLAB?Haskell , 71 bytes
f
toma unInt
y devuelve unString
.Pruébalo en línea!
m
es elN
del OP (las variables de Haskell deben estar en minúsculas).l=[1..m]
se usa en las comprensiones de la lista anidada para recorrer en iteración todas las filas, columnas y divisores potenciales. Esto significa algunas filas iniciales adicionales llenas de espacios en blanco.n
es la columna (también número marcada),i
es fila.['#'|0<-mod n<$>l]
es una lista de'#'
caracteres con longitud del número de divisores den
.fuente
Octava, 61 bytes
Explicación:
Algunas cosas que deseo destacar
Lo que sucede dentro del bucle (supongamos entrada
6
)1,2,4
)1,2,3,6
)Finalmente lo volteamos y lo convertimos en una cadena, cambiando implícitamente el
0
a32
:fuente
Python 3 , 111 bytes
Pruébalo en línea!
Esto produce algunos espacios en blanco verticales principales
fuente
APL (Dyalog) , 19 bytes
Pruébalo en línea!
⎕
obtener la entrada evaluada ( N )⍳
1 ... N∘.|⍨
tabla de resto de división con 1 ... N tanto como eje vertical como horizontal0=
donde igual a cero (es decir, se divide)+⌿
suma las columnas (es decir, da el recuento de divisores para cada número)'#'⍴¨⍨
usa cada número para remodelar el carácter hash (da una lista de cadenas)↑
mix (lista de cadenas en la tabla de filas)⍉
transponer⊖
voltear al revésfuente
Mathematica,
5957 bytesfuente
50
con#
y anexar&
. También puede guardar algunos bytes con notación infija:X~Table~#&
y0~DivisorSigma~Range@#
C #,
333281 bytesCon saltos de línea:
Si bien estoy seguro de que esto también es posible más corto, espero que logremos una solución más corta juntos;)
Guardado 52 bytes con la ayuda de raznagul
fuente
using
declaración.using System.Linq;using C=System.Console;n=>{var v=new int[n];for(var k=1,i;++k<=n;)for(i=1;i<k;)if(k%i++==0)v[k-1]++;for(var i=0,u;i<v.Length;i++)for(u=v.Max()-v[i];u<v.Max();){C.SetCursorPosition(i, u++);C.Write("#");}};
compila aAction
, mueve los incrementos y un par de otros ajustes menores. No lo he probado pero debería funcionar.Mathematica, 99 bytes
para N = 50
fuente
(T=0~DivisorSigma~Range@#;Row[Column/@Table[Join[Table[,Max@T-T[[i]]],$~Table~T[[i]]],{i,1,#}]])&
Carbón ,
232220 bytesPruébalo en línea! El enlace es a la versión detallada del código. Editar: Guardado 1 byte por bucle
k
de0
ai-1
y añadiendo1
el interior del bucle. Ahorró otros dos bytes al no almacenar la entrada en una variable. Explicación:Editar: Este "one-liner" de 18 bytes (el enlace es una versión detallada del código) no habría funcionado con la versión de Charcoal en el momento en que se envió la pregunta: ¡ Pruébelo en línea!
fuente
05AB1E , 12 bytes
Código:
Explicación:
Utiliza la codificación 05AB1E . Pruébalo en línea!
fuente
ζ
lugar de.Bø
? Además, el personaje no tiene que serlo#
ζ
no existía en ese entonces.Python 2 , 101 bytes
Pruébalo en línea!
Esto produce (una gran cantidad) de espacios en blanco con orientación vertical. Imprime un total de
N
líneas, la gran mayoría de las cuales generalmente estarán en blanco.fuente
Japt ,
34 33 1614 bytesAhorró 17 bytes gracias a @ETHproductions
Pruébalo en línea!
fuente
z
el relleno:õ_â lã'#pX÷z w
J , 28 bytes
Define un verbo monádico. Pruébalo en línea!
Explicación
fuente
PHP, 126 bytes
Pruébalo en línea!
fuente
Brachylog , 34 bytes
Pruébalo en línea!
fuente
Alice , 33 bytes
Pruébalo en línea!
La entrada es (desafortunadamente) en forma de un punto de código . Al menos lee un carácter UTF-8, por lo que puede usar entradas más grandes que 255, pero siguen siendo limitadas y es un formato de entrada bastante doloroso. Para tres bytes adicionales, podemos leer un entero decimal:
Pruébalo en línea!
El carácter que no es un espacio en blanco en la salida es
!
.Tenga en cuenta que la solución también imprime una tonelada de espacios en blanco iniciales (siempre comienza con una línea vacía y luego imprime una
NxN
cuadrícula, por lo que, para mayor tamañoN
, habrá muchas líneas de espacios antes del primer!
s).Explicación
He usado y explicado la
&w...k
construcción antes (por ejemplo aquí ). Es un pequeño y prolijo idioma que muestra un número entero n y luego ejecuta un fragmento de código n + 1 veces (en consecuencia, generalmente se usat&w...k
para ejecutar un bucle n veces,t
disminuyendo el valor de entrada). Esto se hace trabajando con la pila de dirección de retorno (RAS).w
empuja la dirección IP actual al RAS y, si la repetimos,&
la dirección se empuja n veces.k
Aparece una dirección del RAS y salta allí. Si el RAS está vacío, no hace nada y se cierra el bucle.Puede notar que no es trivialmente posible anidar estos bucles, porque al final del bucle interno, la pila no está vacía, por lo
k
que no se convierte en un no-op. En cambio, la IP volvería al comienzo del bucle externo. La forma general de solucionar esto implica envolver el bucle interno en su propia subrutina. Pero si podemos organizar el bucle anidado de modo que el bucle externo termine con el bucle interno, ¡podemos utilizar este comportamiento e incluso ahorrar en unok
!Entonces esta construcción:
Es un bucle anidado en funcionamiento que ejecuta
XYYYXYYYXYYY...
(para un número determinado deY
s en cada iteración). Es bastante bueno que podamos terminar ambos bucles con un solok
, porque consumirá una dirección externa de RAS cada vez que las direcciones internas se hayan agotado.Este modismo se usa en el programa para ejecutar el bucle sobre la cuadrícula de salida.
fuente
En realidad , 25 bytes
Pruébalo en línea!
Versión de 22 bytes con muchas líneas nuevas
Pruébalo en línea!
fuente
R,
8382 bytes-1 byte gracias a MickyT
Lecturas
N
de stdin.Pruébalo en línea!
fuente
!=0
puede ser>0
Pyth , 16 bytes
Pruébalo en línea!
fuente
SpecBAS - 149 bytes
Una matriz realiza un seguimiento del número de divisores, luego imprime el número correcto de caracteres hasta la posición 50 de la pantalla.
fuente
PHP, 99 bytes
imprime un espacio inicial; ejecutar como tubería
php -nr '<code>'
o probarlo en línea .Descompostura
fuente
PowerShell, 101 bytes
Menos guión de prueba de golf:
Salida:
fuente
SOGL V0.12 , 8 bytes
Pruébalo aquí!
fuente
Wolfram Language (Mathematica) ,
4644 bytesPruébalo en línea! Pero tal vez intente en línea! con ColumnForm en lugar de Grid , ya
Grid
que no funciona en TIO. En Mathematica, se ve mejor:Una tercera solución de Mathematica ...
Divisors@Range@#
encuentra todos los divisores en el rango que queremos, y luego los multiplicamos0
y restamos" "
, haciendo que cada divisor sea igual a-" "
.PadLeft
agrega ceros a la izquierda, creando un horizonte lateral, cuya orientación arreglamos con
=\[Transpose]
. Finalmente, agregar" "
a todo hace que todas las entradas sean0
o" "
.Como alternativa, el 59 byte
""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&
produce una salida de cadena.fuente
Agregar ++ , 58 bytes
Pruébalo en línea!
Cómo funciona
g
k
g
k
#
fuente