Tenemos muchos ejes horizontales para los números, pero sinceramente creo que son un poco aburridos. Su tarea hoy es construirme una porción de un eje diagonal entre dos enteros distintos no negativos dados como entrada.

¿Cómo construir un eje diagonal?

• Tomemos un ejemplo, con la entrada 0, 5. Nuestro eje debería verse así:

  0 0
   1
    2
     3
      4 4
       5 5
  

• Sin embargo, nuestro eje debería verse bien para los números que también tienen más dígitos. Si la entrada es, por ejemplo 0, 14, el nuevo eje debe ser:

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

• La idea es que el primer dígito del siguiente número en el eje siempre debe colocarse exactamente después del último dígito del número anterior. Para comprender la idea aún mejor, aquí hay otro ejemplo con 997, 1004:

  997
     998
        999
           1000
               1001
                   1002
                       1003
                           1004
  

Reglas

• Puede suponer que la entrada está en orden ascendente o descendente (puede elegir entre 5,3y 3,5).

• También puede suponer que la diferencia entre los dos enteros es inferior a 100.

• Es posible que tenga una nueva línea inicial o un espacio inicial consistente (en cada línea). Los espacios finales / líneas nuevas también están bien.

• Las lagunas predeterminadas están prohibidas.

• Puede tomar entrada y proporcionar salida por cualquier medio estándar .

• Este es el código de golf , por lo que gana el código más corto en bytes en cada idioma.

Otros casos de prueba

• 1, 10:

  1
   2
    3
     4 4
      5 5
       6 6
        7 7
         8
          9 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

¡Gracias a Magic Octopus Urn por guardar un byte!

De alguna manera funciona, pero sinceramente no tengo idea de por qué.

Código

Ÿvy.O=

Utiliza la codificación 05AB1E . Pruébalo en línea!

Explicación

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

Utiliza la pestaña vertical para hacer el efecto de escalera. La forma en que \vse representa depende de la consola, por lo que puede no funcionar en todas partes (como TIO).

Carbón , 9 8 bytes

Ｆ…·ＮＮ⁺¶ι

Pruébalo en línea!

El enlace es a la versión detallada del código. Entrada en orden ascendente.

• ¡1 byte guardado gracias a ASCII-only!

R, 70 69 61 bytes

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

Función que toma la variable inicial y final como argumentos. Recorre la secuencia e imprime cada elemento, antepuesto con suficientes espacios. Fcomienza como FALSE=0, y durante cada iteración, se le agrega la cantidad de caracteres para ese valor. Fdecide la cantidad de espacios impresos.

Pruébalo en línea!

-8 bytes gracias 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;}

Guardado 1 byte gracias a @LiefdeWen.
Guardado 4 bytes gracias a @auhmaan.

Pruébalo en línea!

Versión completa / formateada:

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

Pruébalo en línea!

Mathematica, 59, bytes

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

entrada

[10,15]

-3 bytes @JungHwanMin
problema con 0 solucionado (ver comentarios para más detalles)
gracias a @ngenisis

Jalea , 9 bytes

rD⁶ṁ$;¥\Y

Pruébalo en línea!

Mathematica, 48 bytes

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

Como hay tantas respuestas, pensé que esta debería incluirse

entrada

[0,10]

salida

C, 166 134 95 82 Bytes

Nueva respuesta

Solo como una función, no como un programa completo.

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

¡Gracias a Falken por ayudar a eliminar 13 Bytes (y arreglar un problema técnico)!

¡Gracias a Steph Hen por ayudar a eliminar 12 Bytes!

¡Gracias a Zacharý por su ayuda para eliminar 1 Byte!

Viejas respuestas

Se deshizo de int antes de main y cambió const char * v [] a char ** v y se deshizo de 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;}

Esta es mi primera vez jugando al golf y quería probar algo en C. No estoy seguro si formateé esto correctamente, ¡pero me divertí mucho haciéndolo!

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

Explicación

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 gracias 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 gracias a Zacharý .

Asume ⎕IO←0para el conteo basado en cero. Toma el límite inferior como argumento izquierdo y el límite superior como argumento derecho.

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

Pruébalo en línea!

(... ) aplique la siguiente función tácita entre los argumentos:

 - restar el límite superior inferior del límite superior

 1- restar eso de uno (es decir, 1 + ∆)

 ⊣+∘⍳ límite inferior izquierdo más los enteros 0 a través de ese

 ⍕¨ formatear (stringify) cada

{... } aplique lo siguiente anónimo en eso (representado por ⍵):

 ≢¨ longitud de cada (número)

 +\ suma acumulativa

 - negar

 ⍵↑⍨¨ para cada número en cadena, tome esa cantidad de caracteres del final (almohadillas con espacios)

 ↑ mezclar la lista de cadenas en la matriz de caracteres

Retina , 81 78 bytes

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

Pruébalo en línea! Toma la entrada como una lista separada por nueva línea de dos enteros. Editar: ahorré 3 bytes al robar el código de expansión de rango de mi respuesta a ¿Compartimos el clúster principal? Explicación:

.+
$*

Convierta ambas entradas a unario.

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

Mientras que los dos últimos elementos (a, b) de la lista difieren en más de 1, reemplácelos con (a, a + 1, b). Esto expande la lista de una tupla a un rango.

1+
$.& $.&

Convertir de nuevo a decimal por duplicado.

 (.+)
$.1$* 

Convierta la copia duplicada en espacios.

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

Suma acumulativamente los espacios de cada línea a la siguiente.

Pyth , 14 13 bytes

V}FQ
=k+*dlkN

Pruébalo en línea!

LOGOTIPO , 53 bytes

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

No hay "¡Pruébelo en línea!" enlace porque todos los intérpretes de LOGO en línea no admiten la lista de plantillas.

Esa es una lista de plantillas (equivalente a la función lambda en otros idiomas).

Uso:

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

( applyllama a la función)

imprimirá

997
   998
      999
         1000
             1001
                 1002
                     1003
                         1004

Nota:

Esto usa la tortuga ycor(coordenada Y) para almacenar la cantidad de espacios necesarios para escribir, por lo tanto:

• La tortuga debe establecerse en el hogar en su posición y rumbo predeterminados (hacia arriba) antes de cada invocación.
• windowdebe ejecutarse si ycores demasiado grande para que la tortuga se salga de la pantalla. Descripción del windowcomando: a if the turtle is asked to move past the boundary of the graphics window, it will move off screen.diferencia de la configuración predeterminada 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.

Explicación:

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¼

Pruébalo en línea!

-2 gracias a Adnan .

JavaScript (ES8), 69 67 62 bytes

Toma la entrada como enteros, en orden ascendente, utilizando la sintaxis de curry. Devuelve una matriz de cadenas.

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

Intentalo

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

Toma la entrada en cualquier orden y siempre devuelve los números en orden ascendente, como una matriz de líneas.

Pruébalo en línea! con la -Rbandera para unir la matriz con nuevas líneas.

Explicación

Entrada implícita de Uy V.

òV
£

Cree un rango inclusivo [U, V]y asigne cada valor a ...

¯Y ¬ç

Los valores anteriores al actual ( ¯Y), unidos a una cadena ( ¬) y rellenados con espacios ( ç).

+X

Más el número actual. La matriz resultante se emite implícitamente.

Python 2 , 65 63 62 61 bytes

-2 bytes Gracias a @Mr. Xcoder:exec no necesita llaves

-1 adiós gracias a @ Zacharý: print s*' 'asprint' '*s

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

Pruébalo en línea!

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 gracias a Mr.Xcoder por definir mi s = 0 como una variable opcional en mi función.

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

Pruébalo en línea!

Creo que es posible transferir esto a una versión lambda, pero no sé cómo. También creo que hay algún tipo de mapeo entre los espacios y la longitud del número actual, pero esto aún no lo descubrí. Así que creo que todavía hay margen de mejora.

Lo que hice fue crear un rango desde el límite inferior lal límite superior uimprimiendo cada línea con un espacio multiplicado por un número s. Estoy aumentando el multiplicador con la longitud del número actual.

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`

Pruébalo en línea!

f(A, B) imprimirá la porción del eje entre A y B inclusive.

¡La primera vez que contesto un desafío!

Utiliza y abusa de los backticks de Python 2 para contar el número de espacios que debe agregar antes del número.

-1 byte gracias a Mr.Xcoder

+2 porque olvidé un +1

C (gcc) , 41 38 bytes

-3 bytes Gracias solo a ASCII

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

Funciona en RedHat6, accesible a través de PuTTY

Pruébalo en línea!

V , 16 bytes

ÀñÙywÒ $pça/jd

Pruébalo en línea!

Sería mucho más fácil si pudiera aceptarlo, start end - startpero creo que eso está cambiando demasiado el desafío.

Esto toma el número inicial como entrada en el búfer y el número final como argumento. Realmente crea la escalera de starta start + endy luego elimina todo después del número final.

MATL , 11 bytes

vii&:"t~@Vh

Pruébalo en línea!

Explicación

Esto funciona generando una cadena para cada número y concatenando con una copia negada lógicamente de la cadena anterior. Por lo tanto, char 0 se antepone 0 tantas veces como la longitud de la cadena anterior. Char 0 se muestra como un espacio, y cada cadena se muestra en una línea 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

Creo que nadie habría publicado una solución Swift de todos modos ...

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

Pruébalo en línea!

Perl, 19 bytes

Nota: \x0bse cuenta como un byte.

Junto con otros, pensé que usar los movimientos del cursor sería la ruta más corta, esto significa que no funciona en TIO:

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

Uso

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

Japt , 10 9 bytes

òV åÈç +Y

¡Pruébelo en línea! Devuelve una matriz de líneas; -Rbandera incluida para unirse en nuevas líneas para facilitar la visualización.

Explicación

 ò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

Versión anterior, 10 bytes:

òV £P=ç +X

¡Pruébelo en línea!

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

Se tomaron gelatina y APL.

Pruébalo en línea!

Si está bien con los resultados dependientes de la consola (se sale del mismo principio que la respuesta C de Giacomos) aquí hay uno para 72 71 bytes:

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

¿Cómo? (Solo trucos específicos D)

• f(T)(T a,T b,T s=0) El sistema de plantillas de D puede inferir tipos
• for(T j;j++<s;)Los enteros por defecto son 0.
• ' '.write;a.writelnD te permite llamar fun(arg)como arg.fun(una de las pocas cosas de golf que D tiene)
• a.text.lengthIgual que el anterior, y D también le permite llamar a un método sin parámetros como si fuera una propiedad ( textes la conversión a cadena)
• Una cosa que podría ser relevante (aunque no usé esto) ¡las nuevas líneas pueden estar en cadenas!

Java 8, 79 bytes

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

Pruébalo en línea!