Divisor-Skyline

46

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:

                                                                                                                                                                                   #                    
                                                                                                                                                                                   #                    
                                                                                                                       #                                               #           #                    
                                                                                                                       #                       #                       #           #                    
                                                                                                                       #                       #                       #           #           #        
                                                                                                                       #                       #                       #           #           #        
                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #
                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #
                                               #           #           #       #   #     #     #           #   #       #     #     #       #   #     #     #   # #     #       #   #           #     # #
                                   #           #           #           #       #   #     #     #   #       #   #       #     #     #       #   #     #     #   # #     #       #   #           #   # # #
                       #     #     #   # #     #     # #   #     #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #
                       #     #     #   # #     #     # #   #   # #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #
           #     # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # #   #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #
           #   # # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # ##  #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #
     # # # # ### # ### # ### # ##### ### # ### # ### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ####### ##### ### ##### # ######### # ##### ##### ### # ### ##### # ######### # ### # #
   # # ### # ### # ### ##### # ##### ### # ### ##### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ############# ### ##### # ######### # ##### ##### ### ##### ##### # ######### # ### # #
 #######################################################################################################################################################################################################
########################################################################################################################################################################################################
Luis Mendo
quelle

Antworten:

12

Gelee , 9 Bytes

Verwendet 0anstelle von #.

RÆD0ṁz⁶ṚY

Probieren Sie es online!

Undichte Nonne
quelle
2
5 Minuten und 10 Sekunden :-)
Luis Mendo
13
Ich habe in der Zwischenzeit andere Sachen gelesen ... Ich werde das nächste Mal schneller sein.
Undichte Nonne
7

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 .

2501
quelle
7

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


   #
 ####
#####
rahnema1
quelle
1
Sehr schöner Ansatz!
Luis Mendo
2
Octave führt implizit eine Singleton-Erweiterung durch, sodass @(N)" #"(sort(~mod(k=1:N,k')+1))Sie ein paar Bytes sparen :) Sie erhalten jedoch eine Reihe führender Zeilenumbrüche, ich bin mir nicht sicher, welche Regeln diesbezüglich gelten.
Stewie Griffin
1
Same bytecount (32): @(N)['',35*sort(~mod(k=1:N,k'))].
Stewie Griffin
@StewieGriffin Danke! Diese Funktion war mir nicht bekannt. Ist mod(1:N,(1:N).') in MATLAB akzeptabel?
Rahnema1
2
Ich denke, es ist ab R2016b möglich , aber ich kann es leider nicht selbst testen, da ich es nicht habe.
Stewie Griffin
6

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.
Ørjan Johansen
quelle
6

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 =
     #
   # #
 #####
######
Stewie Griffin
quelle
5

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

ovs
quelle
5

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

Adam
quelle
5

Mathematica, 59 57 Bytes

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

Bildbeschreibung hier eingeben

Ian Miller
quelle
Willkommen bei der Beantwortung auf PPCG, Lego-Minifigur :-)
Luis Mendo
1
Jetzt gibt es kein Zurück mehr ...
Luis Mendo
Herzlich willkommen! Schön, einen anderen Mathematica-Golfer zu sehen. Diese Antwort ist jedoch nicht vollständig gültig, da Sie die Eingabe in das Snippet fest codiert haben. Die Antworten müssen vollständige Programme oder aufrufbare Funktionen sein (die jedoch unbenannt sein können). Dies kann also kostenlos durch Ersetzen 50durch #und Anhängen behoben werden &. Sie können auch einige Bytes mit der Infixnotation speichern: X~Table~#&und0~DivisorSigma~Range@#
Martin Ender
@ MartinEnder Danke. Ich habe dieses bisschen vergessen, als ich vom Testen zum Antworten überging. Und danke für den Hinweis zum Anbringen. Es ist nichts, was ich normalerweise benutze (da ich nicht wirklich Golf spiele).
Ian Miller
Das habe ich mir gedacht. Es war eher eine freche Bemerkung. Entschuldigung für die Verwirrung.
Ian Miller
5

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

MetaColon
quelle
1
Wenn Sie ein Int-Array anstelle einer Liste verwenden, können Sie viele Bytes aus der using-Anweisung speichern.
Raznagul
@raznagul hat es aktualisiert.
MetaColon
222 Bytes: using System.Linq;using C=System.Console;n=>{var v=new int[n];for(var k=1,i;++k<=n;)for(i=1;i<k;)if(k%i++==0)v[k-1]++;for(var i=0,u;i<v.Length;i++)for(u=v.Max()-v[i];u<v.Max();){C.SetCursorPosition(i, u++);C.Write("#");}};Kompilieren Sie zu an Action, verschieben Sie die Inkremente und einige andere kleinere Änderungen. Ich habe das nicht getestet, aber es sollte funktionieren.
TheLethalCoder
@TheLethalCoder Ich werde es testen / meine Antwort morgen aktualisieren.
MetaColon
5

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

Bildbeschreibung hier eingeben

J42161217
quelle
Sind all diese Leerzeichen (und Zeilenumbrüche) erforderlich, damit der Code ausgeführt werden kann? Ich habe selbst nie Mathematica programmiert, aber in den meisten Sprachen konnte man fast alle diese Leerzeichen entfernen.
Kevin Cruijssen
Das ist mein erster Golf. danke für die
tipps
2
Kein Problem und willkommen bei PPCG! Wenn Sie es noch nicht getan haben, finden Sie unter Umständen Tipps zum Golfen in <allen Sprachen> und Tipps zum Golfen in Mathematica interessant zu lesen. :) Genieße deinen Aufenthalt.
Kevin Cruijssen
Die äußeren geschweiften Klammern können in runde Klammern geändert werden, um zu verhindern, dass sie in der Ausgabe (T=0~DivisorSigma~Range@#;Row[Column/@Table[Join[Table[,Max@T-T[[i]]],$~Table~T[[i]]],{i,1,#}]])&
angezeigt
5

Holzkohle , 23 22 20 Bytes

F…·¹N«Jι⁰Fι¿¬﹪ι⁺κ¹↑#

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:

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

↑E…·¹N⪫Eι⎇﹪ι⁺¹λω#ω
Neil
quelle
Bessere Erklärung : P
Nur ASCII
3

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!

Adnan
quelle
Kannst du nicht ζstatt verwenden .Bø? Auch der Charakter muss nicht sein#
Oliver Ni
ζgab es damals nicht.
Magic Octopus Urn
3

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.

mathmandan
quelle
3

Japt , 34 33 16 14 Bytes

17 Bytes dank @ETHproductions eingespart

õ@'#pXâ l÷z w

Probieren Sie es online!

Luke
quelle
Sie können eine Menge Bytes sparen, indem Sie nur zdas Auffüllen õ_â lã'#pX÷z w
vornehmen
Wusste nicht, dass die Saiten automatisch aufgefüllt werden. Vielen Dank!
Luke
2

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.
Zgarb
quelle
2

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!

Jörg Hülsermann
quelle
2

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.
Martin Ender
quelle
1
Erstes Alice-Programm mit einer einzigen Zeile? :-)
Luis Mendo
1
@ LuisMendo Nein, ich denke, Leo hat ein paar reine Kardinal-Programme geschrieben (und vielleicht auch ... das Quine und das Hello, World zum Beispiel). Wahrscheinlich das aufwendigste einzeilige Programm. :)
Martin Ender
Hmm, meine Lösung könnte einige Bytes mit dem Trick "Tonne führender Leerzeichen"
einsparen
2

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!

Undichte Nonne
quelle
Okay, die Readme-Datei auf dem Github sollte so aktualisiert werden, dass sie ÷ l als Standardfunktion für das Zählen von Divisoren enthält ...
quintopia
2

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!

Giuseppe
quelle
1
!=0kann sein>0
MickyT
1

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.

Bildbeschreibung hier eingeben

Brian
quelle
1

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
Titus
quelle
1

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
mazzy
quelle
1

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:

Mathematica-Ausgabe

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.

Mischa Lawrow
quelle
1

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

gkgx1nd(x)k

A=[d(1),d(2),d(3),...,d(n)]#Amax(A)Avon 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.

Caird Coinheringaahing
quelle