Temos muitos eixos horizontais para números, mas honestamente acho que eles são meio chatos. Sua tarefa hoje é construir uma parte de um eixo diagonal entre dois números inteiros não negativos distintos dados como entrada.

Como construir um eixo diagonal?

• Vamos dar um exemplo, com a entrada 0, 5. Nosso eixo deve ficar assim:

  0 0
   1
    2
     3
      4
       5
  

• No entanto, nosso eixo deve ter uma boa aparência para números que também têm mais dígitos! Se a entrada for, por exemplo 0, 14, o novo eixo deve ser:

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

• A idéia é que o primeiro dígito do próximo número no eixo sempre seja colocado exatamente após o último dígito do número anterior. Para entender a idéia ainda melhor, aqui está outro exemplo com 997, 1004:

  997
     998
        999
           1000
               1001
                   1002
                       1003
                           1004
  

Regras

• Você pode assumir que a entrada está em ordem crescente ou decrescente (você pode escolher entre 5,3e 3,5).

• Você também pode assumir que a diferença entre os dois números inteiros é menor que 100.

• Você pode ter uma nova linha principal ou um espaço principal consistente (em cada linha). Espaços à direita / novas linhas também são bons.

• As brechas padrão são proibidas.

• Você pode receber e fornecer saída por qualquer média padrão .

• Isso é código-golfe , então o código mais curto em bytes em todos os idiomas vence!

Outros casos de teste

• 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

Agradecemos ao Magic Octopus Urn por salvar um byte!

De alguma forma funciona, mas sinceramente não tenho idéia do porquê.

Código

Ÿvy.O=

Usa a codificação 05AB1E . Experimente online!

Explicação

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

Faz uso da guia vertical para fazer o efeito de escada. O modo como \vé renderizado depende do console, portanto, pode não funcionar em qualquer lugar (como o TIO).

Carvão , 9 8 bytes

Ｆ…·ＮＮ⁺¶ι

Experimente online!

O link é para a versão detalhada do código. Entrada em ordem crescente.

• 1 byte economizado graças ao ASCII-only!

R, 70 69 61 bytes

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

Função que usa a variável inicial e final como argumentos. Faz um loop na sequência e imprime cada elemento, anexado com espaços suficientes. Fcomeça como FALSE=0e durante cada iteração, a quantidade de caracteres para esse valor é adicionada a ele. Fdecide a quantidade de espaços impressos.

Experimente online!

-8 bytes graças a @ 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;}

Guardou 1 byte graças a @LiefdeWen.
Guardado 4 bytes graças a @auhmaan.

Experimente online!

Versão completa / formatada:

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

Experimente online!

Mathematica, 59, bytes

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

entrada

[10,15]

-3 bytes @JungHwanMin
problema com 0 corrigido (ver comentários para detalhes)
thanx para @ngenisis

Geléia , 9 bytes

rD⁶ṁ$;¥\Y

Experimente online!

Mathematica, 48 bytes

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

como existem tantas respostas, achei que essa deveria ser incluída

entrada

[0,10]

saída

C, 166 134 95 82 bytes

Nova resposta

Apenas como uma função, não como um programa completo.

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

Agradecemos a Falken por ajudar a eliminar 13 bytes (e corrigir uma falha)!

Agradecimentos a Steph Hen por ajudar a derrubar 12 bytes!

Agradecimentos a Zacharý pela ajuda, derrubando 1 byte!

Respostas antigas

Se livrou do int antes de main e alterou const char * v [] para char ** v e se livrou do retorno 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;}

Esta é minha primeira vez jogando golfe e eu queria tentar algo em C. Não tenho certeza se formatei isso corretamente, mas me diverti fazendo isso!

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

Explicação

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 bytes

-2 bytes graças 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 bytes

-1 graças a Zacharý .

Assume ⎕IO←0a contagem baseada em zero. Pega o limite inferior como argumento à esquerda e o limite superior como argumento à direita.

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

Experimente online!

(… ) Aplique a seguinte função tácita entre os argumentos:

 - subtrair a parte superior inferior do limite superior

 1- subtraia isso de um (ou seja, 1 + ∆)

 ⊣+∘⍳ limite inferior esquerdo mais os inteiros 0 através desse

 ⍕¨ formato (stringify) cada

{… } Aplique o seguinte anônimo nisso (representado por ⍵):

 ≢¨ comprimento de cada (número)

 +\ soma acumulada

 - negar

 ⍵↑⍨¨ para cada número estrito, pegue o número de caracteres do final (almofadas com espaços)

 ↑ misturar lista de strings em matriz de caracteres

Retina , 81 78 bytes

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

Experimente online! Recebe a entrada como uma lista separada por nova linha de dois números inteiros. Edit: Salvo 3 bytes, roubando o código de expansão da minha resposta para Nós compartilhamos o cluster principal? Explicação:

.+
$*

Converta ambas as entradas para unárias.

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

Enquanto os dois últimos elementos (a, b) da lista diferem em mais de 1, substitua-os por (a, a + 1, b). Isso expande a lista de uma tupla para um intervalo.

1+
$.& $.&

Converta de volta para decimal em duplicado.

 (.+)
$.1$* 

Converta a cópia duplicada em espaços.

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

Soma cumulativamente os espaços de cada linha para a próxima.

Pyth , 14 13 bytes

V}FQ
=k+*dlkN

Experimente online!

LOGO , 53 bytes

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

Não há "Experimente online!" link porque todos os intérpretes on-line do LOGO não oferecem suporte à lista de modelos.

Essa é uma lista de modelos (equivalente à função lambda em outros idiomas).

Uso:

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

(apply chama a função)

vai imprimir

997
   998
      999
         1000
             1001
                 1002
                     1003
                         1004

Nota:

Isso usa tartarugas ycor(coordenada Y) para armazenar o número de espaços necessários para digitar, portanto:

• A tartaruga precisa ser ajustada para casa em sua posição padrão e em direção (para cima) antes de cada invocação.
• windowdeve ser executado se ycorfor muito grande que a tartaruga se mova para fora da tela. Descrição do windowcomando if the turtle is asked to move past the boundary of the graphics window, it will move off screen.:, diferente da configuração padrão wrap, queif 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.

Explicação:

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¼

Experimente online!

-2 graças a Adnan .

JavaScript (ES8), 69 67 62 bytes

Recebe a entrada como números inteiros, em ordem crescente, usando a sintaxe de currying. Retorna uma matriz de seqüências de caracteres.

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

Tente

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>

Japonês , 12 bytes

òV
£¯Y ¬ç +X

Recebe entrada em qualquer ordem e sempre retorna os números em ordem crescente, como uma matriz de linhas.

Experimente online! com o-R sinalizador para ingressar na matriz com novas linhas.

Explicação

Entrada implícita de Ue V.

òV
£

Crie um intervalo inclusivo [U, V]e mapeie cada valor para ...

¯Y ¬ç

Os valores anteriores ao current ( ¯Y), unidos a uma string ( ¬) e preenchidos com espaços ( ç).

+X

Mais o número atual. A matriz resultante é gerada implicitamente.

Python 2 , 65 63 62 61 bytes

-2 bytes Graças a @Mr. Xcoder: execnão precisa de aparelho

-1 tchau graças a @ Zacharý: print s*' 'asprint' '*s

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

Experimente 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 graças a Mr.Xcoder por definir meu s = 0 como uma variável opcional em minha função.

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

Experimente online!

Eu acho que é possível transferir isso para uma versão lambda, mas não sei como. Eu também acho que existe algum tipo de mapeamento entre os espaços e o comprimento do número atual, mas isso eu ainda não descobri. Então, acho que ainda há espaço para melhorias.

O que fiz foi criar um intervalo entre o limite linferior ue o limite superior, imprimindo cada linha com um espaço multiplicado por um número s. Estou aumentando o multiplicador com o comprimento do número atual.

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`

Experimente online!

f(A, B) imprimirá a parte do eixo entre A e B inclusive.

Primeira vez que respondo a um desafio!

Usa e abusa dos backticks do Python 2 para contar o número de espaços que ele precisa adicionar antes do número.

-1 byte graças a Mr.Xcoder

+2 porque esqueci um +1

C (gcc) , 41 38 bytes

-3 bytes Graças a apenas ASCII

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

Funciona no RedHat6, acessado via PuTTY

Experimente online!

V , 16 bytes

ÀñÙywÒ $pça/jd

Experimente online!

Isso seria muito mais fácil se eu pudesse start end - start mas acho que isso está mudando um pouco demais o desafio.

Isso leva o número inicial como entrada no buffer e o número final como argumento. Ele realmente cria a escada startpara start + ende, em seguida, apaga tudo depois que o número final.

MATL , 11 bytes

vii&:"t~@Vh

Experimente online!

Explicação

Isso funciona gerando uma sequência para cada número e concatenando-a com uma cópia logicamente negada da sequência anterior. Portanto, char 0 é precedido de 0 tantas vezes quanto o comprimento da string anterior. O caractere 0 é exibido como um espaço e cada sequência é exibida em uma linha diferente

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

Eu acho que ninguém teria postado uma solução Swift de qualquer maneira ...

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

Experimente online!

Perl, 19 bytes

Nota: \x0bé contado como um byte.

Juntamente com outros, pensei que o uso de movimentos do cursor seria a rota mais curta, isso significa que não funciona no TIO:

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

Uso

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

Japonês , 10 9 bytes

òV åÈç +Y

Teste online! Retorna uma matriz de linhas; -Rsinalizador incluído para participar de novas linhas para facilitar a visualização.

Explicação

 ò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

Versão antiga, 10 bytes:

òV £P=ç +X

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

Gelatina e APL foram tomados.

Experimente online!

Se você está bem com os resultados dependentes do console (segue o mesmo princípio da resposta C de Giacomos), aqui está um para 72 71 bytes:

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

Quão? (Apenas D truques específicos)

• f(T)(T a,T b,T s=0) O sistema de modelos de D pode inferir tipos
• for(T j;j++<s;)Os números inteiros são padrão para 0.
• ' '.write;a.writelnD permite que você ligue fun(arg)como arg.fun(uma das poucas coisas que D tem no golfe)
• a.text.lengthO mesmo que acima, e D também permite chamar um método sem parâmetros, como se fosse uma propriedade ( texté a conversão para string)
• Uma coisa que pode ser relevante (embora eu não usei isso) é que as novas linhas podem estar em strings!

Java 8, 79 bytes

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

Experimente online!