Помните, что набор неупорядочен без дубликатов.

Определение N -uniquely аддитивная S , длина которой К представляет собой набор таким образом, что все N -длина подмножества S суммы к различным номерам. Другими словами, суммы всех N- длинных подмножеств S все различны.

Цель. Задавая массив / набор в качестве входных данных и число Nдля функции или для полной программы в любом приемлемом формате, найдите и верните или выведите истинное значение или значение Falsey (допустимо ошибочное значение Falsey), обозначающее, является ли ввод N - уникально аддитивный.

Вы можете предположить, что каждый элемент появляется не более одного раза и что каждое число соответствует типу данных вашего языка. При необходимости вы также можете предположить, что вход отсортирован. Наконец, вы можете предположить, что 0 < N <= K.

Примеры

Давайте рассмотрим множество S = {1, 2, 3, 5}и N = 2. Вот все суммы всех уникальных пар S(для уникальных, которые представляют интерес только для сумм):

1 + 2 = 3
1 + 3 = 4
1 + 5 = 6
2 + 3 = 5
2 + 5 = 7
3 + 5 = 8

Мы можем видеть, что в выходных данных нет дубликатов, поэтому S 2 -единственно аддитивно.

Давайте теперь рассмотрим множество T = {12, 17, 44, 80, 82, 90}и N = 4. Вот все возможные суммы длины четыре:

12 + 17 + 44 + 80 = 153
12 + 17 + 44 + 82 = 155
12 + 17 + 44 + 90 = 163
12 + 17 + 80 + 82 = 191
12 + 17 + 80 + 90 = 199
12 + 17 + 82 + 90 = 201
12 + 44 + 80 + 82 = 218
12 + 44 + 80 + 90 = 226
12 + 44 + 82 + 90 = 228
12 + 80 + 82 + 90 = 264
17 + 44 + 80 + 82 = 223
17 + 44 + 80 + 90 = 231
17 + 44 + 82 + 90 = 233
17 + 80 + 82 + 90 = 269
44 + 80 + 82 + 90 = 296

Все они уникальны, и поэтому T является 4-уникально аддитивным.

Тестовые случаи

[members], N => output
[1, 4, 8], 1 => true
[1, 10, 42], 1 => true                ; all sets trivially satisfy N = 1
[1, 2, 3, 4], 3 => true
[1, 2, 3, 4, 5], 5 => true
[1, 2, 3, 5, 8], 3 => true
[1, 2, 3, 4, 5], 2 => false           ;  1 +  4       =  5 =        2 + 3
[-2, -1, 0, 1, 2], 3 => false         ; -2 + -1 + 2   = -1 =   -2 + 0 + 1
[1, 2, 3, 5, 8, 13], 3 => false       ;  1 +  2 + 13  = 16 =    3 + 5 + 8
[1, 2, 4, 8, 16, 32], 3 => true
[1, 2, 4, 8, 16, 32], 4 => true
[1, 2, 4, 8, 16, 32], 5 => true
[1, 2, 4, 8, 16, 32], 6 => true
[3, 4, 7, 9, 12, 16, 18], 6 => true
[3, 4, 7, 9, 12, 16, 18], 3 => false  ; 3 + 4 + 12 = 19 = 3 + 7 + 9

MATL , 7 байт

XN!sSdA

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

Возвращает true(отображается как 1) или false(отображается как 0).

XN   % Take array S and number N. Generate all combinations of elements from S 
     % taken N at a time. Gives a 2D array where each combination is a row
!    % Transpose. Each combination is now a column
s    % Sum of each column: gives a row array. If N=1 computes the sum of
     % the only row, and so gives a number
S    % Sort vector
d    % Array of consecutive differences. For a single number gives an empty array
A    % True if all elements of the input array are nonzero (for an empty array
     % it also gives true)

Желе, 7 байт

œcS€ṢIP

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

Возвращает положительное число для истины и ноль для фальси.

œc       find combinations
  S€     sum each combination
    Ṣ    sort the sums
     I   find the difference between each pair of sums 
           iff any sums are the same, this returns a list containing 0
      P  product of the elements of the resulting list

Matlab, 78 байт

function n=f(s,n);p=perms(s);k=sum(unique(sort(p(:,1:n)),'rows')');unique(k)-k

Эта функция возвращает положительное значение (фактически n) для правдивого и возвращает ошибку в виде ложного ответа (действителен согласно этому комментарию )

Объяснение:

function n=f(s,n);
p=perms(s); %create all permutations of the set

k=sum(unique(sort(p(:,1:n)),'rows')');
                  %just take the first n entries of each permutation
             %sort those entries and
      %filter out all duplicates (we sorted as the order should NOT matter)
  %then sum each of those candidates

unique(k)-k
%if all those sums are distinct, unique(k) will have the same size 
% as k itself, and therefore we can subtract, otherwise it will throw 
% an error as we try to subtract vectors of different sizes

Pyth, 8 байт

{IsM.cFQ

Тестирование.

       Q   eval input (provided as a 2-element array)
    .cF    splat over combination
  sM       sum each combination
{I         is the result invariant under { (dedup/uniq)?

Haskell, 69 байт

import Data.List
n#s=(==)=<<nub$[sum x|x<-subsequences s,length x==n]

Пример использования: 6 # [3,4,7,9,12,16,18]-> True.

Непосредственная реализация определения: составьте список сумм всех подпоследовательностей длины n и проверьте, совпадает ли он с удаленными дубликатами.

JavaScript (ES6), 132 байта

(a,n)=>a.map(m=>{for(i=n;i--;)s[i].map(k=>s[i+1].push(m+k))},s=[...Array(n+1)].map(_=>[]),s[0]=[0])&&new Set(s[n]).size==s[n].length

Создает аддитивные списки от 1 до n, а затем проверяет последний на уникальность.

Брахилог , 20 байт

:1f:+aLdL
[L:I]hs.lI

Ожидается список, содержащий список, а затем целое число как входной, а не выходной, например run_from_atom(':{[L:I]hs.lI}f:+aLdL', [[1:2:3:5]:2])..

объяснение

• Главный предикат

             Input = [A:I]
  :1f        Find all ordered subsets of A of length I
     :+aL    Apply summing to each element of that list of subsets. Call that L
         dL  True if L minus all duplicate elements is still L
  

• Предикат 1: Найти все упорядоченные подмножества фиксированной длины списка

  [L:I]      Input = [L:I]
       hs.   Unify Output with an ordered subset of L
          lI True if I is the length of Output
  

Юлия, 46 41 байт

x\n=(t=map(sum,combinations(x,n)))==t∪t

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

Как это работает

Это (пере) определяет бинарный оператор \для аргументов Array / Int.

combinations(x,n)возвращает все массивы ровно n различных элементов x . Мы отображаем sumэти массивы и сохраняем результат в t .

t∪tвыполняет объединение множества массива t с самим собой, что uniqueв этом случае работает дольше .

Наконец, мы сравниваем t с дедуплицированным t , возвращая, trueесли и только если все суммы разные.

Python, 89 байт

from itertools import*
lambda s,n,c=combinations:all(x^y for x,y in c(map(sum,c(s,n)),2))

Проверьте это на Ideone .

Как это работает

c(s,n)перечисляет все n -комбинации s , т. е. все списки из n различных элементов s . Мы отображаем sumполученные списки, таким образом вычисляя все возможные суммы подсписков длины n .

После подопечных мы используем c(...,2)для создания всех пар полученные суммы. Если любые две суммы x и y равны, x^yвернет 0 и allвернет False . И наоборот, если все суммы уникальны, x^yвсегда будут правдивыми и anyвернут True .

J, 34 байта

load'stats'
[:*/@~:[:+/"1(comb#){]

Прямой подход, требует только statsнадстройки для combфункции. Возвращает 0за ложь и 1за истину.

В качестве альтернативы использованию combвстроенного, существует 38-байтовое решение, которое генерирует набор мощности и выбирает подмножества размера n .

[:*/@~:(>@{[:(</.~+/"1)2#:@i.@^#)+/@#]

Применение

   f =: [:*/@~:[:+/"1(comb#){]
   2 f 1 2 3 5
1
   4 f 12 17 44 80 82 90
1
   3 f _2 _1 0 1 2
0
   6 f 3 4 7 9 12 16 18
1
   3 f 3 4 7 9 12 16 18
0

Рубин , 50 байт

->s,n{!s.combination(n).map{|c|c.inject :+}.uniq!}

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

Если все элементы уникальны, uniq!возвращается nil. Отрицание этого результата, как в, !(...).uniq!делает хороший тест на уникальность.

Этот вопрос был опубликован за несколько недель до выпуска Ruby 2.4.0-preview1 Enumerable#sum, в котором было бы сэкономлено 9 байт.

41 байт (Ruby 2.4+)

->s,n{!s.combination(n).map(&:sum).uniq!}

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

R , 41 байт

function(s,n)max(table(combn(s,n,sum)))<2

Суммирует все n-длина подмножеств s и проверяет, все ли значения в таблице сопряженности этих сумм равны 1 (все суммы уникальны).

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