क्या यह योग-मुक्त सेट है?

32

एक सेट योग-मुक्त है यदि कोई दो (जरूरी नहीं कि अलग-अलग) तत्व एक साथ जोड़े जाने पर सेट का ही हिस्सा हो।

उदाहरण के लिए, {1, 5, 7}योग-मुक्त है, क्योंकि सभी सदस्य विषम हैं, और दो विषम संख्याएँ जब एक साथ जुड़ती हैं, तो हमेशा होती हैं। दूसरी ओर, {2, 4, 9, 13}योग-मुक्त नहीं है, जैसा कि 2 + 2 = 4या तो 4 + 9 = 13सेट के एक सदस्य को एक साथ जोड़ना है।

एक प्रोग्राम या फ़ंक्शन लिखिए जो एक सेट को इनपुट के रूप में लेता है, और एक सत्य मान को आउटपुट करता है यदि सेट नि: शुल्क है, और मिथ्या अन्यथा।

उदाहरण:

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

Not sum-free:
{0}
{1, 4, 5, 7}
{3, 0}
{16, 1, 4, 8}
code-golf  arithmetic  set-theory 
— orlp
स्रोत
क्या सेट एक सरणी / सूची हो सकता है?
— कॉनर ओ'ब्रायन
@ C @O'Bʀɪᴇɴ ज़रूर।
— orlp
5
कुछ और परीक्षण मामले अच्छे हो सकते हैं!
— लिन
4
बुरी तरह से परीक्षण मामलों की जरूरत है। क्या विशुद्ध रूप से अद्वितीय हैं?
— बिल्ली
3
मुझे लगता है कि आपको स्पष्ट करना चाहिए कि आप दो का मतलब सेट से अलग तत्व नहीं हैं।
— ग्रेगरी निस्बेट

जवाबों:

14

पायथ - 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).
— Maltysen
स्रोत
@FryAmTheEggman smart ....
— माल्टसेन
मुझे बस एक ही उत्तर मिला, लेकिन फिर एहसास हुआ * क्यूक्यू वास्तव में [1,1] का उत्पादन करता है, जो दो समान तत्व हैं, और नक्शे में दिखाई नहीं देना चाहिए।
— बसुकक्सुआन
@busukxuan सवाल वास्तव में आपको डुप्लिकेट पर विचार करने के लिए कहता है: 2 + 2 = 4ओपी से। FryAmTheEggman के गोल्फ से पहले मेरे जवाब ने वास्तव में इस वजह से प्रतिस्थापन के साथ.C गर्भाशय का उपयोग किया था।
— माल्टीसेन
@Maltysen ओह अच्छा!
— बुसकुक्सुआन
40

पायथन 2, 41 बाइट्स

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

s एक अजगर सेट होना चाहिए।

मजेदार तथ्य: sum-freeमेरे नाम का एक विपर्यय है।

— feersum
स्रोत
lambda s:not{a+b for a in s for b in s}&sसमान लंबाई है। मैं दुःख को कम करने के लिए एक रास्ता नहीं ढूँढ सकता।
— FryAmTheEggman
16
विपर्यय के लिए उत्कीर्ण।
— नील
@ Faersum यह आपका प्रश्न है।
— फिलिप हगलुंड
@FilipHaglund नहीं, यह orlp का है।
— mbomb007
@ mbomb007 यदि गंभीर है, तो हाँ। लेकिन, इसका एक गैर-गंभीर अर्थ हो सकता है: यह आपका प्रश्न है / आप प्रश्न पूछते हैं / आपने अन्य सभी को यहां (पायथन) को हराया है। वे कहते हैं कि नहीं किया " आप कर रहे हैं ओ पी ।"
— आउटगोल्फ जूल
26

जेली , 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.
— डेनिस
स्रोत
13

जावास्क्रिप्ट, 86 42 41 बाइट्स

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

धन्यवाद मुझे कोष्ठक / घुंघराले कोष्ठक से बाइट्स का एक टन बचाने के लिए Ctes O'Btes। इसके अलावा, नील यह बताने के लिए धन्यवाद कि फ़ंक्शन विपरीत बूलियन मान लौटा रहा है, जितना होना चाहिए था।

मैंने बाइट्स को फिर से परिभाषित करके कटौती करने की कोशिश की, n.someलेकिन यह काम नहीं करता है क्योंकि यह दुर्भाग्य से एक प्रोटोटाइप फ़ंक्शन है। Array.prototype.mapजेएस के साथ एक बेहतर समाधान हो सकता है लेकिन कुछ फ़ंक्शन वास्तव में मजेदार हैं।

मुझे अब आश्चर्य हो रहा है कि अगर .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
— charredgrass
स्रोत
1
कोशिशn=>n.some(m=>n.some(o=>n.some(p=>m+o==p)))
— कॉनर ओ'ब्रायन
1
कोई बात नहीं! यह अनाम कार्यों के व्यवहार के कारण काम करता है। अन्य ईएस 6 उत्तरों को यहां देखें, आप काफी कुछ सीखेंगे :)
— कॉनर ओ'ब्रायन
1
नमस्कार, और PPCG में आपका स्वागत है!
— NoOneIsHere
1
इसका मतलब गलत है, यह आपको बताता है कि क्या सेट योग-मुक्त नहीं है। इसके अलावा, उपयोग करें n.contains(o+p)जो आपको अंतरतम पर 2 बाइट्स बचाता है some।
— नील
1
क्षमा करें, हां, मेरा मतलब था includes(यह मूल रूप से कहा जाने वाला था containsलेकिन कुछ पुस्तकालय में परस्पर विरोधी परिभाषा है)।
— नील
12

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
— Suever
स्रोत
12

गणितज्ञ, 23 बाइट्स

{}==#⋂Tr/@#~Tuples~2&
— एक सीमन्स
स्रोत
मैंने गलती से आपकी सबमिशन को एडिट कर दिया था, लेकिन फिर उसे वापस उसी तरह से रोल किया। माफ़ कीजिये!
— डेविड जुएल
वैसे, अच्छी जानकारी है कि ट्यूपल्स बनाने से पहले किसी भी तत्व को सूची से हटाया नहीं गया था।
— डेविड जुएल
1
की जगह कृपया ∩के साथ ⋂(यू-22C2)। कोड अभी Mathematica में प्रचुर मात्रा में नहीं है।
— LLLAMnYP
@ LLlAMnYP धन्यवाद, मुझे मैन्युअल रूप से यूनिकोड वर्ण ढूंढना पड़ा क्योंकि जब आप उन्हें कॉपी करते हैं तो मैथेमेटिका स्वतः अभिव्यक्तियों को प्रारूपित करता है; मुझे गलत मिल गया होगा।
— एक सीमन्स
1
@ASimmons यदि आप गणितज्ञ के चरित्र को उजागर करते हैं और F1 को हिट करते हैं तो यह आपको उस विशिष्ट चरित्र के लिए सहायता पृष्ठ दिखाएगा जिसमें हमेशा चरित्र का यूनिकोड कोड बिंदु (हेक्साडेसिमल में) होता है। यह वास्तव में कष्टप्रद है कि आप इसे यूनिकोड के रूप में कॉपी नहीं कर सकते। मुझे लगता है कि Mathematica.SE पर कहीं कहीं "यूनिकोड के रूप में कॉपी" के लिए एक समाधान है लेकिन IIRC यह तुच्छ से बहुत दूर था।
— मार्टिन एंडर
11

हास्केल, 32 , 30 बाइट्स

सरल समाधान:

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

@Lynn द्वारा सहेजे गए दो बाइट्स

— माइकल क्लेन
स्रोत
f x=and[a+b/=c|a<-x,b<-x,c<-x]30 बाइट्स के लिए।
— लिन
6

जे, १ 18 १० 8 बाइट्स

8 बाइट्स मीलों के लिए धन्यवाद बचाए, और 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.जाँचता है कि क्या वे सदस्य मूल सेट में हैं। बाकी का तत्व अधिकतम तत्व को नकार रहा है।

— कोनोर ओ ब्रायन
स्रोत
-:]-.&,+/~सेट अंतर -.और सूची मिलान का उपयोग करते हुए 10 बाइट्स के लिए-:
— मील
ओ, बहुत अच्छा!
— कॉनर ओ'ब्रायन
आपको जरूरत नहीं है और, -.पहले से ही y की कोशिकाओं के साथ काम करता है।
— FrownyFrog
@FrownyFrog आकर्षक, टीआईएल। धन्यवाद!
— कॉनर ओ'ब्रायन
5

रेटिना , 45 44 बाइट्स

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

इनपुट अल्पविराम से विभाजित संख्याओं की एक दशमलव सूची है। आउटपुट 0(मिथ्या) या 1(सत्य) है।

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

व्याख्या

चरण 1: प्रतिस्थापन

\d+
<$&$*1>

यह इनपुट के सभी तत्वों को एकजुट करता है और उन्हें अंदर लपेटता है <...>। कोण कोष्ठक का उद्देश्य केवल 0खाली सूची से एक सूची को अलग करना है (क्योंकि संयुक्त प्रतिनिधित्व 0केवल खाली है)।

चरण 2: प्रतिस्थापन

$
$`$`

हम स्ट्रिंग को 3 बार दोहराते हैं इसे अंत में दो बार जोड़ते हैं।

स्टेज 3: मैच

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

अब हम परिणाम में तीन संख्याओं को खोजने की कोशिश करते हैं जैसे कि पहले दो तीसरे तक जोड़ते हैं। उन मैचों को गिना जाता है (यह वास्तव में ऐसे सभी ट्यूपल्स की गिनती नहीं करता है, क्योंकि मैच ओवरलैप नहीं कर सकते हैं, लेकिन अगर इस तरह के एक ट्यूपल मौजूद है तो यह पाया जाएगा)। इसलिए, हम 0योग-मुक्त सेट और कुछ सकारात्मक के लिए अन्यथा प्राप्त करते हैं।

स्टेज 4: मैच

^0

के बाद से पिछले चरण हम क्या चाहते हैं के विपरीत दे दी है, हम मैचों की गणना के द्वारा परिणाम नकारना ^0जो 1इनपुट के लिए 0और 0सब कुछ के लिए।

— मार्टिन एंडर
स्रोत
5

ऑक्टेव, 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))
— मार्को
स्रोत
आप इसे बदल हो सकती है @(s)~ismember(s+s',s)के बाद से सरणियों हो सकता है truthy / falsey
— Suever
5

क्लोजर, 47 37 बाइट्स

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

काफी सादा समाधान। सभी तत्वों को खोजने के लिए सूची समझ का उपयोग करता है जो योग दूसरे तत्व के बराबर है।

38 बाइट्स प्रकार:

#(every? nil?(for[a % b %](%(+ a b))))
— cliffroot
स्रोत
1
चूंकि आप एक सेट को अपने इनपुट के रूप में ले रहे हैं, इसलिए आप सदस्यता के लिए जांच के लिए सेट का उपयोग कर सकते हैं, #(=(for[a % b % :when(%(+ a b))]a)[])जिसमें 10 बाइट्स बचा सकते हैं
— मील
@ मीलों ओह वाह, धन्यवाद, मैंने थोड़े से उस तथ्य की अनदेखी की और सूचियों के साथ काम किया।
— क्लिफट्रॉट
4

पर्ल 6 ,  24 21 20  19 बाइट्स

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

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

इनपुट सूची की तरह किसी भी स्थितिगत मूल्य है । (एक सेट
एक सहयोगी है इसलिए आपको कॉल करना होगा.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
— ब्रैड गिल्बर्ट b2gills
स्रोत
4

मेथेमेटिका 63 62 42 बाइट्स

इस छोटे संस्करण को ए सिमंस की अधीनता से लाभ हुआ। किसी भी तत्व को पहले सूची से हटाने की आवश्यकता नहीं है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}

सच

— DavidC
स्रोत
क्या आपने aअपनी कार्यपुस्तिका में कहीं और परिभाषित किया है? जब मैं उनका मूल्यांकन करता हूं तो ये भाव वांछित आउटपुट नहीं देते हैं।
— एक सीमन्स
धन्यवाद। ऐसा aहोना चाहिए था #। मैंने इसे ठीक किया और एक शानदार को हटा दिया @।
— डेविड जूल
3

रूबी, 36 बाइट्स

खुद के खिलाफ सेट के एक कार्टेशियन उत्पाद का निर्माण करता है और सभी तत्वों का योग पाता है, फिर मूल सेट के साथ चौराहे की जांच करता है। इनपुट एरेज़ है, लेकिन रूबी में उनके पास पर्याप्त संचालन है ताकि यह अच्छी तरह से काम कर सके।

मेरे मूल समाधान पर -1 बाइट (के &बजाय -और के साथ तुलना में प्रयोग किया जाता है)[] ) @ फर्सम से प्रेरणा के कारण

यहाँ कोशिश करो!

->s{s-s.product(s).map{|x,y|x+y}==s}
— मूल्य स्याही
स्रोत
3

पायथन, 40 बाइट्स

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

^ = सममित अंतर, दोनों सेट में तत्वों के साथ नया सेट लेकिन दोनों नहीं

> सही है अगर बायाँ सेट दाहिने सेट का सुपरसेट है।

— Lulhum
स्रोत
यह खाली सेट के लिए काम नहीं करता है, हालांकि मुझे नहीं पता कि क्या आवश्यक है।
— xnor
1
खैर, विकिपीडिया कहता है (अन्य बातों के अलावा) A is sum-free if the equation a + b = c has no solution with a, b, c ∈ A। इस परिभाषा के साथ, खाली सेट नि: शुल्क नहीं है, और मेरा उत्तर सही है। लेकिन मैं पक्षपाती हो सकता हूं।
— लुलहुम
3
यही कारण है कि परिभाषा का तात्पर्य है कि खाली सेट है योग से मुक्त, के रूप में देखते हैं कोई ए, बी और खाली सेट है कि समीकरण को संतुष्ट में सी। ओपी के नए जोड़े गए परीक्षण मामले इसका समर्थन करते हैं।
— डेनिस
3

ब्रेकीलॉग , 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
— Fatalize
स्रोत
है [2:2]की 2 तत्वों का एक सबसेट [2:4:9]?
— लीकी नून
@LeakyNun नहीं, क्योंकि 2 केवल एक बार दिखाई देता है [2:4:9]।
— घातक
3

आर, 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)
— कॉन मैन
स्रोत
बहुत अच्छा। यदि आप चाहें तो आप एक अनाम फ़ंक्शन के रूप में पोस्ट कर सकते हैं। यह आपको 3 बाइट्स बचाएगा। जैसेfunction(s)!any(outer(s,s,'+')%in%s)
— मिकट
3

रैकेट, 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
— स्टीवन एच।
स्रोत
3

05AB1E , 9 5 बाइट्स

मैजिक ऑक्टोपस Urn के लिए धन्यवाद 4 बाइट्स सहेजे गए

ãOå_P

इसे ऑनलाइन आज़माएं!

व्याख्या

ã       # cartesian product
 O      # sum
  å     # check each if it exists in input
   _    # logical negation
    P   # product
— Emigna
स्रोत
है 0 वास्तव में 05AB1E में truthy?
— डेनिस
@ डेनिस I ने इस चुनौती के लिए 0 सत्य के रूप में परिभाषित किया और कुछ भी मिथ्या के रूप में। क्या यह सामान्य रूप से ठीक नहीं है जब तक कि यह अस्पष्ट है और ओपी ने एक विशिष्ट प्रारूप निर्दिष्ट नहीं किया है?
— एमिग्ना जूल
यह सत्य / मिथ्या की हमारी डिफ़ॉल्ट व्याख्या है।
— डेनिस
@ डेनिस: आह, बहुत बुरा। sum-free = 0 और non-sum-free = "sum" एक चुनौती के लिए अच्छी तरह से फिट है। बहुत सी अन्य चुनौतियाँ देखीं, जो कि परिभाषित की गईं और इसी तरह के गैर-मानक मूल्यों को सच / गलत के रूप में परिभाषित किया गया जिससे मुझे लगा कि संयुक्त राष्ट्र की अस्पष्टता डिफ़ॉल्ट थी। मैं जवाब को संपादित करूँगा। सर उठाने के लिए धन्यवाद।
— एमिगा जूल
1
@MagicOctopusUrn: धन्यवाद! अनिश्चित अगर ये आज्ञाएँ इस तरह से वापस काम करती हैं, लेकिन वे अब ऐसा करते हैं धन्यवाद :) (मैं अभी भी इसे याद कर सकता था, मैं 05AB1E के लिए बहुत नया था जब मैंने यह चुनौती दी थी)
— एमिगा
2

एपीएल, 8 बाइट्स

⊢≡⊢~∘.+⍨

स्पष्टीकरण:

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

परीक्षा:

      ( ⊢≡⊢~∘.+⍨ ) ¨ (1 5 7)(2 4 9 13)
1 0
— मारीनस
स्रोत
2

हास्केल, 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
— XNOR
स्रोत
sएलईएम का उपयोग करने पर और काम के अंतिम भाग से छुटकारा पाने के लिए क्या करता है?
— माल्टीसेन
@ मैलेटेन अगर आपका मतलब है f s=and[notElem(x+y)s|x<-s,y<-s], वह 32 है f s=all(`notElem`s)$(+)<$>s<*>s। 31 के लिए भी है।
— xnor
2

दरअसल , 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
— लीक नन
स्रोत
हो सकता है कि आपका कोड अधिक लिंग-समान हो? ( ♂)
— एरिक आउटगॉल्फ जूल
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 अतिरिक्त बाइट्स का उपयोग करता है - फिडल संस्करण को सफाई की आवश्यकता नहीं होती है।

बेला

— t-clausen.dk
स्रोत
1

पर्ल, 46 बाइट्स

45 बाइट्स कोड + 1 बाइट कमांड लाइन (-p)

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

एक मैच के भीतर मूल्यांकन के लिए अनुमति देने के लिए रेगेक्स के अंदर 'कोड एक्सप्रेशंस' के लिए पर्ल के समर्थन के साथ एकल रेगेक्स मैच का उपयोग करता है।

इस आवश्यकता को प्राप्त करने के लिए कि इनपुट अनसोल्ड है, हम इनपुट स्ट्रिंग को तीन बार दोहराते हैं। यह गारंटी देता है कि परिणाम दो ऑपरेंड के बाद है, और उसी अंक को फिर से मिलान करने की अनुमति देता है (उदाहरण के मामले में इनपुट 2 4)।

उपयोग उदाहरण:

echo "3 5 6 8" | perl -p entry.pl
— Jarmex
स्रोत
1

फैक्टर, 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

मुझे केवल विश्वास है कि पहले दो सही हैं। यह इस सवाल से स्पष्ट नहीं है कि बाकी क्या होना चाहिए, इसलिए मुझे लगता है कि यह अभी के लिए ठीक है।

— बिल्ली
स्रोत
1

PHP, 73 बाइट्स

+8 स्निपेट को एक प्रोग्राम में बदलने के लिए, -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));
}
— टाइटस
स्रोत
1
आप का उपयोग कभी नहीं के रूप में $iऔर $jआप त्यागने कर सकते हैं $i=>और साथ ही $j=>और सेव 8 बाइट्स । दुर्भाग्य से कोड स्निपेट मान्य उत्तर नहीं हैं। इसे एक फंक्शन या पूरा कार्यक्रम बनाएं और इसे अपनी बाइट की गिनती में शामिल करें और आप जाने के लिए तैयार हैं। :)
— सम्मिलित
1

जावा, 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]
— डेविड कोनराड
स्रोत
1

क्लोजर, 34 बाइट्स

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

मैंने पहले के क्लोजर समाधान को ध्यान देने से पहले यह लिखा था। वैसे भी, यह एक अधिक कॉम्पैक्ट है क्योंकि यह एक predफ़ंक्शन के रूप में इनपुट सेट का उपयोग करता है not-any?।

— NikoNyrh
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.