Ricorda che un set non è ordinato senza duplicati.

Definizione Un insieme di additivi N - S S la cui lunghezza è K è un insieme tale che tutti i sottoinsiemi di lunghezza N in S sommano numeri diversi. In altre parole, le somme di tutti i sottoinsiemi di lunghezza N di S sono tutte distinte.

Obiettivo Dato un array / set come input e un numero Nper una funzione o per un programma completo in qualsiasi formato ragionevole, trova e restituisce o emette un valore di verità o falsità (l'errore per false è corretto) che indica se l'ingresso è o meno N - unicamente additivo.

Puoi presumere che ogni elemento appaia al massimo una volta e che ogni numero sia all'interno del tipo di dati nativo della tua lingua. Se necessario, puoi anche supporre che l'input sia ordinato. Infine, puoi supporre che 0 < N <= K.

Esempi

Consideriamo il set S = {1, 2, 3, 5}e N = 2. Ecco tutte le somme di tutte le coppie univoche S(per quelle uniche sono le uniche di interesse per le somme):

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

Possiamo vedere che non ci sono duplicati nell'output, quindi S è un additivo unicamente 2.

Consideriamo ora il set T = {12, 17, 44, 80, 82, 90}e N = 4. Ecco tutte le possibili somme di lunghezza quattro:

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

Sono tutti unici, quindi T è un additivo unicamente 4.

Casi test

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

XN!sSdA

Provalo online!

Restituisce true(visualizzato come 1) o false(visualizzato come 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)

Gelatina, 7 byte

œcS€ṢIP

Provalo online!

Restituisce un numero positivo per verità e zero per falso.

œ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 byte

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

Questa funzione restituisce un valore positivo (in effetti n) per la verità e restituisce un errore come risposta falsa (valida secondo questo commento )

Spiegazione:

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 byte

{IsM.cFQ

Suite di test.

       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 byte

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

Esempio di utilizzo: 6 # [3,4,7,9,12,16,18]-> True.

Implementazione diretta della definizione: crea un elenco di somme di tutte le sottosequenze di lunghezza n e controlla se è uguale a se stesso con i duplicati rimossi.

JavaScript (ES6), 132 byte

(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

Costruisce gli elenchi di additivi da 1 a n e quindi controlla l'ultimo per unicità.

Brachylog , 20 byte

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

Si aspetta un elenco contenente l'elenco e quindi l'intero come input e nessun output, ad es run_from_atom(':{[L:I]hs.lI}f:+aLdL', [[1:2:3:5]:2])..

Spiegazione

• Predicato principale

             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
  

• Predicato 1: trova tutti i sottoinsiemi ordinati di lunghezza fissa di un elenco

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

Julia, 46 41 byte

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

Provalo online!

Come funziona

Questo (ri) definisce l'operatore binario \per gli argomenti Array / Int.

combinations(x,n)restituisce tutti gli array di esattamente n diversi elementi di x . Mappiamo sumsu questi array e memorizziamo il risultato in t .

t∪tesegue l'unione set dell'array t con se stesso, che uniquein questo caso funziona come il più lungo .

Infine, confrontiamo t con la t deduplicata , restituendo truese e solo se tutte le somme sono diverse.

Python, 89 byte

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

Provalo su Ideone .

Come funziona

c(s,n)elenca tutte le n -combinazioni di s , cioè tutte le liste di n diversi elementi di s . Mappiamo sumsopra le liste risultanti, calcolando in tal modo tutte le possibili somme di sottoliste di lunghezza n .

Dopo i reparti, usiamo c(...,2)per creare tutte le coppie delle somme risultanti. Se due somme x e y sono uguali, x^yrestituirà 0 e allrestituirà False . Al contrario, se tutte le somme sono uniche, x^ysaranno sempre veritiere e anyrestituiranno Vero .

J, 34 byte

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

Approccio diretto, richiede solo il statscomponente aggiuntivo per la combfunzione. Restituisce 0per falso e 1per vero.

In alternativa all'utilizzo del combbuilt-in, esiste una soluzione a 38 byte che genera il gruppo di alimentazione e sceglie i sottoinsiemi di dimensione n .

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

uso

   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

Rubino , 50 byte

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

Provalo online!

Se tutti gli elementi sono unici, uniq!restituisce nil. Negare quel risultato, come in, !(...).uniq!rende un bel test di unicità.

Questa domanda è stata pubblicata alcune settimane prima di Ruby 2.4.0-preview1, che ha introdotto Enumerable#sum, il che consentirebbe di risparmiare 9 byte qui.

41 byte (Ruby 2.4+)

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

Provalo online!

R , 41 byte

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

Somma tutti i sottoinsiemi di lunghezza n di se verifica se tutti i valori in una tabella di contingenza di queste somme sono 1 (tutte le somme sono univoche).

Provalo online!