Divisor skyline

46

Para cualquier número entero positivo k, d(k)denote el número de divisores de k. Por ejemplo, d(6)es 4, porque 6tiene 4divisores (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 ksea 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:

                                                                                                                                                                                   #                    
                                                                                                                                                                                   #                    
                                                                                                                       #                                               #           #                    
                                                                                                                       #                       #                       #           #                    
                                                                                                                       #                       #                       #           #           #        
                                                                                                                       #                       #                       #           #           #        
                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #
                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #
                                               #           #           #       #   #     #     #           #   #       #     #     #       #   #     #     #   # #     #       #   #           #     # #
                                   #           #           #           #       #   #     #     #   #       #   #       #     #     #       #   #     #     #   # #     #       #   #           #   # # #
                       #     #     #   # #     #     # #   #     #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #
                       #     #     #   # #     #     # #   #   # #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #
           #     # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # #   #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #
           #   # # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # ##  #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #
     # # # # ### # ### # ### # ##### ### # ### # ### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ####### ##### ### ##### # ######### # ##### ##### ### # ### ##### # ######### # ### # #
   # # ### # ### # ### ##### # ##### ### # ### ##### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ############# ### ##### # ######### # ##### ##### ### ##### ##### # ######### # ### # #
 #######################################################################################################################################################################################################
########################################################################################################################################################################################################
Luis Mendo
fuente

Respuestas:

12

Jalea , 9 bytes

Usos en 0lugar de #.

RÆD0ṁz⁶ṚY

Pruébalo en línea!

Monja permeable
fuente
2
5 minutos y 10 segundos :-)
Luis Mendo
13
Mientras tanto, estaba leyendo otras cosas ... La próxima vez seré más rápido.
Leaky Nun
7

C, 99 95 92 91 90 bytes

c,l,i,j;f(n){for(j=n;j--;puts(""))for(i=0;i<n;c=!putchar(32|c>j))for(l=++i;l;c+=i%l--<1);}

Véalo funcionar aquí .

2501
fuente
7

Octava, 41 40 32 bytes

Gracias a @StewieGriffin ahorró 8 bytes.

@(N)" #"(sort(~mod(k=1:N,k'))+1)

Pruébalo en línea!

Respuestas anteriores:

@(N)" #"(sort(~bsxfun(@mod,k=1:N,k')+1))

Pruébalo en línea!

@(N)" #"(sort(ismember((k=1:N)./k',k))+1)

Pruébalo en línea!

Explicación:

N=5;
d = (1:N)./(1:N)'    %divide each of numbers from 1 to N by 1 to N 
                     %a [N by N] matrix created
d =

   1.00   2.00   3.00   4.00   5.00
   0.50   1.00   1.50   2.00   2.50
   0.33   0.66   1.00   1.33   1.66
   0.25   0.50   0.75   1.00   1.25
   0.20   0.40   0.60   0.80   1.00

m = ismember(d,1:N)      %find divisors of each number
m =

  1  1  1  1  1
  0  1  0  1  0
  0  0  1  0  0
  0  0  0  1  0
  0  0  0  0  1

idx = sort(m)                  %sort the matrix

idx =

  0  0  0  0  0
  0  0  0  0  0
  0  0  0  1  0
  0  1  1  1  1
  1  1  1  1  1

" #"(idx+1)     %replace 0 and 1 with ' ' and '#' respectively


   #
 ####
#####
rahnema1
fuente
1
Muy buen enfoque!
Luis Mendo
2
Octave realiza la expansión singleton implícitamente, por lo que le @(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.
Stewie Griffin
1
ByteCount misma (32): @(N)['',35*sort(~mod(k=1:N,k'))].
Stewie Griffin
@StewieGriffin ¡Gracias! No sabía de esa característica. ¿Es mod(1:N,(1:N).') aceptable en MATLAB?
rahnema1
2
Yo creo que es posible, ya que de R2016b , pero no puedo probarlo yo por desgracia, ya que no tengo.
Stewie Griffin
6

Haskell , 71 bytes

ftoma un Inty devuelve un String.

f m|l<-[1..m]=unlines[[last$' ':drop(m-i)['#'|0<-mod n<$>l]|n<-l]|i<-l]

Pruébalo en línea!

  • mes el Ndel OP (las variables de Haskell deben estar en minúsculas).
  • La abreviatura 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.
  • nes la columna (también número marcada), ies fila.
  • ['#'|0<-mod n<$>l]es una lista de '#'caracteres con longitud del número de divisores de n.
Ørjan Johansen
fuente
6

Octava, 61 bytes

for i=1:input(''),p(1:nnz(~rem(i,1:i)),i)=35;end,[flip(p),'']

Explicación:

for i=1:input('')         % Loop, for i from 1 to the input value
 p(1:nnz(~rem(i,1:i)),i)=35;end,[flip(p),'']   
% Breakdown:
         ~rem(i,1:i)      % Return true if the remainder of i divided by any of the values
                          % in the vector 1 - i
     nnz(~rem(i,1:i))     % Check how many of them are non-zero
 p(1:nnz(~rem(i,1:i)),i)=35;end   % Assign the value 35 (ASCII for #) to rows 1
                                  % to the number of divisors of i, in column i
end,              % End loop
[flip(p),'']      % Flip the matrix, and concatenate it with the empty string

Algunas cosas que deseo destacar

  • Toma la entrada directamente en el bucle
    • No asigna el valor de entrada a ninguna variable
  • No inicializa ninguna matriz
    • Lo crea sobre la marcha, agregando columnas y filas según sea necesario.
  • Convierte automáticamente el valor 0 ASCII en espacios en blanco (ASCII-32)

Lo que sucede dentro del bucle (supongamos entrada 6)

p =  35
p =
   35   35
    0   35
p =
   35   35   35
    0   35   35
p =
   35   35   35   35
    0   35   35   35
    0    0    0   35
p =
   35   35   35   35   35
    0   35   35   35   35
    0    0    0   35    0
p =
   35   35   35   35   35   35
    0   35   35   35   35   35
    0    0    0   35    0   35
    0    0    0    0    0   35

  1. Comienza como un solo 35
  2. Expande una columna y una fila, para dejar espacio para los dos divisores de 2
  3. Expande una columna, para dejar espacio para 3 (solo dos divisores)
  4. Expande una columna y una fila, para dejar espacio para los 3 divisores ( 1,2,4)
  5. Expande una columna, para dejar espacio para 5
  6. Expande una columna y una fila, para dejar espacio para los 4 divisores ( 1,2,3,6)

Finalmente lo volteamos y lo convertimos en una cadena, cambiando implícitamente el 0a 32:

warning: implicit conversion from numeric to char
ans =
     #
   # #
 #####
######
Stewie Griffin
fuente
5

Python 3 , 111 bytes

lambda n:'\n'.join([*map(''.join,zip(*['#'*sum(x%-~i==0for i in range(x))+n*' 'for x in range(1,n+1)]))][::-1])

Pruébalo en línea!


Esto produce algunos espacios en blanco verticales principales

ovs
fuente
5

APL (Dyalog) , 19 bytes

⊖⍉↑'#'⍴¨⍨+⌿0=∘.|⍨⍳⎕

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 horizontal

0= 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és

Adán
fuente
5

Mathematica, 59 57 bytes

Rotate[Grid@Map[X~Table~#&,0~DivisorSigma~Range@#],Pi/2]&

ingrese la descripción de la imagen aquí

Ian Miller
fuente
Bienvenido a responder en PPCG, compañero de minifigura de Lego :-)
Luis Mendo
1
Ahora no hay vuelta atrás ...
Luis Mendo
¡Bienvenidos! Es bueno ver a otro golfista de Mathematica. Sin embargo, esta respuesta no es completamente válida porque ha codificado la entrada en el fragmento. Las respuestas deben ser programas completos o funciones invocables (aunque pueden no tener nombre). Así que esto se puede solucionar sin costo mediante la sustitución 50con #y anexar &. También puede guardar algunos bytes con notación infija: X~Table~#&y0~DivisorSigma~Range@#
Martin Ender
@MartinEnder Gracias. Olvidé esa parte cuando pasé de la prueba a la respuesta. Y gracias por la pista sobre infixing. No es algo que normalmente uso (ya que realmente no juego al golf).
Ian Miller
Pensé tanto. Fue más un comentario de lengua en mejilla. Perdón por la confusion.
Ian Miller
5

C #, 333 281 bytes

using System.Linq;using C=System.Console;class P{static void Main(){var n=int.Parse(C.ReadLine());var v=new int[n];for(var k=2;k<=n;k++)for(var i=1;i<k;i++)if(k%i==0)v[k-1]++;for(var i=0;i<v.Length;i++)for(var u=v.Max()-v[i];u<v.Max();u++){C.SetCursorPosition(i,u);C.Write("#");}}}

Con saltos de línea:

using System.Linq;
using C = System.Console;

class P
{
    static void Main()
    {
        var n = int.Parse(C.ReadLine());
        var v = new int[n];
        for (var k = 2; k <= n; k++)
            for (var i = 1; i < k; i++)
                if (k % i == 0)
                    v[k - 1]++;
        for (var i = 0; i < v.Length; i++)
            for (var u = v.Max() - v[i]; u < v.Max(); u++)
            {
                C.SetCursorPosition(i, u);
                C.Write("#");
            }
    }
}

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

MetaColon
fuente
1
Si usa un int-array en lugar de una lista, puede guardar muchos bytes de la usingdeclaración.
raznagul
@raznagul lo actualizó.
MetaColon
222 bytes: 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 a Action, mueve los incrementos y un par de otros ajustes menores. No lo he probado pero debería funcionar.
TheLethalCoder
@TheLethalCoder Lo probaré / actualizaré mi respuesta mañana.
MetaColon
5

Mathematica, 99 bytes

{T=DivisorSigma[0,Range@#];Row[Column/@Table[Join[Table[,Max[T]-T[[i]]],$~Table~T[[i]]],{i,1,#}]]}&

para N = 50

ingrese la descripción de la imagen aquí

J42161217
fuente
¿Son necesarios todos esos espacios (y líneas nuevas) para que se ejecute el código? Nunca he programado Mathematica, pero en la mayoría de los lenguajes puedes eliminar casi todos esos espacios.
Kevin Cruijssen
Este es mi primer golf. gracias por los consejos
J42161217
2
No hay problema, y ​​bienvenido a PPCG! Si aún no lo ha hecho, puede encontrar sugerencias para jugar golf en <todos los idiomas> y sugerencias para jugar golf en Mathematica interesantes para leer. :) Disfruta tu estancia.
Kevin Cruijssen
Los corchetes externos se pueden cambiar a corchetes para evitar que se muestren en la salida, y puede usar una sintaxis de infijo / prefijo para guardar 2 bytes:(T=0~DivisorSigma~Range@#;Row[Column/@Table[Join[Table[,Max@T-T[[i]]],$~Table~T[[i]]],{i,1,#}]])&
numbermaniac
5

Carbón , 23 22 20 bytes

F…·¹N«Jι⁰Fι¿¬﹪ι⁺κ¹↑#

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: Guardado 1 byte por bucle kde 0a i-1y añadiendo 1el interior del bucle. Ahorró otros dos bytes al no almacenar la entrada en una variable. Explicación:

F…·¹N       for (i : InclusiveRange(1, InputNumber()))
«           {
 Jι⁰         JumpTo(i, 0);
 Fι          for (k : Range(i))
  ¿¬﹪ι⁺κ¹     if (!(i % (k + 1)))
   ↑#          Print(:Up, "#");
            }

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!

↑E…·¹N⪫Eι⎇﹪ι⁺¹λω#ω
Neil
fuente
mejor explicación : P
Solo ASCII
3

05AB1E , 12 bytes

Código:

LÑ€g'#×.BøR»

Explicación:

L             # Create the range 1 .. input
 Ñ            # Get the list of divisors of each
  €g          # Get the length of each element
    '#        # Push a hash tag character
      ×       # String multiply
       .B     # Squarify, make them all of equal length by adding spaces
         ø    # Transpose
          R   # Reverse the array
           »  # Join by newlines

Utiliza la codificación 05AB1E . Pruébalo en línea!

Adnan
fuente
¿No puedes usar en ζlugar de .Bø? Además, el personaje no tiene que serlo#
Oliver Ni
ζno existía en ese entonces.
Urna mágica del pulpo
3

Python 2 , 101 bytes

N=input();r=range
for i in r(N,0,-1):print''.join('# '[i>sum(x%-~p<1for p in r(x))]for x in r(1,1+N))

Pruébalo en línea!

Esto produce (una gran cantidad) de espacios en blanco con orientación vertical. Imprime un total de Nlíneas, la gran mayoría de las cuales generalmente estarán en blanco.

Mathmandan
fuente
3

Japt , 34 33 16 14 bytes

Ahorró 17 bytes gracias a @ETHproductions

õ@'#pXâ l÷z w

Pruébalo en línea!

Luke
fuente
Puede guardar muchos bytes simplemente dejando zel relleno:õ_â lã'#pX÷z w
ETHproductions
No sabía que acolchaba las cuerdas automáticamente. ¡Gracias!
Lucas
2

J , 28 bytes

[:|:&.|.[('#',@$~1+_&q:)@-i.

Define un verbo monádico. Pruébalo en línea!

Explicación

[:|:&.|.[('#',@$~1+_&q:)@-i.  Input is y.
                          i.  Range from 0 to y-1
        [                -    subtracted from y (gives range from y to 1).
         (             )@     For each of the numbers:
                   _&q:         Compute exponents in prime decomposition,
                 1+             add 1 to each,
          '#'  $~               make char matrix of #s with those dimensions,
             ,@                 and flatten into a string.
                              The resulting 2D char matrix is padded with spaces.
[:|:&.|.                      Reverse, transpose, reverse again.
Zgarb
fuente
2

PHP, 126 bytes

for(;$n++<$argn;)for($c=$d=0;$d++<$n;)$n%$d?:$r[$n]=++$c;for($h=max($r);$h--;print"
")for($n=0;$n++<$argn;)echo$h<$r[$n]?:" ";

Pruébalo en línea!

Jörg Hülsermann
fuente
2

Alice , 33 bytes

I.!.t&w?t!aot&wh.Bdt.?-ex' +o&;k@

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:

/
ki@/.!.t&w?t!aot&wh.Bdt.?-ex' +o&;

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 NxNcuadrícula, por lo que, para mayor tamaño N, habrá muchas líneas de espacios antes del primer !s).

Explicación

He usado y explicado la &w...kconstrucció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 usa t&w...kpara ejecutar un bucle n veces, tdisminuyendo el valor de entrada). Esto se hace trabajando con la pila de dirección de retorno (RAS). wempuja la dirección IP actual al RAS y, si la repetimos, &la dirección se empuja n veces. kAparece 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 kque 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 uno k!

Entonces esta construcción:

&wX&wYk

Es un bucle anidado en funcionamiento que ejecuta XYYYXYYYXYYY...(para un número determinado de Ys en cada iteración). Es bastante bueno que podamos terminar ambos bucles con un solo k, 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.

I         Read a character and push its code point as input N.
.!        Store a copy on the tape.
.         Make another copy.
t&w       Run this outer loop N times. This loops over the lines of the
          output, so the current iteration corresponds to a divisor count
          no more than i (i counting down from N).
  ?t!       Decrement the value on the tape. That means we'll actually have
            i-1 on the tape during the iteration.
  ao        Print a linefeed. Doing this now leads to the weird leading linefeed, 
            but it's necessary for the &w...&w...k pattern.
  t&w       Remember that we still have a copy of N on the stack. We'll also
            ensure that this is the case after each loop iteration. So this
            also runs the inner loop N times. This iterates over the columns
            of the output grid so it's j that goes from 1 to N and corresponds
            to the number whose divisors we want to visualise.
              At this point the stack will always be empty. However, operating
              on an empty stack works with implicit zeros at the bottom of
              the stack. We'll use the top zero to keep track of j.
    h         Increment j.
    .B        Duplicate j and push all of its divisors.
    dt        Push the stack depth minus 1, i.e. the divisor count of j.
    .         Duplicate the divisor count.
    ?-        Retrieve i-1 from the tape and subtract it. So we're computing
              d(j)-i+1. We want to output a non-whitespace character iff this
              value is positive (i.e. if i is no greater than d(j)).
    ex        Extract the most significant bit of this value. This is 1 for
              all positive values and 0 for non-positive ones. It's the shortest
              way (I believe) to determine if a value is positive.
    ' +       Add this to the code point of a space. This gives a 33, or '!',
              if the cell is part of the skyline.
    o         Output the character.
    &;        We still have all the divisors and the divisor count on the stack.
              We pop the divisor count to discard that many values (i.e. to
              get rid of the divisors again).
k         Return to the appropriate loop beginning to run the continue the
          nested loop.
@         Terminate the program.
Martin Ender
fuente
1
¿El primer programa de Alice con una sola línea? :-)
Luis Mendo
1
@LuisMendo No, creo que Leo ha escrito algunos programas exclusivos de Cardinal (y tal vez yo también tengo ... el quine y Hello, World, por ejemplo). Sin embargo, probablemente sea el programa de línea única más elaborado. :)
Martin Ender
Hmm, mi solución podría ahorrar algunos bytes con el truco "tonelada de espacios en blanco"
quintopia
2

En realidad , 25 bytes

R♂÷♂l;M' *╗⌠'#*╜@+⌡M┬♂ΣRi

Pruébalo en línea!

Versión de 22 bytes con muchas líneas nuevas

;╗R⌠÷l'#*╜' *@+⌡M┬♂ΣRi

Pruébalo en línea!

Monja permeable
fuente
De acuerdo, el Readme del github debería actualizarse para incluir ÷ l, como la función de conteo divisor estándar ...
quintopia
2

R, 83 82 bytes

-1 byte gracias a MickyT

N=scan();m=matrix('#',N,N);for(i in 1:N)m[i,1:sum(i%%1:N>0)]=' ';write(m,'',N,,'')

Lecturas Nde stdin.

N=scan()                        # read N
m=matrix('#',N,N)               # make an NxN matrix of '#' characters
for(i in 1:N)                   # for each integer in the range
    m[i,1:sum(i%%1:N!=0)]=' '   # set the first n-d(n) columns of row i to ' '
write(m,'',N,,'')               # print to console with appropriate formatting

Pruébalo en línea!

Giuseppe
fuente
1
!=0puede ser>0
MickyT
1

SpecBAS - 149 bytes

1 INPUT n: DIM h(n)
2 FOR i=1 TO n
3 FOR j=1 TO i
4 h(i)+=(i MOD j=0)
5 NEXT j
6 NEXT i
7 FOR i=1 TO n
8 FOR j=51-h(i) TO 50
9  ?AT j,i;"#"
10 NEXT j
11 NEXT i

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.

ingrese la descripción de la imagen aquí

Brian
fuente
1

PHP, 99 bytes

for(;$d<$k?:$k++<$argn+$d=$n=0;)$k%++$d?:$r[--$n]=str_pad($r[$n],$k).H;ksort($r);echo join("
",$r);

imprime un espacio inicial; ejecutar como tubería php -nr '<code>'o probarlo en línea .

Descompostura

for(;$d<$k?:                    # inner: loop $d from 1 to $k
    $k++<$argn+$d=$n=0;)        # outer: loop $k from 1 to $argn, reset $d and $n
    $k%++$d?:                       # if $d divides $k
        $r[--$n]=str_pad($r[$n],$k).H;  # add one store to building $k
ksort($r);echo join("\n",$r);   # reverse and print resulting array
Titus
fuente
1

PowerShell, 101 bytes

((($d=1.."$args"|%{($x=$_)-(1..$_|?{$x%$_}).Count})|sort)[-1])..1|%{$l=$_;-join($d|%{' #'[$_-ge$l]})}

Menos guión de prueba de golf:

$f = {

$d=1.."$args"|%{
    ($x=$_)-(1..$_|?{$x%$_}).Count
}                                     # $d is the Divisor count array
$maxHeight=($d|sort)[-1]
$maxHeight..1|%{
    $l=$_
    -join($d|%{' #'[$_-ge$l]})
}

}

@(
    ,(10, 
    "     # # #",
    "   # # ###",
    " #########",
    "##########")

    ,(50, 
    "                                               #  ",
    "                                   #           #  ",
    "                       #     #     #   # #     #  ",
    "                       #     #     #   # #     #  ",
    "           #     # #   #   # # #   #   # # ##  # #",
    "           #   # # #   #   # # #   #   # # ##  # #",
    "     # # # # ### # ### # ### # ##### ### # ### # #",
    "   # # ### # ### # ### ##### # ##### ### # ### ###",
    " #################################################",
    "##################################################")

    ,(200,
    "                                                                                                                                                                                   #                    ",
    "                                                                                                                                                                                   #                    ",
    "                                                                                                                       #                                               #           #                    ",
    "                                                                                                                       #                       #                       #           #                    ",
    "                                                                                                                       #                       #                       #           #           #        ",
    "                                                                                                                       #                       #                       #           #           #        ",
    "                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #",
    "                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #",
    "                                               #           #           #       #   #     #     #           #   #       #     #     #       #   #     #     #   # #     #       #   #           #     # #",
    "                                   #           #           #           #       #   #     #     #   #       #   #       #     #     #       #   #     #     #   # #     #       #   #           #   # # #",
    "                       #     #     #   # #     #     # #   #     #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #",
    "                       #     #     #   # #     #     # #   #   # #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #",
    "           #     # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # #   #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #",
    "           #   # # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # ##  #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #",
    "     # # # # ### # ### # ### # ##### ### # ### # ### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ####### ##### ### ##### # ######### # ##### ##### ### # ### ##### # ######### # ### # #",
    "   # # ### # ### # ### ##### # ##### ### # ### ##### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ############# ### ##### # ######### # ##### ##### ### ##### ##### # ######### # ### # #",
    " #######################################################################################################################################################################################################",
    "########################################################################################################################################################################################################")


) | % {
    $n,$expected = $_
    $result = &$f $n
    "$result"-eq"$expected"
    #$result    # uncomment this to enjoy the view of the Divisor skyline
}

Salida:

True
True
True
mazzy
fuente
1

Wolfram Language (Mathematica) , 46 44 bytes

Grid[PadLeft[0Divisors@Range@#-" "]+" "]&

Pruébalo en línea! Pero tal vez intente en línea! con ColumnForm en lugar de Grid , ya Gridque no funciona en TIO. En Mathematica, se ve mejor:

Salida de Mathematica

Una tercera solución de Mathematica ... Divisors@Range@#encuentra todos los divisores en el rango que queremos, y luego los multiplicamos 0y restamos " ", haciendo que cada divisor sea igual a -" ".

PadLeftagrega ceros a la izquierda, creando un horizonte lateral, cuya orientación arreglamos con = \[Transpose]. Finalmente, agregar " "a todo hace que todas las entradas sean 0o " ".

Como alternativa, el 59 byte ""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&produce una salida de cadena.

Misha Lavrov
fuente
1

Agregar ++ , 58 bytes

D,g,@,FL1+
D,k,@~,J
L,R€gd"#"€*$dbM€_32C€*z£+bUBcB]bR€kbUn

Pruébalo en línea!

Cómo funciona

gkgx1nd(x)k

A=[d(1),d(2),d(3),...,d(n)]#Amax(A)Adesde este máximo, antes de ceder este número de espacios para cada elemento y concatenar los espacios a los hashes repetidos. A continuación, transponemos e invertimos las filas, antes de unir cada línea en líneas nuevas. Finalmente, sacamos el horizonte.

caird coinheringaahing
fuente