Eine Menge ist summenfrei, wenn keine zwei (nicht notwendigerweise unterschiedlichen) Elemente, wenn sie zusammenaddiert werden, Teil der Menge selbst sind.

Ist zum Beispiel {1, 5, 7}summenfrei, weil alle Mitglieder ungerade sind und zwei ungerade Zahlen, wenn sie addiert werden, immer gerade sind. Auf der anderen Seite {2, 4, 9, 13}ist nicht summenfrei, wie entweder 2 + 2 = 4oder 4 + 9 = 13zusammen zu einem Mitglied der Menge.

Schreiben Sie ein Programm oder eine Funktion, die eine Menge als Eingabe akzeptiert und einen Wahrheitswert ausgibt, wenn die Menge keine Summe enthält, und andernfalls Falsy.

Beispiele:

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 Bytes

Vielen Dank an @FryAmTheEggman für das Speichern von 3 Bytes.

!@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 Bytes

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

s sollte ein Python-Set sein.

Lustige Tatsache: sum-freeist ein Anagramm meines Namens.

Gelee , 5 Bytes

ṗ3ḅ-P

Probieren Sie es online!

Wie es funktioniert

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

Danke Cᴏɴᴏʀ O'Bʀɪᴇɴ, dass du mir eine Menge Bytes in Klammern / geschweiften Klammern gespart hast. Vielen Dank auch an Neil, der darauf hingewiesen hat, dass die Funktion den entgegengesetzten Booleschen Wert zurückgibt, als sie haben sollte.

Ich habe versucht, Bytes durch Neudefinition zu reduzieren, n.someaber das funktioniert nicht, da es sich leider um eine Prototypfunktion handelt. Es gibt vielleicht eine bessere Lösung mit Array.prototype.mapin JS, aber die eine oder andere Funktion macht wirklich Spaß.

Ich frage mich jetzt, ob es einen kürzeren Weg gibt, als .includesetwas wie .indexOf zu verwenden und 1 hinzuzufügen (was einen wahrheitsgemäßen Wert ergeben würde, wenn es die Zahl enthält).

Testen:

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

Dies gibt ein Array aus, das wahr ist, wenn alle Einträge 1falsch sind. Hier ist eine Demo, um verschiedene Wahrheits- / Falschheitswerte in MATL zu zeigen .

Probieren Sie es online

Erläuterung

        % 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

Einfache Lösung:

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

Zwei von @Lynn gespeicherte Bytes

Julia, 18 Bytes

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

Probieren Sie es online!

J, 18 10 8 Bytes

Dank Meilen 8 Bytes gespart und dank FrownyFrog 2!

-:]-.+/~

Entspricht der ursprünglichen Liste der eingestellten Differenz tabellarischer Summen. Dies ist äquivalent zu:

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

zur Eingabe y. Dies bedeutet:

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

+/~gibt eine Summentabelle mit zurück y. Denn y =: 16 1 4 9dies gibt:

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

Dann verwenden wir -., was eine Liste erzeugt, die aus allen Elementen besteht, die ynicht in dieser Tabelle enthalten sind. Wenn die Liste summenfrei ist, wird dieselbe Liste erstellt. Dann -:prüft auf Gleichheit von Listen, die die gewünschte Ausgabe erzeugt.

Alt, 18 Bytes

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

+/~Erstellt eine Tabelle mit den Werten der Gruppe, die zu sich selbst hinzugefügt wurden, und e.prüft, ob sich diese Mitglieder in der ursprünglichen Gruppe befinden. Der Rest davon negiert das maximale Element.

Retina , 45 44 Bytes

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

Die Eingabe ist eine dezimale Liste von durch Kommas getrennten Zahlen. Die Ausgabe ist 0(falsch) oder 1(wahr).

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Erläuterung

Stufe 1: Substitution

\d+
<$&$*1>

Dadurch werden alle Elemente der Eingabe in Unary konvertiert und eingeschlossen <...>. Der Zweck der spitzen Klammern besteht darin, eine Liste, die nur 0eine leere Liste enthält, zu unterscheiden (da die unäre Darstellung von 0selbst leer ist).

Stufe 2: Substitution

$
$`$`

Wir wiederholen die Zeichenfolge dreimal, indem wir sie am Ende zweimal anhängen.

Stufe 3: Spiel

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

Wir versuchen nun, drei Zahlen im Ergebnis so zu finden, dass die ersten beiden zur dritten addieren. Diese Übereinstimmungen werden gezählt (dies zählt eigentlich nicht alle derartigen Tupel, da Übereinstimmungen nicht überlappen können, aber wenn ein solches Tupel existiert, wird es gefunden). Daher bekommen wir0 für summenfreie Mengen und sonst etwas Positives.

Stufe 4: Match

^0

Da die vorherige Stufe das Gegenteil von dem ergab, was wir wollen, negieren wir das Ergebnis, indem wir die Übereinstimmungen zählen, ^0die 1für die Eingabe 0und 0für alles andere gelten.

Oktave, 29 21 25 Bytes

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

Vielen Dank an Suever ! Es wird ein Array zurückgegeben. Ich habe 0am Ende hinzugefügt , []um summenfrei zu machen . So überprüfen Sie die Richtigkeit und Falschheit in Octave:

> 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

Eine Alternative, die 0 oder 1 zurückgibt, ist:

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

Clojure, 47 37 Bytes

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

ganz einfache Lösung. verwendet das Listenverständnis, um alle Elemente zu finden, deren Summe einem anderen Element entspricht.

Variante mit 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+@_))}

Die Eingabe ist ein beliebiger Positionswert wie eine Liste .
(ein Set ist ein Assoziativer, also müsstest du ihn aufrufen .keys.)

Prüfung:

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

Diese kürzere Version profitierte von der Einreichung von A Simmons. Es muss kein Element aus der Liste entfernt werden, bevor IntegerPartitionses angewendet wird.

Wenn ein Element nicht in zwei ganze Zahlen (jeweils aus der Liste) unterteilt werden kann, IntegerPartitions[#,{2},#]=={}gilt. Andprüft, ob dies für jedes Element in der Liste gilt. In diesem Fall ist die Liste ohne Summen.

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

Beispiele

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

Falsch

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

Wahr

Es gibt eine 2, aber keine ungeraden Zahlen, die sich um 2 unterscheiden.

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

Wahr

Ruby, 36 Bytes

Konstruiert ein kartesisches Produkt der Menge gegen sich selbst, ermittelt die Summe aller Elemente und prüft dann, ob eine Überschneidung mit der ursprünglichen Menge vorliegt. Die Eingabe ist ein Array, aber in Ruby gibt es genügend festgelegte Operationen, damit es trotzdem gut funktioniert.

-1 Byte über meiner ursprünglichen Lösung ( &anstelle von -und verglichen mit []) aufgrund der Inspiration von @feersum

Probieren Sie es hier aus!

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

^ = symmetrischer Unterschied, neue Menge mit Elementen in beiden Mengen, aber nicht in beiden

> True, wenn die linke Menge eine Obermenge der rechten Menge ist.

Brachylog , 13 Bytes

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

Erläuterung

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

Aufruf als w(s), wo sist die Menge (eigentlich Vektor) von Werten. Hier ist die Ausgabe für einige Testfälle:

> 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

Woher c() ist die Verkettungsfunktion, die eine Reihe von Werten annimmt und daraus einen Vektor macht?

BEARBEITEN: Dank @MickyT wird es zu einer anonymen Funktion, 3 Bytes zu speichern.

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

Schläger, 58 Bytes

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

Erläuterung:

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

4 Bytes dank Magic Octopus Urn gespart

ãOå_P

Probieren Sie es online!

Erläuterung

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

APL, 8 Bytes

⊢≡⊢~∘.+⍨

Erläuterung:

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

Prüfung:

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

Haskell, 30 Bytes

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

Ich denke, es gibt eine kürzere Lösung, die interessanter ist, aber ich habe sie nicht gefunden.

Dies sind 33 und 34 Bytes:

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

Eigentlich 7 Bytes

;;∙♂Σ∩Y

Probieren Sie es 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

Hinweis: Dies wird nur einmal ausgeführt. Dann muss die Tabelle gelöscht oder gelöscht werden, um erneut ausgeführt zu werden. Der Geigeneditor erlaubt keine Erstellung von Tabellen. Aus diesem Grund verwendet die in meiner Antwort enthaltene Geige 2 zusätzliche Bytes, um dies zu kompensieren - die Geigenversion erfordert keine Bereinigung.

Geige

Perl, 46 Bytes

45-Byte-Code + 1-Byte-Befehlszeile (-p)

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

Verwendet eine einzelne Regex-Übereinstimmung mit Perls Unterstützung für 'Code-Ausdrücke' innerhalb der Regex, um eine Auswertung innerhalb einer Übereinstimmung zu ermöglichen.

Um die Anforderung zu umgehen, dass die Eingabe unsortiert ist, wiederholen wir die Eingabezeichenfolge dreimal. Dies stellt sicher, dass das Ergebnis nach den beiden Operanden liegt, und ermöglicht die erneute Übereinstimmung derselben Ziffer (z. B. bei der Eingabe)2 4 ).

Anwendungsbeispiel:

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

Faktor 47 Bytes

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

• ∩ { } =entspricht aber kürzer als intersects?.
• Σist kürzer als aber äquivalent zu sum.

Danke, math.unicode !

Testcode:

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

Ich bin nur zuversichtlich, dass die ersten beiden richtig sind. Aus der Frage, was der Rest sein soll, ist nicht klar, daher denke ich, dass es für den Moment in Ordnung ist.

PHP, 73 Bytes

+8, um das Snippet in ein Programm zu verwandeln, -8 bei veralteten Variablen dank insertusernamehere

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

druckt 1für true, leere Ausgabe zur false
Verwendung:php <filename> <value1> <value2> ...

qualifizierte Funktion zum Testen ( 94 86): Gibt zurück 1oder nichts

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

Tests

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

Input ist a Set<Integer>. Tests:

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

Ausgabe:

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

Ich schrieb dies, bevor ich die frühere Clojure-Lösung bemerkte. Auf jeden Fall ist dieser kompakter, da er den Eingangssatz als predFunktion für verwendet not-any?.

Prolog (SWI) , 66 56 49 Bytes

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

Probieren Sie es online!