함께 추가 될 때 두 개 (필수 별개의 것은 아님) 요소가 세트 자체의 일부가 아닌 경우 세트에는 합계가 없습니다.

예를 들어, {1, 5, 7}모든 멤버가 홀수이고 함께 추가 할 때 홀수 두 개가 항상 짝수이므로 합계가 없습니다. 반면 에, 세트의 멤버에 함께 추가 하거나 함께 추가 할 때 {2, 4, 9, 13}합계가 필요하지 않습니다 .2 + 2 = 44 + 9 = 13

세트를 입력으로 취하고 세트에 합계가 없으면 Truthy 값을 출력하고 그렇지 않으면 Falsy를 출력하는 프로그램 또는 함수를 작성하십시오.

예 :

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 바이트

3 바이트를 절약 해 준 @FryAmTheEggman에게 감사합니다.

!@sM*

테스트 스위트 .

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

파이썬 2, 41 바이트

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

s 파이썬 세트 여야합니다.

재미있는 사실 sum-free은 내 이름의 아나그램입니다.

젤리 , 5 바이트

ṗ3ḅ-P

온라인으로 사용해보십시오!

작동 원리

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

자바 스크립트, 86 42 41 바이트

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

괄호 / 중괄호에서 많은 바이트를 절약 해 주신 Cᴏɴᴏʀ O'Bʀɪᴇɴ에게 감사드립니다. 또한 함수가 있어야하는 반대 부울 값을 반환한다고 지적한 Neil에게 감사드립니다.

재정 의하여 바이트를 줄이려고 시도했지만 n.some불행히도 프로토 타입 함수이기 때문에 작동하지 않습니다. Array.prototype.mapJS 에는 더 나은 솔루션이있을 수 있지만 일부 기능은 정말 재미 있습니다.

.includes.indexOf와 같은 것을 사용하고 1을 추가하는 것 보다 더 짧은 방법이 있는지 궁금합니다 .

테스트 :

> (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 바이트

t&+m~

이것은 모든 항목이 사실이라면 1거짓이고 그렇지 않으면 거짓 인 배열을 출력합니다 . 다음은 MATL에서 다양한 진실 / 거짓 값을 보여주는 데모 입니다.

온라인으로 사용해보십시오

설명

        % 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

매스 매 티카, 23 바이트

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

하스켈, 32 , 30 바이트

간단한 해결책 :

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

@Lynn이 저장 한 2 바이트

줄리아, 18 바이트

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

온라인으로 사용해보십시오!

J, 18 10 8 바이트

마일 덕분에 8 바이트가 절약되었고 FrownyFrog 덕분에 2 바이트가 절약되었습니다!

-:]-.+/~

원래 목록과 설정된 합계의 차이를 일치시킵니다. 이것은 다음과 같습니다.

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

입력 용 y. 이것은 다음과 같이 번역됩니다.

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

+/~를 사용하여 합계 테이블을 반환합니다 y. 의 경우 y =: 16 1 4 9다음을 제공합니다.

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

그런 다음 이 테이블 -.에 y없는 모든 요소로 구성된 목록을 생성하는를 사용 합니다. 목록에 합계가없는 경우 동일한 목록이 생성됩니다. 그런 다음 -:목록이 동일한 지 확인하여 원하는 출력을 생성합니다.

올드, 18 바이트

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

+/~자신에게 추가 된 세트 값의 테이블을 작성하고 e.해당 멤버가 원래 세트에 있는지 확인합니다. 나머지는 최대 요소를 부정하고 있습니다.

망막 , 45 44 바이트

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

입력은 쉼표로 구분 된 10 진수 목록입니다. 출력이 0(거짓) 또는 1(거친)입니다.

온라인으로 사용해보십시오! 첫 번째 줄은 줄 바꿈으로 구분 된 테스트 스위트를 활성화합니다.

설명

1 단계 : 대체

\d+
<$&$*1>

입력의 모든 요소를 ​​단항으로 변환하고에 래핑합니다 <...>. 꺾쇠 괄호의 목적은 0빈 목록과 만 포함 된 목록을 구별하는 것입니다 (단일 표현은 0자체가 비어 있기 때문에 ).

2 단계 : 교체

$
$`$`

우리는 끝에 두 번 추가하여 문자열을 3 번 반복합니다.

3 단계 : 경기

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

우리는 이제 결과에서 세 개의 숫자를 찾아서 첫 번째 두 숫자가 세 번째 숫자를 더합니다. 일치하는 항목이 계산됩니다 (실제로 일치하는 항목은 겹칠 수 없기 때문에 이러한 모든 튜플을 계산하지는 않지만 해당 튜플이있는 경우 검색됩니다). 따라서 우리 0는 합계가없는 세트와 그렇지 않으면 긍정적 인 것을 얻 습니다.

4 단계 : 경기

^0

이전 단계가 우리가 원하는 것과 반대를 준 이후, 우리의 일치 계산에 의한 결과 무효화 ^0되는 1입력 0및 0다른 모든 것들에 대한합니다.

옥타브, 29 21 25 바이트

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

Suever 에게 감사합니다 ! 배열을 반환합니다. 나는 0끝에 []무결 제로 만들기 위해 추가 했습니다 . 옥타브에서 진실과 거짓을 확인하려면 다음을 수행하십시오.

> 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

0 또는 1을 반환하는 대안은 다음과 같습니다.

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

클로저, 47 37 바이트

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

아주 평범한 해결책. list comprehension을 사용하여 합이 다른 요소와 동일한 모든 요소를 ​​찾습니다.

38 바이트 변형 :

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

펄 6 ,  24 21 20  19 바이트

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

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

입력은 List 와 같은 위치 값 입니다. ( 세트 는 Associative 이므로 호출 해야합니다.)
.keys

테스트:

#! /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 바이트

이 더 짧은 버전은 A Simmons의 제출로부터 이익을 얻었습니다. IntegerPartitions적용 하기 전에 목록에서 요소를 제거 할 필요가 없습니다 .

요소를 두 개의 정수 (각각 목록에서)로 분할 할 수없는 경우 IntegerPartitions[#,{2},#]=={}보유합니다. And이것이 목록의 모든 요소를 ​​보유하는지 확인합니다. 그렇다면 목록에 합계가 없습니다.

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

예

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

그릇된

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

참된

2는 있지만 2만큼 다른 홀수는 없습니다.

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

참된

루비, 36 바이트

집합에 대한 직교 곱을 구성하고 모든 요소의 합을 찾은 다음 원래 집합과의 교차를 확인합니다. 입력은 배열이지만 루비에서는 어쨌든 잘 작동하도록 충분한 세트 작업이 있습니다.

@feersum의 영감으로 인해 원래 솔루션보다 -1 바이트 ( &대신 사용 -및 비교 [])

여기 사용해보십시오!

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

파이썬, 40 바이트

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

^ = 대칭 적 차이, 두 세트 중 하나에 요소가있는 새로운 세트

> 왼쪽 집합이 오른쪽 집합의 상위 집합이면 참입니다.

Brachylog , 13 바이트

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

설명

'(          )  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 바이트

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

로 설정합니다. w(s)여기서 s값의 집합 (실제로는 벡터)입니다. 다음은 일부 테스트 사례의 출력입니다.

> 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

c()많은 값을 가져와 벡터로 만드는 연결 함수는 어디에 있습니까 ?

편집 : @MickyT 덕분에 3 바이트를 절약하는 익명 함수로 만들었습니다.

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

라켓, 58 바이트

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

설명:

(λ(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 바이트

Magic Octopus Urn 덕분에 4 바이트 절약

ãOå_P

온라인으로 사용해보십시오!

설명

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

APL, 8 바이트

⊢≡⊢~∘.+⍨

설명:

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

테스트:

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

하스켈, 30 바이트

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

더 흥미로운 더 짧은 솔루션이 있다고 생각하지만 찾지 못했습니다.

이들은 33 및 34 바이트입니다.

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

실제로 7 바이트

;;∙♂Σ∩Y

온라인으로 사용해보십시오!

;;∙♂Σ∩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 바이트

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

참고 :이 작업은 한 번만 실행 된 후 테이블을 삭제하거나 삭제하여 다시 실행해야합니다. 바이올린 편집기에서는 테이블을 만들 수 없습니다. 따라서 내 대답에 포함 된 바이올린은 이것을 보완하기 위해 2 바이트를 더 사용합니다. 바이올린 버전은 정리가 필요하지 않습니다.

깡깡이

펄, 46 바이트

45 바이트 코드 + 1 바이트 명령 줄 (-p)

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

정규식 내에서 '코드 표현식'에 대한 Perl의 지원과 함께 단일 정규식 일치를 사용하여 일치 내에서 평가할 수 있습니다.

입력이 정렬되지 않은 요구 사항을 해결하기 위해 입력 문자열을 세 번 반복합니다. 이렇게하면 결과가 두 피연산자 뒤에 오게되며 동일한 숫자를 다시 일치시킬 수 있습니다 (예 : input의 경우 2 4).

사용 예 :

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

인자, 47 바이트

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

• ∩ { } =보다 작지만보다 짧습니다 intersects?.
• Σ보다 짧지 만과 같습니다 sum.

감사합니다. math.unicode !

테스트 코드 :

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

처음 두 개만 정확하다고 확신합니다. 나머지는 무엇인지에 대한 질문에서 명확하지 않으므로 지금은 괜찮습니다.

PHP, 73 바이트

코드 조각을 프로그램으로 바꾸려면 +8, insertusername 덕분에 쓸모없는 변수에 -8

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

인쇄 1를위한 true빈 출력, false
사용 :php <filename> <value1> <value2> ...

테스트를위한 적격 기능 ( 94 86) : 반환 1또는 없음

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

테스트

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

자바, 67 바이트

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

입력은입니다 Set<Integer>. 테스트 :

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

산출:

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]

클로저, 34 바이트

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

나는 이전 Clojure 솔루션을 알기 전에 이것을 썼습니다. 어쨌든 이것은 입력 세트를의 pred함수 로 사용하기 때문에 더 컴팩트 합니다 not-any?.

프롤로그 (SWI) , 66 56 49 바이트

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

온라인으로 사용해보십시오!