Giriş

Tam sayıların L boş bir listesini düşünün . Bir sıfır toplam dilim arasında L bitişik bir sekans olan L miktarı toplamı Örneğin 0'a eşit, [-3, 2, 1] bir sıfır toplam dilim [-2, 4, 1, -3, 2, 2 , -1, -1] , ancak [2, 2] değil (çünkü 0'ı toplamaz) ve hiçbiri [4, -3, -1] (çünkü bitişik değildir).

Sıfır toplamı dilimlerinin bir toplama L a, sıfır toplamı kapak arasında L her eleman dilimleri en az birine ait ise. Örneğin:

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

Sıfır toplam üç dilim A , B ve C , sıfır toplam L kapağını oluşturur . Aynı dilimin birden fazla kopyası, sıfır toplamlı bir kapakta şöyle görünebilir:

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

Tabii ki, tüm listelerin sıfır toplamlı bir kapsamı yoktur; Bazı örnekler [2, -1] (her dilim sıfır toplamına sahip değildir) ve [2, 2, -1, -1, 0, 1] (en soldaki 2 sıfır toplam dilimin bir parçası değildir).

Görev

Girişiniz , makul bir biçimde alınmış, boş olmayan bir tamsayı listesi L'dir . Çıktınız, L' nin sıfır toplamlı bir kapsama sahip olması durumunda gerçeğe uygun bir değer, değilse de sahte bir değer olacaktır.

Tam bir program veya fonksiyon yazabilirsiniz ve en düşük bayt sayısı kazanır.

Test durumları

[-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

Jöle , 13 12 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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.

Mathematica, 66 65 bayt

1 bayt kurtarıldı ve umarım ngenisis sayesinde gelecek için yeni bir numara öğrendi!

Her ikisi de giriş ve dönüş olarak tamsayıların listesini alan adsız işlevler olan eşit derecede uzun iki alternatif Trueveya 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^#]}]&

Her iki durumda da, Tr@#[[i;;j]]girişin diliminin toplamını pozisyondan ipozisyona j(1 indeksli) hesaplar . en fazla olan endekslerin üstündeki ve en azından olan endekslerin üstündeki Product[...,{i,k},{j,k,l}]tüm bu dilim toplamlarını bir araya getirir . ( Giriş listesindeki tüm güçlerin toplamı olarak tanımlandığını unutmayın; bu yalnızca listenin uzunluğudur.) Başka bir deyişle, bu ürün, yalnızca th öğesi sıfır toplamlı bir dilime aitse 0'a eşittir. .ikjkl=Tr[1^#]l1k

İlk versiyonda, bu ürünlerin her biri karşılaştırılıyor 0ve her bir ürün eşit olduğunda tam olarak And@@geri dönüyor . İkinci versiyonda, ürün listesine, sadece her girişin eşit olup olmadığına eşit olan (boyutsal vektörün uzunluğu) fonksiyonu tarafından etkilenir .True0Norml00

Mathematica, 65 64 bayt

1 byte tasarruf için ngenisis teşekkürler.

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

Saf bir kalıp eşleştirme çözümü bulmayı tercih ederim, ama zor olduğu kanıtlandı (ve bunun gibi şeyler {___,a__,___}her zaman süper uzun).

Haskell, 94 bayt

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

Kullanım örneği: 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.

Nasıl çalışır ( [-1,1,5,-5]giriş için kullanalım ):

        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. 

Ruby, 81 bayt

Çevrimiçi deneyin

Basit kaba kuvvet çözümü; dizinin her elemanı için onu içeren sıfır toplamlı bir dilim bulmaya çalışın.

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

J, 36 35 bayt

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

Her altsum için elementin indekslerini eklerim ve ben onun altında indeksleri tutarım 0.

Hile: Bir listenin 1 tabanlı dizinleri #\, her ön ekin uzunluğuyla oluşturulabilir .

Kullanımı:

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

Burada çevrimiçi deneyin.

JavaScript (ES6), 109 bayt

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)

Test pasajı

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>

Python, 123 120 bayt

_{@Zgarb sayesinde -3 bayt}

Sıfır toplamlı dilimlerle aynı boyutta olan bir listeyi doldurur ve endekslere göre üzerine yazar, eşitliği sonunda orijinaline döndürür.

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

Scala, 49 bayt

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

İdeone de dene

Kullanımı:

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

Ungolfed:

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

Açıklama:

% =>            //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
  )

Python, 86 Bayt

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

Truthy = 1 Falsy = Yok

Clojure, 109 bayt

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

Sıfıra toplanan tüm bölümleri oluşturur, "giriş vektörünün uzunluğu" farklı endekslerine sahip olduğunu kontrol eder.

PHP, 104 bayt

Kaba kuvvet ve hala 99 bayttan fazla. :-(

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;

komut satırı argümanlarından girdi alır; gerçek 1için, boşsa boş. İle koş -r.

Yıkmak

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]dosya adını içerir; ile çalıştırırsanız -r, bu olacak -ve değerlendirmek 0sayısal operasyonlar için.

JavaScript (ES6), 102 bayt

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)

Kısmi elemanlar herkes için toplamları hesaplar i..jherşey dahil ve sıfırlanır ilgili unsurları bgelen 1için 0nihayet hiçbir olmadığını kontrol ettikten sıfır toplamı bulduğunda 1kaldıysa.