때로는 지루할 때 음이 아닌 정수 배열의 합계를 취하고 싶습니다. 나는 2의 거듭 제곱 길이의 합을 취합니다. 불행히도 나는 종종 실수를한다. 다행스럽게도 다음과 같은 방식으로 작업을 추적합니다.

하나만 남을 때까지 인접한 숫자 쌍을 추가합니다. 예를 들면 다음과 같습니다.

 6 + 18 + 9 + 6 + 6 + 3 + 8 + 10
=  24   +   15  +   9   +   18
=       39      +       27
=               66

당신이 할 일은 내가 어딘가에 실수를했는지 알아내는 것입니다. 함수에 입력을 전달하거나 표준 입력에서 읽을 수 있습니다. 출력을 인쇄하거나 반환 할 수 있습니다.

입력 : 배열 / 목록 / 등 음수가 아닌 정수 및 언어에 필요한 경우 해당 배열의 길이. 이 배열은 왼쪽에서 오른쪽으로, 위에서 아래로 읽는 모든 숫자입니다. 예를 들어 위의 배열은 다음
[[6, 18, 9, 6, 6, 3, 8, 10], [24, 15, 9, 18], [39, 27], [66]]
과 같습니다
[6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66].

출력 : 실수 여부를 나타내는 단일 부울입니다. 부울을 이용하여 표현 될 수 있는 실수가 돌아 오지 포함 실수 복귀되어 모든 입력 / 동일한 결과를 인쇄하는 것을 제공 매핑 모든 입력 / 동일한 결과를 출력한다. 이것은 말할 것도없이 진행되어야하지만이 두 출력은 같을 수 없습니다.

올바른 요약의 일부 예 :

6

5+6
=11

  3 + 2 + 4 + 5
=   5   +   9
=       14

[0, 1, 2, 3, 1, 5, 6]

[[1, 2, 4, 8], [3, 12], [15]]

잘못된 요약의 일부 예 :

5+4
=8

4 + 4 + 4 + 4
= 9   +   7
=     16

[[1, 2, 3, 4], [7, 3], [10]]

[3, 4, 5, 6, 7, 8, 9]

실수를해도 여전히 정답을 얻을 수 있습니다. 실수를하면 최종 배열에서 여분의 숫자가 누락되거나 숫자가 누락되지 않으며 잘못된 숫자 만 발생합니다.

표준 허점은 금지되어 있습니다. 각 언어에서 가장 짧은 답변이 승자입니다. 넥타이의 경우 더 오래된 답변이 이길 것입니다. 나는 "동일한 언어"가 무엇인지 결정할 권리가 있지만, 파이썬 2와 파이썬 3 모두에서 포인트를 얻을 수는 없다고 말할 것입니다.

젤리 , 6 바이트

Ṗ+2/€ẇ

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

작동 원리

Ṗ+2/€ẇ  Main link. Argument: A (2D array)

Ṗ       Pop; yield A without its last element. Let's call the result B.
  2/    Pairwise reduce...
    €     each array in B...
 +          by addition.
     ẇ  Window exists; test if the result appears in A as a contiguous subarray.

파이썬 2 , 51 바이트

lambda l:map(sum,zip(*[iter(l)]*2))==l[len(l)/2+1:]

온라인으로 사용해보십시오! 테스트 사례에 대해 Rod에게 감사드립니다.

전체 목록을 입력으로 사용합니다. zip / iter trick을 사용하여 요소를 인접한 쌍으로 그룹화 하고 쌍의 합을 취하여 결과가 목록의 후반과 같은지 확인합니다.

재귀 방법은 55 바이트에서 듯했습니다 :

f=lambda l:len(l)<2or l[0]+l[1]==l[len(l)/2+1]*f(l[2:])

이것은 입력 정수가 양수라는 것을 사용하여 스펙에서 변경되었습니다.

로다 , 40 바이트

{[0]if{|x|[[x()|[_+_]]=y]if tryPeek y}_}

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

0실수가 없으면 리턴 하고 실수가 없으면 리턴하는 익명 함수입니다 .

설명:

{[0]if{|x|[[x()|[_+_]]=y]if tryPeek y}_}
{                                      } /* Anonymous function */
      {|x|                           }_  /* Loop over lists in the stream */
                         if tryPeek y    /* If there are lists left after this */
            x()                          /* Push values in list x to the stream */
               |[_+_]                    /* Sum every pair of numbers in x */
           [         ]                   /* Create a list of sums */
                      =y                 /* If the list equals to the next list */
          [             ]                /* Push the result */
    if                                   /* If all results are TRUE */
 [0]                                     /* Return 0 */
                                         /* Otherwise return nothing */

다음은 더 짧은 (35 바이트) 버전이지만 규칙에 위배되는 버전입니다 (제 생각에).

{{|x|[[x()|[_+_]]=y]if tryPeek y}_}

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

스트림에서 값을 읽고 각 올바른 행을 푸시 TRUE하거나 푸시하는 익명 함수입니다 FALSE.

규칙 에서이 (여러 반환 값)가 허용되는지 확실하지 않습니다. 내 방어는 다음과 같습니다. Röda에서 조건 if과 while블록은 부울 값이 아니라 스트림입니다. "truthy"스트림은 비어 있거나 TRUEs 만 포함 하고 "falsy"스트림에는 하나 이상의 FALSEs가 포함됩니다. 이런 식으로이 함수는 "부울"값을 반환합니다. 또한 if축소 연산 등이 없어도 명령문 의 조건으로 사용할 수 있습니다 .

파이썬 2 , 69 65 바이트

lambda x:reduce(lambda a,b:(b==map(sum,zip(a[::2],a[1::2])))*b,x)

온라인으로 사용해보십시오!
반환 :
빈 Falsy
총계 목록Truthy

Mathematica, 36 바이트

Most[Tr/@#~Partition~2&/@#]==Rest@#&

입력 및 반환 등의 중첩 된 목록 복용 순수 기능 True또는 False. 이 함수 Tr/@#~Partition~2&는 목록의 쌍별 합계를 취한 다음 /@#입력 목록의 각 하위 목록에 적용됩니다 ( ). 결과 목록의 첫 번째, 두 번째 ... 하위 목록은 원래 입력의 두 번째, 세 번째 ... 하위 목록과 동일합니다. Most[...]==Rest@#이 속성을 테스트합니다.

파이썬 2 , 80 바이트

lambda l:all(l[i+1]==map(sum,zip(l[i][::2],l[i][1::2]))for i in range(len(l)-1))

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

다른 파이썬 답변만큼 좋지는 않지만 어쨌든 게시하는 느낌이 들었습니다. 이것은 왜 내가 정규 언어 로 골프를 잘하지 못하는지를 보여줍니다 .

자바 스크립트 (ES6), 54 바이트

a=>!a.slice(-a.length/2).some((n,i)=>a[i+=i]+a[i+1]-n)

평평한 배열을 취합니다.

05AB1E , 15 12 바이트

¬svyQy2ôO}\P

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

설명

¬             # get the first element from input without popping
 sv      }    # for each element y in input
   yQ         # compare y to the top of the stack 
              # leaves 1 on the stack if equal and otherwise 0
     y2ô      # split y in pieces of 2
        O     # sum each pair in the list
          \   # discard the top of the stack (the left over final element of the list)
           P  # product of stack (all the 1's and/or 0's from the comparisons)

하스켈 , 82 79 65 바이트

nimi 덕분에 -14 바이트!

p(x:y:z)=x+y:p z
f x=and.zipWith(==)(drop(length x`div`2+1)x)$p x

각 요소 쌍의 합계를 다음 줄의 해당 요소와 비교하여 작동합니다. 일부 바이트는에서 골프를 칠 f수 있지만 어디에서 알 수는 없습니다.

파이썬 3 , 69 68 바이트

lambda v:any(x+v[i-1]-v[(len(v)+i)//2]for i,x in enumerate(v)if i%2)

나는 이미 두 개의 다른 파이썬 답변이 있다는 것을 알고 있습니다 ... 그러나 이것은 파이썬 3에 있으므로 이국적인 것입니다.

이것은 평평한 입력에서 작동합니다.

출력 :

False 실수가 없다면

True 실수가 있다면.

루비, 50 바이트

->x{a=b=0;b&&=x[a/2]==x[a]+x[a-1]while x[-a-=2];b}

배열을 반대로하면 전반부의 요소 (위치 n)는 위치 n * 2 및 n * 2 + 1에있는 요소의 합이어야합니다.

Brachylog , 16 13 바이트

s₂ᵘ{{ġ₂+ᵐ}ᵈ}ᵐ

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

이것은 끔찍하게 길다! 인라인 술어를 여기에 중첩시키지 않는 방법이 있어야합니다.

술어는 true.실수가 없으면 실패하고 ( false.프로그램으로 인쇄 ) 그렇지 않으면 실패합니다 ( 프로그램으로 인쇄 ).

s₂ᵘ              Every length 2 substring of the input
   {       }ᵐ    for every element satisfies the following:
    {ġ₂          the pairs of elements of the input
       +ᵐ        when each pair is summed is the output
         }ᵈ      where the input is the first item and the output is the second.

파이썬 2 , 64 바이트

lambda a:[map(int.__add__,x[::2],x[1::2])for x in a[:-1]]==a[1:]

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

이름이없는 함수는 목록 목록 (작업 당 한 줄에 하나씩)을 가져오고 실수가 없으면 True를, 그렇지 않으면 False를 반환합니다.

마지막 항목이 a[:-1]없는 입력을 사용하여 첫 번째 항목이없는 입력을 구성하고 입력 된 내용을 확인하여 작동 ==a[1:]합니다.

이 형식은 정수 유형의 덧셈 함수 int.__add__를 두 개의 "슬라이스"에 의해 생성 된 숫자 쌍 에 매핑하여 달성됩니다 . 하나는 슬라이스가 0 번째 인덱스에서 시작하는 모든 다른 항목이고 다른 하나 x[::2]는 1 일부터 시작하는 모든 다른 항목입니다. 색인 x[1::2].

핍 , 20 19 바이트

$*{{b=$+*Ya<>2}MPa}

이것은 하나의 인수, 목록 목록 (예 :)을 취하는 익명 함수입니다 [[1 2 3 4] [3 7] [10]]. 모든 테스트 사례를 확인하십시오 : 온라인으로 사용해보십시오!

설명

Pip 함수에서 처음 두 인수는 a및에 할당됩니다 b.

  {               }  Anonymous function:
   {          }MPa    To each pair of sublists from a, map this helper function:
          a<>2         Group the 1st member of the pair into 2-item sublists
         Y             Yank that value (no-op used to override precedence order)
      $+*              Map (*) the fold ($) on addition (+) operator
    b=                 If the 2nd member of the pair is = to the result, 1; else 0
$*                   Modify the outside function by folding its return value on *
                     (makes a list containing all 1's into 1 and any 0's into 0)

예를 들면 다음과 같습니다.

a
[[1 2 3 4] [7 3] [10]]

{...}MP
a:[1 2 3 4] b:[7 3]
a:[7 3]     b:[10]

a<>2
[[1 2] [3 4]]
[[7 3]]

$+*
[3 7]
[10]

b=
0
1

Final result of {...}MPa
[0 1]

$*
0

PHP, 96 95 바이트 :

내장 사용하기 :

function f($a){return!$a[1]||array_pop($a)==array_map(array_sum,array_chunk(end($a),2))&f($a);}
// or
function f($a){return!$a[1]||array_map(array_sum,array_chunk(array_shift($a),2))==$a[0]&f($a);}

재귀 함수는 true또는을 반환 false합니다.

첫 번째 기능에 대한 분석 :

function f($a){
    return!$a[1]||      // true if array has no two rows ... or
    array_pop($a)==     // remove last row, true if equal to
    array_map(array_sum,    // 3. sum up every chunk
        array_chunk(        // 2. split to chunks of 2
            end($a)         // 1. new last row
        ,2))
    &f($a);             // and recursion returns true
}

루프를 사용하는 이전 솔루션 (각 96 바이트) :

function f($a){foreach($a[0]as$k=>$v)$b[$k/2]+=$v;return$b==$a[1]&&!$a[2]|f(array_slice($a,1));}
//or
function f($a,$y=0){foreach($a[$y]as$k=>$v)$b[$k/2]+=$v;return$b==$a[++$y]&&!$a[$y+1]|f($a,$y);}

마지막 기능에 대한 분석 :

function f($a,$y=0){
    foreach($a[$y]as$k=>$v)$b[$k/2]+=$v;    // build $b with correct sums from current row
    return$b==$a[++$y]                      // true if $b equals next row
    &&!$a[$y+1]                             // and (finished
        |f($a,$y);                          //      or recursion returns true)
}

반복 스 니펫, 81 바이트

for(;$a[1];)if(array_pop($a)!=array_map(array_sum,array_chunk(end($a),2)))die(1);
for(;$a[1];)if(array_map(array_sum,array_chunk(array_shift($a),2))!=$a[0])die(1);
for(;$a[++$y];$b=[]){foreach($a[$y-1]as$k=>$v)$b[$k/2]+=$v;if($a[$y]!=$b)die(1);}

에서 사전 정의 된 배열을 가정합니다 $a. 올바르지 않으면 오류와 함께 종료됩니다.

C, 54 바이트 :

f(int*s,int*e){return e-s>1?*s+s[1]-*e||f(s+2,e+1):0;}

언 골프 드 :

int f(int*s,int*e) {
    if(e-s>1) {
        return *s+s[1] != *e || f(s+2,e+1);
    } else {
        return 0;
    }
}

로 테스트

#include <assert.h>
int main() {
    int input1[15] = {6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66};
    assert(!f(input1, input1+8));

    int input2[7] = {3, 4, 5, 6, 7, 8, 9};
    assert(f(input2, input2+4));
}

보시다시피, f()유효하지 않은 입력에 대해서는 true를, 유효 입력에 대해서는 false (= 0)를 반환합니다.

항상 그렇듯이 재귀는 반복보다 바이트 수가 적기 때문에 f()두 개의 반복자를 인수로 사용하더라도 재귀 적입니다. 레벨 경계를 무시하고 2 개의 정수의 합을 반복 할 때까지 2 개의 정수의 합 s을 1의 정수와 반복하여 비교합니다 e. 또한 코드를 더 짧게하기 위해 C에서 0이 아닌 정수 값이 true로 간주된다는 사실과 함께 부울 선을 사용했습니다.

R, 92 77 바이트

일련의 숫자를 입력으로 사용하는 익명 함수. 반환 TRUE하거나 FALSE적절하게. xnor의 python answer와 개념적으로 동일한 접근 방식을 사용합니다.

function(x,l=sum(1|x)/2)all(rowSums(cbind(x[1:l*2-1],x[1:l*2]))==tail(x,l-1))

패키지 의 rollapply기능을 사용하고 zoo목록으로 입력을받는 이전 솔루션 list(c(6, 18, 9, 6, 6, 3, 8, 10), c(24, 15, 9, 18), c(39, 27), c(66)): 예 :

function(l,T=1){for(i in 2:length(l))T=T&all(zoo::rollapply(l[[i-1]],2,sum,by=2)==l[[i]]);T}

자바 스크립트 (ES6), 46 44 바이트

평평한 배열로 입력을받습니다. NaN유효 또는 0무효를 반환 합니다 .

f=([a,b,...c])=>a+b==c[c.length>>1]?f(c):b-b

테스트

f=([a,b,...c])=>a+b==c[c.length>>1]?f(c):b-b

console.log(f([6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66])) // NaN
console.log(f([0, 1, 2, 3, 1, 5, 6]))                                 // NaN
console.log(f([1, 2, 4, 8, 3, 12, 15]))                               // NaN
console.log(f([1, 2, 3, 4, 7, 3, 10]))                                // 0
console.log(f([3, 4, 5, 6, 7, 8, 9]))                                 // 0

PHP, 102 바이트

이 형식의 input als url 매개 변수는 ?0=[1,2,3]&1=[3,3]&2=[6] 이 입력을 사용합니다.[[int,int],[int]]

<?$r=[$_GET[0]];for(;count(end($r))>1;)$r[]=array_map(array_sum,array_chunk(end($r),2));echo$r==$_GET;

고장

$r=[$_GET[0]]; # Set the first item of the input in the result array 
for(;count(end($r))>1;) # till the last item in the result array has only one int
$r[]=array_map(array_sum,array_chunk(end($r),2));# add the next item to the result array
echo$r==$_GET; # compare the input array with the result array

apt, 10 바이트

입력을 2 차원 배열로 취합니다.

äÏeXò mxÃe

시도 해봐

äÏeXò mxÃe     :Implicit input of 2-D array
ä              :Reduce each consecutive pair of sub-arrays
 Ï             :By passing them through the following function as X & Y, respectively
  e            :  Test Y for equality with
   Xò          :    Split X on every 2nd element
      m        :    Map
       x       :      Reduce by addition
        Ã      :End function
         e     :All true?