Abbiamo molti assi orizzontali per i numeri, ma onestamente penso che siano noiosi. Il tuo compito oggi è di costruirmi una porzione di un asse diagonale tra due interi non negativi distinti dati come input.

Come costruire un asse diagonale?

• Facciamo un esempio, con l'input 0, 5. Il nostro asse dovrebbe assomigliare a questo:

  0
   1
    2
     3
      4
       5
  

• Tuttavia, il nostro asse dovrebbe avere un bell'aspetto anche per i numeri che hanno più cifre! Se l'input è, ad esempio 0, 14, il nuovo asse dovrebbe essere:

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

• L'idea è che la prima cifra del prossimo numero sull'asse deve essere sempre posizionata esattamente dopo l'ultima cifra del numero precedente. Per capire ancora meglio l'idea, ecco un altro esempio con 997, 1004:

  997
     998
        999
           1000
               1001
                   1002
                       1003
                           1004
  

Regole

• Puoi presumere che l'input sia in ordine crescente o decrescente (puoi scegliere tra 5,3e 3,5).

• Puoi anche supporre che la differenza tra i due numeri interi sia inferiore a 100.

• Potresti avere una nuova riga iniziale o uno spazio iniziale coerente (su ogni riga). Anche gli spazi finali / le nuove righe vanno bene.

• Le scappatoie predefinite sono vietate.

• Puoi prendere input e fornire output con qualsiasi media standard .

• Questo è code-golf , quindi vince il codice più breve in byte in ogni lingua!

Altri casi di test

• 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 byte

Grazie a Magic Octopus Urn per aver salvato un byte!

Funziona in qualche modo, ma onestamente non ho idea del perché.

Codice

Ÿvy.O=

Utilizza la codifica 05AB1E . Provalo online!

Spiegazione

Ÿ          # 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 byte

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

Utilizza la scheda verticale per rendere l'effetto scala. Il modo in cui \vviene eseguito il rendering dipende dalla console, quindi potrebbe non funzionare ovunque (come TIO).

Carbone , 9 8 byte

Ｆ…·ＮＮ⁺¶ι

Provalo online!

Il collegamento è alla versione dettagliata del codice. Inserire in ordine crescente.

• 1 byte salvato grazie solo a ASCII!

R, 70 69 61 byte

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

Funzione che accetta la variabile iniziale e finale come argomenti. Passa sopra la sequenza e stampa ogni elemento, anteposto con spazi sufficienti. Finizia come FALSE=0e durante ogni iterazione viene aggiunta la quantità di caratteri per quel valore. Fdecide la quantità di spazi stampati.

Provalo online!

-8 byte grazie a @Giuseppe

C #, 90 89 85 byte

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

Salvato 1 byte grazie a @LiefdeWen.
Salvato 4 byte grazie a @auhmaan.

Provalo online!

Versione completa / formattata:

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 byte

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

Provalo online!

Mathematica, 59, byte

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

ingresso

[10,15]

-3 byte
problema @JungHwanMin con 0 risolto (vedi commenti per dettagli)
grazie a @ngenisis

Gelatina , 9 byte

rD⁶ṁ$;¥\Y

Provalo online!

Mathematica, 48 byte

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

dato che ci sono così tante risposte, ho pensato che questo dovesse essere incluso

ingresso

[0,10]

produzione

C, 166 134 95 95 82 byte

Nuova risposta

Proprio come una funzione non come un intero programma.

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

Grazie a Falken per aver contribuito a eliminare 13 byte (e correggere un problema tecnico)!

Grazie a Steph Hen per aver contribuito a eliminare 12 byte!

Grazie a Zacharý per l'aiuto a eliminare 1 byte!

Risposte antiche

Si è sbarazzato di int prima di main e ha cambiato const char * v [] in char ** v e si è liberato di return 0;

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

Questa è la prima volta che gioco a golf e volevo provare qualcosa in C. Non sono sicuro di averlo formattato correttamente, ma mi sono divertito a farlo!

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

Spiegazione

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

uso

C ++, 167 165 byte

-2 byte grazie a 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 byte

-1 grazie a Zacharý .

Presuppone ⎕IO←0per il conteggio basato su zero. Prende il limite inferiore come argomento sinistro e il limite superiore come argomento destro.

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

Provalo online!

(... ) applica la seguente funzione tacita tra gli argomenti:

 - sottrarre la parte superiore inferiore dal limite superiore

 1- sottrai quello da uno (cioè 1 + ∆)

 ⊣+∘⍳ limite inferiore sinistro più gli interi da 0 a quello

 ⍕¨ formato (stringify) ciascuno

{... } applica il seguente anonimo (rappresentato da ⍵):

 ≢¨ lunghezza di ciascuno (numero)

 +\ somma cumulativa

 - negare

 ⍵↑⍨¨ per ogni numero limitato, prendi tanti caratteri dalla fine (pad con spazi)

 ↑ mescola l'elenco di stringhe in una matrice di caratteri

Retina , 81 78 byte

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

Provalo online! Prende l'input come un elenco separato da riga di due numeri interi. Modifica: salvato 3 byte rubando il codice di espansione dell'intervallo dalla mia risposta a Condividiamo il cluster principale? Spiegazione:

.+
$*

Converti entrambi gli input in unari.

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

Mentre gli ultimi due elementi (a, b) dell'elenco differiscono di oltre 1, sostituiscili con (a, a + 1, b). Questo espande l'elenco da una tupla in un intervallo.

1+
$.& $.&

Converti in decimale in duplicato.

 (.+)
$.1$* 

Converti la copia duplicata in spazi.

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

Sommare cumulativamente gli spazi da ciascuna riga alla successiva.

Pyth , 14 13 byte

V}FQ
=k+*dlkN

Provalo online!

LOGO , 53 byte

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

Non esiste "Provalo online!" collegamento perché tutto l'interprete LOGO online non supporta l'elenco dei modelli.

Questo è un elenco di modelli (equivalente della funzione lambda in altre lingue).

Uso:

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

( applychiama la funzione)

stamperà

997
   998
      999
         1000
             1001
                 1002
                     1003
                         1004

Nota:

Questo utilizza la tartaruga ycor(coordinata Y) per memorizzare il numero di spazi necessari per digitare, quindi:

• La tartaruga deve essere impostata su home nella sua posizione predefinita e andando (verso l'alto) prima di ogni invocazione.
• windowdovrebbe essere eseguito se ycordiventa troppo grande e la tartaruga si sposta dallo schermo. Descrizione del windowcomando if the turtle is asked to move past the boundary of the graphics window, it will move off screen.:, a differenza dell'impostazione predefinita wrap, cheif 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.

Spiegazione:

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 byte

Ÿʒ¾ú=þv¼

Provalo online!

-2 grazie ad Adnan .

JavaScript (ES8), 69 67 62 byte

Accetta input come numeri interi, in ordine crescente, utilizzando la sintassi del curry. Restituisce una matrice di stringhe.

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

Provalo

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 byte

òV
£¯Y ¬ç +X

Accetta input in entrambi gli ordini e restituisce sempre i numeri in ordine crescente, come una matrice di righe.

Provalo online! con la -Rbandiera per unire l'array con le nuove righe.

Spiegazione

Input implicito di Ue V.

òV
£

Crea un intervallo inclusivo [U, V]e associa ogni valore a ...

¯Y ¬ç

I valori prima di current ( ¯Y), uniti a una stringa ( ¬) e riempiti con spazi ( ç).

+X

Più il numero attuale. L'array risultante viene implicitamente emesso.

Python 2 , 65 63 62 61 byte

-2 byte Grazie a @Mr. Xcoder: execnon necessita di parentesi graffe

-1 ciao grazie a @ Zacharý: print s*' 'asprint' '*s

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

Provalo online!

JavaScript, 57 byte

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

Python 2, 60 59 byte

-1 byte grazie a Mr.Xcoder per aver definito my s = 0 come variabile opzionale nella mia funzione.

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

Provalo online!

Penso che sia possibile trasferirlo in una versione lambda, ma non so come. Penso anche che ci sia una sorta di mappatura tra gli spazi e la lunghezza del numero corrente, ma anche questo non l'ho ancora capito. Quindi penso che ci sia ancora spazio per miglioramenti.

Quello che ho fatto è stato creare un intervallo dal limite inferiore lal limite superiore ustampando ogni riga con uno spazio moltiplicato per un numero s. Sto aumentando il moltiplicatore con la lunghezza del numero corrente.

Python 2, 78 77 79 byte

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

Provalo online!

f(A, B) stamperà la parte dell'asse tra A e B incluse.

La prima volta che rispondo a una sfida!

Utilizza e abusa dei backtick di Python 2 per contare il numero di spazi che deve aggiungere prima del numero.

-1 byte grazie a Mr.Xcoder

+2 perché ho dimenticato a +1

C (gcc) , 41 38 byte

-3 byte Grazie solo a ASCII

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

Funziona su RedHat6, accessibile tramite PuTTY

Provalo online!

V , 16 byte

ÀñÙywÒ $pça/jd

Provalo online!

Sarebbe molto più semplice se potessi prenderlo start end - start ma penso che cambiando un po 'troppo la sfida.

Questo prende il numero iniziale come input nel buffer e il numero finale come argomento. In realtà crea la scala da starta start + ende quindi elimina tutto dopo il numero finale.

MATL , 11 byte

vii&:"t~@Vh

Provalo online!

Spiegazione

Funziona generando una stringa per ciascun numero e concatenandola con una copia negata logicamente della stringa precedente. Pertanto char 0 viene anteposto 0 tante volte quanto la lunghezza della stringa precedente. Il carattere 0 viene visualizzato come spazio e ogni stringa viene visualizzata su una riga diversa

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 byte

Penso che nessuno avrebbe pubblicato una soluzione Swift comunque ...

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

Provalo online!

Perl, 19 byte

Nota: \x0b viene conteggiato come un byte.

Insieme ad altri, ho pensato che usare i movimenti del cursore sarebbe il percorso più breve, questo significa che non funziona su TIO:

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

uso

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

Japt , 10 9 byte

òV åÈç +Y

Provalo online! Restituisce una matrice di linee;-Rflag incluso per unire le newline per una visualizzazione più semplice.

Spiegazione

 ò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

Vecchia versione, 10 byte:

òV £P=ç +X

Provalo online!

 ò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 byte

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

Furono prese Jelly e APL.

Provalo online!

Se stai bene con i risultati dipendenti dalla console (va fuori lo stesso principio della risposta C di Giacomos) eccone uno per 72 71 byte:

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

Come? (Solo trucchi specifici per D)

• f(T)(T a,T b,T s=0) Il sistema di template di D può inferire i tipi
• for(T j;j++<s;)I numeri interi sono impostati su 0.
• ' '.write;a.writelnD ti permette di chiamare fun(arg)come arg.fun(una delle poche cose da golf che D ha)
• a.text.lengthCome sopra e D consente anche di chiamare un metodo senza parametri come se fosse una proprietà ( textè la conversione in stringa)
• Una cosa che potrebbe essere rilevante (non l'ho usato però) le nuove righe possono essere nelle stringhe!

Java 8, 79 byte

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

Provalo online!