Für jede positive ganze Zahl k, lassen Sie d(k)die Anzahl der Teiler von bezeichnen k. Zum Beispiel d(6)ist 4, da 6hat 4Teilern (nämlich 1, 2, 3, 6).

Bei einer positiven ganzen Zahl N, zeigen eine „Skyline“ in ASCII - Art einen festen Charakter verwendet wird , so dass die Höhe des „Gebäude“ an horizontalen Position befindet kist d(k)für k = 1, ..., N. Siehe Testfälle unten.

Regeln

• Jedes Nicht-Leerzeichen kann konsistent verwendet werden, nicht unbedingt #wie in den Testfällen gezeigt.
• Der Algorithmus sollte theoretisch für beliebig hohe Werte arbeiten N. In der Praxis ist es akzeptabel, wenn das Programm durch Zeit, Speicher, Datentypgröße oder Bildschirmgröße begrenzt ist.
• Horizontal oder vertikal führende oder nachfolgende Leerzeichen oder Zeilenumbrüche sind zulässig.
• Eingabe und Ausgabe können mit jedem vernünftigen Mittel erfolgen .
• Programme oder Funktionen sind in jeder Programmiersprache zulässig . Standardlücken sind verboten.
• Kürzester Code in Bytes gewinnt.

Testfälle

N = 10:

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

N = 50:

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

N = 200:

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

Gelee , 9 Bytes

Verwendet 0anstelle von #.

RÆD0ṁz⁶ṚY

Probieren Sie es 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);}

Sehen Sie , wie es hier funktioniert .

Oktave, 41 40 32 Bytes

Dank @StewieGriffin 8 Bytes gespart.

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

Probieren Sie es online!

Bisherige Antworten:

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

Probieren Sie es online!

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

Probieren Sie es online!

Erläuterung:

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

fnimmt ein Intund gibt ein zurück String.

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

Probieren Sie es online!

• mist die Ndes OP (Haskell-Variablen müssen in Kleinbuchstaben geschrieben werden.)
• Die Abkürzung l=[1..m]wird in verschachtelten Listen verwendet, um alle Zeilen, Spalten und potenziellen Teiler zu durchlaufen. Dies bedeutet einige zusätzliche Anfangszeilen, die mit Leerzeichen gefüllt sind.
• nist Spalte (auch Nummer geprüft), iist Zeile.
• ['#'|0<-mod n<$>l]ist eine Liste von '#'Zeichen mit der Länge der Anzahl der Teiler von n.

Oktave, 61 Bytes

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

Erläuterung:

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

Ein paar Dinge, die ich hervorheben möchte

• Übernimmt die Eingabe direkt in die Schleife
  • Weist den Eingabewert keiner Variablen zu
• Initialisiert kein Array
  • Es erstellt es im Handumdrehen und fügt nach Bedarf Spalten und Zeilen hinzu
• Wandelt den ASCII-Wert 0 automatisch in ein Leerzeichen um (ASCII-32)

Was passiert in der Schleife (suppose Eingang 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. Beginnt als Einzel 35
2. Erweitert eine Spalte und eine Zeile, um Platz für die beiden Teiler von 2 zu schaffen
3. Erweitert eine Spalte, um Platz für 3 zu schaffen (nur zwei Teiler)
4. Erweitert eine Spalte und eine Zeile, um Platz für die 3 Teiler zu schaffen ( 1,2,4)
5. Erweitert eine Spalte, um Platz für 5 zu schaffen
6. Erweitert eine Spalte und eine Zeile, um Platz für die 4 Teiler zu schaffen ( 1,2,3,6)

Schließlich drehen wir es um und wandeln es in einen String um, indem wir implizit das 0in 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])

Probieren Sie es online!

Dies erzeugt einige führende vertikale Leerzeichen

APL (Dyalog) , 19 Bytes

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

Probieren Sie es online!

⎕ ausgewertete Eingabe erhalten ( N )

⍳ 1 ... N

∘.|⍨ Aufteilung Resttabelle mit 1 ... N sowohl als vertikale als auch als horizontale Achse

0= wo gleich Null (dh es teilt)

+⌿ Summe der Spalten (dh Anzahl der Teiler für jede Zahl)

'#'⍴¨⍨ Verwenden Sie jede Zahl, um das Hash-Zeichen umzugestalten (Liste der Zeichenfolgen)

↑ mix (Liste von Strings in Zeilentabelle)

⍉ transponieren

⊖ umdrehen

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

Mit Zeilenumbrüchen:

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

Obwohl ich sicher bin, dass dies auch kürzer sein kann, hoffe ich, dass wir gemeinsam eine kürzere Lösung finden werden;)

52 Bytes mit Hilfe von Raznagul gespeichert

Mathematica, 99 Bytes

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

für N = 50

Holzkohle , 23 22 20 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: 1 Byte durch Schleifen kvon 0bis i-1und Hinzufügen 1innerhalb der Schleife gespeichert . Weitere zwei Bytes wurden gespeichert, indem die Eingabe nicht in einer Variablen gespeichert wurde. Erläuterung:

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

Bearbeiten: Diese 18-Byte "Einzeiler" (Link ist eine ausführliche Version des Codes) hätte nicht mit der Version von Charcoal zusammengearbeitet, als die Frage gestellt wurde: Probieren Sie es online aus!

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

05AB1E , 12 Bytes

Code:

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

Erläuterung:

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

Verwendet die 05AB1E- Codierung. Probieren Sie es 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))

Probieren Sie es online!

Dies erzeugt (viele) vertikal führende Leerzeichen. Es werden insgesamt NZeilen gedruckt , von denen die meisten normalerweise leer sind.

Japt , 34 33 16 14 Bytes

17 Bytes dank @ETHproductions eingespart

õ@'#pXâ l÷z w

Probieren Sie es online!

J , 28 Bytes

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

Definiert ein monadisches Verb. Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Brachylog , 34 Bytes

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

Probieren Sie es online!

Alice , 33 Bytes

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

Probieren Sie es online!

Die Eingabe erfolgt (leider) in Form eines Codepunktes . Zumindest liest es ein UTF-8-Zeichen, so dass Sie größere Eingaben als 255 verwenden können, aber sie sind immer noch begrenzt und es ist ein ziemlich schmerzhaftes Eingabeformat. Für drei zusätzliche Bytes können wir eine Dezimalzahl lesen:

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

Probieren Sie es online!

Das Nicht-Leerzeichen in der Ausgabe ist !.

Beachten Sie, dass die Lösung auch eine Tonne führender Leerzeichen druckt (sie beginnt immer mit einer leeren Zeile und druckt dann ein NxNRaster, sodass bei größeren NZeilen viele Leerzeichen vor den ersten !s stehen.)

Erläuterung

Ich habe die &w...kKonstruktion schon einmal benutzt und erklärt (zum Beispiel hier ). Es ist eine nette kleine Redewendung, die eine ganze Zahl n auftaucht und dann n + 1 Mal einen Code ausführt (folglich wird sie normalerweise verwendet t&w...k, um eine Schleife n- mal auszuführen , wobei tder Eingabewert dekrementiert wird). Dies erfolgt durch Arbeiten mit dem Rücksendeadressenstapel (RAS). wSendet die aktuelle IP-Adresse an den RAS. Wenn wir sie wiederholen, &wird die Adresse n- mal gesendet . kRuft eine Adresse vom RAS ab und springt dorthin zurück. Wenn das RAS leer ist, tut es überhaupt nichts und die Schleife wird beendet.

Sie werden vielleicht bemerken, dass es nicht trivial möglich ist, diese Schleifen zu verschachteln, da der Stapel am Ende der inneren Schleife nicht leer ist und somit kkein No-Op wird. Stattdessen springt die IP zum Anfang der äußeren Schleife zurück. Die allgemeine Möglichkeit, dies zu beheben, besteht darin, die innere Schleife in eine eigene Unterroutine zu packen. Aber wenn wir die verschachtelte Schleife so anordnen können, dass die äußere Schleife mit der inneren Schleife endet , können wir dieses Verhalten tatsächlich nutzen und sogar eine speichern k!

Also diese Konstruktion:

&wX&wYk

Ist eine funktionierende verschachtelte Schleife, die die XYYYXYYYXYYY...(für eine bestimmte Anzahl von Ys in jeder Iteration) ausführt. Es ist ziemlich nett, dass wir beide Schleifen mit einer einzigen beenden können k, da sie jedes Mal eine äußere Adresse von RAS verbrauchen, wenn die inneren Adressen erschöpft sind.

Diese Redewendung wird im Programm verwendet, um die Schleife über das Ausgaberaster auszuführen.

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.

Eigentlich 25 Bytes

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

Probieren Sie es online!

22-Byte-Version mit vielen führenden Zeilenumbrüchen

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

Probieren Sie es online!

R 83 82 Bytes

-1 Byte dank MickyT

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

Liest Nvon 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

Probieren Sie es online!

Pyth , 16 Bytes

j_.tm*\#/%LdSQ0S

Probieren Sie es 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

Ein Array verfolgt die Anzahl der Teiler und druckt dann die richtige Anzahl von Zeichen bis zur Bildschirmposition 50.

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

druckt ein führendes Leerzeichen; Laufen Sie als Pipe mit php -nr '<code>'oder versuchen Sie es online .

Nervenzusammenbruch

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

Weniger Golf-Testskript:

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

Ausgabe:

True
True
True

SOGL V0.12 , 8 Bytes

∫Λ⁄╗*}⁰H

Probieren Sie es hier aus!

Wolfram Language (Mathematica) , 46 44 Bytes

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

Probieren Sie es online! Aber vielleicht online ausprobieren! mit ColumnForm anstelle von Grid , da Gridin TIO nicht funktioniert. In Mathematica sieht es besser aus:

Eine dritte Mathematica-Lösung ... Divisors@Range@#findet alle Teiler in dem Bereich, den wir wollen, und multipliziert 0und subtrahiert dann " "jeden Teiler gleich -" ".

PadLeftFügt links Nullen hinzu und erstellt eine seitliche Skyline, deren Ausrichtung wir mit = festlegen \[Transpose]. Wenn Sie schließlich " "zu allem hinzufügen , werden alle Einträge entweder 0oder erstellt " ".

Alternativ erzeugt das 59-Byte ""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&eine String-Ausgabe.

Add ++ , 58 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

$A = [d(1), d(2), d(3), ..., d(n)]$#$A$$\max(A)$$A$von diesem Maximum, bevor Sie diese Anzahl von Leerzeichen für jedes Element ergeben und die Leerzeichen zu den wiederholten Hashes verketten. Als nächstes transponieren und kehren wir die Zeilen um, bevor wir jede Zeile in Zeilenumbrüchen verbinden. Schließlich geben wir die Skyline aus.