Обложки с нулевой суммой

38

Введение

Рассмотрим непустой список L целых чисел. С нулевой суммой срез из L представляет собой непрерывную подпоследовательность L , сумма которых равна 0. Например, [1, -3, 2] является нулевой суммой срез [-2, 4, 1, -3, 2, 2 , -1, -1] , но [2, 2] - нет (потому что оно не суммируется с 0), и нет [4, -3, -1] (потому что оно не является смежным).

Коллекция с нулевой суммой ломтиков L является нулевой суммой крышкой из L , если каждый элемент принадлежит , по меньшей мере , одного из слоев. Например:

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

Три с нулевой суммой нарезает , В и С образуют с нулевой суммой крышку 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
code-golf array-manipulation decision-problem Zgarb
источник
«Каждый элемент принадлежит одному из срезов», вы рассматриваете одно и то же значение с разными индексами как разные?
ngenisis
@ngenisis Да, они различны, и каждый должен находиться в срезе, который содержит соответствующий индекс.
Згарб
2
Разве третий пример не [2,2,-1,-1,0,1] -> Falseдолжен быть правдивым, поскольку оба среза [2,-1,-1]и [-1,0,1]прибавляют к нулю, а все их элементы находятся в исходном списке?
Дфернан
Крайний левый 2 не является частью любого среза с нулевой суммой. Это немного неясно, но они должны появляться в срезе, который «содержит их индекс».
Згарб
Понял. Это делает это сложнее. : o)
dfernan

Ответы:

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

Mathematica, 66 65 байт

Сохранено 1 байт, и, надеюсь, выучил новый трюк на будущее, благодаря ngenisis!

Две одинаково длинных альтернативы, обе из которых являются безымянными функциями, принимающими список целых чисел в качестве входных данных и возвращающих 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элемент th принадлежит срезу с нулевой суммой ,

В первой версии каждый из этих продуктов сравнивается 0и And@@возвращается Trueточно, когда каждый отдельный продукт равен 0. Во второй версии на список товаров воздействует функция Norm(длина l-мерного вектора), которая равна 0тогда и только тогда, когда каждая запись равна 0.

Грег Мартин
источник
1
Tr[1^#]сохраняет 1байт из Length@#.
ngenisis
Будет 0^работать вместо 0==? Не уверен, как Mathematica справится с этим. (вы бы вернулись 1/ 0вместо true/ false)
Cyoce
1
Классная идея, но Mathematica возвращается Indeterminateза 0^0. Кроме того, в Mathematica 1/ на 0самом деле не правдивые / ложные - он слишком сильно напечатан, чтобы осчастливить игроков в гольф :)
Грег Мартин
7

Mathematica, 65 64 байта

Спасибо ngenisis за сохранение 1 байта.

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

Я бы предпочел найти чистое решение для сопоставления с образцом, но оно оказалось сложным (а такие вещи {___,a__,___}всегда очень длинные).

Мартин Эндер
источник
4

Haskell, 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.
Ними
источник
powersliceтакое отличное имя функции.
Згарб
3

Рубин, 81 байт

Попробуйте онлайн

Упрощенное решение методом грубой силы; для каждого элемента массива попробуйте найти срез с нулевой суммой, который содержит его.

->a{(0..l=a.size).all?{|i|(0..i).any?{|j|(i..l).any?{|k|a[j..k].inject(:+)==0}}}}
Значение чернил
источник
3

J, 36 35 байт

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

Для каждой подгруппы я добавляю индексы элемента и сохраняю индексы, если подсумма есть, 0а затем проверяю, присутствует ли каждый индекс.

Уловка: основанные на 1 индексы списка могут быть сгенерированы с #\длиной каждого префикса.

Использование:

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

Попробуйте это онлайн здесь.

randomra
источник
Я думаю, что вы можете сэкономить 2 байта, используя базовый трюк 1 для суммирования и используя #\*/@e.&,]({:*0=1#.{.)@|:\.\@,.#\
мили
2

JavaScript (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

Python, 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
dfernan
источник
1
Я думаю, что вы можете использовать 0в качестве заполнителя вместо None. Не будет ложных срабатываний, потому что каждый 0на входе всегда является частью или срезом с нулевой суммой.
Згарб
Вы правы. Я думал об этом, но в итоге пришел к выводу, что это может повлечь за собой ложные срабатывания.
Дфернан
0

Скала, 49 байт

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

Попробуйте в Ideone

Использование:

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
источник
Я не совсем уверен, как это работает, но я думаю, что это может не сработать в некоторых тестовых случаях.
Згарб
@Zgarb Я добавил ссылку на ideone, чтобы вы могли убедиться, что это правильно. Это в основном грубая сила, пробующая все возможные кусочки.
corvus_192
Вы можете использовать %в качестве имени параметра? Круто!
Cyoce
@Cyoce Вы можете использовать практически любой символ Юникода, кроме .,;:()[]{}\"'. Довольно полезно для игры в гольф, потому что они разбираются буквами при разборе, поэтому вы можете сэкономить свободное место.
corvus_192
Я проверил контрольные примеры, и, похоже, trueдля второго ложного случая.
Згарб
0

Python, 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 Ложь = Нет

sonrad10
источник
Это неверно возвращается 1для третьего теста.
Згарб
1
Он фактически возвращается 1для всех тестовых случаев, кроме первых двух ложных.
Дфернан
0

Clojure, 109 байт

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

Генерирует все разделы, которые суммируются с нулем, проверяет, имеет ли он различные индексы длины входного вектора.

NikoNyrh
источник
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для числовых операций.

Titus
источник
0

JavaScript (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ы остались.

Нил
источник