Pour tout entier positif k, d(k)notons le nombre de diviseurs de k. Par exemple, d(6)est 4, parce que 6a 4diviseurs ( à savoir 1, 2, 3, 6).

Avec un nombre entier positif N, affichez un "horizon" dans la technique ASCII en utilisant un caractère fixe, de sorte que la hauteur du "bâtiment" situé en position horizontale ksoit définie d(k)par k = 1, ..., N. Voir les cas de test ci-dessous.

Règles

• Tout caractère non-blanc peut être utilisé de manière cohérente, pas nécessairement #comme le montrent les cas de test.
• L'algorithme devrait théoriquement fonctionner arbitrairement haut N. En pratique, il est acceptable que le programme soit limité par le temps, la mémoire, la taille du type de données ou la taille de l'écran.
• Les espaces ou les nouvelles lignes sont précédés ou suivis horizontalement ou verticalement.
• L'entrée et la sortie peuvent être prises par n'importe quel moyen raisonnable .
• Les programmes ou fonctions sont autorisés, dans n'importe quel langage de programmation . Les failles standard sont interdites.
• Le code le plus court en octets gagne.

Cas de test

N = 10:

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

N = 50:

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

N = 200:

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

Gelée , 9 octets

Utilise 0au lieu de #.

RÆD0ṁz⁶ṚY

Essayez-le en ligne!

C, 99 95 92 91 90 octets

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

Voir le travail ici .

Octave, 41 40 32 octets

Merci à @StewieGriffin sauvé 8 octets.

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

Essayez-le en ligne!

Réponses précédentes:

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

Essayez-le en ligne!

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

Essayez-le en ligne!

Explication:

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 octets

fprend un Intet retourne un String.

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

Essayez-le en ligne!

• mest le Nde l'OP (les variables Haskell doivent être en minuscules.)
• L'abréviation l=[1..m]est utilisée dans les interprétations de liste imbriquées pour parcourir toutes les lignes, les colonnes et les diviseurs potentiels. Cela signifie quelques lignes initiales supplémentaires remplies d'espaces.
• nest la colonne (également le nombre vérifié), iest la ligne.
• ['#'|0<-mod n<$>l]est une liste de '#'caractères avec la longueur du nombre de diviseurs de n.

Octave, 61 octets

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

Explication:

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

Quelques points à souligner

• Prend l'entrée directement dans la boucle
  • N'attribue la valeur d'entrée à aucune variable
• N'initialise aucun tableau
  • Il le crée à la volée, en ajoutant des colonnes et des lignes si nécessaire
• Convertit automatiquement la valeur ASCII 0 en espaces (ASCII-32)

Que se passe-t-il à l'intérieur de la boucle (supposons une entrée 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. Commence comme un seul 35
2. Agrandit une colonne et une rangée pour faire de la place pour les deux diviseurs de 2
3. Développe une colonne pour faire de la place pour 3 (seulement deux diviseurs)
4. Agrandit une colonne et une rangée pour faire de la place pour les 3 diviseurs ( 1,2,4)
5. Agrandit une colonne pour faire de la place pour 5
6. Agrandit une colonne et une ligne pour faire de la place pour les 4 diviseurs ( 1,2,3,6)

Enfin, nous le retournons et le convertissons en une chaîne, en modifiant implicitement le 0à 32:

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

Python 3 , 111 octets

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

Essayez-le en ligne!

Cela produit des espaces blancs verticaux

APL (Dyalog) , 19 octets

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

Essayez-le en ligne!

⎕ obtenir une entrée évaluée ( N )

⍳ 1 ... N

∘.|⍨ division reste table avec 1 ... N à la fois comme axe vertical et horizontal

0= où égal à zéro (c'est à dire qu'il divise)

+⌿ additionner les colonnes (c'est-à-dire donner le nombre de diviseurs pour chaque nombre)

'#'⍴¨⍨ utiliser chaque nombre pour remodeler le caractère de hachage (donne la liste des chaînes)

↑ mix (liste de chaînes dans un tableau de lignes)

⍉ transposer

⊖ retourner à l'envers

Mathematica, 59 57 octets

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

C #, 333 281 octets

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

Avec des sauts de ligne:

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

Bien que je sois sûr que cela soit possible plus rapidement, j'espère que nous parviendrons ensemble à une solution plus courte;)

52 octets sauvés avec l'aide de raznagul

Mathematica, 99 octets

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

pour N = 50

Charbon de bois , 23 22 20 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Edit: 1 octet enregistrées par bouclage à kpartir 0de i-1et en ajoutant à l' 1intérieur de la boucle. Enregistré deux octets supplémentaires en ne stockant pas l'entrée dans une variable. Explication:

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

Edit: Ce "one-liner" de 18 octets (lien vers version du code verbeuse) n'aurait pas fonctionné avec la version de Charcoal au moment où la question a été soumise: essayez-le en ligne!

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

05AB1E , 12 octets

Code:

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

Explication:

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

Utilise le codage 05AB1E . Essayez-le en ligne!

Python 2 , 101 octets

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

Essayez-le en ligne!

Cela produit (beaucoup) d’espaces blancs verticalement. Il imprime un total de Nlignes dont la grande majorité sera généralement vierge.

Japt , 34 33 16 14 octets

17 octets sauvés grâce à @ETHproductions

õ@'#pXâ l÷z w

Essayez-le en ligne!

J , 28 octets

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

Définit un verbe monadique. Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Brachylog , 34 octets

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

Essayez-le en ligne!

Alice , 33 octets

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

Essayez-le en ligne!

L'entrée est (malheureusement) sous la forme d'un point de code . Au moins, il lit un caractère UTF-8, vous pouvez donc utiliser des entrées plus grandes que 255, mais elles sont toujours limitées et le format d’entrée est très pénible. Pour trois octets supplémentaires, on peut lire un entier décimal:

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

Essayez-le en ligne!

Le caractère non-blanc de la sortie est !.

Notez que la solution imprime également une tonne d'espaces de premier plan (elle commence toujours par une ligne vide, puis une NxNgrille; ainsi, pour les plus grandes N, il y aura plusieurs lignes d'espaces avant les premières !.)

Explication

J'ai déjà utilisé et expliqué la &w...kconstruction (par exemple ici ). C'est un joli petit idiome qui fait apparaître un entier n puis exécute un morceau de code n + 1 fois (par conséquent, il est généralement utilisé t&w...kpour exécuter une boucle n fois en tdécrémentant la valeur d'entrée). Cela est fait en travaillant avec la pile d'adresses de retour (RAS). wtransmet l'adresse IP actuelle au serveur d'accès à distance et si nous la répétons avec, &l'adresse sera poussée n fois. kaffiche une adresse du serveur d'accès à distance et y retourne. Si le RAS est vide, il ne fait rien du tout et la boucle est sortie.

Vous remarquerez peut-être qu'il n'est pas trivial d'imbriquer ces boucles, car à la fin de la boucle interne, la pile n'est pas vide et kne devient donc pas un non-op. Au lieu de cela, l'IP reviendrait au début de la boucle externe. La solution générale consiste à envelopper la boucle interne dans son propre sous-programme. Mais si nous pouvons organiser la boucle imbriquée de telle sorte que la boucle externe se termine par la boucle interne, nous pouvons en fait utiliser ce comportement et même en économiser un k!

Donc cette construction:

&wX&wYk

C'est une boucle imbriquée fonctionnelle qui exécute le XYYYXYYYXYYY...(pour un certain nombre de Ys dans chaque itération). Il est intéressant de pouvoir terminer les deux boucles par une seule k, car elle consomme une adresse externe du serveur d'accès à distance chaque fois que les adresses internes sont épuisées.

Cet idiome est utilisé dans le programme pour exécuter la boucle sur la grille de sortie.

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 fait , 25 octets

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

Essayez-le en ligne!

Version de 22 octets avec beaucoup de nouvelles lignes principales

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

Essayez-le en ligne!

R, 83 82 octets

-1 octet grâce à MickyT

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

Lit 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

Essayez-le en ligne!

Pyth , 16 octets

j_.tm*\#/%LdSQ0S

Essayez-le en ligne!

SpecBAS - 149 octets

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 tableau conserve le nombre de diviseurs, puis affiche le nombre correct de caractères jusqu'à la position 50.

PHP, 99 octets

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 premier espace; courir comme pipe php -nr '<code>'ou essayer en ligne .

panne

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 octets

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

Script de test moins joué:

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

Sortie:

True
True
True

SOGL V0.12 , 8 octets

∫Λ⁄╗*}⁰H

Essayez-le ici!

Wolfram Language (Mathematica) , 46 44 octets

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

Essayez-le en ligne! Mais peut-être l' essayer en ligne! avec ColumnForm au lieu de Grid , car Gridne fonctionne pas dans TIO. Dans Mathematica, cela a l'air mieux:

Une troisième solution Mathematica ... Divisors@Range@#recherche tous les diviseurs dans la plage que nous voulons, puis multiplie 0et soustrayons " ", rendant chaque diviseur égal à -" ".

PadLeftajoute des zéros à gauche, créant une ligne d'horizon latérale, dont nous corrigeons l'orientation avec = \[Transpose]. Enfin, ajouter " "à tout fait que toutes les entrées sont 0soit " ".

Au lieu de cela, le 59 octets ""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&produit une sortie chaîne.

Ajouter ++ , 58 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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

$A = [d(1), d(2), d(3), ..., d(n)]$#$A$$\max(A)$$A$à partir de ce maximum, avant de céder ce nombre d'espaces pour chaque élément et de concaténer les espaces aux hachages répétés. Ensuite, nous transposons et inversons les lignes avant de joindre chaque ligne aux nouvelles lignes. Enfin, nous sortons la ligne d'horizon.