考虑正整数数组：

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, ...

然后，将它们串联：

1234567891011121314151617181920212223242526...

然后将它们分成可变长度的块，每个长度等于第N个正整数：

[1][23][456][7891][01112][131415][1617181][92021222][324252627][2829303132] ...
---------------------------------------------------------------------------
 1  2    3     4     5       6       7        8          9          10      ...

任务

给定整数N（对于1索引为正数或对于0索引为非负数），您的任务是输出第N个块中的数字增量（和连续数字之间的差）。

• 默认情况下禁止使用漏洞。

• 适用标准输入和输出方法。

• 您可以为N选择0或1索引。

• 序列必须以1开始。

• 这是代码高尔夫球，以字节为单位的最短代码获胜。

范例与测试案例

1个索引的测试用例。如果您希望索引为0，则只需将N减1。

N, Chunk, Deltas, Sum

1  -> 1          -> []                               -> 0
2  -> 23         -> [1]                              -> 1
3  -> 456        -> [1, 1]                           -> 2
4  -> 7891       -> [1, 1, -8]                       -> -6
5  -> 01112      -> [1, 0, 0,1]                      -> 2
6  -> 131415     -> [2, -2, 3, -3, 4]                -> 4
7  -> 1617181    -> [5, -5, 6, -6, 7, -7]            -> 0
8  -> 92021222   -> [-7, -2, 2, -1, 1, 0, 0]         -> -7
9  -> 324252627  -> [-1, 2, -2, 3, -3, 4, -4, 5]     -> 4
10 -> 2829303132 -> [6, -6, 7, -6, -3, 3, -2, 2, -1] -> 0

_{CodeGolf-Hackathon上的Puzzle 2（我也是该游戏的原始作者，因此可以重新发布）。相关，灵感。相关的。}

JavaScript（ES6），54 53 51 50字节

@tsh节省了1个字节

0索引。

k=>-(n=1,g=s=>s[x=k*-~k/2]-s[x+k]-n||g(s+n++))``-n

测试用例

let f =

k=>-(n=1,g=s=>s[x=k*-~k/2]-s[x+k]-n||g(s+n++))``-n

for(i = 0; i < 10; i++) {
  console.log('a(' + i + ') = ' + f(i));
}

APL（Dyalog），32字节

{+/2-⍨/⍎¨⍵↑(+/⍳⍵-1)↓' '~⍨⍕⍳+/⍳⍵}

在线尝试！

怎么样？

+/⍳⍵-的总和1来n

⍳ -使范围

' '~⍨⍕ -成字符串，无空格

(+/⍳⍵-1)↓-先删除（的总和1为n-1）个字符

⍵↑-保留下一个n字符

⍎¨ -将每个字符变成整数

2-⍨/ -差异列表（每2个项目向后减去）

+/ - 总结一下。

外壳，9个字节

ΣẊ-!SCṁdN

在线尝试！

我对Hackathon的解决方案。

说明：

ΣẊ-!SCṁdN⁰
    S      (x -> y -> z):f -> (x -> y):g -> x:x :: return f(x, g(x))
     C      f= [num]:x -> [x]:y -> [x] :: cut y in pieces where each piece has its respective length in x
      ṁ     g= (x -> [y]):f -> ([x]:x -> [y]) :: maps f over x then concatenate
       d     f= num:x -> [num] :: return decimal digits of x
        N   x= sequence of natural numbers [1..]
   !     ⁰ [x]:x -> num:y -> x :: get yth (impl. input) element of x (above result)
 Ẋ         (x -> x -> y):f -> [x]:x -> [y] :: map f over overlapping pairs of x (above result)
  -         f= num:x -> num:y -> num :: return y - x
Σ          [num]:x -> num :: return sum of x (above result)

Haskell，61 60字节

l=fromEnum<$>(show=<<[1..])
f n|t<-sum[2..n]=l!!t-l!!(t-n+1)

在线尝试！

说明：

列表增量的总和与最后一个元素与第一个元素之间的差相同。

最后一个元素（零索引）是t，triangle(n)-1 = sum[2..n]。然后，第一个元素是t-n+1，因为列表具有n元素。

Python 2，80个字节

n=input()
s=map(int,''.join(map(str,range(2**n))))
print s[n*-~n/2]-s[~-n*n/2+1]

在线尝试！

2**n当然有点过头了，但是比像这样的东西短一个字节n*n+1。

Mathematica，71个字节

Tr@Differences[TakeList[Join@@IntegerDigits[Range[#^2]],Range@#][[#]]]&

在线尝试！

JavaScript（ES6），60 57 53字节

f=(n,s=i='',m=n*-~n/2)=>s[m]?s[m]-s[m-n+1]:f(n,s+i++)

<input type=number min=1 oninput=o.textContent=f(this.value)><pre id=o>

1个索引。以前的60字节非递归版本：

f=
(n,s=[...Array(n*n+1).keys()].join``)=>s[m=n*-~n/2]-s[m-n+1]

<input type=number min=1 oninput=o.textContent=f(this.value)><pre id=o>

05AB1E，8个字节

∞LJā£è¥O

0索引。

在线尝试！

Python 2，87个字节

n=input()
a=map(int,''.join(map(str,range(1,n*n))))[n*~-n/2:][:n]or[0]
print a[-1]-a[0]

在线尝试！

Python 2，104个字节

def f(N):A=map(int,"".join(map(str,range(1,N*N)))[~-N*N/2:][:N]);return sum(a-b for a,b in zip(A[1:],A))

在线尝试！

Perl 6的， 58  55个字节

{[+] ($_=(1..*).map(|*.comb).rotor(1..*)[$^a])[1..*]Z-@$_}

测试一下

{[+] ($_=(1..*).map(|*.comb)[^$^a+[+] ^$a])[1..*]Z-@$_}

测试一下

展开：

{ # bare block lambda with placeholder parameter ｢$a｣
  [+]  # reduce using &infix:«+» the following


    (
      $_ =                # store into ｢$_｣ for later use

        ( 1 .. * )        # Range of all positive integers
        .map( | *.comb )\ # split into digits and flatten into single list

        [                 # index into the sequence (1 based)

          ^$^a            # Range up to (and excluding) the input
                          # ｢0 ..^ $a｣ or ｢0 .. $a-1｣

          +               # shift it up by
          [+] ^$a         # the sum of the values up to (and excluding) the input

        ]

    )[ 1 .. *]            # skip the first value

    Z-                    # zip using &infix:«-»

    @$_                   # ｢$_｣ used as a List
}

PHP，163147字节

$v=$argv[1];for($i=1;$i<=$v*$v;$i++){$s.=$i;$j+=$i<$v?$i:0;}$s=array_slice(str_split($s),$j,$v);for($i=0;$i<$v-1;$i++){$k+=$s[$i+1]-$s[$i];}echo$k;

在线尝试！

我第一次尝试打高尔夫球...感觉可以缩短

编辑：通过删除几个实例保存16个字节

Perl 5、79 + 1（-p）= 80字节

$_=substr join('',1..$_**2),$_*($_-1)/2,$_;1while s/(.)(.)/$r+=$2-$1;$2/e;$_=$r

在线尝试！

Pyth，29 27字节

@ Mr.Xcoder节省了2个字节。

s.+msdc:sm+hd""U*QQKsUQ+QK1

在线尝试！

果冻，14字节

²RDFṫ³ḶS‘¤ðḣIS

在线尝试！

说明

²RDFṫ³ḶS‘¤ðḣIS    Main Link
²                  Square input
 R                 Range: [1,2,3,..,n^2]
  D                Digits: [1,2,...,[1,0],[1,1],...]
   F               Flatten list
     ³ḶS‘¤         n(n-1)/2+1
    ṫ              Remove the first n(n-1)/2+1 elements from the list of digits
          ðḣ       Take the first n digits of the list. ð is needed to prevent I from acting on n.
            I      Increment. Take the diferences
             S     Sum

我最初是从range（n（n + 1）/ 2）开始的，但是由于在切片之前您可以在列表的末尾有额外的数字，所以我将其更改为range（n ^ 2）。无论如何，您在1-9之后还有多余的数字。