Um conjunto é livre de soma se não houver dois elementos (não necessariamente distintos) quando adicionados juntos fizerem parte do próprio conjunto.

Por exemplo, {1, 5, 7}é livre de soma, porque todos os membros são ímpares e dois números ímpares quando somados são sempre pares. Por outro lado, {2, 4, 9, 13}não é livre de soma, como um 2 + 2 = 4ou 4 + 9 = 13adicionado a um membro do conjunto.

Escreva um programa ou função que aceite um conjunto como entrada e emita um valor Truthy se o conjunto estiver sem soma e Falsy caso contrário.

Exemplos:

Sum-free:
{}
{4}
{1, 5, 7}
{16, 1, 4, 9}

Not sum-free:
{0}
{1, 4, 5, 7}
{3, 0}
{16, 1, 4, 8}

Pitão - 8 5 bytes

Obrigado a @FryAmTheEggman por me salvar 3 bytes.

!@sM*

Conjunto de Teste .

!             Logical not. This makes the empty intersection true and vice versa.
 @    Q       Setwise intersection with input (implictly).
  sM          Map sum to all the pairs.
   *QQ        Get all pairs by doing cartesian product with input*input (implicit).

Python 2, 41 bytes

lambda s:s==s-{a+b for a in s for b in s}

s deve ser um conjunto Python.

Curiosidade: sum-freeé um anagrama do meu nome.

Gelatina , 5 bytes

ṗ3ḅ-P

Experimente online!

Como funciona

ṗ3ḅ-P  Main link. Argument: A (array)

ṗ3     Take the third Cartesian power of A, i.e., generate all triplets that
       consist of elements of A.
  ḅ-   Convert each triplet from base -1 to integer.
       This maps [a, b, c] to a - b + c = (a + c) - b.
       If (a + c) belong to A, this will yield 0 for some b.
    P  Take the product of all resulting integers. 

JavaScript, 86 42 41 bytes

n=>!n.some(m=>n.some(o=>n.includes(m+o)))

Obrigado Cᴏɴᴏʀ O'Bʀɪᴇɴ por me salvar uma tonelada de bytes entre parênteses / colchetes. Agradecemos também a Neil por apontar que a função estava retornando o valor booleano oposto ao que deveria.

Tentei reduzir os bytes redefinindo, n.somemas isso não funciona porque, infelizmente, é uma função de protótipo. Pode haver uma solução melhor Array.prototype.mapno JS, mas a função some é realmente divertida.

Agora estou me perguntando se existe uma maneira mais curta do que .includesusar algo como .indexOf e adicionar 1 (o que daria um valor verdadeiro se contiver o número).

Teste:

> (n=>!n.some(m=>n.some(o=>n.includes(m+o))))([1,5,7]);
true
> (n=>!n.some(m=>n.some(o=>n.includes(m+o))))([1,5,7,12]);
false

MATL, 5 bytes

t&+m~

Isso gera uma matriz que é verdadeira se todas as entradas forem 1e falsey de outra forma. Aqui está uma demonstração para mostrar vários valores de verdade / falsey no MATL .

Experimente Online

Explicação

        % Implicitly grab input
t       % Duplicate
&+      % Compute sum of each element with every other element (2D Matrix)
m       % Check which members of the input are present in this matrix of sums
~       % Negate the result to yield a truthy value for sum-free sets
        % Implicitly display truthy/falsey value

Mathematica, 23 bytes

{}==#⋂Tr/@#~Tuples~2&

Haskell, 32 , 30 bytes

Solução simples:

f x=and[a+b/=c|a<-x,b<-x,c<-x]

Dois bytes salvos por @Lynn

Julia, 18 bytes

!x=x∩(x'.+x)==[]

Experimente online!

J, 18 10 8 bytes

8 bytes economizados graças a milhas e 2 graças ao FrownyFrog!

-:]-.+/~

Corresponde à lista original com a diferença definida de somas tabuladas. Isso é equivalente a:

(-: (] -. +/~)) y

para entrada y. Isso se traduz em:

y -: (] -. +/~) y
y -: (y -. +/~ y)

+/~retorna uma tabela de somas usando y. Pois y =: 16 1 4 9, isso fornece:

   +/~ 16 1 4 9
32 17 20 25
17  2  5 10
20  5  8 13
25 10 13 18

Então, usamos -., que produz uma lista que consiste em todos os elementos que ynão estão nesta tabela. Se a lista estiver sem soma, isso produzirá a mesma lista. Em seguida, -:verifica a igualdade de listas, o que produz a saída desejada.

Antigo, 18 bytes

[:-.[:>./^:_+/~e.]

+/~cria uma tabela dos valores do conjunto adicionado a si próprio e e.verifica se esses membros estão no conjunto original. O restante disso está negando o elemento máximo.

Retina , 45 44 bytes

\d+
<$&$*1>
$
$`$`
M`(<1*)>.*<(1*>).*\1\2
^0

Entrada é uma lista decimal de números separados por vírgula. A saída é 0(falsy) ou 1(truthy).

Experimente online! (A primeira linha ativa um conjunto de testes separado por avanço de linha.)

Explicação

Etapa 1: Substituição

\d+
<$&$*1>

Isso converte todos os elementos da entrada em unários e os envolve <...>. O objetivo dos colchetes angulares é distinguir uma lista que contém apenas 0uma lista vazia (já que a representação unária de 0é a própria vazia).

Etapa 2: Substituição

$
$`$`

Repetimos a string 3 vezes, acrescentando-a duas vezes no final.

Etapa 3: partida

M`(<1*)>.*<(1*>).*\1\2

Agora, tentamos encontrar três números no resultado, de modo que os dois primeiros sejam o terceiro. Essas correspondências são contadas (na verdade, isso não conta todas as tuplas, porque as correspondências não podem se sobrepor, mas se essa tupla existir, será encontrada). Portanto, obtemos 0conjuntos sem soma e algo positivo de outra forma.

Etapa 4: partida

^0

Desde a etapa anterior deu o oposto do que queremos, nós negamos o resultado contando os jogos de ^0que é 1para a entrada 0e 0para tudo o resto.

Oitava, 29 21 25 bytes

@(s)~[ismember(s,s+s') 0]

Graças a Suever ! Retorna uma matriz. Eu adicionei 0no final para []tornar-se livre de soma. Para verificar verdade e falsidade no Octave, você pode fazer o seguinte:

> f=@(s)~[ismember(s,s+s') 0]

> if f([]) "sum-free" else "not sum-free" end
ans = sum-free

> if f([0]) "sum-free" else "not sum-free" end
ans = not sum-free

> if f([4]) "sum-free" else "not sum-free" end
ans = sum-free

> if f([1 3]) "sum-free" else "not sum-free" end
ans = sum-free

> if f([2 4]) "sum-free" else "not sum-free" end
ans = not sum-free

Uma alternativa que retorna 0 ou 1 é:

@(s)~numel(intersect(s+s',s))

Clojure, 47 37 bytes

#(=(for[a % b % :when(%(+ a b))]a)[])

solução bastante simples. usa compreensão de lista para encontrar todos os elementos cuja soma é igual a outro elemento.

Variante de 38 bytes:

#(every? nil?(for[a % b %](%(+ a b))))

Perl 6 ,  24 21 20  19 bytes

{not any (@_ X+@_)X==@_}
{so all (@_ X+@_)X!==@_}
{not @_ (&)(@_ X+@_)}
{not @_∩(@_ X+@_)}

{!(@_∩(@_ X+@_))}

Entrada é qualquer valor posicional como uma lista .
(um Conjunto é uma Associativa, portanto você precisaria chamá .keys-lo.)

Teste:

#! /usr/bin/env perl6
use v6.c;
use Test;

my @sum-free = (
  (),
  (4,),
  (1, 5, 7),
  (16, 1, 4, 9),
);

my @not-sum-free = (
  (0,),
  (1, 4, 5, 7),
  (3, 0),
  (16, 1, 4, 8),
);

my @tests = ( |(@sum-free X=> True), |(@not-sum-free X=> False) );

plan +@tests;

# store the lambda in lexical namespace for clarity
my &sum-free-set = {!(@_∩(@_ X+@_))}

for @tests -> $_ ( :key(@list), :value($expected) ) {
  is sum-free-set(@list), $expected, .gist
}

1..8
ok 1 - () => True
ok 2 - (4) => True
ok 3 - (1 5 7) => True
ok 4 - (16 1 4 9) => True
ok 5 - (0) => False
ok 6 - (1 4 5 7) => False
ok 7 - (3 0) => False
ok 8 - (16 1 4 8) => False

Mathematica 63 62 42 bytes

Esta versão mais curta se beneficiou da submissão de A Simmons. Nenhum elemento precisa ser removido da lista antes de IntegerPartitionsser aplicado.

Se um elemento não puder ser particionado em dois números inteiros (cada um da lista), ele será IntegerPartitions[#,{2},#]=={}retido. Andverifica se isso é válido para todos os elementos da lista. Nesse caso, a lista é livre de soma.

And@@(IntegerPartitions[#,{2},#]=={}&/@#)&

Exemplos

 And@@(IntegerPartitions[#,{2},#]=={}&/@ #)&@{2, 4, 9, 13}

Falso

 And@@(IntegerPartitions[#,{2},#]=={}&/@ #)&@{1, 5, 7}

Verdade

Existe um 2, mas não há números ímpares que diferem por 2.

 And@@(IntegerPartitions[#,{2},#]=={}&/@#)&@{2, 3, 7, 11, 17, 23, 29, 37, 41, 47, 53, 59, 67, 71}

Verdade

Ruby, 36 bytes

Constrói um produto cartesiano do conjunto contra si mesmo e encontra a soma de todos os elementos, depois verifica a interseção com o conjunto original. A entrada é arrays, mas no Ruby eles têm operações de conjunto suficientes para fazê-lo funcionar de qualquer maneira.

-1 byte sobre a minha solução original (usada em &vez de -e comparada com []) por causa da inspiração do @feersum

Experimente aqui!

->s{s-s.product(s).map{|x,y|x+y}==s}

Python, 40 bytes

lambda s:s^{a+b for a in s for b in s}>s

^ = diferença simétrica, novo conjunto com elementos nos dois conjuntos, mas não nos dois

> Verdadeiro se o conjunto esquerdo for um superconjunto do conjunto direito.

Braquilog , 13 bytes

'(p:?+L:?x'L)

Explicação

'(          )  True if what's in the parentheses is impossible, false otherwise
  p            Get a permutation of Input
   :?+L        L is the list of element-wise sums of the permutation with Input
       :?x'L   There is at least one element of Input in L

R, 39 36 bytes

w<-function(s)!any(outer(s,s,'+')%in%s)

Chame como w(s), onde sestá o conjunto (na verdade vetor) de valores. Aqui está a saída para alguns casos de teste:

> w(numeric(0)) # The empty set
[1] TRUE
> w(0)
[1] FALSE
> w(1)
[1] TRUE
> w(c(1, 5, 7))
[1] TRUE
> w(c(2, 4, 9, 13))
[1] FALSE

Onde c()está a função de concatenação que pega um monte de valores e o torna um vetor.

EDIT: Tornando uma função anônima para salvar 3 bytes, graças a @MickyT.

function(s)!any(outer(s,s,'+')%in%s)

Raquete, 58 bytes

(λ(l)(andmap(λ(m)(andmap(λ(n)(not(memq(+ n m)l)))l))l))

Explicação:

(λ(l)(andmap(λ(m)(andmap(λ(n)(not(memq(+ n m)l)))l))l))
(λ(l)                                                 ) # Define a lambda function that takes in one parameter
     (andmap(λ(m)                                  )l)  # If for all m in l
                 (andmap(λ(n)                   )l)     # If for all n in l
                             (not(memq(+ n m)l))        # n + m is not in l

05AB1E , 9 5 bytes

Economizou 4 bytes graças ao Magic Octopus Urn

ãOå_P

Experimente online!

Explicação

ã       # cartesian product
 O      # sum
  å     # check each if it exists in input
   _    # logical negation
    P   # product

APL, 8 bytes

⊢≡⊢~∘.+⍨

Explicação:

⊢         argument
 ≡        equals
  ⊢       argument
   ~      without 
    ∘.+⍨  sums of its elements

Teste:

      ( ⊢≡⊢~∘.+⍨ ) ¨ (1 5 7)(2 4 9 13)
1 0

Haskell, 30 bytes

f s=and[x+y/=z|x<-s,y<-s,z<-s]

Acho que existe uma solução mais curta que é mais interessante, mas ainda não a encontrei.

Estes são 33 e 34 bytes:

f s=and$((/=)<$>s<*>)$(+)<$>s<*>s
f s|q<-((-)<$>s<*>)=all(/=0)$q$q$s

Na verdade , 7 bytes

;;∙♂Σ∩Y

Experimente online!

;;∙♂Σ∩Y              Stack: [1,5,7]
;         duplicate         [1,5,7] [1,5,7]
 ;        duplicate         [1,5,7] [1,5,7] [1,5,7]
  ∙       cartesian product [1,5,7] [[1,1],[1,5],[1,7],[5,1],[5,5],[5,7],[7,1],[7,5],[7,7]]
   ♂Σ     sum each          [1,5,7] [2,6,8,6,10,12,8,12,14]
     ∩    intersect         []
      Y   negate            1

TSQL, 47 bytes

CREATE table T(a int)
INSERT T values(1),(5),(7),(12)

SELECT min(iif(a.a+b.a<>T.a,1,0))FROM T a,T b,T

Nota: Isso será executado apenas uma vez, e a tabela precisará ser excluída ou descartada para ser executada novamente. O editor de violino não permite a criação de tabelas. Portanto, o violino incluído na minha resposta usa 2 bytes extras para compensar isso - a versão do violino não requer limpeza.

Violino

Perl, 46 bytes

Código de 45 bytes + linha de comando de 1 byte (-p)

$_="$_ $_ $_"!~/(\b\d++.*)((?1))(??{$1+$2})/

Usa uma única correspondência de regex com o suporte do Perl para 'expressões de código' dentro da regex para permitir a avaliação dentro de uma correspondência.

Para contornar o requisito de que a entrada não seja classificada, repetimos a sequência de entrada três vezes. Isso garante que o resultado seja após os dois operandos e permite que o mesmo dígito seja correspondido novamente (por exemplo, no caso de entrada 2 4).

Exemplo de uso:

echo "3 5 6 8" | perl -p entry.pl

Fator, 47 bytes

[ dup dup 2array [ Σ ] product-map ∩ { } = ]

• ∩ { } =é equivalente a, mas menor que intersects?.
• Σé mais curto do que mas equivalente a sum.

Obrigado, math.unicode !

código de teste:

USING: arrays kernel math.unicode sequences sequences.product ;
IN: sum-free

: sum-free? ( seq -- ? )
  dup dup 2array [ Σ ] product-map ∩ { } = ;

USING: tools.test sum-free ;
IN: sum-free.tests

{ t } [ { 5 7 9 } sum-free? ] unit-test
{ f } [ { 2 4 9 13 } sum-free? ] unit-test
{ t } [ { } sum-free? ] unit-test
{ f } [ { 0 } sum-free? ] unit-test
{ t } [ { 1 } sum-free? ] unit-test
{ f } [ { 0 1 } sum-free? ] unit-test

Só estou confiante que os dois primeiros estão corretos. Não está claro da pergunta qual deve ser o resto, então acho que está bom por enquanto.

PHP, 73 bytes

+8 para transformar o trecho em um programa, -8 em variáveis ​​obsoletas, graças a insertusernamehere

<?foreach($argv as$p)foreach($argv as$q)if(in_array($p+$q,$argv))die;echo 1;

gravuras 1para true, saída vazia parafalse
uso:php <filename> <value1> <value2> ...

função qualificada para teste ( 94 86): retornos 1ou nada

function f($a){foreach($a as$p)foreach($a as$q)if(in_array($p+$q,$a))return;return 1;}

testes

function out($a){if(!is_array($a))return$a;$r=[];foreach($a as$v)$r[]=out($v);return'['.join(',',$r).']';}
function cmp($a,$b){if(is_numeric($a)&&is_numeric($b))return 1e-2<abs($a-$b);if(is_array($a)&&is_array($b)&&count($a)==count($b)){foreach($a as $v){$w = array_shift($b);if(cmp($v,$w))return true;}return false;}return strcmp($a,$b);}
function test($x,$e,$y){static $h='<table border=1><tr><th>input</th><th>output</th><th>expected</th><th>ok?</th></tr>';echo"$h<tr><td>",out($x),'</td><td>',out($y),'</td><td>',out($e),'</td><td>',cmp($e,$y)?'N':'Y',"</td></tr>";$h='';}
$samples = [
    [], 1,
    [0], false,
    [1], 1,
    [0,1], false,
    [2, 4, 9, 13], false,
    [1,5,7], 1
];
while($samples)
{
    $a=array_shift($samples);
    $e=array_shift($samples);
    test($a,$e,f($a));
}

Java, 67 bytes

s->!s.stream().anyMatch(p->s.stream().anyMatch(q->s.contains(p+q)))

Entrada é a Set<Integer>. Testes:

import java.util.Arrays;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

public class SumFree {
    public static void main(String[] args) {
        sumFree(s->!s.stream()
            .anyMatch(p->s.stream()
                .anyMatch(q->s.contains(p+q)))); // formatted to avoid wrapping
    }

    public static void sumFree(Function<Set<Integer>, Boolean> func) {
        test(func);
        test(func, 4);
        test(func, 1, 5, 7);
        test(func, 16, 1, 4, 9);
        test(func, 1, 4, 5, 7);
        test(func, 0);
        test(func, 3, 0);
        test(func, 16, 1, 4, 8);
    }

    public static void test(Function<Set<Integer>, Boolean> func, Integer... vals) {
        Set<Integer> set = Arrays.stream(vals).collect(Collectors.toSet());
        System.out.format("%b %s%n", func.apply(set), set);
    }
}

Saída:

true []
true [4]
true [1, 5, 7]
true [16, 1, 4, 9]
false [0]
false [1, 4, 5, 7]
false [0, 3]
false [16, 1, 4, 8]

Clojure, 34 bytes

#(not-any? %(for[i % j %](+ i j)))

Eu escrevi isso antes de perceber a solução anterior do Clojure. De qualquer forma, este é mais compacto, pois usa o conjunto de entrada como uma predfunção not-any?.

Prolog (SWI) , 66 56 49 bytes

A/B:-member(A,B).
-L:- \+ (E/L,F/L,G is E+F,G/L).

Experimente online!