Un set è senza somma se non ci sono due elementi (non necessariamente distinti) quando aggiunti insieme fanno parte del set stesso.

Ad esempio, {1, 5, 7}è senza somma, perché tutti i membri sono dispari e due numeri dispari aggiunti insieme sono sempre pari. D'altra parte, {2, 4, 9, 13}non è privo di somma, sia come 2 + 2 = 4o 4 + 9 = 13aggiungere insieme ad un membro del set.

Scrivi un programma o una funzione che accetta un set come input e genera un valore Truthy se il set è senza somma e Falsy in caso contrario.

Esempi:

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

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

Pyth - 8 5 byte

Grazie a @FryAmTheEggman per avermi salvato 3 byte.

!@sM*

Test Suite .

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

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

s dovrebbe essere un set Python.

Curiosità: sum-freeè un anagramma del mio nome.

Gelatina , 5 byte

ṗ3ḅ-P

Provalo online!

Come funziona

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

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

Grazie Cᴏɴᴏʀ O'Bʀɪᴇɴ per avermi salvato un sacco di byte tra parentesi / parentesi graffe. Inoltre ringrazia Neil per aver sottolineato che la funzione stava restituendo il valore booleano opposto di quanto avrebbe dovuto.

Ho provato a ridurre i byte ridefinendo, n.somema non funziona perché sfortunatamente è una funzione prototipo. In Array.prototype.mapJS potrebbe esserci una soluzione migliore, ma alcune funzioni sono davvero divertenti.

Ora mi chiedo se c'è un modo più breve rispetto .includesall'uso di qualcosa come .indexOf e l'aggiunta di 1 (il che gli darebbe un valore veritiero se contiene il numero).

test:

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

t&+m~

Questo genera un array che è vero se tutte le voci lo sono 1e falso altrimenti. Ecco una demo per mostrare vari valori di verità / falsità in MATL .

Provalo online

Spiegazione

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

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

Haskell, 32 , 30 byte

Soluzione semplice:

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

Due byte salvati da @Lynn

Julia, 18 byte

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

Provalo online!

J, 18 10 8 byte

8 byte risparmiati grazie alle miglia e 2 grazie a FrownyFrog!

-:]-.+/~

Corrisponde all'elenco originale con la differenza impostata di somme tabulate. Ciò equivale a:

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

per input y. Questo si traduce in:

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

+/~restituisce una tabella di somme usando y. Per y =: 16 1 4 9, questo dà:

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

Quindi, usiamo -., che produce un elenco composto da tutti gli elementi ynon presenti in questa tabella. Se l'elenco è senza somma, questo produrrà lo stesso elenco. Quindi, -:verifica l'uguaglianza degli elenchi, che produce l'output desiderato.

Vecchio, 18 byte

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

+/~crea una tabella dei valori dell'insieme aggiunto a se stesso e e.verifica se tali membri si trovano nell'insieme originale. Il resto è negare l'elemento massimo.

Retina , 45 44 byte

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

L'input è un elenco decimale di numeri separati da virgola. L'output è 0(falso) o 1(verità).

Provalo online! (La prima riga abilita una suite di test separata da avanzamento riga.)

Spiegazione

Fase 1: sostituzione

\d+
<$&$*1>

Questo converte tutti gli elementi dell'input in unari e li avvolge <...> . Lo scopo delle parentesi angolari è di distinguere un elenco contenente solo 0da un elenco vuoto (poiché la rappresentazione unaria di 0è vuota stessa).

Fase 2: sostituzione

$
$`$`

Ripetiamo la stringa 3 volte aggiungendola due volte alla fine.

Fase 3: partita

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

Ora proviamo a trovare tre numeri nel risultato in modo tale che i primi due si sommino al terzo. Queste corrispondenze vengono contate (in realtà non contano tutte queste tuple, poiché le corrispondenze non possono sovrapporsi, ma se esiste una tale tupla verrà trovata). Quindi, otteniamo 0set senza somma e qualcosa di positivo in caso contrario.

Fase 4: incontro

^0

Poiché la fase precedente ha dato il contrario di ciò che vogliamo, neghiamo il risultato contando le corrispondenze di ^0cui è 1per l'input 0e 0per tutto il resto.

Ottava, 29 21 25 byte

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

Grazie a Suever ! Restituisce un array. Ho aggiunto 0alla fine per rendere la []somma libera. Per verificare la verità e la falsità in Octave, puoi fare questo:

> 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

Un'alternativa che restituisce 0 o 1 è:

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

Clojure, 47 37 byte

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

soluzione abbastanza semplice. usa la comprensione dell'elenco per trovare tutti gli elementi la cui somma è uguale a un altro elemento.

38 byte variante:

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

Perl 6 ,  24 21 20  19 byte

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

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

L'input è qualsiasi valore di posizione come un elenco .
(un set è un'associazione quindi dovresti chiamarlo .keys).

Test:

#! /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 byte

Questa versione più breve ha beneficiato della presentazione di A Simmons. Nessun elemento deve essere rimosso dall'elenco prima di IntegerPartitionsessere applicato.

Se un elemento non può essere partizionato in due numeri interi (ciascuno dall'elenco), quindi IntegerPartitions[#,{2},#]=={}vale. Andcontrolla se questo vale per ogni elemento nell'elenco. In tal caso, l'elenco è senza somma.

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

Esempi

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

falso

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

Vero

C'è un 2, ma nessun numero dispari che differisce per 2.

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

Vero

Rubino, 36 byte

Costruisce un prodotto cartesiano dell'insieme contro se stesso e trova la somma di tutti gli elementi, quindi verifica l'intersezione con l'insieme originale. Gli input sono array, ma in Ruby hanno abbastanza operazioni impostate per farlo funzionare bene comunque.

-1 byte sulla mia soluzione originale (utilizzata &anziché -e confrontata con[] ) a causa dell'ispirazione di @feersum

Provalo qui!

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

Python, 40 byte

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

^ = differenza simmetrica, nuovo set con elementi in entrambi i set ma non in entrambi

> Vero se il set di sinistra è un superset del set di destra.

Brachylog , 13 byte

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

Spiegazione

'(          )  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 byte

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

Chiama come w(s), dove si strova l'insieme (in realtà vettore) di valori. Ecco l'output per alcuni casi di test:

> 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

Dov'è c()la funzione di concatenazione che accetta un sacco di valori e lo rende un vettore.

EDIT: rendendolo una funzione anonima per salvare 3 byte, grazie a @MickyT.

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

Racchetta, 58 byte

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

Spiegazione:

(λ(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 byte

Salvato 4 byte grazie a Magic Octopus Urn

ãOå_P

Provalo online!

Spiegazione

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

APL, 8 byte

⊢≡⊢~∘.+⍨

Spiegazione:

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

Test:

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

Haskell, 30 byte

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

Penso che esista una soluzione più breve che è più interessante, ma non l'ho trovata.

Questi sono 33 e 34 byte:

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

In realtà , 7 byte

;;∙♂Σ∩Y

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

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: questo verrà eseguito solo una volta, quindi la tabella deve essere eliminata o rilasciata per essere eseguita nuovamente. L'editor del violino non consente la creazione di tabelle. Pertanto il violino incluso nella mia risposta utilizza 2 byte extra per compensare ciò: la versione del violino non richiede pulizia.

Violino

Perl, 46 byte

Codice 45 byte + riga comandi 1 byte (-p)

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

Utilizza una singola corrispondenza regex con il supporto di Perl per "espressioni di codice" all'interno della regex per consentire la valutazione all'interno di una partita.

Per aggirare il requisito che l'input non sia ordinato, ripetiamo la stringa di input tre volte. Ciò garantisce che il risultato sia dopo i due operandi e consente di abbinare nuovamente la stessa cifra (ad es. In caso di input 2 4).

Esempio di utilizzo:

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

Fattore, 47 byte

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

• ∩ { } =è equivalente ma inferiore a intersects?.
• Σè più breve di ma equivalente a sum.

Grazie, math.unicode !

codice di prova:

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

Sono solo sicuro che i primi due siano corretti. Non è chiaro dalla domanda quale dovrebbe essere il resto, quindi penso che per ora vada bene.

PHP, 73 byte

+8 per trasformare lo snippet in un programma, -8 su variabili obsolete grazie a insertusernamehere

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

stampa 1per true, output vuoto per l' false
uso:php <filename> <value1> <value2> ...

funzione qualificata per il test ( 94 86): ritorni 1o niente

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

test

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 byte

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

L'input è a Set<Integer>. test:

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);
    }
}

Produzione:

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 byte

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

Ho scritto questo prima di notare la precedente soluzione Clojure. Comunque, questo è più compatto in quanto utilizza il set di input come predfunzione per not-any?.

Prolog (SWI) , 66 56 49 byte

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

Provalo online!