양의 정수 배열을 고려하십시오.

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로 시작해야합니다 .

• 이것은 바이트 단위의 code-golf , 가장 짧은 코드입니다.

예제 및 테스트 사례

1 인덱스 테스트 사례. 인덱스가 0이 아닌 것을 원하면 N을 줄이십시오.

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

_{퍼즐 2 에 CodeGolf - 해커 톤은 (내가 재 게시를 허용하고, 그래서 나도 거기에 원래 저자). 관련, 영감 . 관련 .}

자바 스크립트 (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)

하스켈 , 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요소 가 있으므로 첫 번째 요소 는 입니다.

파이썬 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@#][[#]]]&

온라인으로 사용해보십시오!

자바 스크립트 (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입니다.

온라인으로 사용해보십시오!

파이썬 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]

온라인으로 사용해보십시오!

파이썬 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))

온라인으로 사용해보십시오!

펄 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 이후에 추가 숫자가 있습니다.