Wir haben viele horizontale Achsen für Zahlen, aber ich denke ehrlich, dass sie irgendwie langweilig sind. Ihre Aufgabe heute ist es, einen Teil einer diagonalen Achse zwischen zwei verschiedenen nicht-negativen Ganzzahlen zu bilden, die als Eingabe angegeben werden.

Wie baue ich eine diagonale Achse?

• Nehmen wir ein Beispiel mit der Eingabe 0, 5. Unsere Achse sollte so aussehen:

  0
   1
    2
     3
      4
       5
  

• Unsere Achse sollte jedoch auch für Zahlen mit mehr Ziffern gut aussehen! Wenn die Eingabe beispielsweise lautet, 0, 14sollte die neue Achse wie folgt lauten:

  0
   1
    2
     3
      4
       5
        6
         7
          8
           9
            10
              11
                12
                  13
                    14
  

• Die Idee ist, dass die erste Ziffer der nächsten Ziffer auf der Achse immer genau nach der letzten Ziffer der vorherigen Ziffer platziert werden muss. Um die Idee noch besser zu verstehen, hier ein weiteres Beispiel mit 997, 1004:

  997
     998
        999
           1000
               1001
                   1002
                       1003
                           1004
  

Regeln

• Sie können davon ausgehen, dass die Eingabe in aufsteigender oder absteigender Reihenfolge erfolgt (Sie können zwischen 5,3und wählen 3,5).

• Sie können auch davon ausgehen, dass der Unterschied zwischen den beiden Ganzzahlen kleiner als 100 ist.

• Möglicherweise haben Sie in jeder Zeile einen führenden Zeilenumbruch oder ein konsistentes Leerzeichen. Nachgestellte Leerzeichen / Zeilenumbrüche sind ebenfalls in Ordnung.

• Standardlücken sind verboten.

• Sie können die Eingabe und Ausgabe mit jedem Standardmittelwert vornehmen .

• Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes in jeder Sprache!

Andere Testfälle

• 1, 10:

  1
   2
    3
     4
      5
       6
        7
         8
          9
           10
  

• 95, 103:

  95
    96
      97
        98
          99
            100
               101
                  102
                     103
  

• 999999, 1000009:

  999999
        1000000
               1000001
                      1000002
                             1000003
                                    1000004
                                           1000005
                                                  1000006
                                                         1000007
                                                                1000008
                                                                       1000009
  

05AB1E , 8 7 6 Bytes

Vielen Dank an Magic Octopus Urn für das Speichern eines Bytes!

Es funktioniert irgendwie, aber ehrlich gesagt habe ich keine Ahnung warum.

Code

Ÿvy.O=

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Erläuterung

Ÿ          # Create the range [a, .., b] from the input array
 vy        # For each element
   .O      #   Push the connected overlapped version of that string using the
                 previous version of that string. The previous version initially
                 is the input repeated again. Somehow, when the input array is
                 repeated again, this command sees it as 1 character, which gives
                 the leading space before each line outputted. After the first
                 iteration, it reuses on what is left on the stack from the
                 previous iteration and basically attaches (or overlaps) itself 
                 onto the previous string, whereas the previous string is replaced 
                 by spaces and merged into the initial string. The previous string
                 is then discarded. We do not have to worry about numbers overlapping 
                 other numbers, since the incremented version of a number never
                 overlaps entirely on the previous number. An example of 123 and 456:

                 123
                    456

                 Which leaves us "   456" on the stack.
     =     #   Print with a newline without popping

Python 2 , 43 Bytes

lambda a,b:'\v'.join(map(str,range(a,b+1)))

Verwendet die vertikale Registerkarte, um den Leiter-Effekt zu erzielen. Die Art und Weise, \vwie das gerendert wird, ist konsolenabhängig, daher funktioniert es möglicherweise nicht überall (wie bei TIO).

Kohle , 9 8 Bytes

Ｆ…·ＮＮ⁺¶ι

Probieren Sie es online!

Der Link verweist auf die ausführliche Version des Codes. Eingabe in aufsteigender Reihenfolge.

• Dank nur ASCII 1 Byte gespart!

R 70 69 61 Bytes

function(a,b)for(i in a:b){cat(rep('',F),i,'
');F=F+nchar(i)}

Funktion, die die Start- und Endvariable als Argumente verwendet. Durchläuft die Sequenz und druckt jedes Element, dem genügend Leerzeichen vorangestellt sind. FBeginnt mit FALSE=0und während jeder Iteration wird die Anzahl der Zeichen für diesen Wert hinzugefügt. Flegt die Anzahl der gedruckten Leerzeichen fest.

Probieren Sie es online!

-8 Bytes dank @ Giuseppe

C #, 90 89 85 Bytes

s=>e=>{var r="";for(int g=0;e>s;g+=(s+++"").Length)r+="".PadLeft(g)+s+"\n";return r;}

1 Byte dank @LiefdeWen gespeichert.
4 Bytes dank @auhmaan gespeichert.

Probieren Sie es online!

Voll / Formatierte Version:

namespace System
{
    class P
    {
        static void Main()
        {
            Func<int, Func<int, string>> f = s => e =>
            {
                var r = "";
                for (int g = 0; e > s; g += (s++ + "").Length)
                    r += "".PadLeft(g) + s + "\n";

                return r;
            };

            Console.WriteLine(f(0)(5));
            Console.WriteLine(f(0)(14));
            Console.WriteLine(f(997)(1004));
            Console.WriteLine(f(1)(10));
            Console.WriteLine(f(95)(103));
            Console.WriteLine(f(999999)(1000009));

            Console.ReadLine();
        }
    }
}

Python 2 , 58 54 Bytes

def f(a,b,s=''):print s;b<a or f(a+1,b,' '*len(s)+`a`)

Probieren Sie es online!

Mathematica, 59, Bytes

Grid[(DiagonalMatrix@Range[1+##]/. 0->""+1)-1,Spacings->0]&

Eingang

[10,15]

-3 Bytes @JungHwanMin
Problem mit 0 behoben (siehe Kommentare für Details)
Danke an @ngenisis

Gelee , 9 Bytes

rD⁶ṁ$;¥\Y

Probieren Sie es online!

Mathematica, 48 Bytes

Rotate[""<>Table[ToString@i<>" ",{i,##}],-Pi/4]&

Da es so viele Antworten gibt, dachte ich, dass diese enthalten sein sollte

Eingang

[0,10]

Ausgabe

C 166 134 95 82 Bytes

Neue Antwort

Nur als Funktion nicht als ganzes Programm.

f(a,b){int s=0,i;while(a<=b){i=s;while(i--)printf(" ");s+=printf("%i\n",a++)-1;}}

Vielen Dank an Falken, der geholfen hat, 13 Bytes zu beseitigen (und einen Fehler zu beheben)!

Danke an Steph Hen für die Hilfe, 12 Bytes wegzuschlagen!

Vielen Dank an Zacharý für die Hilfe!

Alte Antworten

Wurde das int vor main entfernt und const char * v [] in char ** v geändert und return 0 entfernt;

main(int c,char**v){int s=0;for(int a=atoi(v[1]);a<=atoi(v[2]);a++){for(int i=0;i<s;i++)printf(" ");printf("%i\n",a);s+=log10(a)+1;}}


int main(int c,const char*v[]){int s=0;for(int a=atoi(v[1]);a<=atoi(v[2]);a++){for(int i=0;i<s;i++)printf(" ");printf("%i\n",a);s+=log10(a)+1;}return 0;}

Dies ist mein erstes Mal beim Golfen und ich wollte etwas in C ausprobieren. Ich bin mir nicht sicher, ob ich das richtig formatiert habe, aber ich hatte Spaß daran!

int main(int c, const char * v[]) {
    int s = 0;
    for(int a=atoi(v[1]); a<=atoi(v[2]); a++) {
        for(int i=0; i<s; i++) printf(" ");
        printf("%i\n",a);
        s += log10(a)+1;
    }
    return 0;
}

Erläuterung

int s = 0; // Number of spaces for each line

for(int a=atoi(argv[1]); a<=atoi(argv[2]); a++) { // Loop thru numbers

for(int i=0; i<s; i++) printf(" "); // Add leading spaces

printf("%i\n",a); // Print number

s += log10(a)+1; // Update leading spaces

Verwendung

C ++, 167 165 Bytes

-2 Bytes dank Zacharý

#include<string>
#define S std::string
S d(int l,int h){S r;for(int m=0,i=l,j;i<=h;){for(j=0;j<m;++j)r+=32;S t=std::to_string(i++);r+=t;r+=10;m+=t.size();}return r;}

APL (Dyalog) , 25 24 Bytes

-1 danke an Zacharý .

Nimmt ⎕IO←0für nullbasiertes Zählen an. Nimmt die Untergrenze als linkes Argument und die Obergrenze als rechtes Argument.

{↑⍵↑⍨¨-+\≢¨⍵}(⍕¨⊣+∘⍳1--)

Probieren Sie es online!

(… ) Wende folgende implizite Funktion zwischen den Argumenten an:

 - subtrahieren Sie die obere untere von der oberen Grenze

 1- subtrahiere das von eins (dh 1 + ∆)

 ⊣+∘⍳ linke untere Grenze plus die ganzen Zahlen 0 durch

 ⍕¨ jedes formatieren (stringifizieren)

{… } Wenden Sie dazu anonym Folgendes an (dargestellt durch ⍵):

 ≢¨ Länge von jedem (Anzahl)

 +\ kumulative Summe

 - negieren

 ⍵↑⍨¨ Nimm für jede Zeichenfolge so viele Zeichen vom Ende (Pads mit Leerzeichen)

 ↑ Liste der Zeichenketten in eine Zeichenmatrix mischen

Netzhaut , 81 bis 78 Bytes

.+
$*
+`\b(1+)¶11\1
$1¶1$&
1+
$.& $.&
 (.+)
$.1$* 
+1`( *)(.+?)( +)¶
$1$2¶$1$3

Probieren Sie es online! Übernimmt die Eingabe als durch Zeilenumbrüche getrennte Liste mit zwei Ganzzahlen. Bearbeiten: 3 Bytes durch Stehlen des Bereichserweiterungscodes aus meiner Antwort auf "Teilen wir den primären Cluster?" Erläuterung:

.+
$*

Konvertieren Sie beide Eingänge in unary.

+`\b(1+)¶11\1
$1¶1$&

Während sich die letzten beiden Elemente (a, b) der Liste um mehr als 1 unterscheiden, ersetzen Sie sie durch (a, a + 1, b). Dies erweitert die Liste von einem Tupel in einen Bereich.

1+
$.& $.&

Zurück in doppeltes Dezimalformat konvertieren.

 (.+)
$.1$* 

Konvertieren Sie die Kopie in Leerzeichen.

+1`( *)(.+?)( +)¶
$1$2¶$1$3

Summieren Sie die Leerzeichen von einer Zeile zur nächsten.

Pyth , 14 13 Bytes

V}FQ
=k+*dlkN

Probieren Sie es online!

LOGO , 53 Bytes

[for[i ? ?2][repeat ycor[type "\ ]pr :i fd count :i]]

Es gibt kein "Online ausprobieren!" Link, da alle Online-LOGO-Interpreter keine Vorlagenliste unterstützen.

Das ist eine Template-Liste (entspricht der Lambda-Funktion in anderen Sprachen).

Verwendung:

apply [for[i ? ?2][repeat ycor[type "\ ]pr :i fd count :i]] [997 1004]

( applyruft die Funktion auf)

wird gedruckt

997
   998
      999
         1000
             1001
                 1002
                     1003
                         1004

Hinweis:

Dies verwendet Schildkröten ycor(Y-Koordinate), um die Anzahl der für die Eingabe erforderlichen Leerzeichen zu speichern.

• Die Schildkröte muss vor jedem Aufruf in ihrer Standardposition und Richtung (nach oben) nach Hause gebracht werden.
• windowsollte ausgeführt werden, wenn es ycorzu groß wird, dass sich die Schildkröte vom Bildschirm entfernt. Beschreibung des windowBefehls: Im if the turtle is asked to move past the boundary of the graphics window, it will move off screen.Gegensatz zur Standardeinstellung wrap, dieif the turtle is asked to move past the boundary of the FMSLogo screen window, it will "wrap around" and reappear at the opposite edge of the window.

Erläuterung:

for[i ? ?2]        Loop variable i in range [?, ?2], which is 2 input values
repeat ycor        That number of times
type "\            space character need to be escaped to be typed out.
pr :i              print the value of :i with a newline
fd count :i        increase turtle's y-coordinate by the length of the word :i. (Numbers in LOGO are stored as words)

05AB1E , 8 Bytes

Ÿʒ¾ú=þv¼

Probieren Sie es online!

-2 danke an Adnan .

JavaScript (ES8), 69 67 62 Byte

Übernimmt die Eingabe als Ganzzahl in aufsteigender Reihenfolge unter Verwendung der Curry-Syntax. Gibt ein Array von Zeichenfolgen zurück.

x=>y=>[...Array(++y-x)].map(_=>s="".padEnd(s.length)+x++,s="")

Versuch es

o.innerText=(f=

x=>y=>[...Array(++y-x)].map(_=>s="".padEnd(s.length)+x++,s="")

)(i.value=93)(j.value=105).join`\n`
oninput=_=>o.innerText=f(Math.min(i.value,j.value))(Math.max(i.value,j.value)).join`\n`

label,input{font-family:sans-serif}input{margin:0 5px 0 0;width:100px;}

<label for=i>x: </label><input id=i type=number><label for=j>y: </label><input id=j type=number><pre id=o>

Japt , 12 Bytes

òV
£¯Y ¬ç +X

Nimmt Eingaben in beliebiger Reihenfolge vor und gibt die Zahlen immer in aufsteigender Reihenfolge als Array von Zeilen zurück.

Probieren Sie es online! mit dem -RFlag, um das Array mit Zeilenumbrüchen zu verbinden.

Erläuterung

Implizite Eingabe von Uund V.

òV
£

Erstellen Sie einen Inklusivbereich [U, V]und ordnen Sie jeden Wert ...

¯Y ¬ç

Die Werte vor dem aktuellen ( ¯Y), verbunden mit einem String ( ¬) und gefüllt mit Leerzeichen ( ç).

+X

Plus die aktuelle Nummer. Das resultierende Array wird implizit ausgegeben.

Python 2 , 65 63 62 61 Bytes

-2 Bytes Dank an @Mr. Xcoder: execbraucht keine geschweiften Klammern

-1 Tschüss, danke an @ Zacharý: print s*' 'asprint' '*s

def f(m,n,s=0):exec(n-m+1)*"print' '*s+`m`;s+=len(`m`);m+=1;"

Probieren Sie es online!

JavaScript, 57 Bytes

f=(x,y,s='')=>y>=x?s+`
`+f(x+1,y,s.replace(/./g,' ')+x):s

Python 2, 60 59 Bytes

-1 Byte Danke an Mr.Xcoder für die Definition von s = 0 als optionale Variable in meiner Funktion.

def f(l,u,s=0):
 while l<=u:print' '*s+`l`;s+=len(`l`);l+=1

Probieren Sie es online!

Ich denke, es ist möglich, dies in eine Lambda-Version zu übertragen, aber ich weiß nicht wie. Ich denke auch, dass es eine Art Zuordnung zwischen den Leerzeichen und der Länge der aktuellen Nummer gibt, aber das habe ich auch noch nicht herausgefunden. Ich denke also, es gibt noch Raum für Verbesserungen.

Ich habe einen Bereich vom unteren lbis zum oberen Rand erstellt, in dem ujede Zeile mit einem Leerzeichen multipliziert mit einer Zahl gedruckt wird s. Ich erhöhe den Multiplikator mit der Länge der aktuellen Zahl.

Python 2, 78 77 79 Bytes

def f(a,b):
 for i in range(a,b+1):print sum(len(`j`)for j in range(i))*' '+`i`

Probieren Sie es online!

f(A, B) Gibt den Teil der Achse zwischen A und B einschließlich aus.

Zum ersten Mal beantworte ich eine Herausforderung!

Verwendet und missbraucht die Backticks von Python 2, um die Anzahl der Leerzeichen zu zählen, die vor der Zahl hinzugefügt werden müssen.

-1 Byte dank Mr.Xcoder

+2 weil ich a vergessen habe +1

C (GCC) , 41 38 Bytes

-3 Bytes Nur dank ASCII

t(x,v){while(x<=v)printf("%d\v",x++);}

Funktioniert mit RedHat6, Zugriff über PuTTY

Probieren Sie es online!

V , 16 Bytes

ÀñÙywÒ $pça/jd

Probieren Sie es online!

Das wäre viel einfacher, wenn ich es aushalten könnte, start end - startaber ich denke, das ändert die Herausforderung ein bisschen zu sehr.

Dabei wird die Startnummer als Eingabe in den Puffer und die Endnummer als Argument verwendet. Es erstellt tatsächlich die Leiter von startbis start + endund löscht dann alles nach der Endnummer.

MATL , 11 Bytes

vii&:"t~@Vh

Probieren Sie es online!

Erläuterung

Dazu wird für jede Zahl eine Zeichenfolge generiert und mit einer logisch negierten Kopie der vorherigen Zeichenfolge verknüpft. Daher wird char 0 so oft 0 vorangestellt wie die Länge der vorherigen Zeichenfolge. Zeichen 0 wird als Leerzeichen angezeigt, und jede Zeichenfolge wird in einer anderen Zeile angezeigt

v       % Concatenate stack (which is empty): pushes []
ii      % Input two numbers
&:      % Range between the two numbers
"       % For each
  t     %   Duplicate
  ~     %   Logical negation. This gives a vector of zeros
  @     %   Push current number
  V     %   Convert to string
  h     %   Concatenate with the vector of zeros, which gets automatically 
        %   converted into chars.
        % End (implicit). Display stack (implicit), each string on a diferent
        % line, char 0 shown as space

Swift 4 , 115 Bytes

Ich denke, niemand hätte sowieso eine Swift-Lösung gepostet ...

func f(l:Int,b:Int){for i in l...b{print(String(repeating:" ",count:(l..<i).map{String($0).count}.reduce(0,+)),i)}}

Probieren Sie es online!

Perl, 19 Bytes

Hinweis: \x0bWird als ein Byte gezählt.

Zusammen mit anderen habe ich gedacht, dass die Verwendung von Cursorbewegungen die kürzeste Route ist. Dies bedeutet, dass dies bei TIO nicht funktioniert:

print"$_\x0b"for<>..<>

Verwendung

perl -e 'print"$_\x0b"for<>..<>' <<< '5
10'
5
 6
  7
   8
    9
     10

Japt , 10 9 Bytes

òV åÈç +Y

Online testen! Gibt ein Array von Zeilen zurück. -RFahne eingeschlossen, um sich in Zeilenumbrüchen zur leichteren Anzeige zu verbinden.

Erläuterung

 òV åÈ   ç +Y
UòV åXY{Xç +Y}   Ungolfed
                 Implicit: U, V = inputs, P = empty string
UòV              Create the range [U, U+1, ..., V-1, V].
    åXY{     }   Cumulative reduce: Map each previous result X and current item Y to:
        Xç         Fill X with spaces.
           +Y      Append Y.
                 Implicit: output result of last expression

Alte Version, 10 Bytes:

òV £P=ç +X

Online testen!

 òV £  P= ç +X
UòV mX{P=Pç +X}  Ungolfed
                 Implicit: U, V = inputs, P = empty string
UòV              Create the range [U, U+1, ..., V-1, V].
    mX{       }  Map each item X to:
         Pç        Fill P with spaces.
            +X     Append X.
       P=          Re-set P to the result.
                   Implicitly return the same.
                 Implicit: output result of last expression

D, 133 127 126 125 121 119 Bytes

import std.conv,std.stdio;void f(T)(T a,T b,T s=0){for(T j;j++<s;)' '.write;a.writeln;if(a-b)f(a+1,b,s+a.text.length);}

Gelee und APL wurden genommen.

Probieren Sie es online!

Wenn Sie mit konsolenabhängigen Ergebnissen zufrieden sind (entspricht dem Prinzip der C-Antwort von Giacomos), finden Sie hier eine für 72 bis 71 Byte:

import std.stdio;void f(T)(T a,T b){while(a<=b){a++.write;'\v'.write;}}

Wie? (Nur D-spezifische Tricks)

• f(T)(T a,T b,T s=0) Das Vorlagensystem von D kann auf Typen schließen
• for(T j;j++<s;)Ganzzahlen standardmäßig auf 0.
• ' '.write;a.writelnD lässt dich anrufen fun(arg)wie arg.fun(eines der wenigen golferischen Dinge, die D hat)
• a.text.lengthDasselbe wie oben, und D ermöglicht es Ihnen auch, eine Methode ohne Parameter aufzurufen, als wäre es eine Eigenschaft ( textKonvertierung in einen String).
• Eine Sache, die relevant sein könnte (ich habe das aber nicht benutzt), sind Zeilenumbrüche in Strings!

Java 8, 79 Bytes

(a,b)->{for(String s="";a<=b;System.out.printf("%"+s.length()+"d\n",a++))s+=a;}

Probieren Sie es online!