शून्य राशि कवर

Question

परिचय

पूर्णांक की एक गैर-रिक्त सूची L पर विचार करें । एक शून्य राशि टुकड़ा के एल का एक सन्निहित परिणाम को है एल जिसका योग 0. उदाहरण के लिए बराबर होती है, [, 1 -3, 2] के एक शून्य राशि टुकड़ा है [-2, 4, 1, -3, 2, 2 , -1, -1] , लेकिन [2, 2] नहीं है (क्योंकि यह 0 का योग नहीं है), और न ही [4, -3, -1] (क्योंकि यह सन्निहित नहीं है)।

के शून्य राशि स्लाइस का एक संग्रह एल एक है शून्य राशि कवर के एल हर तत्व स्लाइस की कम से कम एक के अंतर्गत आता है, तो। उदाहरण के लिए:

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

तीन शून्य-राशि के स्लाइस 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] (हर स्लाइस में नॉनजरो योग है) और [2, 2, -1, -1, 0, 1] (सबसे बाईं ओर 2 एक शून्य-योग स्लाइस का हिस्सा नहीं है)।

काम

आपका इनपुट एक गैर-रिक्त पूर्णांक सूची L है , जिसे किसी भी उचित प्रारूप में लिया गया है। यदि L के पास शून्य-समाहित कवर है, और नहीं तो एक मिथ्या मूल्य, आपका आउटपुट एक सत्य मूल्य होगा।

आप एक पूर्ण प्रोग्राम या फ़ंक्शन लिख सकते हैं, और सबसे कम बाइट काउंट जीतता है।

परीक्षण के मामलों

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

Comments

"प्रत्येक तत्व स्लाइस में से एक के अंतर्गत आता है", क्या आप अलग-अलग सूचकांकों पर समान मूल्य को अलग-अलग मान रहे हैं?

— ngenisis

@ngenisis हां, वे अलग-अलग हैं और प्रत्येक को एक स्लाइस में होना चाहिए जिसमें संबंधित सूचकांक होता है।

— जर्बर्ब

क्या [2,2,-1,-1,0,1] -> Falseदोनों के स्लाइस [2,-1,-1]और [-1,0,1]शून्य में जोड़ने से तीसरा मिथ्या उदाहरण सत्य नहीं होना चाहिए और उनके सभी तत्व मूल सूची में हैं?

— 21

बाईं ओर 2 किसी भी शून्य-योगी स्लाइस का हिस्सा नहीं है। यह थोड़ा अस्पष्ट है, लेकिन उन्हें एक स्लाइस में घटित होना है जो "उनके सूचकांक में शामिल है"।

— ज़र्गब

समझ लिया। यह कठिन बनाता है। : ओ)

— २१

Answer 1

जेली , 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.

Answer 2

गणितज्ञ, 66 65 बाइट्स

सहेजे गए 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}]इन सभी स्लाइस-सॉम्स को एक साथ गुणा करते हैं, जैसे iकि अधिक से अधिक सूचकांकों की सीमा होती है kऔर jकम से कम होने वाले सूचकांकों की सीमा होती है k। (ध्यान दें कि l=Tr[1^#]परिभाषित करता है lकी राशि होने के लिए 1इनपुट सूची, जो केवल सूची की लंबाई। है में सभी शक्तियों को) दूसरे शब्दों में, इस उत्पाद के बराबर होती है 0 यदि और केवल यदि kवें तत्व एक शून्य राशि टुकड़ा के अंतर्गत आता है ।

पहले संस्करण में, उन उत्पादों में से प्रत्येक की तुलना की जाती है 0, और हर एक उत्पाद के बराबर होने पर ठीक And@@लौटता Trueहै 0। दूसरे संस्करण में, उत्पादों की सूची को फ़ंक्शन Norm( l-dimensional वेक्टर की लंबाई ) द्वारा कार्य किया जाता है , जो 0यदि और केवल प्रत्येक प्रविष्टि के बराबर होने पर बराबर होता है 0।

Comments

Tr[1^#]से 1बाइट बचाता है Length@#।

— नगीनिसिस

के 0^बजाय काम करेंगे 0==? यकीन नहीं होता कि मैथेमेटिका कैसे संभालती है। (आप 1/ के 0बदले true/ false)

— लौटेंगे

विचार कूल, लेकिन मेथेमेटिका रिटर्न Indeterminateके लिए 0^0। इसके अलावा, 1/ 0नहीं वास्तव में truthy / falsy मेथेमेटिका-यह भी दृढ़ता से कर गोल्फरों के लिए आपके द्वारा लिखा गया है में खुश :)

— ग्रेग मार्टिन

Answer 3

मैथेमेटिका, 65 64 बाइट्स

1 बाइट बचाने के लिए ngenisis के लिए धन्यवाद।

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

मैं इसके बजाय एक शुद्ध पैटर्न मिलान समाधान ढूंढूंगा, लेकिन यह मुश्किल साबित हो रहा है (और चीजें {___,a__,___}हमेशा सुपर लंबी होती हैं)।

Answer 4

हास्केल, 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. 

Comments

powersliceइस तरह के एक महान समारोह का नाम है।

— जर्गब

Answer 5

रूबी, 81 बाइट्स

इसे ऑनलाइन आज़माएं

सरलीकृत जानवर बल बल समाधान; सरणी के प्रत्येक तत्व के लिए, एक शून्य-राशि टुकड़ा खोजने की कोशिश करें जिसमें यह शामिल है।

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

Answer 6

जे, 36 35 बाइट्स

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

प्रत्येक उपसमूह के लिए मैं तत्व के अनुक्रमित को जोड़ता हूं और मैं सूचकांक रखता हूं यदि उपसमूह है 0और फिर जांचें कि क्या प्रत्येक सूचकांक मौजूद है।

ट्रिक: किसी सूची के 1-आधारित इंडेक्स #\को हर उपसर्ग की लंबाई के साथ उत्पन्न किया जा सकता है ।

उपयोग:

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

इसे यहाँ ऑनलाइन आज़माएँ।

Comments

मुझे लगता है कि आप सारांश के लिए बेस 1 ट्रिक का उपयोग करके और एक समतल समतल का उपयोग करके 2 बाइट्स बचा सकते हैं#\*/@e.&,]({:*0=1#.{.)@|:\.\@,.#\

— मील

Answer 7

जावास्क्रिप्ट (ईएस 6), 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>

Answer 8

पायथन, 123 120 बाइट्स

_{-3 बाइट्स @Zgarb के लिए धन्यवाद}

शून्य-आकार के स्लाइस के साथ इनपुट के समान सूची के साथ एक सूची को पॉप्युलेट करता है और इंडेक्स के अनुसार ओवरराइट करता है, अंत में इसकी समानता को वापस करता है।

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

Comments

मुझे लगता है कि आप 0इसके स्थान पर प्लेसहोल्डर के रूप में उपयोग कर सकते हैं None। झूठी सकारात्मकता नहीं होगी, क्योंकि 0इनपुट में हर हिस्सा हमेशा या शून्य-राशि का टुकड़ा होता है।

— जर्बर्ब

तुम सही हो। मैंने इसके बारे में सोचा लेकिन यह निष्कर्ष निकाला कि यह झूठी सकारात्मकता को भड़का सकता है।

— dfernan

Answer 9

स्काला, 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

Ungolfed:

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
  )

Comments

मुझे यकीन नहीं है कि यह कैसे काम करता है, लेकिन मुझे लगता है कि यह कुछ सत्य परीक्षण मामलों पर विफल होना चाहिए।

— जर्गर्ब

@Zgarb मैंने ideone के लिए एक लिंक जोड़ा है, जिससे आप सत्यापित कर सकते हैं कि यह सही है। यह मूल रूप से एक जानवर-बल है, हर संभव स्लाइस की कोशिश कर रहा है।

— corvus_192

आप %एक पैरामीटर नाम के रूप में उपयोग कर सकते हैं ? ठंडा!

— साइओस

@Cyoce आप किसी भी यूनिकोड चार को छोड़कर बहुत अधिक उपयोग कर सकते हैं .,;:()[]{}\"'। गोल्फ के लिए बहुत उपयोगी है, क्योंकि वे पार्स द्वारा पत्रों से अलग हो जाते हैं, इसलिए आप कुछ व्हाट्सएप को बचा सकते हैं।

— corvus_192

मैंने परीक्षण के मामलों की जाँच की, और यह trueदूसरा झूठा मामला है।

— जर्गर्ब

Answer 10

अजगर, 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 मिथ्या = कोई नहीं

Comments

यह 1तीसरे टेस्ट केस के लिए गलत रिटर्न है ।

— जर्गब

यह वास्तव 1में पहले दो झूठे लोगों को छोड़कर सभी परीक्षण मामलों के लिए लौटता है।

— 'को

Answer 11

क्लोजर, 109 बाइट्स

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

सभी विभाजन उत्पन्न करता है जो शून्य के बराबर होता है, यह जांचता है कि इसमें "इनपुट वेक्टर की लंबाई" अलग-अलग सूचकांक है।

Answer 12

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।

Answer 13

जावास्क्रिप्ट (ईएस 6), 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समावेशी, और फिर सेट करता है के प्रासंगिक तत्वों bसे 1करने के लिए 0जब यह एक शून्य राशि पाता है, अंत में जाँच वहाँ कोई हैं कि 1छोड़ दिया रहा है।