[Question]
  [
We have lots of horizontal axis for numbers, but I honestly think they're kind of boring. Your task today is to build me a portion of a diagonal axis between two distinct non-negative integers given as input.
## How to build a diagonal axis?
* Let's take an example, with the input `0, 5`. Our axis should look like this:
```
0
 1
  2
   3
    4
     5
```
* However, our axis should look nice for numbers that have more digits too! If the input is, for instance `0, 14`, the new axis should be:
```
0
 1
  2
   3
    4
     5
      6
       7
        8
         9
          10
            11
              12
                13
                  14
```
* The idea is that the first digit of next number on the axis must always be placed exactly after the last digit of the previous number. To understand the idea even better, here is another example with `997, 1004`:
```
997
   998
      999
         1000
             1001
                 1002
                     1003
                         1004
```
---
## Rules
* You may assume that input is in ascending or descending order (you may choose between `5,3` and `3,5`).
* You may also assume that the difference between the two integers is lower than 100.
* You may have a leading newline or a consistent leading space (on each line). Trailing spaces / newlines are fine as well.
* [Default Loopholes are forbidden.](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default)
* You can take input and provide output by [any standard mean](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods).
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes in every language wins!
---
## Other Test Cases
* `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
```
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~8~~ ~~7~~ 6 bytes
Thanks to *Magic Octopus Urn* for saving a byte!
It somehow works, but honestly I have no idea why.
### Code
```
Ÿvy.O=
```
Uses the **05AB1E** encoding. [Try it online!](https://tio.run/##MzBNTDJM/f//6I6ySj1/2///oy1NdRQMDUxjAQ "05AB1E – Try It Online")
### Explanation
```
Ÿ          # 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
```
[Answer]
# [Python 2](https://docs.python.org/2/), 43 bytes
```
lambda a,b:'\v'.join(map(str,range(a,b+1)))
```
Makes use of vertical tab to make the ladder effect. The way thet `\v` is rendered is console dependent, so it may not work everywhere (like TIO).  
[![running code](https://i.stack.imgur.com/yThNu.png)](https://i.stack.imgur.com/yThNu.png)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 9 8 bytes
```
Ｆ…·ＮＮ⁺¶ι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8tv0hBwzMvOae0OLMsNSgxLz0VyC0oLfErzU1KLdLQ1FFA4WpqcikoBBRl5pVoOKakaCjF5CnpZGpqWv//b6BgaPJft@y/bnEOAA "Charcoal – Try It Online")
Link is to the verbose version of the code. Input in ascending order.
* 1 byte saved thanks to ASCII-only!
[Answer]
# R, ~~70~~ ~~69~~ 61 bytes
```
function(a,b)for(i in a:b){cat(rep('',F),i,'
');F=F+nchar(i)}
```
Function that takes the start and end variable as arguments. Loops over the sequence, and prints each element, prepended with enough spaces. `F` starts as `FALSE=0`, and during each iteration, the amount of characters for that value is added to it. `F` decides the amount of spaces printed.
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP08jUSdJMy2/SCNTITNPIdEqSbM6ObFEoyi1QENdXSdEUydTR51LXdM6xDZEOy85IxGoULP2f5qGoY6CkYHmfwA "R – Try It Online")
-8 bytes thanks to @Giuseppe
[Answer]
# 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;}
```
*Saved 1 byte thanks to @LiefdeWen.*  
*Saved 4 bytes thanks to @auhmaan.*
[Try it online!](https://tio.run/##jZCxasMwEIZ3P4XQJKHGOLShGFVeCp1cCO3QpYtwzq4gPhWdEijBz@5KCbQpdPA3iEP6/uNHHa1Gj35GOwJ92g7Y6xdFGItTwRLd3hKx7Xm@3GQo2ug6dvRux56tQyF/nn6lzNMBuweH8eZqohgcDk3DemZmMg2Y5nS0gQXDue59EMlig6k0NKQHZQQppTiXZQs4xA8ZVBLLrd210EcxSEWKvyPXAeIhIAt6mnXxp8WjR/J7KN@Ci9A6BNGLSoqNlHqJt75bItb1fVKrapG8zuqirZts3i4rkDl3SNQ58m/mBdLX5cjVzqm4nNP8DQ "C# (Mono) – Try It Online")
Full/Formatted 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();
        }
    }
}
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~58~~ 54 bytes
```
def f(a,b,s=''):print s;b<a or f(a+1,b,' '*len(s)+`a`)
```
[Try it online!](https://tio.run/##K6gsycjPM/r/PyU1TSFNI1EnSafYVl1d06qgKDOvRKHYOskmUSG/CCSlbQiUVFdQ18pJzdMo1tROSEzQ/J@mYaBjZKD5HwA "Python 2 – Try It Online")
[Answer]
# Mathematica, 59, bytes
```
Grid[(DiagonalMatrix@Range[1+##]/. 0->""+1)-1,Spacings->0]&
```
**input**
> 
> [10,15]
> 
> 
> 
-3 bytes @JungHwanMin  
problem with 0 fixed (see comments for details)  
thanx to @ngenisis
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
rD⁶ṁ$;¥\Y
```
[Try it online!](https://tio.run/##y0rNyan8/7/I5VHjtoc7G1WsDy2Nifz//78lGPw3NAABSwA "Jelly – Try It Online")
[Answer]
# Mathematica, 48 bytes
```
Rotate[""<>Table[ToString@i<>" ",{i,##}],-Pi/4]&
```
since there are so many answers, I thought this one should be included
**input**
> 
> [0,10]
> 
> 
> 
**output**  
[![enter image description here](https://i.stack.imgur.com/fm0VB.jpg)](https://i.stack.imgur.com/fm0VB.jpg)
[Answer]
# C, ~~166~~ ~~134~~ ~~95~~ 82 Bytes
## New Answer
Just as a function not as a whole program.
```
f(a,b){int s=0,i;while(a<=b){i=s;while(i--)printf(" ");s+=printf("%i\n",a++)-1;}}
```
Thanks to Falken for helping knock off 13 Bytes (and fix a glitch)!
Thanks to Steph Hen for helping knock off 12 Bytes!
Thanks to Zacharý for help knock off 1 Byte!
## Old Answers
Got rid of the int before main and changed const char\*v[] to char\*\*v and got rid of 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;}
```
This is my first time golfing and I wanted to try something in C. Not sure if I formatted this correctly, but I had fun making it!
```
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;
}
```
**Explanation**
```
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
```
**Usage**
[![enter image description here](https://i.stack.imgur.com/k53tC.png)](https://i.stack.imgur.com/k53tC.png)
[Answer]
## C++, ~~167~~ 165 bytes
-2 bytes thanks to 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;}
```
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~25~~ 24 bytes
-1 thanks to [Zacharý](https://codegolf.stackexchange.com/users/55550/zachar%c3%bd).
Assumes `⎕IO←0` for zero based counting. Takes the lower bound as left argument and the upper bound as right argument.
```
{↑⍵↑⍨¨-+\≢¨⍵}(⍕¨⊣+∘⍳1--)
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/0vygVT1o7aJj3q3gskVh1boasc86lx0aAVQqFbjUe9UIKtrsfajjhmPejcb6upq/v9voFCSr2BowmVpaQ5mGRiYcBlCWFyWphCGMVAWBKAKgMASAA "APL (Dyalog Unicode) – Try It Online")
`(`…`)` apply the following tacit function between the arguments:
 `-` subtract the upper lower from the upper bound
 `1-` subtract that from one (i.e. 1 + ∆)
 `⊣+∘⍳` left lower bound plus the integers 0 through that
 `⍕¨` format (stringify) each
`{`…`}` apply the following anonymous on that (represented by ⍵):
 `≢¨` length of each (number)
 `+\` cumulative sum
 `-` negate
 `⍵↑⍨¨` for each stringified number, take that many characters from the end (pads with spaces)
 `↑` mix list of strings into character matrix
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~81~~ 78 bytes
```
.+
$*
+`\b(1+)¶11\1
$1¶1$&
1+
$.& $.&
 (.+)
$.1$* 
+1`( *)(.+?)( +)¶
$1$2¶$1$3
```
[Try it online!](https://tio.run/##K0otycxL/P9fT5tLRYtLOyEmScNQW/PQNkPDGEMuFUMgQ0WNyxAoqaemAMRcChp62ppAnqGKlgKXtmGChoKWJlDIXlNDAaQNqEXF6NA2IGn8/78Fl6ERAA "Retina 0.8.2 – Try It Online") Takes input as a newline-separated list of two integers. Edit: Saved 3 bytes by stealing the range-expansion code from my answer to [Do we share the prime cluster?](https://codegolf.stackexchange.com/questions/147254) Explanation:
```
.+
$*
```
Convert both inputs to unary.
```
+`\b(1+)¶11\1
$1¶1$&
```
While the last two elements (a, b) of the list differ by more than 1, replace them with (a, a+1, b). This expands the list from a tuple into a range.
```
1+
$.& $.&
```
Convert back to decimal in duplicate.
```
 (.+)
$.1$* 
```
Convert the duplicate copy to spaces.
```
+1`( *)(.+?)( +)¶
$1$2¶$1$3
```
Cumulatively sum the spaces from each line to the next.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~14~~ 13 bytes
```
V}FQ
=k+*dlkN
```
[Try it online!](http://pyth.herokuapp.com/?code=V%7DFQ%0A%3Dk%2B%2adlkN&input=999999%2C+1000009&debug=0)
[Answer]
# [LOGO](https://sourceforge.net/projects/fmslogo/), 53 bytes
```
[for[i ? ?2][repeat ycor[type "\ ]pr :i fd count :i]]
```
There is no "Try it online!" link because all online LOGO interpreter does not support template-list.
That is a template-list (equivalent of lambda function in other languages).
Usage:
```
apply [for[i ? ?2][repeat ycor[type "\ ]pr :i fd count :i]] [997 1004]
```
(`apply` calls the function)
will print
```
997
   998
      999
         1000
             1001
                 1002
                     1003
                         1004
```
Note:
This uses turtle's `ycor` (Y-coordinate) to store the number of spaces needed to type, therefore:
* The turtle need to be set to home in its default position and heading (upwards) before each invocation.
* `window` should be executed if `ycor` gets too large that the turtle moves off the screen. Description of `window` command: `if the turtle is asked to move past the boundary of the graphics window, it will move off screen.`, unlike the default setting `wrap`, which `if 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.`
Explanation:
```
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)
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
Ÿʒ¾ú=þv¼
```
[Try it online!](https://tio.run/##AR4A4f8wNWFiMWX//8W4ypLCvsO6PcO@dsK8//85NQoxMDM "05AB1E – Try It Online")
-2 thanks to [Adnan](https://codegolf.stackexchange.com/users/34388/adnan).
[Answer]
# JavaScript (ES8), ~~69~~ ~~67~~ 62 bytes
Takes input as integers, in ascending order, using currying syntax. Returns an array of strings.
```
x=>y=>[...Array(++y-x)].map(_=>s="".padEnd(s.length)+x++,s="")
```
---
## Try it
```
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>
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 12 bytes
```
òV
£¯Y ¬ç +X
```
Takes input in either order and always returns the numbers in ascending order, as an array of lines.
[Try it online!](https://codepen.io/justinm53/full/NvKjZr?code=8lYKo69ZIKznICtY&inputs=MAo1,MAoxNA==,OTk3CjEwMDQ=,MQoxMA==,OTUKMTAz,OTk5OTk5CjEwMDAwMDk=&flags=LVI=) with the `-R` flag to join the array with newlines.
## Explanation
Implicit input of `U` and `V`.
```
òV
£
```
Create inclusive range `[U, V]` and map each value to...
```
¯Y ¬ç
```
The values before the current (`¯Y`), joined to a string (`¬`) and filled with spaces (`ç`).
```
+X
```
Plus the current number. Resulting array is implicitly output.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~65 63 62~~ 61 bytes
*-2 bytes Thanks to @Mr. Xcoder: `exec` doesn't need braces*
*-1 bye thanks to @Zacharý: `print s*' '` as `print' '*s`* 
```
def f(m,n,s=0):exec(n-m+1)*"print' '*s+`m`;s+=len(`m`);m+=1;"
```
[Try it online!](https://tio.run/##K6gsycjPM/r/PyU1TSFNI1cnT6fY1kDTKrUiNVkjTzdX21BTS6mgKDOvRF1BXatYOyE3wbpY2zYnNU8DyNS0ztW2NbRW@p@mYaBjaKL5HwA "Python 2 – Try It Online")
[Answer]
# JavaScript, 57 bytes
```
f=(x,y,s='')=>y>=x?s+`
`+f(x+1,y,s.replace(/./g,' ')+x):s
```
[Answer]
# Python 2, 60 59 bytes
-1 byte thanks to Mr.Xcoder for defining my s=0 as an optional variable in my function.
```
def f(l,u,s=0):
 while l<=u:print' '*s+`l`;s+=len(`l`);l+=1
```
[Try it online!](https://tio.run/##HcixCoAgFEDRva94W5oOWjRY@S8NKQoPk1Sir7fsTocbn@zOMNZ6GAuWIC88aUGXDm7n0QBuuizx8iH30A@J7biviWk0gXykKzItqyWSgxS0s0TNXIrp11/7LUXrCw)
I think it is possible to transfer this into a lambda version, but I do not know how. I also think that there is some sort of mapping between the spaces and the length of the current number, but this I also did not figure out yet. So I think there still is room for improvement.
What i did was creating a range from the lowerbound `l`to the upper bound `u` printing each line with a space multiplied with a number `s`. I am increasing the multiplier with the length of the current number.
[Answer]
# 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`
```
[Try it online!](https://tio.run/##RcoxDoAgDADA3Vd0k6qDMvKaYgQt0WoQB19fw@R6uest2ylWdQkRovHDjK6BeGZgYIHsZQ1V@wndlVkK3M9h9iCGEmF96X@M2LXQ9sSk0YyDHVE/ "Python 2 – Try It Online")
`f(A, B)` will print the portion of the axis between A and B inclusive.
First time I answer a challenge!
Uses and abuses Python 2's backticks to count the number of spaces it has to add before the number.
-1 byte thanks to [Mr.Xcoder](https://codegolf.stackexchange.com/users/59487/mr-xcoder)
+2 because I forgot a `+1`
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~41~~ 38 bytes
*-3 bytes Thanks to [ASCII-only](https://codegolf.stackexchange.com/users/39244/ascii-only)*
```
t(x,v){while(x<=v)printf("%d\v",x++);}
```
Works on RedHat6, accessed via PuTTY 
[![Proof](https://i.stack.imgur.com/kWgYj.png)](https://i.stack.imgur.com/kWgYj.png)
[Try it online!](https://tio.run/##S9ZNT07@/79Eo0KnTLO6PCMzJ1Wjwsa2TLOgKDOvJE1DSTUlpkxJp0JbW9O69n9uYmaehmZ1iYaBjimIDwA "C (gcc) – Try It Online")
[Answer]
# [V](https://github.com/DJMcMayhem/V), 16 bytes
```
ÀñÙywÒ $pça/jd
```
[Try it online!](https://tio.run/##K/v//3DD4Y2HZ1aWH56koFLAeHi5UKJ@Vsr//6b/DU0B "V – Try It Online")
This would be way easier if I could take `start` `end - start` but I think that's changing the challenge a bit too much.
This takes the start number as input in the buffer and the end number as an argument. It actually creates the ladder from `start` to `start + end` and then deletes everything after the end number.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 11 bytes
```
vii&:"t~@Vh
```
[**Try it online!**](https://tio.run/##y00syfn/vywzU81KqaTOISzj/39Lcy5DA1MA "MATL – Try It Online")
### Explanation
This works by generating a string for each number and concatenating it with a logically-negated copy of the previous string. Thus char 0 is prepended 0 as many times as the length of the previous string. Char 0 is displayed as a space, and each string is displayed on a different line
```
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
```
[Answer]
# [Swift 4](https://swift.org/blog/swift-4-0-release-process/), 115 bytes
I think nobody would have posted a Swift solution anyway...
```
func f(l:Int,b:Int){for i in l...b{print(String(repeating:" ",count:(l..<i).map{String($0).count}.reduce(0,+)),i)}}
```
[Try it online!](http://swift.sandbox.bluemix.net/#/repl/597f2a514ed958681150d0b9)
[Answer]
## Perl, 19 bytes
**Note: `\x0b` is counted as one byte.**
Along with others, I thought using cursor movements would be the shortest route, this does mean it doesn't work on TIO:
```
print"$_\x0b"for<>..<>
```
### Usage
```
perl -e 'print"$_\x0b"for<>..<>' <<< '5
10'
5
 6
  7
   8
    9
     10
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~10~~ 9 bytes
```
òV åÈç +Y
```
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=8lYg5cjnICtZ&input=OTk3LCAxMDA0Ci1S) Returns an array of lines; `-R` flag included to join on newlines for easier viewing.
### Explanation
```
 ò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
```
---
Old version, 10 bytes:
```
òV £P=ç +X
```
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=8lYgo1A95yArWA==&input=OTk3LCAxMDA0Ci1S)
```
 ò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
```
[Answer]
# 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);}
```
Jelly and APL were taken.
[Try it online!](https://tio.run/##JYxNDsIgEEb3PQW7QkBS1ugtuAAI6DQtmDJpTYxnx1EX30/e4sXeYX3UDVnDqK@17Op7KFDtXiGyzJ3gjnnlWKC0yyReuW6EZjtLeW5WjGzUxwaYrP/vUixk7k9BUEujgmrSa0xP1EsqN7wL@x6Gn371UDgZuVFmItz7Bw)
If you're fine with console-dependent results (goes off the same principle as Giacomos's C answer) here's one for ~~72~~ 71 bytes:
```
import std.stdio;void f(T)(T a,T b){while(a<=b){a++.write;'\v'.write;}}
```
## How? (Only D specific tricks)
* `f(T)(T a,T b,T s=0)` D's template system can infer types
* `for(T j;j++<s;)` Integers default to `0`.
* `' '.write;a.writeln` D lets you call `fun(arg)` like `arg.fun` (one of the few golfy things D has)
* `a.text.length` Same as above, and D also allows you to call a method with no parameters as if it was a property (`text` is conversion to string)
* One thing that might be relevant (I didn't use this though) newlines can be in strings!
[Answer]
# Java 8, 79 bytes
```
(a,b)->{for(String s="";a<=b;System.out.printf("%"+s.length()+"d\n",a++))s+=a;}
```
[Try it online!](https://tio.run/##LYyxasMwFAB3f4UQFCTkiJbSoSjO0E4dOmVsOzzLkiPXlozeU6AEf7urIdMNd9wEVzik1cVp@N3tDIjsE0Jkt2Yt/RwsQwKquKYwsKUacaYc4vj1A3lEWbupHnShMGtfoqWQon4L7yliWVw@fkRyo8vtnSfmWbcLaHt5ON18yvcdw45zA8euN@c/JLfoVEivVZEX/IEr1LOLI12EVHz4jrwFpaRE1YHZdtN4Dda6lcTrS8ueHp@labZm2/8B)
]