শূন্যের সমষ্টি

38

ভূমিকা

পূর্ণসংখ্যার একটি Nompty তালিকা এল বিবেচনা করুন । একটি শূন্য-সমষ্টি ফালি এর এল একটি সংলগ্ন subsequence হয় এল যার সমষ্টি 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]

এ , বি এবং সি তিনটি শূন্য-সম টুকরা এল এর শূন্য-সমষ্টি কভার গঠন করে । একই স্লাইসের একাধিক অনুলিপি শূন্য-সমষ্টি কভারে উপস্থিত হতে পারে:

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 না একটি শূন্য-সমষ্টি ফালি অংশ)।

কাজটি

আপনার ইনপুটটি কোনও যুক্তিসঙ্গত বিন্যাসে নেওয়া একটি সর্বমোট পূর্ণসংখ্যা তালিকা এল । আপনার আউটপুট একটি truthy মান হইবে যদি এল একটি শূন্য-সমষ্টি আচ্ছাদন আছে এবং একটি 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
code-golf  array-manipulation  decision-problem 
— Zgarb
সূত্র
"প্রতিটি উপাদান একটি ফালিগুলির মধ্যে অন্তর্ভুক্ত", আপনি কি আলাদা সূচকগুলিতে স্বতন্ত্র হিসাবে একই মান হিসাবে আচরণ করছেন?
— নেজেনিসিস
@ এনজেনিসিস হ্যাঁ, এগুলি স্বতন্ত্র এবং প্রতিটি সূচিযুক্ত স্লাইসে হওয়া উচিত।
— জাগারব
2
[2,2,-1,-1,0,1] -> Falseউভয় টুকরা [2,-1,-1]এবং [-1,0,1]শূন্য যোগ করা এবং তাদের সমস্ত উপাদান মূল তালিকায় রয়েছে তাই তৃতীয় মিথ্যা উদাহরণটি কি সত্য নয়?
— dfernan
বামতম 2 টি কোনও শূন্য-যোগ স্লাইসের অংশ নয়। এটি কিছুটা অস্পষ্ট, তবে তাদের একটি টুকরোতে ঘটতে হবে যা "তাদের সূচকগুলিতে থাকে"।
— জাগারব
বুঝতে পারছিল না। এটি আরও শক্ত করে তোলে। : ও)
— ডিফারানান

উত্তর:

11

জেলি , 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.
— ডেনিস
সূত্র
9

গণিত, 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@@ফিরে আসে । দ্বিতীয় সংস্করণে, পণ্যগুলির তালিকাটি ফাংশন ( ডাইমেনশনাল ভেক্টরের দৈর্ঘ্য ) দ্বারা কাজ করা হয়, যা প্রতিটি প্রবেশের সমান হলে এবং যদি সমান হয় ।True0Norml00

— গ্রেগ মার্টিন
সূত্র
1
Tr[1^#]1থেকে বাইট সংরক্ষণ করে Length@#।
— নেজেনিসিস
0^পরিবর্তে কাজ করবে 0==? ম্যাথমেটিকা ​​কীভাবে এটি পরিচালনা করে তা নিশ্চিত নয়। (আপনি ফিরে আসবে 1/ 0পরিবর্তে true/ false)
— Cyoce
1
ধারণা Cool কিন্তু ম্যাথামেটিকাল আয় Indeterminateজন্য 0^0। এছাড়াও, 1/ 0ম্যাথমেটিকায় আসলে সত্য / মিথ্যা নয় g গল্ফারদের খুশি করতে খুব দৃ strongly়ভাবে টাইপ করা হয়েছে :)
— গ্রেগ মার্টিন
7

গণিত, 65 64 বাইট

1 বাইট সংরক্ষণের জন্য নেজেনিসিসকে ধন্যবাদ।

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

আমি বরং একটি খাঁটি প্যাটার্ন মেলানো সমাধানটি খুঁজে পেয়েছি তবে এটি কৃপণ বলে প্রমাণিত হচ্ছে (এবং এই জাতীয় জিনিসগুলি {___,a__,___}সর্বদা অত্যন্ত দীর্ঘ)।

— মার্টিন ইন্ডার
সূত্র
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.
— nimi
সূত্র
powersliceযেমন একটি দুর্দান্ত ফাংশন নাম।
— জাগারব
3

রুবি, 81 বাইট

এটি অনলাইনে চেষ্টা করুন

সরলবাদী ব্রুট-ফোর্স সমাধান; অ্যারের প্রতিটি উপাদানগুলির জন্য, এটিতে শূন্য-যোগের স্লাইস সন্ধান করার চেষ্টা করুন।

->a{(0..l=a.size).all?{|i|(0..i).any?{|j|(i..l).any?{|k|a[j..k].inject(:+)==0}}}}
— মান কালি
সূত্র
3

জে, 36 35 বাইট

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

প্রতিটি সাবমের জন্য আমি এলিমেন্টের সূচকগুলি যুক্ত করি এবং আমি সূচীগুলি রাখি যদি if সাবসাম থাকে 0এবং তারপরে প্রতিটি সূচক উপস্থিত কিনা তা যাচাই করে নিই ।

ট্রিক: তালিকার 1-ভিত্তিক সূচকগুলি #\প্রতিটি উপসর্গের দৈর্ঘ্যের সাথে উত্পন্ন করা যায় ।

ব্যবহার:

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

এটি এখানে অনলাইনে চেষ্টা করুন।

— randomra
সূত্র
আমি মনে করি আপনি সংক্ষেপের জন্য বেস 1 ট্রিকটি ব্যবহার করে এবং একটি সমন্বিত #\*/@e.&,]({:*0=1#.{.)@|:\.\@,.#\
— মাইল
2

জাভাস্ক্রিপ্ট (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)

পরীক্ষার স্নিপেট

কোড স্নিপেট দেখান

— ETHproductions
সূত্র
1

পাইথন, 123 120 বাইট

-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
— dfernan
সূত্র
1
আমি মনে করি আপনি 0পরিবর্তে স্থানধারক হিসাবে ব্যবহার করতে পারেন None। মিথ্যা ধনাত্মক হবে না, কারণ প্রতিটি 0ইনপুট সর্বদা অংশ বা শূন্য-যোগের স্লাইস।
— জাগারব
তুমি ঠিক. আমি সে সম্পর্কে ভেবেছিলাম তবে এই সিদ্ধান্তে এসে শেষ করেছিলাম যে এটি মিথ্যা ইতিবাচক হতে পারে।
— dfernan
0

স্কালা, 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
  )
— corvus_192
সূত্র
এটি কীভাবে কাজ করে আমি ঠিক তা নিশ্চিত নই, তবে আমি মনে করি সত্যবাদী পরীক্ষার কয়েকটি ক্ষেত্রে এটি ব্যর্থ হওয়া উচিত।
— জাগারব
@ জাগারব আমি আইডিয়োনে একটি লিঙ্ক যুক্ত করেছি, যাতে আপনি এটি সঠিক কিনা তা যাচাই করতে পারেন। এটি মূলত একটি হিংস্র শক্তি, প্রতিটি সম্ভাব্য টুকরো চেষ্টা করে।
— corvus_192
আপনি %একটি পরামিতি নাম হিসাবে ব্যবহার করতে পারেন ? শান্ত!
— সাইয়েস
@ কিয়েস আপনি ইউনিকোড চর বাদে বেশ কিছু ব্যবহার করতে পারেন .,;:()[]{}\"'। গল্ফিংয়ের জন্য বেশ কার্যকর, কারণ তারা পার্সের দ্বারা চিঠিগুলি পৃথক করা হয়েছে, তাই আপনি কিছু সাদা জায়গা সংরক্ষণ করতে পারেন।
— করভাস_192
আমি পরীক্ষার কেসগুলি পরীক্ষা করে দেখেছি এবং এটি trueদ্বিতীয় জালিয়াতির মামলার জন্য মনে হচ্ছে ।
— জাগারব
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 মিথ্যা = কিছুই নয় None

— sonrad10
সূত্র
এটি ভুলভাবে 1তৃতীয় পরীক্ষার ক্ষেত্রে ফিরে আসে ।
— জগারব
1
এটি আসলে 1প্রথম দুটি মিথ্যা মামলা বাদে সমস্ত পরীক্ষার ক্ষেত্রে ফিরে আসে for
— dfernan
0

ক্লোজার, 109 বাইট

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

সমস্ত পার্টিশন তৈরি করে যা সমান শূন্য, এটিতে "ইনপুট ভেক্টরের দৈর্ঘ্য" স্বতন্ত্র সূচক রয়েছে কিনা তা পরীক্ষা করে।

— NikoNyrh
সূত্র
0

পিএইচপি, 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।

— তিতাস
সূত্র
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সমেত, এবং রিসেট প্রাসঙ্গিক উপাদান bথেকে 1করার 0যখন এটি একটি শূন্য সমষ্টি খুঁজে বের করে, অবশেষে পরীক্ষণ কোন আছে 1বাম s।

— নিল
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.