Per qualsiasi numero intero positivo k, d(k)indichiamo il numero di divisori di k. Ad esempio, d(6)è 4perché 6ha 4divisori (cioè 1, 2, 3, 6).

Dato un numero intero positivo N, visualizza uno "skyline" nell'arte ASCII usando un carattere fisso, in modo che l'altezza dell '"edificio" situato in posizione orizzontale ksia d(k)per k = 1, ..., N. Vedi i casi di test di seguito.

Regole

• Qualsiasi carattere non bianco può essere utilizzato in modo coerente, non necessariamente #come mostrato nei casi di test.
• L'algoritmo dovrebbe teoricamente funzionare in modo arbitrariamente alto N. In pratica, è accettabile se il programma è limitato da tempo, memoria, dimensioni del tipo di dati o dimensioni dello schermo.
• Sono consentiti spazi o newline orizzontalmente o verticalmente in testa o in coda.
• Input e output possono essere presi con qualsiasi mezzo ragionevole .
• Programmi o funzioni sono consentiti, in qualsiasi linguaggio di programmazione . Sono vietate le scappatoie standard .
• Vince il codice più breve in byte.

Casi test

N = 10:

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

N = 50:

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

N = 200:

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

Gelatina , 9 byte

Utilizza 0invece di #.

RÆD0ṁz⁶ṚY

Provalo online!

C, 99 95 92 91 90 byte

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);}

Guarda che funziona qui .

Ottava, 41 40 32 byte

Grazie a @StewieGriffin salvato 8 byte.

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

Provalo online!

Risposte precedenti:

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

Provalo online!

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

Provalo online!

Spiegazione:

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 byte

fprende un Inte restituisce un String.

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

Provalo online!

• mè l' NOP (le variabili di Haskell devono essere minuscole).
• L'abbreviazione l=[1..m]viene utilizzata nelle comprensioni dell'elenco nidificato per scorrere tutte le righe, le colonne e i potenziali divisori. Ciò significa che alcune righe iniziali aggiuntive sono piene di spazi bianchi.
• nè la colonna (anche il numero selezionato), iè la riga.
• ['#'|0<-mod n<$>l]è un elenco di '#'caratteri con lunghezza pari al numero di divisori di n.

Ottava, 61 byte

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

Spiegazione:

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

Alcune cose che vorrei evidenziare

• Porta l'ingresso direttamente nel loop
  • Non assegna il valore di input a nessuna variabile
• Non inizializza alcun array
  • Lo crea al volo, aggiungendo colonne e righe se necessario
• Lancia automaticamente il valore ASCII da 0 a spazio bianco (ASCII-32)

Cosa succede all'interno del loop (supponiamo input 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. Inizia come un singolo 35
2. Espande una colonna e una riga, per fare spazio ai due divisori di 2
3. Espande una colonna, per fare spazio a 3 (solo due divisori)
4. Espande una colonna e una riga, per fare spazio ai 3 divisori ( 1,2,4)
5. Espande una colonna, per fare spazio a 5
6. Espande una colonna e una riga, per fare spazio ai 4 divisori ( 1,2,3,6)

Infine lo capovolgiamo e lo convertiamo in una stringa, cambiando implicitamente il 0in 32:

warning: implicit conversion from numeric to char
ans =
     #
   # #
 #####
######

Python 3 , 111 byte

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

Provalo online!

Questo produce alcuni spazi bianchi verticali principali

APL (Dyalog) , 19 byte

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

Provalo online!

⎕ ottenere input valutato ( N )

⍳ 1 ... N

∘.|⍨ tabella dei resti di divisione con 1 ... N sia come asse verticale che come asse orizzontale

0= dove uguale a zero (cioè divide)

+⌿ somma le colonne (ovvero indica il conteggio dei divisori per ciascun numero)

'#'⍴¨⍨ usa ogni numero per rimodellare il carattere hash (fornisce un elenco di stringhe)

↑ mix (elenco di stringhe in tabella di righe)

⍉ trasporre

⊖ capovolgere

Mathematica, 59 57 byte

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

C #, 333 281 byte

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 interruzioni di riga:

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("#");
            }
    }
}

Anche se sono sicuro che questo sia possibile anche più breve, spero che raggiungeremo una soluzione più breve insieme;)

Salvato 52 byte con l'aiuto di raznagul

Mathematica, 99 byte

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

per N = 50

Carbone , 23 22 20 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Modifica: salvato 1 byte eseguendo il loop kda 0a i-1e aggiungendolo 1all'interno del loop. Salvati altri due byte non memorizzando l'input in una variabile. Spiegazione:

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

Modifica: questo "one-liner" a 18 byte (il collegamento è alla versione dettagliata del codice) non avrebbe funzionato con la versione di Charcoal al momento della presentazione della domanda: provalo online!

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

05AB1E , 12 byte

Codice:

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

Spiegazione:

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

Utilizza la codifica 05AB1E . Provalo online!

Python 2 , 101 byte

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))

Provalo online!

Questo produce (molti) spazi bianchi che portano verticalmente. Stampa un totale di Nlinee, la maggior parte delle quali sarà in genere vuota.

Japt , 34 33 16 14 byte

Risparmiato 17 byte grazie a @ETHproductions

õ@'#pXâ l÷z w

Provalo online!

J , 28 byte

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

Definisce un verbo monadico. Provalo online!

Spiegazione

[:|:&.|.[('#',@$~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 byte

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]?:" ";

Provalo online!

Brachylog , 34 byte

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

Provalo online!

Alice , 33 byte

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

Provalo online!

L'input è (purtroppo) sotto forma di punto di codice . Almeno legge un carattere UTF-8, quindi puoi usare input più grandi di 255, ma sono ancora limitati ed è un formato di input piuttosto doloroso. Per tre byte aggiuntivi, possiamo leggere un numero intero decimale:

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

Provalo online!

Il carattere non di spazi bianchi nell'output è !.

Si noti che la soluzione stampa anche una tonnellata di spazi bianchi iniziali (inizia sempre con una linea vuota e quindi stampa una NxNgriglia in modo che, per dimensioni maggiori N, ci saranno molte linee di spazi prima delle prime !).

Spiegazione

Ho usato e spiegato la &w...kcostruzione prima (per esempio qui ). È un piccolo idioma pulito che fa apparire un intero n e quindi esegue un pezzo di codice n + 1 volte (di conseguenza, di solito, viene utilizzato t&w...kper eseguire un ciclo n volte, con il tdecremento del valore di input). Questo viene fatto lavorando con lo stack degli indirizzi di ritorno (RAS). winvia l'indirizzo IP corrente al RAS e, se lo ripetiamo con, &l'indirizzo viene inviato n volte. kapre un indirizzo dal RAS e salta laggiù. Se il RAS è vuoto, non fa nulla e il ciclo viene chiuso.

Potresti notare che non è banalmente possibile nidificare questi loop, perché alla fine del loop interno, lo stack non è vuoto, quindi knon diventa un no-op. Invece, l'IP tornerebbe all'inizio del loop esterno. Il modo generale per risolvere questo problema consiste nell'avvolgere il ciclo interno nella propria subroutine. Ma se siamo in grado di organizzare il ciclo nidificato in modo tale che il ciclo esterno termina con il ciclo interno, si può effettivamente fare uso di questo comportamento e anche salvare su un unico k!

Quindi questa costruzione:

&wX&wYk

È un ciclo nidificato funzionante che esegue il XYYYXYYYXYYY...(per un certo numero di Ys in ogni iterazione). È abbastanza ordinato che possiamo terminare entrambi i loop con un singolo k, perché consumerà un indirizzo esterno da RAS ogni volta che gli indirizzi interni sono stati esauriti.

Questo idioma viene utilizzato nel programma per eseguire il loop sulla griglia di output.

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.

In realtà , 25 byte

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

Provalo online!

Versione a 22 byte con molte nuove linee principali

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

Provalo online!

R, 83 82 byte

-1 byte grazie a MickyT

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

Legge Nda 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

Provalo online!

Pyth , 16 byte

j_.tm*\#/%LdSQ0S

Provalo online!

SpecBAS - 149 byte

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

Un array tiene traccia del numero di divisori, quindi stampa il giusto numero di caratteri fino alla posizione 50 dello schermo.

PHP, 99 byte

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

stampa uno spazio principale; esegui come pipe php -nr '<code>'o provalo online .

abbattersi

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 byte

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

Script di test meno golfato:

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

Produzione:

True
True
True

SOGL V0.12 , 8 byte

∫Λ⁄╗*}⁰H

Provalo qui!

Wolfram Language (Mathematica) , 46 44 byte

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

Provalo online! Ma forse provalo online! con ColumnForm anziché Grid , poiché Gridnon funziona in TIO. In Mathematica, sembra migliore:

Una terza soluzione Mathematica ... Divisors@Range@#trova tutti i divisori nella gamma che vogliamo, e quindi moltiplichiamo 0e sottraggiamo " ", rendendo uguale ogni divisore -" ".

PadLeftaggiunge zero sulla sinistra, creando uno skyline laterale, il cui orientamento viene fissato con = \[Transpose]. Infine, l'aggiunta " "a tutto rende tutte o le voci 0o " ".

In alternativa, il 59 byte ""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&produce output di stringa.

Aggiungi ++ , 58 byte

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

Provalo online!

Come funziona

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

$A = [d(1), d(2), d(3), ..., d(n)]$#$A$$\max(A)$$A$da questo massimo, prima di cedere questo numero di spazi per ciascun elemento e concatenare gli spazi agli hash ripetuti. Successivamente, trasponiamo e invertiamo le righe, prima di unire ogni riga su newline. Infine, abbiamo prodotto l'orizzonte.