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:

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

Jalea , 9 bytes

Usos en 0lugar de #.

RÆD0ṁz⁶ṚY

Pruébalo en línea!

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í .

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


   #
 ####
#####

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.

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

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

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

Mathematica, 59 57 bytes

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

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

Mathematica, 99 bytes

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

para N = 50

Carbón , 23 22 20 bytes

Ｆ…·¹Ｎ«Ｊι⁰Ｆι¿¬﹪ι⁺κ¹↑#

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:

Ｆ…·¹Ｎ       for (i : InclusiveRange(1, InputNumber()))
«           {
 Ｊι⁰         JumpTo(i, 0);
 Ｆι          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!

↑Ｅ…·¹Ｎ⪫Ｅι⎇﹪ι⁺¹λω#ω

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!

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.

Japt , 34 33 16 14 bytes

Ahorró 17 bytes gracias a @ETHproductions

õ@'#pXâ l÷z w

Pruébalo en línea!

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.

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!

Brachylog , 34 bytes

⟦fᵐlᵐgDh⌉⟦↔gᵐ;D↔z{z{>₁∧0ṫ|∧Ṣ}ᵐcẉ}ᵐ

Pruébalo en línea!

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.

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!

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!

Pyth , 16 bytes

j_.tm*\#/%LdSQ0S

Pruébalo en línea!

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.

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

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

SOGL V0.12 , 8 bytes

∫Λ⁄╗*}⁰H

Pruébalo aquí!

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:

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.

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

gkg$x$$1$$n$$d(x)$k

$A = [d(1), d(2), d(3), ..., d(n)]$#$A$$\max(A)$$A$desde 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.