PPCG 사용자 및 선출 모드는 @Dennis는 단지 100,000 담당자를 통해 적립 두 번째 이제까지 사용자가되었습니다!

이것은 내가 다른 사람에게서 얻지 못한 완전히 독창적 인 아이디어 이지만 그의 사용자 ID를 바탕 12012으로 공물로 도전합시다 !

그것을 보면, 그의 ID에는 두 개의 별개의 "섹션"이 있음을 알 수 있습니다.

12

과

012

이 두 섹션은 모두 3을 더합니다. 그것은 꽤 흥미로운 속성입니다.

"Dennis 2.0 숫자"를 양의 정수로 정의하여 엄격하게 증가하는 숫자의 최대 하위 시퀀스가 ​​모두 같은 숫자가되도록합니다. 예를 들어

123

엄격하게 증가하는 자릿수의 최대 하위 목록이 하나뿐이기 때문에 Dennis 2.0 숫자이며 6의 합계입니다. 또한 2,846,145는 증가하는 자릿수의 세 개의 최대 하위 목록, 즉

28
46
145

모든 합은 10입니다. 또한 동일한 숫자를 반복하는 숫자 는 예를 들어 다음과 777같이 나눌 수 있으므로 Dennis 2.0 숫자 여야합니다.

7
7
7

이는 분명 일곱 모든 합계입니다.

같은 숫자 는 Dennis 2.0 숫자 42가 아닙니다 .

4
2

분명히 같은 숫자와 합치 지 않습니다.

도전

주어진 숫자가 Dennis 2.0 숫자인지 여부를 판별하기 위해 프로그램 또는 함수를 작성해야합니다. 문자열, 숫자, 파일, 함수 인수 / 반환, STDIN / STDOUT 등의 합리적인 입력 형식으로 입력하고 출력 한 다음 이 숫자가 Dennis 2.0 인 경우 정확한 값 을 반환 할 수 있습니다. 그렇지 않으면 거짓 값입니다. 참고로, 모든 Dennis 2.0 번호는 최대 1,000입니다.

1
2
3
4
5
6
7
8
9
11
12
13
14
15
16
17
18
19
22
23
24
25
26
27
28
29
33
34
35
36
37
38
39
44
45
46
47
48
49
55
56
57
58
59
66
67
68
69
77
78
79
88
89
99
101
111
123
124
125
126
127
128
129
134
135
136
137
138
139
145
146
147
148
149
156
157
158
159
167
168
169
178
179
189
202
222
234
235
236
237
238
239
245
246
247
248
249
256
257
258
259
267
268
269
278
279
289
303
312
333
345
346
347
348
349
356
357
358
359
367
368
369
378
379
389
404
413
444
456
457
458
459
467
468
469
478
479
489
505
514
523
555
567
568
569
578
579
589
606
615
624
666
678
679
689
707
716
725
734
777
789
808
817
826
835
888
909
918
927
936
945
999

표준 허점이 적용되며 바이트 단위로 측정 된 최단 응답이 승리합니다!

젤리, 13 12 바이트

@Dennis 덕분에 1 바이트.

DIṠ’0;œṗDS€E

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

설명

DIṠ’0;œṗDS€E    Main link. Argument: N
D               Convert N to its digits.
 I              Find the differences between the elements.
  Ṡ             Find the sign of each difference. This yields 1 for locations where the
                list is strictly increasing and 0 or -1 elsewhere.
   ’            Decrement. This yields 0 for locations where the list is strictly
                increasing and -1 or -2 elsewhere.
    0;          Prepend a 0.
        D       Get another list of digits.
      œṗ        Split the list of digits at truthy positions, i.e. the -1s and -2s.
         S€     Sum each sublist.
           E    Check if all values are equal.

자바 스크립트 (ES6), 72 70 바이트

문자열을 입력으로 사용합니다. false 또는 true 값 (숫자 일 수 있음)을 반환합니다.

정규 표현식을 사용하여 다음과 같은 입력 문자열을 변환합니다 "2846145".

"(a=2+8)&&(a==4+6)&&(a==1+4+5)"

그런 다음 eval()이 표현을 호출 하십시오.

let f =

n=>eval(n.replace(/./g,(v,i)=>(v>n[i-1]?'+':i?')&&(a==':'(a=')+v)+')')

console.log(f("101"));
console.log(f("102"));
console.log(f("777"));
console.log(f("2846145"));

파이썬, 50 바이트

r='0'
for d in input():r=d+'=+'[r<d]*2+r
1/eval(r)

input()문자열로 평가할 것으로 예상 되므로 입력에 파이썬 2의 따옴표가 필요합니다. 출력은 종료 코드 를 통해 이루어집니다 . 여기서 0 은 성공 (거짓)을 나타내고 1 은 실패 (거짓)를 나타냅니다.

Ideone에서 테스트하십시오 .

작동 원리

r 을 문자열 0으로 초기화 하고 입력의 모든 숫자 d 를 반복 합니다.

• 경우 d는 의 첫 번째 숫자보다 큰 R (초기에 0 의 값을 이전 한 후 동일 D ) r<d로 평가되는 참 및 '=+'[r<d]*2수율 ++.

• 경우 D는 처음 숫자보다 작은 R , '=+'[r<d]*2수율 ==.

• 경우 d는 의 첫 번째 자리에 동일한 R , R은 싱글 캐릭터보다 더 길어질 수 D 하므로 '=+'[r<d]*2수율 한번 ==.

모든 경우에 숫자 d 와 생성 된 두 문자는 r 앞에 추가됩니다 .

모든 입력 숫자가 처리되면 eval(r)생성 된 표현식을 평가합니다.

• 입력이 엄격하게 증가하는 (양수) 숫자 시퀀스로 구성된 경우 표현식은 해당 합계로 평가됩니다.

  예를 들어, 정수 12345 는 식 5++4++3++2++1++0을 산출하며 평가시 15 를 산출 합니다. 각 초 + 는 단항 더하기이므로 결과에 영향을 미치지 않습니다. 1 을 15 로 나누는 것은 유효합니다 (결과는 중요하지 않습니다). 프로그램이 정상적으로 종료됩니다.

• 입력이 엄격하게 증가하는 두 자릿수 시퀀스로 구성된 경우 간단한 비교로 표현됩니다.

  예를 들어 정수 12012 는식이 2++1++0==2++1++0되며, 두 항의 합계가 3 이므로 평가할 때 True가 됩니다 . 1 을 True ( 1 )로 나누는 것은 유효합니다 (결과는 중요하지 않습니다). 프로그램이 정상적으로 종료됩니다.

  한편, 정수 12366 개 발현 결과 6==6++3++2++1++0산출, 거짓 조건이 합계를 갖기 때문에 검사시 6 및 12 . 1 을 False ( 0 )로 나누면 ZeroDivisionError가 발생합니다 . 프로그램이 오류와 함께 종료됩니다.

• 입력이 숫자 세 개 이상의 엄격하게 증가하는 시퀀스로 구성하는 경우, 표현식은 구성 연쇄 비교 반환, 진정한 관련된 모든 비교는 반환의 경우에만 사실 .

  예를 들어, 정수 94,536 발현 결과 6++3==5++4==9++0산출, 트루 모든 용어들은 합이 때문에 검사시 9 . 이전과 마찬가지로 프로그램이 정상적으로 종료됩니다.

  한편, 정수 17,263 발현 결과 3==6++2==7++1++0산출, 거짓 조건이 합이 때문에 검사시 3 , 8 , 및 8 . 이전과 마찬가지로 프로그램이 오류와 함께 종료됩니다.

Brachylog , 13 바이트

~c@e:{<+}a!#=

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

설명

~c               Find a list of integers which when concatenated result in the Input
  @e             Split the integers into lists of digits
    :{<+}a       Each list of digit is stricly increasing, and compute its sum
          !      Discard all other choice points (prevents backtracking for smaller sublists)
           #=    All sums must be equal

~c 가장 큰 하위 목록과 먼저 통합됩니다.

파이크, 18 바이트

mb$1m>0R+fMbms}lt!

여기 사용해보십시오!

mb                 -         map(int, input)
  $                -        delta(^)
   1m>             -       map(^, 1>i)
      0R+          -      [0]+^
         f         -     input.split_at(^) 
          Mb       -    deep_map(int, ^)
            ms     -   map(sum, ^)
              }    -  uniquify(^)
               lt! - len(^) == 1

PowerShell v2 +, 100 64 61 바이트

-join([char[]]$args[0]|%{("+$_","-eq$_")[$_-le$i];$i=$_})|iex

이것은 모두 하나의 파이프 라인이므로 문자 그대로의 단일 라이너입니다. 입력을 문자열로 $args[0]받습니다. A와 그것을 통해 루프 char-array하는 전류와 소자 중 하나를 배치하는 각 반복 +또는 -eq여부에 따라 파이프 라인 상에 그것의 앞에 현재 값은 -lESS보다 또는 - e이전 값 QUAL $i. 이러한 문자열되어 -join함께 에드에 파이프 및 iex짧은 ( Invoke-Expression및 유사한 eval. 예를 들어, 입력 2846145으로 이러한 평가한다 +2+8-eq4+6-eq1+4+5인 True.

해당 부울은 파이프 라인에 남아 있으며 프로그램 완료시 True/ False가 암시 적으로 작성됩니다.

NB-한 자릿수 입력의 경우 결과 숫자는 파이프 라인에 남습니다. 이는 PowerShell에서 확실한 값입니다.

예

PS C:\Tools\Scripts\golfing> 2846145,681,777,12366,2|%{"$_ -> "+(.\dennis-number-20.ps1 "$_")}
2846145 -> True
681 -> False
777 -> True
12366 -> False
2 -> 2

GNU sed 217 또는 115

둘 다 -r에 +1 포함

217 :

s/./&,/g;s/^/,/g;:;s,0,,;s,2,11,;s,3,21,;s,4,31,;s,5,41,;s,6,51,
s,7,61,;s,8,71,;s,9,81,;t;s/(,1*)(1*)\1,/\1\2X\1,/;t;s/,//g
s,1X1(1*),X\1a,;t;/^1.*X/c0
/Xa*$/s,a*$,,;y,a,1,;/1X1/b;/1X|X1/c0
c1

보통 10 진수로 입력을받습니다.

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

115 :

s/^|$/,/g;:;s/(,1*)(1*)\1,/\1\2X\1,/;t;s/,//g
s,1X1(1*),X\1a,;t;/^1.*X/c0
/Xa*$/s,a*$,,;y,a,1,;/1X1/b;/1X|X1/c0
c1

쉼표로 구분 된 숫자 자릿수 목록을 단항으로 입력합니다. 예를 들면 123것1,11,111

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

펄, 38 + 3 ( -p) = 41 바이트

@Ton Hospel 덕분에 -9 바이트 !

s%.%2x$&.(~$&le~$')%eg;$_=/^(2+1)\1*$/

가 있으므로 $'코드를 실행하려면 파일에 있어야합니다. 따라서 -p3 바이트로 계산됩니다. 숫자가 Dennis 2.0 숫자이면 1을 출력하고 그렇지 않으면 빈 문자열을 출력합니다.

$ cat dennis_numbers.pl
s%.%2x$&.(~$&le~$')%eg;$_=/^(2+1)\1*$/
$ perl -p dennis_numbers.pl <<< "1
10
12315
12314"

자바 스크립트 (ES6), 66 65 63 바이트

@ edc65 덕분에 2 바이트 절약

x=>[...x,p=t=z=0].every(c=>p>=(t+=+p,p=c)?(z?z==t:z=t)+(t=0):1)

입력을 문자열로받습니다. 이전 버전 (Firefox 30 이상에서만 작동) :

x=>[for(c of(p=t=0,x))if(p>=(t+=+p,p=c))t+(t=0)].every(q=>q==+p+t)

수학, 38 바이트

Equal@@Tr/@IntegerDigits@#~Split~Less&

익명의 기능. 숫자를 입력으로 사용하고 반환 True하거나 False출력합니다.

Brachylog 2, 10 바이트, 언어 날짜 도전 과제

ẹ~c<₁ᵐ!+ᵐ=

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

이것은 기본적으로 @Fatalize의 답변과 같은 알고리즘입니다 (이 글을 쓴 후에야 보지 못했습니다).하지만 Brachylog 2의 구문에 따라 골퍼가되도록 약간 재정렬되었습니다.

그것은 완전한 프로그램이며, false.Dennis 2.0 번호가 아닌지 또는 true그렇지 않은지를 반환 합니다 .

설명

ẹ~c<₁ᵐ!+ᵐ=
ẹ           Interpret the input number as a list of digits
      !     Find the first (in default order)
 ~c           partition of the digits
   <₁ᵐ        such that each is in strictly increasing order
         =  Assert that the following are all equal:
       +ᵐ     the sums of each partition

Brachylog 전체 프로그램에서 평소와 같이 모든 주장이 동시에 충족 될 수 있다면 우리는 진실한 결과를 얻습니다. 그렇지 않으면 거짓입니다. 의 기본 순서는 ~c첫째 적은와 파티션, 더 이상 요소를 정렬하고, 프롤로그 (따라서 Brachylog)에, 그래서의 A 타이 브레이크로 제 등을 사용하여 프로그램의 첫 번째 술어에 의해 정의 된 기본 순서의가 (여기서, ~c지배, ẹ결정적이므로 주문할 것이 없기 때문 입니다).

MATL, 24 23 20 18 16 바이트

Tjdl<vYsG!UlXQ&=

거짓 행렬 의 진위를 반환

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

또한 @Dennis를 축하합니다!

설명

T       % Push a literal TRUE to the stack
        %   STACK: {1}
j       % Explicitly grab the input as a string
        %   STACK: {1, '2846145'}
d       % Compute the difference between successive ASCII codes
        %   STACK: {1, [6 -4 2 -5 3 1]}
l<      % Find where that difference is less than 1
        %   STACK: {1, [0 1 0 1 0 0]}
v       % Prepend the TRUE value we pushed previously
        %   STACK: {[1 0 1 0 1 0 0]}
Ys      % Compute the cumulative sum. This assigns a unique integer label to
        % each set of increasing numbers
        %   STACK: {[1 1 2 2 3 3 3]}
G!U     % Grab the input as numeric digits
        %   STACK: {[1 1 2 2 3 3 3], [2 8 4 6 1 4 5]}
lXQ     % Compute the sum of each group of increasing digits
        %   STACK: {[10 10 10]}
&=      % Computes element-wise equality (automatically broadcasts). A
        % truthy value in MATL is a matrix of all ones which is only the case
        % when all elements are equal:
        %   STACK: {[1 1 1
        %            1 1 1
        %            1 1 1]}
        % Implicitly display the result

PHP, 108 (105) 92 바이트

$p=-1;foreach(str_split("$argv[1].")as$d)$p>=$d?$r&&$s-$r?die(1):($r=$s)&$s=$p=$d:$s+=$p=$d;

인수에서 입력을 받고 0Dennis-2.0 번호로 종료 1합니다.

고장

$p=-1;                              // init $p(revious digit) to -1
foreach(str_split("$argv[1].")as$d) // loop $d(igit) through input characters
                                    // (plus a dot, to catch the final sum)
    $p>=$d                              // if not ascending:
        ?$r                             // do we have a sum remembered 
        &&$s-$r                         // and does it differ from the current sum?
                ?die(1)                     // then exit with failure
                :($r=$s)&$s=$p=$d           // remember sum, set sum to digit, remember digit
        :$s+=$p=$d                      // ascending: increase sum, remember digit
    ;
// 

05AB1E , 18 바이트

SD¥X‹X¸«DgL*ꥣOÙg

설명

N = 12012 예제로 사용됩니다.

                    # implicit input N = 12012
S                   # split input number to list of digits  
                    # STACK: [1,2,0,1,2]
 D                  # duplicate
                    # STACK: [1,2,0,1,2], [1,2,0,1,2]
  ¥                 # reduce by subtraction
                    # STACK: [1,2,0,1,2], [1,-2,1,1]
   X‹               # is less than 1
                    # STACK: [1,2,0,1,2], [0,1,0,0]
     X¸«            # append 1
                    # STACK: [1,2,0,1,2], [0,1,0,0,1]
        DgL*        # multiply by index (1-indexed)
                    # STACK: [1,2,0,1,2], [0,2,0,0,5]
            ê       # sorted unique
                    # STACK: [1,2,0,1,2], [0,2,5]
             ¥      # reduce by subtraction
                    # STACK: [1,2,0,1,2], [2,3]
              £     # split into chunks
                    # STACK: [[1,2],[0,1,2]]
               O    # sum each
                    # STACK: [3,3]
                Ù   # unique
                    # STACK: [3]
                 g  # length, 1 is true in 05AB1E
                    # STACK: 1

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

루비 2.3, 56 바이트

p !gets.chars.chunk_while(&:<).map{|a|eval a*?+}.uniq[1]

이 작업을 수행하는 가장 골치 아픈 방법은 아니지만 멋진 언어 기능을 보여줍니다.

(줄 바꿈 허용되지 않으므로 다음과 같이 실행하십시오 ruby dennis2.rb <<< '12012')

PHP, 144 바이트

<?php preg_match_all("/0?1?2?3?4?5?6?7?8?9?/",$argv[1],$n);foreach($n[0]as$i)if(strlen($i)&&($a=array_sum(str_split($i)))!=$s=$s??$a)die;echo 1;

이 작업을 수행하는 훨씬 영리하고 짧은 방법이 있지만 지금은 그렇게 할 것입니다.

파이썬 2, 69 바이트

입력을 문자열로받습니다.

lambda I:len(set(eval(reduce(lambda x,y:x+',+'[y>x[-1]]+y,I+' '))))<2

설명:

전의 1201212012

합계 목록으로 변환합니다.

1+2,0+1+2,1+2,0+1+2,

평가하고 세트로 변환합니다.

set([3])

집합의 길이가 1이면 모든 합이 동일합니다.

자바 스크립트 (ES6), 58

s=>![...s,z=x=p=0].some(c=>[c>p?0:z-=(x=x||z),z-=p=c][0])

매우 유용한 팁 적용하기 https://codegolf.stackexchange.com/a/49967/21348

오름차순 문자의 실행을 식별하는 문자로 문자열 문자를 스캔하고 각 럼의 끝에서 합계가 항상 같은지 확인합니다.

• c : 현재 문자
• p : 이전 문자
• z : 런 종료시 런 합을 비교합니다 ...
• x : 첫 번째 실행에서 비교할 합계는 단순히 z와 같습니다.

테스트

f=
s=>![...s,z=x=p=0].some(c=>[c>p?0:z-=(x=x||z),z-=p=c][0])

function run()
{
  var i=I.value
  O.textContent = i + ' -> ' + f(i)
}

run()

test=`1 2 3 4 5 6 7 8 9 11 12 13 14 15 16 17 18 19 22 23 24 25 26 27 28 29 33 34 35 36 37 38 39 44 45 46 47 48 49 55 56 57 58 59 66 67 68 69 77 78 79 88 89 99 101 111 123 124 125 126 127 128 129 134 135 136 137 138 139 145 146 147 148 149 156 157 158 159 167 168 169 178 179 189 202 222 234 235 236 237 238 239 245 246 247 248 249 256 257 258 259 267 268 269 278 279 289 303 312 333 345 346 347 348 349 356 357 358 359 367 368 369 378 379 389 404 413 444 456 457 458 459 467 468 469 478 479 489 505 514 523 555 567 568 569 578 579 589 606 615 624 666 678 679 689 707 716 725 734 777 789 808 817 826 835 888 909 918 927 936 945 999`.split` `

numerr=0
for(i=1; i<1000; i++)
{
  v = i + '';
  r = f(v);
  ok = r == (test.indexOf(v) >= 0)
  if (!ok) console.log('Error',++numerr, v)
}  
if(!numerr) console.log('All test 1..999 ok')

<input id=I value=612324 type=number oninput='run()'>
<pre id=O>

Pyth , 20 바이트

두 가지 버전

!t{sMcJjQThMx1<R0.+J
LS{b!t{sMhyI#I#./jQT

첫 번째 온라인을 시도하십시오!

두 번째 온라인을 사용해보십시오!

루비, 117 105 85 바이트

# original (117):
j,k=0,?0;"#{i}".chars.group_by{|n|n>k||j=j+1;k=n;j}.values.map{|a|a.map(&:to_i).reduce(&:+)}.reduce{|m,n|n==m ?m:nil}

# inspired by PHP regexp approach (105):
"#{i}".scan(/0?1?2?3?4?5?6?7?8?9?/).map{|a|a.chars.map(&:to_i).reduce(&:+)}.reduce{|m,n|!n||n==m ?m:nil}

# some number comparison simplification (85):
!"#{i}".scan(/0?1?2?3?4?5?6?7?8?9?/).map{|a|a.chars.map(&:to_i).reduce(&:+)}.uniq[1]

이것은이 dennis 숫자의 정수를 반환하거나 dennis 숫자 nil가 아닌 경우 반환합니다 . 루비에서는 모든 정수가 참으로 nil간주되며 거짓으로 간주됩니다. i확인중인 정수입니다.

세 번째 버전은 실제로 true및을 반환합니다 false.

PS는 답변에서와 같이 1에서 1000 사이의 정수 172를 반환하도록 테스트했습니다.

APL, 23 바이트

{1=≢∪+/↑N⊂⍨1,2>/N←⍎¨⍕⍵}

설명:

• N←⍎¨⍕⍵: 입력에 개별 숫자를 가져 와서 저장하십시오. N
• N⊂⍨1,2>/N: 숫자가 엄청나게 증가하는 하위 목록 찾기 N
• +/↑: 각 하위 목록 합계
• 1=≢∪: 결과 목록에 고유 한 요소가 하나만 있는지 확인

++ , 109 바이트 추가

D,g,@@#,BF1_B
D,k,@@#,bR$d@$!Q@BFB
D,f,@,BDdVÑ_€?1€_0b]$+€?dbLRBcB*BZB]GbL1+b]+qG€gd€bLÑ_0b]$+BcB]£k€¦+Ñ=1$ª=

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

작동 원리

$f$$g$$k$$f$

$f(x)$

$x$$1$$[4, 4, 4]$$0$$-1$$1$$0$$A$$0$$1$$0$

$[1, 2, ... length(A)]$$0$$A$$A'$$A'$$A'$$A''$

다음으로 도우미 함수를 사용합니다 . 마찬가지로 이항 (2 개 인수를 사용)를 페어링하면 약간 다르게 작동 각 오퍼레이터 . Dyadic 함수는 스택에서 값을 팝하고 해당 값을 올바른 인수로 바인딩하여 부분 모나 딕 함수를 만듭니다. 그런 다음이 부분 함수는 인수의 각 요소에 맵핑됩니다. 여기서 바운드 오른쪽 인수는 입력 숫자이며 부분 함수는 위에 매핑 됩니다.$g$$g$€$A''$

$g(x, y)$

이제 단 하나의 반복을 살펴 보자 위치를 및 . 참고 의 첫번째 인덱스 의 부호 에 대응 것이 아니라, . 실제로 경우 입니다. 은 0이 아닌 유일한 인덱스 이고 은 에 1을 더한 길이입니다 .$g(x, y)$$x := [1, 2, 0, 1, 2]$$y = 3$$3$$A''$$A$$1$$0$$x = 12012$$A'' = [3, 6]$$3$$A$$6$$x$

따라서 경우 다음과 같은 일이 발생합니다. 먼저 스택 아래의 숫자가 스택 아래에 있도록 두 인수를 서로 바꿉니다. 그런 다음 배열을 평평하게하고 인덱스를 줄입니다. 지금까지 스택은 다음과 같습니다 . 그런 다음 head 명령 을 수행합니다 . 스택 맨 위에서 인덱스를 팝하고 맨 아래부터 스택에서 많은 문자를 가져옵니다. 이것은 산출 한 다음 로 반환됩니다 .$g([1, 2, 0, 1, 2], 3)$[1 2 0 1 2 2]$[1, 2]$$g$

따라서 는 각 요소 매핑되며 다양한 증가하는 길이의 입력에 대한 일련의 접두사를 반환합니다. 이 부분은 약간 혼동 될 수 있으므로 입력 예를 사용하여 살펴 보겠습니다 . 의 매핑 후 스택은 현재$g(x, y)$$y \in A''$$x := 12012$$g$

[[[1 2] [1 2 0 1 2]]]

그런 다음 맨 위 요소 또는이 경우 배열 에서 각 배열의 길이를 포함하는 배열을 푸시합니다 . 연산자가 맵핑 되면 과 동일 하지만이 관계를 사용하려면 더 많은 바이트가 필요합니다. 다음으로, 길이의 전방 차이가 취해지고, 이 예에서, 산출하는 이 앞에 붙는다 . 이것은 새로운 어레이는 다음의 결과로 압축된다 만드는 상기 Starmap 교육 사업자는 각각의 쌍을 통해 실행된다.$[2, 5]$$A'' - 1$$-$$0$$[0, 3]$$g$$B$

$k(x, n)$

Starmap 교육 연산자 기능 사용 인수로서, 그리고 이항 함수와 중첩 배열을 취함으로써 작동한다. 배열은 과 같이 쌍으로 구성되어야하며 쌍 함수는 쌍마다 매핑되며 쌍의 각 요소는 왼쪽과 오른쪽입니다 각각의 주장.$k$$[[1, 2], [3, 4], [5, 6]]$

여기서 중첩 배열의 예는 이고 함수는 입니다. 우리는 지금 간단히 에 집중할 것 입니다.$[[[1, 2], 0], [[1, 2, 0, 1, 2], 3]]$$k$$k([1, 2, 0, 1, 2], 3)$

g n = 0 [ n , x , n ] n = 0 [ [ 2 , 1 , 0 , 1 , 2 ] , 3 ] n x x $k(x, n)$ 유사하게, 개시 어레이 스택의 위쪽이되도록 상기 두 개의 인자를 바꾼다. 그런 다음 배열을 뒤집고 인수를 다시 바꿉니다. 이제 이므로 배열을 변경하지 않고 정수를 복제하고 상위 세 개의 인수를 회전하여 스택의 형식이 입니다. 다음으로, 배열을 반환합니다 . 그렇지 않으면, 최상위 요소는 버려지고, 우리는 스택을 어떻게 배열했는지, 즉 아래쪽에있는 역배열과 상단에있는 정수, 또는 예 : . 그런 다음 스택을 평평하게하고 의 처음 요소를 가져옵니다.$g$$n = 0$$[n, x, n]$$n = 0$$[[2, 1, 0, 1, 2], 3]$$n$$x$. 그런 다음 이러한 요소가 리턴되고 에서 대체 합니다.$x$$B$

입력의 경우 반환합니다 . 엄격히 말하면 반환 하지만 순서는 나머지 프로그램에는 중요하지 않습니다.[ 2 , 1 , 0 $[0, 1, 2]$$[2, 1, 0]$

후에 각각의 쌍에 걸쳐 매핑된다 , 우리는 각 쌍의 합을, 각각의 인접한 한 쌍의 동일하다고 주장하고 있다고 주장하는 각 요소가 동일하다고 확인 각 동등성 검정의 결과는 (진실한 값)입니다. 마지막으로이 결과가 반환됩니다.( x , n ) ∈ B $k(x, n)$$(x, n) \in B$$1$