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 6
hat 4
Teilern (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 k
ist 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
:
#
#
# # #
# # # #
# # # # #
# # # # #
# # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # ## # # # # # # # # # ## # # # # # # # # # # # # # # # # # # ## # ## # #
# # # # # # # # # # # # # # # # # # # # # ## # # # # # # # # # ## # # # # # # # # # # # # # # # # # # ## # ## # #
# # # # # # # # # # ## # # # # # # ## # # # # ## # # # # # # # ### # ## # # # # ## # # # # # # ## # # # ## # ### # # # ## # ### ### # # # # ### # ## # #
# # # # # # # # # # # ## # # # # # # ## # # # # ## # ## # # # # # ### # ## # # # # ## # # # # # # ## # # # ## # ### # # # ## # ### ### # # # # ### # ## # #
# # # # ### # ### # ### # ##### ### # ### # ### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ####### ##### ### ##### # ######### # ##### ##### ### # ### ##### # ######### # ### # #
# # ### # ### # ### ##### # ##### ### # ### ##### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ############# ### ##### # ######### # ##### ##### ### ##### ##### # ######### # ### # #
#######################################################################################################################################################################################################
########################################################################################################################################################################################################
C
9995929190 BytesSehen Sie , wie es hier funktioniert .
quelle
Oktave,
414032 BytesDank @StewieGriffin 8 Bytes gespart.
Probieren Sie es online!
Bisherige Antworten:
Probieren Sie es online!
Probieren Sie es online!
Erläuterung:
quelle
@(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.@(N)['',35*sort(~mod(k=1:N,k'))]
.mod(1:N,(1:N).')
in MATLAB akzeptabel?Haskell , 71 Bytes
f
nimmt einInt
und gibt ein zurückString
.Probieren Sie es online!
m
ist dieN
des OP (Haskell-Variablen müssen in Kleinbuchstaben geschrieben werden.)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.n
ist Spalte (auch Nummer geprüft),i
ist Zeile.['#'|0<-mod n<$>l]
ist eine Liste von'#'
Zeichen mit der Länge der Anzahl der Teiler vonn
.quelle
Oktave, 61 Bytes
Erläuterung:
Ein paar Dinge, die ich hervorheben möchte
Was passiert in der Schleife (suppose Eingang
6
)1,2,4
)1,2,3,6
)Schließlich drehen wir es um und wandeln es in einen String um, indem wir implizit das
0
in32
:quelle
Python 3 , 111 Bytes
Probieren Sie es online!
Dies erzeugt einige führende vertikale Leerzeichen
quelle
APL (Dyalog) , 19 Bytes
Probieren Sie es online!
⎕
ausgewertete Eingabe erhalten ( N )⍳
1 ... N∘.|⍨
Aufteilung Resttabelle mit 1 ... N sowohl als vertikale als auch als horizontale Achse0=
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⊖
umdrehenquelle
Mathematica,
5957 Bytesquelle
50
durch#
und Anhängen behoben werden&
. Sie können auch einige Bytes mit der Infixnotation speichern:X~Table~#&
und0~DivisorSigma~Range@#
C #,
333281 BytesMit Zeilenumbrüchen:
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
quelle
using
-Anweisung speichern.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 anAction
, verschieben Sie die Inkremente und einige andere kleinere Änderungen. Ich habe das nicht getestet, aber es sollte funktionieren.Mathematica, 99 Bytes
für N = 50
quelle
(T=0~DivisorSigma~Range@#;Row[Column/@Table[Join[Table[,Max@T-T[[i]]],$~Table~T[[i]]],{i,1,#}]])&
Holzkohle ,
232220 BytesProbieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: 1 Byte durch Schleifen
k
von0
bisi-1
und Hinzufügen1
innerhalb der Schleife gespeichert . Weitere zwei Bytes wurden gespeichert, indem die Eingabe nicht in einer Variablen gespeichert wurde. Erläuterung: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!
quelle
05AB1E , 12 Bytes
Code:
Erläuterung:
Verwendet die 05AB1E- Codierung. Probieren Sie es online!
quelle
ζ
statt verwenden.Bø
? Auch der Charakter muss nicht sein#
ζ
gab es damals nicht.Python 2 , 101 Bytes
Probieren Sie es online!
Dies erzeugt (viele) vertikal führende Leerzeichen. Es werden insgesamt
N
Zeilen gedruckt , von denen die meisten normalerweise leer sind.quelle
Japt ,
34 33 1614 Bytes17 Bytes dank @ETHproductions eingespart
Probieren Sie es online!
quelle
z
das Auffüllenõ_â lã'#pX÷z w
J , 28 Bytes
Definiert ein monadisches Verb. Probieren Sie es online!
Erläuterung
quelle
PHP, 126 Bytes
Probieren Sie es online!
quelle
Brachylog , 34 Bytes
Probieren Sie es online!
quelle
Alice , 33 Bytes
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:
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
NxN
Raster, sodass bei größerenN
Zeilen viele Leerzeichen vor den ersten!
s stehen.)Erläuterung
Ich habe die
&w...k
Konstruktion 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 verwendett&w...k
, um eine Schleife n- mal auszuführen , wobeit
der Eingabewert dekrementiert wird). Dies erfolgt durch Arbeiten mit dem Rücksendeadressenstapel (RAS).w
Sendet die aktuelle IP-Adresse an den RAS. Wenn wir sie wiederholen,&
wird die Adresse n- mal gesendet .k
Ruft 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
k
kein 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 speichernk
!Also diese Konstruktion:
Ist eine funktionierende verschachtelte Schleife, die die
XYYYXYYYXYYY...
(für eine bestimmte Anzahl vonY
s in jeder Iteration) ausführt. Es ist ziemlich nett, dass wir beide Schleifen mit einer einzigen beenden könnenk
, 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.
quelle
Eigentlich 25 Bytes
Probieren Sie es online!
22-Byte-Version mit vielen führenden Zeilenumbrüchen
Probieren Sie es online!
quelle
R
8382 Bytes-1 Byte dank MickyT
Liest
N
von stdin.Probieren Sie es online!
quelle
!=0
kann sein>0
Pyth , 16 Bytes
Probieren Sie es online!
quelle
SpecBAS - 149 Bytes
Ein Array verfolgt die Anzahl der Teiler und druckt dann die richtige Anzahl von Zeichen bis zur Bildschirmposition 50.
quelle
PHP, 99 Bytes
druckt ein führendes Leerzeichen; Laufen Sie als Pipe mit
php -nr '<code>'
oder versuchen Sie es online .Nervenzusammenbruch
quelle
PowerShell, 101 Byte
Weniger Golf-Testskript:
Ausgabe:
quelle
SOGL V0.12 , 8 Bytes
Probieren Sie es hier aus!
quelle
Wolfram Language (Mathematica) ,
4644 BytesProbieren Sie es online! Aber vielleicht online ausprobieren! mit ColumnForm anstelle von Grid , da
Grid
in 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 multipliziert0
und subtrahiert dann" "
jeden Teiler gleich-" "
.PadLeft
Fü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 entweder0
oder erstellt" "
.Alternativ erzeugt das 59-Byte
""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&
eine String-Ausgabe.quelle
Add ++ , 58 Bytes
Probieren Sie es online!
Wie es funktioniert
g
k
g
k
#
quelle