소개

비어 있지 않은 정수 목록 L 을 고려하십시오 . 제로섬 슬라이스 의 L은 의 연속 시퀀스이다 L 합이 예컨대 0과 동일, [-2, 2, 1] 의 제로 합 슬라이스 인 [-2, 4, 1, -3, 2, 2 , -1, -1] 이지만 [2, 2] 는 0이 아니기 때문에 아니고 [4, -3, -1]도 아니고 (연속적이지 않기 때문에)도 아닙니다.

제로 합 조각 모음 L은 A는 제로 합 커버 의 L 모든 요소가 조각들 중 적어도 하나에 속하는 경우. 예를 들면 다음과 같습니다.

L = [-2, 4, 1, -3, 2, 2, -1, -1]
A = [-2, 4, 1, -3]
B =        [1, -3, 2]
C =                  [2, -1, -1]

3 개의 제로섬 슬라이스 A , B 및 C 는 L의 제로섬 커버를 형성한다 . 동일한 슬라이스의 여러 복사본이 다음과 같이 제로섬 커버에 나타날 수 있습니다.

L = [2, -1, -1, -1, 2, -1, -1]
A = [2, -1, -1]
B =        [-1, -1, 2]
C =                [2, -1, -1]

물론 모든 목록에 제로섬 커버가있는 것은 아닙니다. 일부 예는 [2, -1] (모든 슬라이스에 0이 아닌 합계가 있음) 및 [2, 2, -1, -1, 0, 1] (가장 왼쪽에있는 2 는 0 합계 슬라이스의 일부가 아님)입니다.

작업

입력 값은 비어 있지 않은 정수 목록 L 입니다. 합리적인 형식으로 가져옵니다. 경우 출력은 truthy 값이어야한다 L이 제로 합 커버를 갖고, falsy 값 아니라면.

전체 프로그램이나 함수를 작성할 수 있으며 가장 낮은 바이트 수가 이깁니다.

테스트 사례

[-1] -> False
[2,-1] -> False
[2,2,-1,-1,0,1] -> False
[2,-2,1,2,-2,-2,4] -> False
[3,-5,-2,0,-3,-2,-1,-2,0,-2] -> False
[-2,6,3,-3,-3,-3,1,2,2,-2,-5,1] -> False
[5,-8,2,-1,-7,-4,4,1,-8,2,-1,-3,-3,-3,5,1] -> False
[-8,-8,4,1,3,10,9,-11,4,4,10,-2,-3,4,-10,-3,-5,0,6,9,7,-5,-3,-3] -> False
[10,8,6,-4,-2,-10,1,1,-5,-11,-3,4,11,6,-3,-4,-3,-9,-11,-12,-4,7,-10,-4] -> False
[0] -> True
[4,-2,-2] -> True
[2,2,-3,1,-2,3,1] -> True
[5,-3,-1,-2,1,5,-4] -> True
[2,-1,-1,-1,2,-1,-1] -> True
[-2,4,1,-3,2,2,-1,-1] -> True
[-4,-1,-1,6,3,6,-5,1,-5,-4,5,3] -> True
[-11,8,-2,-6,2,-12,5,3,-7,4,-7,7,12,-1,-1,6,-7,-4,-5,-12,9,5,6,-3] -> True
[4,-9,12,12,-11,-11,9,-4,8,5,-10,-6,2,-9,10,-11,-9,-2,8,4,-11,7,12,-5] -> True

젤리 , 13 12 바이트

JẆịS¥ÐḟċþJḄẠ

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

작동 원리

JẆịS¥ÐḟċþJḄẠ  Main link. Argument: A (array)

J             Yield all indices of A.
 Ẇ            Window; yield all slices of indices.
     Ðḟ       Filter; keep slices for which the link to the left returns 0.
    ¥           Combine the two atoms to the left into a dyadic chain.
  ị               Retrieve the elements of A at the slice's indices.
   S              Take the sum.
         J    Yield the indices of A.
       ċþ     Count table; count how many times each index appears in each table.
          Ḅ   Unbinary; convery the array of counts of each index from base 2 to 
              integer. This yields 0 iff an index does not appear in any slice.
           Ạ  All; return 1 iff all integers are non-zero.

매스 매 티카, 66 65 바이트

ngenisis 덕분에 1 바이트를 절약하고 미래를위한 새로운 트릭을 배웠습니다!

입력 및 반환 등 정수의 목록 복용 익명의 함수입니다 둘 다 두 똑같이 긴 대안, True또는 False:

And@@Table[0==Product[Tr@#[[i;;j]],{i,k},{j,k,l}],{k,l=Tr[1^#]}]&

0==Norm@Table[Product[Tr@#[[i;;j]],{i,k},{j,k,l}],{k,l=Tr[1^#]}]&

두 경우 모두 Tr@#[[i;;j]]위치 i에서 위치 j(1 색인)로 입력 슬라이스의 합계를 계산합니다 . 최대 인 인덱스의 범위 와 최소 인 인덱스의 범위 Product[...,{i,k},{j,k,l}]로 이러한 모든 슬라이스 합계를 곱 합니다. ( 입력 목록에있는 모든 거듭 제곱 의 합으로 정의 됩니다. 간단히 말하면 목록의 길이입니다.) 즉,이 요소는 th 요소가 zero-sum slice에 속하는 경우에만 0과 같습니다. .ikjkl=Tr[1^#]l1k

첫 번째 버전에서는 해당 제품의 각각과 비교 0하고, And@@반환 True모든 단일 제품이 동일 정확하게 할 때 0. 두 번째 버전에서 제품 목록은 함수 Norm( l차원 벡터 의 길이) 에 의해 수행되며 , 0모든 항목이 같거나 같을 경우에만 같습니다 0.

Mathematica, 65 64 바이트

1 바이트 저장을위한 ngenisis 덕분입니다.

Union@@Cases[Subsequences[x=Range@Tr[1^#]],a_/;Tr@#[[a]]==0]==x&

오히려 순수한 패턴 매칭 솔루션을 찾고 싶지만 까다로운 것으로 판명되었습니다 ( {___,a__,___}항상 매우 길다).

하스켈, 94 바이트

import Data.Lists
g x=(1<$x)==(1<$nub(id=<<[i|(i,0)<-fmap sum.unzip<$>powerslice(zip[1..]x)]))

사용 예 : g [-11,8,-2,-6,2,-12,5,3,-7,4,-7,7,12,-1,-1,6,-7,-4,-5,-12,9,5,6,-3] -> True.

작동 방식 ( [-1,1,5,-5]입력에 사용 ) :

        zip[1..]x  -- zip each element with its index
                   -- -> [(1,-1),(2,1),(3,5),(4,-5)]
      powerslice   -- make a list of all continuous subsequences
                   -- -> [[],[(1,-1)],[(1,-1),(2,1)],[(1,-1),(2,1),(3,5)],[(1,-1),(2,1),(3,5),(4,-5)],[(2,1)],[(2,1),(3,5)],[(2,1),(3,5),(4,-5)],[(3,5)],[(3,5),(4,-5)],[(4,-5)]]
    <$>            -- for each subsequence
   unzip           --   turn the list of pairs into a pair of lists
                   --   -> [([],[]),([1],[-1]),([1,2],[-1,1]),([1,2,3],[-1,1,5]),([1,2,3,4],[-1,1,5,-5]),([2],[1]),([2,3],[1,5]),([2,3,4],[1,5,-5]),([3],[5]),([3,4],[5,-5]),([4],[-5])]
  fmap sum         --   and sum the second element
                   --   -> [([],0),([1],-1),([1,2],0),([1,2,3],5),([1,2,3,4],0),([2],1),([2,3],6),([2,3,4],1),([3],5),([3,4],0),([4],-5)]
 [i|(i,0)<-    ]   -- take all list of indices where the corresponding sum == 0
                   -- -> [[],[1,2],[1,2,3,4],[3,4]]
 id=<<             -- flatten the list
                   -- -> [1,2,1,2,3,4,3,4]
nub                -- remove duplicates
                   -- -> [1,2,3,4]

(1<$x)==(1<$    )  -- check if the above list has the same length as the input list. 

루비, 81 바이트

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

단순한 무차별 솔루션; 배열의 모든 요소에 대해 배열을 포함하는 제로섬 슬라이스를 찾으십시오.

->a{(0..l=a.size).all?{|i|(0..i).any?{|j|(i..l).any?{|k|a[j..k].inject(:+)==0}}}}

J, 36 35 바이트

#\*/@e.[:;]({:*0=[:+/{.)@|:\.\@,.#\

모든 하위 합계에 대해 요소의 색인을 추가하고 하위 합계가있는 경우 색인을 유지 0한 다음 모든 색인이 있는지 확인합니다.

트릭 : 목록의 1 기반 인덱스 #\는 모든 접두사 길이 로 생성 될 수 있습니다 .

용법:

   (#\*/@e.[:;]({:*0=[:+/{.)@|:\.\@,.#\) 2 _1 _1 2
1
   (#\*/@e.[:;]({:*0=[:+/{.)@|:\.\@,.#\) 2 _1
0

여기에서 온라인으로 사용해보십시오.

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

f=([q,...a],b=[],c=[])=>1/q?f(a,[...b,0].map((x,i)=>x+q||(c=c.map((n,j)=>n|i<=j)),c.push(0)),c):c.every(x=>x)

테스트 스 니펫

f=([q,...a],b=[],c=[])=>1/q?f(a,[...b,0].map((x,i)=>x+q||(c=c.map((n,j)=>n|i<=j)),c.push(0)),c):c.every(x=>x)

I.textContent = I.textContent.replace(/.+/g,x=>x+` (${f(eval(x.split(" ")[0]))})`)

<pre id=I>[-1] -> False
[2,-1] -> False
[2,2,-1,-1,0,1] -> False
[2,-2,1,2,-2,-2,4] -> False
[3,-5,-2,0,-3,-2,-1,-2,0,-2] -> False
[-2,6,3,-3,-3,-3,1,2,2,-2,-5,1] -> False
[5,-8,2,-1,-7,-4,4,1,-8,2,-1,-3,-3,-3,5,1] -> False
[-8,-8,4,1,3,10,9,-11,4,4,10,-2,-3,4,-10,-3,-5,0,6,9,7,-5,-3,-3] -> False
[10,8,6,-4,-2,-10,1,1,-5,-11,-3,4,11,6,-3,-4,-3,-9,-11,-12,-4,7,-10,-4] -> False
[0] -> True
[4,-2,-2] -> True
[2,2,-3,1,-2,3,1] -> True
[5,-3,-1,-2,1,5,-4] -> True
[2,-1,-1,-1,2,-1,-1] -> True
[-2,4,1,-3,2,2,-1,-1] -> True
[-4,-1,-1,6,3,6,-5,1,-5,-4,5,3] -> True
[-11,8,-2,-6,2,-12,5,3,-7,4,-7,7,12,-1,-1,6,-7,-4,-5,-12,9,5,6,-3] -> True
[4,-9,12,12,-11,-11,9,-4,8,5,-10,-6,2,-9,10,-11,-9,-2,8,4,-11,7,12,-5] -> True</pre>

파이썬, 123120 바이트

_{@Zgarb 덕분에 -3 바이트}

제로섬 슬라이스가있는 입력과 동일한 크기의 목록을 채우고 인덱스에 따라 덮어 쓰고 끝에서 원본과의 동등성을 반환합니다.

def f(l):
 s=len(l);n=[0]*s
 for i in range(s):
  for j in range(i,s+1):
   if sum(l[i:j])==0:n[i:j]=l[i:j]
 return n==l

스칼라, 49 바이트

% =>(1 to%.size)flatMap(%sliding)exists(_.sum==0)

이데온에서 사용해보십시오

용법:

val f:(Seq[Int]=>Boolean)= % =>(1 to%.size)flatMap(%sliding)exists(_.sum==0)
f(Seq(4, -2, -2)) //returns true

언 골프 드 :

array=>(1 to array.size)
  .flatMap(n => array.sliding(n))
  .exists(slice => slice.sum == 0)

설명:

% =>            //define a anonymouns function with a parameter called %
  (1 to %.size) //create a range from 1 to the size of %
  flatMap(      //flatMap each number n of the range
    %sliding    //to an iterator with all slices of % with length n
  )exists(      //check whether there's an iterator with a sum of 0
    _.sum==0
  )

파이썬, 86 바이트

def f(l):
 r=range(len(l))
 if[i for i in r for j in r if sum(l[j:j+i+1])==0]:return 1

진실한 = 1 거짓 = 없음

클로저, 109 바이트

#(=(count %)(count(set(flatten(for[r[(range(count %))]l r p(partition l 1 r):when(=(apply +(map % p))0)]p))))

합이 0 인 모든 파티션을 생성하고, "입력 벡터 길이"고유 인덱스가 있는지 확인합니다.

PHP, 104 바이트

무차별 대입 및 여전히 99 바이트 이상. :-(

for($p=$r=$c=$argc;$s=--$p;)for($i=$c;$s&&$k=--$i;)for($s=0;$k<$c&&($r-=!$s+=$argv[$k++])&&$s;);echo!$r;

1진실을 위해 명령 줄 인수에서 입력 을 받고 거짓을 위해 비어 있습니다. 로 실행하십시오 -r.

고장

for($p=$r=$argc;$s=$p--;)   # loop $p from $argc-1 to 0 with dummy value >0 for $s
    for($i=$p;$s&&$k=$i--;)     # loop $i (slice start) from $p to 1, break if sum is 0
        for($s=0;                   # init sum to 0
            $k<$argc                # loop $k (slice end) from $i to $argc-1
            &&($r-=!$s+=$argv[$k++])    # update sum, decrement $r if sum is 0
            &&$s;);                     # break loop if sum is 0
echo!$r;                    # $r = number of elements that are not part of a zero-sum slice

$argv[0]파일 이름을 포함합니다. 으로 실행하는 경우 -r, 그것은 것입니다 -및로 평가 0숫자 작전을 위해.

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

a=>(g=f=>a.map((_,i)=>f(i)))(i=>g(j=>j<i||(t+=a[j])||g(k=>b[k]&=k<i|k>j),t=0),b=g(_=>1))&&!/1/.test(b)

모든 요소를 i..j포함 하여 모든 요소에 대한 부분 합계를 계산하고 0 합계를 발견 하면 관련 요소를 b에서 1로 재설정하고 0마지막으로 1s 가 없는지 확인합니다 .