Para qualquer número inteiro positivo k, vamos d(k)denotar o número de divisores de k. Por exemplo, d(6)é 4, porque 6tem 4divisores (ou seja 1, 2, 3, 6).

Dado um número inteiro positivo N, exiba um "horizonte" na arte ASCII usando um caractere fixo, de modo que a altura do "edifício" localizado na posição horizontal kseja d(k)para k = 1, ..., N. Veja os casos de teste abaixo.

Regras

• Qualquer caractere que não seja um espaço em branco pode ser usado consistentemente, não necessariamente #como mostrado nos casos de teste.
• O algoritmo deve teoricamente funcionar arbitrariamente alto N. Na prática, é aceitável se o programa for limitado por tempo, memória, tamanho do tipo de dados ou tamanho da tela.
• São permitidos espaços à frente ou à direita, na horizontal ou na vertical, ou novas linhas.
• A entrada e a saída podem ser obtidas por qualquer meio razoável .
• Programas ou funções são permitidos, em qualquer linguagem de programação . As brechas padrão são proibidas.
• O menor código em bytes vence.

Casos de teste

N = 10:

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

N = 50:

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

N = 200:

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

Geléia , 9 bytes

Usa em 0vez de #.

RÆD0ṁz⁶ṚY

Experimente online!

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

Veja como funciona aqui .

Oitava, 41 40 32 bytes

Graças a @StewieGriffin, foram salvos 8 bytes.

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

Experimente online!

Respostas anteriores:

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

Experimente online!

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

Experimente online!

Explicação:

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

fpega um Inte retorna um String.

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

Experimente online!

• mé o Ndo OP (as variáveis ​​Haskell devem estar em minúsculas.)
• A abreviação l=[1..m]é usada nas compreensões da lista aninhada para iterar por todas as linhas, colunas e divisores em potencial. Isso significa algumas linhas iniciais extras preenchidas com espaço em branco.
• né coluna (também número marcado), ié linha.
• ['#'|0<-mod n<$>l]é uma lista de '#'caracteres com o comprimento do número de divisores de n.

Oitava, 61 bytes

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

Explicação:

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

Algumas coisas que gostaria de destacar

• Leva a entrada diretamente para o loop
  • Não atribui o valor de entrada a nenhuma variável
• Não inicializa nenhuma matriz
  • Cria-o rapidamente, adicionando colunas e linhas conforme necessário
• Transmite automaticamente o valor ASCII 0 para o espaço em branco (ASCII-32)

O que acontece dentro do loop (suponha 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. Começa como um único 35
2. Expande uma coluna e uma linha, para abrir espaço para os dois divisores de 2
3. Expande uma coluna, para abrir espaço para 3 (apenas dois divisores)
4. Expande uma coluna e uma linha, para liberar espaço para os 3 divisores ( 1,2,4)
5. Expande uma coluna, para abrir espaço para 5
6. Expande uma coluna e uma linha, para liberar espaço para os 4 divisores ( 1,2,3,6)

Finalmente, invertemos e convertemos em uma string, alterando implicitamente o 0para 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])

Experimente online!

Isso produz alguns espaços em branco verticais

APL (Dyalog) , 19 bytes

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

Experimente online!

⎕ obter entrada avaliada ( N )

⍳ 1 ... N

∘.|⍨ tabela de divisão remanescente com 1 ... N, tanto no eixo vertical como no eixo horizontal

0= onde igual a zero (ou seja, divide)

+⌿ somar as colunas (ou seja, fornece a contagem de divisores para cada número)

'#'⍴¨⍨ use cada número para remodelar o caractere de hash (fornece uma lista de strings)

↑ mix (lista de strings na tabela de linhas)

⍉ transpor

⊖ virar de cabeça para baixo

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

Com quebras de linha:

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

Embora eu tenha certeza de que isso também é possível, espero que consigamos juntos uma solução mais curta;)

Guardou 52 bytes com a ajuda 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

Carvão , 23 22 20 bytes

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

Experimente online! Link é a versão detalhada do código. Editar: salvou 1 byte fazendo um loop kde 0para i-1e adicionando 1dentro do loop. Economizou mais dois bytes por não armazenar a entrada em uma variável. Explicação:

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

Edit: Este "one-liner" de 18 bytes (o link é para a versão detalhada do código) não teria funcionado com a versão do Charcoal no momento em que a pergunta foi enviada: Experimente online!

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

05AB1E , 12 bytes

Código:

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

Explicação:

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

Usa a codificação 05AB1E . Experimente online!

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

Experimente online!

Isso produz (muitos) espaços em branco à esquerda na vertical. Imprime um total de Nlinhas, a grande maioria das quais normalmente fica em branco.

Japt , 34 33 16 14 bytes

Economizou 17 bytes graças a @ETHproductions

õ@'#pXâ l÷z w

Experimente online!

J , 28 bytes

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

Define um verbo monádico. Experimente online!

Explicação

[:|:&.|.[('#',@$~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]?:" ";

Experimente online!

Braquilog , 34 bytes

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

Experimente online!

Alice , 33 bytes

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

Experimente online!

A entrada é (infelizmente) na forma de um ponto de código . Pelo menos, ele lê um caractere UTF-8, para que você possa usar entradas maiores que 255, mas elas ainda são limitadas e é um formato de entrada bastante doloroso. Por três bytes adicionais, podemos ler um número inteiro decimal:

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

Experimente online!

O caractere não em branco na saída é !.

Observe que a solução também imprime uma tonelada de espaço em branco à esquerda (sempre começa com uma linha vazia e depois imprime uma NxNgrade para que, para maiores N, existam muitas linhas de espaços antes dos primeiros !s).

Explicação

Eu já usei e expliquei a &w...kconstrução antes (por exemplo, aqui ). É um pequeno idioma puro que exibe um número inteiro n e, em seguida, executa um pedaço de código n + 1 vezes (consequentemente, é geralmente usado t&w...kpara executar um loop n vezes, com a tdiminuição do valor de entrada). Isso é feito trabalhando com a pilha de endereços de retorno (RAS). wenvia o endereço IP atual ao RAS e, se o repetirmos, &o endereço será enviado n vezes. kaparece um endereço do RAS e volta para lá. Se o RAS estiver vazio, ele não fará nada e o loop será encerrado.

Você pode notar que não é trivialmente possível aninhar esses loops, porque no final do loop interno, a pilha não está vazia e, portanto, knão se torna um não-op. Em vez disso, o IP retornaria ao início do loop externo. A maneira geral de corrigir isso envolve agrupar o loop interno em sua própria sub-rotina. Mas se pudermos organizar o loop aninhado de modo que o loop externo termine com o loop interno, podemos realmente usar esse comportamento e até economizar um k!

Então, essa construção:

&wX&wYk

É um loop aninhado de trabalho que executa o XYYYXYYYXYYY...(para algum número de Ys em cada iteração). É bem legal que possamos terminar os dois loops com um único k, porque ele consumirá um endereço externo do RAS cada vez que os endereços internos forem esgotados.

Esse idioma é usado no programa para executar o loop na grade de saída.

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.

Na verdade , 25 bytes

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

Experimente online!

Versão de 22 bytes com muitas das novas linhas principais

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

Experimente online!

R, 83 bytes

-1 byte graças a MickyT

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

Lê 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

Experimente online!

Pitão , 16 bytes

j_.tm*\#/%LdSQ0S

Experimente online!

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

Uma matriz controla o número de divisores e depois imprime o número certo de caracteres até a posição 50 da tela.

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 um espaço à esquerda; execute como pipe php -nr '<code>'ou experimente online .

demolir

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

Script de teste com menos golfe:

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

Resultado:

True
True
True

SOGL V0.12 , 8 bytes

∫Λ⁄╗*}⁰H

Experimente aqui!

Wolfram Language (Mathematica) , 46 44 bytes

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

Experimente online! Mas talvez tente online! com ColumnForm em vez de Grid , pois Gridnão funciona no TIO. No Mathematica, parece melhor:

Uma terceira solução Mathematica ... Divisors@Range@#encontra todos os divisores no intervalo que queremos, e depois multiplicamos 0e subtraímos " ", tornando cada divisor igual a-" " .

PadLeftadiciona zeros à esquerda, criando um horizonte lateral, cuja orientação corrigimos com = \[Transpose]. Finalmente, acrescentando " "a tudo faz todas as entradas quer 0ou" " .

Como alternativa, o 59 bytes ""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&produz saída de string.

Adicionar ++ , 58 bytes

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

Experimente online!

Como funciona

Nosso programa consiste em duas funções auxiliares, ge k, e na principal função lambda. gitera sobre cada número inteiro,$x$, entre $1$ e $n$ e retorna $d(x)$conforme definido no corpo do desafio, enquanto kpega uma lista de caracteres e os concatena em uma única sequência.

A função lambda principal gera $A = [d(1), d(2), d(3), ..., d(n)]$e repete o #caractere para cada elemento de$A$. Nós então tomamos$\max(A)$e subtraia cada elemento em $A$desse máximo, antes de render esse número de espaços para cada elemento e concatenar os espaços para os hashes repetidos. Em seguida, transpomos e invertemos as linhas, antes de unir cada linha em novas linhas. Finalmente, produzimos o horizonte.