我们有很多数字的水平轴，但是老实说，我觉得它们很无聊。今天的任务是在输入的两个不同的非负整数之间建立对角轴的一部分。

如何建立对角线轴？

• 让我们以输入为例0, 5。我们的轴应如下所示：

  0
   1个
    2
     3
      4
       5
  

• 但是，对于具有更多数字的数字，我们的轴也应该看起来不错！例如0, 14，如果输入为，则新轴应为：

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

• 这个想法是，轴上下一个数字的第一位必须始终准确地放在前一个数字的最后一位之后。为了更好地理解这个想法，下面是另一个示例997, 1004：

  997
     998
        999
           1000
               1001
                   1002
                       1003
                           1004
  

规则

• 您可以假定输入是升序还是降序（可以在5,3和之间进行选择3,5）。

• 您还可以假定两个整数之间的差小于100。

• 您可能有一个换行符开头或一致的空格（在每行上）。尾随空格/换行符也很好。

• 默认漏洞是禁止的。

• 您可以采用任何标准均值进行输入并提供输出。

• 这是代码高尔夫球，因此每种语言中以字节为单位的最短代码胜出！

其他测试用例

• 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字节

感谢魔术章鱼缸节省了一个字节！

它以某种方式起作用，但是老实说我不知道​​为什么。

码

Ÿvy.O=

使用05AB1E编码。在线尝试！

说明

Ÿ          # 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个字节

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

利用垂直制表符制作梯形效果。泰德的方式\v呈现是安慰依赖，所以它可能不会工作无处不在（如TIO）。

木炭，9 8字节

Ｆ…·ＮＮ⁺¶ι

在线尝试！

链接是该代码的详细版本。以升序输入。

• 仅使用ASCII节省了1个字节！

R，70 69 61字节

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

以start和end变量作为参数的函数。循环遍历序列，并打印每个元素，并在其前面加上足够的空格。F从开始于FALSE=0，并且在每次迭代期间，都会向该值中添加字符数。F决定打印的空间量。

在线尝试！

-8个字节，感谢@Giuseppe

C＃，90 89 85字节

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

感谢@LiefdeWen，节省了1个字节。
感谢@auhmaan，节省了4个字节。

在线尝试！

完整/格式化版本：

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字节

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

在线尝试！

Mathematica，59个字节

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

输入

[10,15]

-3字节@JungHwanMin
问题，已固定为0（有关详细信息，请参见注释）
thanx到@ngenisis

果冻，9字节

rD⁶ṁ$;¥\Y

在线尝试！

Mathematica，48个字节

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

由于答案如此之多，我认为应该包括这一答案

输入

[0,10]

输出

C，166 134 95个 82字节

新答案

只是功能而不是整个程序。

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

感谢Falken帮助完成了13个字节（并修复了一个小故障）！

感谢Steph Hen帮助完成12个字节！

感谢Zacharý的帮助，完成了1个字节！

旧答案

在main之前删除了int，并将const char * v []更改为char ** v并删除了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;}

这是我第一次打高尔夫球，我想尝试用C进行一些练习。不确定是否正确设置了格式，但是制作起来很有趣！

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

说明

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

用法

C ++，167165字节

-2个字节，感谢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字节

-1感谢Zacharý。

假设⎕IO←0基于零的计数。将下限作为左参数，将上限作为右参数。

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

在线尝试！

(… ) 在参数之间应用以下默认函数：

 - 从上限减去上限

 1- 从一减去（即1 + ∆）

 ⊣+∘⍳ 左下限加上整数0到那个

 ⍕¨ 格式化（字符串化）每个

{…… } 对此应用以下匿名（以present表示）：

 ≢¨ 每个的长度（数字）

 +\ 累计金额

 - 否定

 ⍵↑⍨¨ 对于每个字符串，请从末尾取那么多字符（带空格的小键盘）

 ↑ 将字符串列表混合到字符矩阵中

视网膜，81 78字节

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

在线尝试！将输入作为两个整数的换行符分隔列表。编辑：从我的回答中窃取范围扩展代码节省了3个字节，我们是否共享素数群集？说明：

.+
$*

将两个输入都转换为一元。

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

虽然列表的最后两个元素（a，b）相差超过1，但将其替换为（a，a + 1，b）。这会将列表从元组扩展到一个范围。

1+
$.& $.&

重复转换回十进制。

 (.+)
$.1$* 

将重复的副本转换为空格。

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

累计每一行到下一行的空格。

Pyth，14 13字节

V}FQ
=k+*dlkN

在线尝试！

LOGO，53字节

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

没有“在线试用！” 链接，因为所有在线LOGO解释器均不支持模板列表。

那是一个模板列表（在其他语言中相当于lambda函数）。

用法：

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

（apply调用函数）

将打印

997
   998
      999
         1000
             1001
                 1002
                     1003
                         1004

注意：

这使用乌龟的ycor（Y坐标）存储键入所需的空格数，因此：

• 每次调用之前，都需要将乌龟设置为其默认位置的主屏幕，并使其前进（向上）。
• window如果ycor过大导致乌龟离开屏幕，应执行此命令。window命令说明：if the turtle is asked to move past the boundary of the graphics window, it will move off screen.与默认设置不同wrap，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.

说明：

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个字节

Ÿʒ¾ú=þv¼

在线尝试！

-2感谢Adnan。

JavaScript（ES8），69 67 62字节

使用currying语法以升序将输入作为整数。返回字符串数组。

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

试试吧

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个字节

òV
£¯Y ¬ç +X

以任意顺序输入，并始终以升序返回数字（以行数组表示）。

在线尝试！带有-R标志，以换行符加入数组。

说明

隐式输入U和V。

òV
£

创建包含范围[U, V]并将每个值映射到...

¯Y ¬ç

当前（¯Y）之前的值连接到字符串（¬），并用空格（ç）填充。

+X

加上当前号码。结果数组隐式输出。

Python 2中，65个63 62 61字节

-2个字节感谢@Mr。Xcoder：exec不需要大括号

-1再见，感谢@Zacharý：print s*' 'asprint' '*s

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

在线尝试！

JavaScript，57个字节

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

Python 2中，60 59个字节

-1个字节，感谢Mr.Xcoder将我的s = 0定义为函数中的可选变量。

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

在线尝试！

我认为可以将其转换为lambda版本，但我不知道如何。我还认为空格和当前数字的长度之间存在某种映射，但是我也没有弄清楚。因此，我认为仍有改进的空间。

我所做的是创建一个从l下限到上限的范围，并在u每行上打印一个空格乘以一个数字s。我正在用当前数字的长度增加乘数。

Python 2，78 77 79字节

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

在线尝试！

f(A, B) 将打印A和B之间（包括A和B）的轴的一部分。

我第一次回答挑战！

使用和滥用Python 2的反引号来计算必须在数字之前添加的空格数。

-1字节感谢Mr.Xcoder

+2因为我忘记了 +1

C（gcc），41 38字节

-3个字节，仅依靠ASCII

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

可通过PuTTY访问RedHat6

在线尝试！

V，16字节

ÀñÙywÒ $pça/jd

在线尝试！

如果可以的话，这会更容易，start end - start但是我认为这对挑战的改变太大了。

这将开始编号作为缓冲区中的输入，并将结束编号作为参数。实际上，它创建了从start到的阶梯start + end，然后删除了结束编号之后的所有内容。

MATL，11个字节

vii&:"t~@Vh

在线尝试！

说明

这是通过为每个数字生成一个字符串并将其与上一个字符串的逻辑取反副本连接起来而起作用的。因此，将char 0前置0到前一个字符串的长度是0。字符0显示为空格，并且每个字符串显示在不同的行上

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

迅捷 4，115字节

我认为反正没人会发布Swift解决方案...

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

在线尝试！

Perl，19个字节

注意：\x0b计为一个字节。

与其他人一起，我认为使用光标移动是最短的路线，这确实意味着它不适用于TIO：

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

用法

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

Japt，10 9字节

òV åÈç +Y

在线测试！返回行数组；-R包含标志以加入换行符以便于查看。

说明

 ò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

旧版本，10个字节：

òV £P=ç +X

在线测试！

 ò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字节

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

果冻和APL被采取。

在线尝试！

如果您满意控制台相关的结果（遵循与Giacomos的C回答相同的原理），则为72 71字节：

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

怎么样？（仅D特技）

• f(T)(T a,T b,T s=0) D的模板系统可以推断类型
• for(T j;j++<s;)整数默认为0。
• ' '.write;a.writelnD让您fun(arg)像arg.fun（D拥有的少数高尔夫产品之一）那样打电话
• a.text.length与上面相同，D还允许您调用不带参数的方法，就好像它是属性一样（text转换为字符串）
• 一件事可能是相关的（尽管我没有使用）换行符可以在字符串中！

Java 8，79字节

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

在线尝试！