गोल्फ द सबसेट-सम प्रॉब्लम

Question

कार्य

इनपुट के रूप में अंतरिक्ष-सीमांकित पूर्णांक की एक सूची को देखते हुए, इन संख्याओं के सभी अनूठे गैर-खाली उप-आउटपुटों को आउटपुट करते हैं, जो प्रत्येक सब्मिट 0 पर बैठता है।

---

परीक्षण का मामला

इनपुट: 8 −7 5 −3 −2
आउटपुट:-3 -2 5

---

जीत का मानदंड

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीतता है!

Comments

यदि इनपुट में गैर-अद्वितीय संख्याएँ हैं, तो क्या हमें विशिष्टता की चिंता करनी होगी? दूसरे शब्दों में, मुझे इनपुट के लिए कितने परिणाम प्रिंट करने होंगे 3 3 -3 -3?

— कीथ रान्डेल

@Keith। अधिवेशन द्वारा, सेट में अलग-अलग तत्व होते हैं जो एक बार में दिखाई देते हैं। मल्टीसेट में ऐसे तत्व हो सकते हैं जो एक से अधिक बार दिखाई देते हैं। en.wikipedia.org/wiki/Multiset

— डेविड

@DavidCarraher, ओपी सूचियों के सबसेट के बारे में बात करके शब्दावली का मिश्रण करता है।

— पीटर टेलर

@PeterTaylor साभार अच्छी बात।

— डेविड ऑक्ट

Answer 1

GolfScript, 41 अक्षर

~][[]]\{`{1$+$}+%}%;(;.&{{+}*!},{" "*}%n*

यदि आप विशिष्ट आउटपुट प्रारूप के बारे में परवाह नहीं करते हैं तो आप कोड को 33 वर्णों तक छोटा कर सकते हैं।

~][[]]\{`{1$+$}+%}%;(;.&{{+}*!},`

उदाहरण ( ऑनलाइन देखें ):

> 8 -7 5 -3 -2 4
-3 -2 5
-7 -2 4 5
-7 -3 -2 4 8

Answer 2

ब्रेकीलॉग (2), 9 अक्षर

{⊇.+0∧}ᵘb

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

{⊇.+0∧}ᵘb
 ⊇           subset
   +0        that sums to 0
  .  ∧       output the subset
{     }ᵘ     take all unique solutions
        b    except the first (which is the empty solution)

Answer 3

अजगर, 119 चरस

def S(C,L):
 if L:S(C,L[1:]);S(C+[L[0]],L[1:])
 elif sum(map(int,C))==0and C:print' '.join(C)
S([],raw_input().split())

सभी 2 ^ n सबटेट्स को पुनरावर्ती रूप से गणना करता है और प्रत्येक की जांच करता है।

Comments

वाहवाही! मैं एक चरित्र के भीतर आया ...

— बूथ

Answer 4

अजगर, 120

मैं कीथ समाधान से भी बदतर चरित्र हूं। लेकिन ... यह पोस्ट न करने के बहुत करीब है। कोड-गोल्फ की मेरी पसंदीदा विशेषताओं में से एक यह है कि असमानता समान लंबाई वाले समाधान कैसे हो सकते हैं।

l=raw_input().split()
print[c for c in[[int(j)for t,j in enumerate(l)if 2**t&i]for i in range(1,2**len(l))]if sum(c)==0]

Answer 5

अजगर ( 128 137 136)

लानत है तुम पर, itertools.permutations इतने लंबे नाम रखने के लिए!

जानवर बल समाधान। मुझे आश्चर्य है कि यह सबसे छोटा नहीं है: लेकिन मुझे लगता हैitertools है कि समाधान को बर्बाद कर देता है।

Ungolfed:

import itertools
initial_set=map(int, input().split())
ans=[]
for length in range(1, len(x)+1):
    for subset in itertools.permutations(initial_set, length):
        if sum(subset)==0:
            ans+=str(sorted(subset))
print set(ans)

गोल्फ (बदसूरत आउटपुट):

from itertools import*
x=map(int,input().split())
print set(`sorted(j)`for a in range(1,len(x)+1)for j in permutations(x,a)if sum(j)==0)

गोल्फ (सुंदर आउटपुट) (183):

from itertools import*
x=map(int,input().split())
print `set(`sorted(j)`[1:-1]for a in range(1,len(x)+1)for j in permutations(x,a)if sum(j)==0)`[5:-2].replace("'","\n").replace(",","")

import itertools as i: itertools मॉड्यूल को आयात करना और इसे कॉल करना i

x=map(int,input().split()): रिक्त स्थान द्वारा इनपुट को अलग करता है, फिर परिणामी सूचियों को पूर्णांक में बदल देता है (2 3 -5 -> [2, 3, -5])

सेट के लिए ( sorted(j)रेंज में (1, len (x) +1) j के लिए i.permutations (x, a) यदि sum (j) == 0):
में सभी सबसेट्स की सूची देता है x, सॉर्ट किया गया, जहाँ योग 0 है, और तब केवल अनन्य आइटम मिलते हैं
( set(...))

आसपास कब्र (`) के sorted(j)लिए अजगर शॉर्टहैंड है repr(sorted(j))। इसका कारण यह है कि पायथन में सेट सूची को संभाल नहीं सकते हैं, इसलिए अगली सबसे अच्छी बात यह है कि पाठ के रूप में एक सूची के साथ तार का उपयोग करें।

Comments

मैं इस बारे में उलझन में हूँ कि आप स्ट्रिंग्स के बजाय पूर्णांक कैसे प्राप्त कर रहे हैं। split()तार की एक सूची बनाता है, लेकिन फिर बाद में आप sumउस विभाजन के सबसेट पर कॉल कर रहे हैं ।

— कीथ रान्डेल

@KeithRandall: facepalm मैं एक भीड़ में था, इसलिए मैंने अपने कोड का परीक्षण नहीं किया। उसे इंगित करने के लिए धन्यवाद।

— beary605

आप शायद कर के किसी पात्र को बचा सकते हैंfrom itertools import*

— मैट

वास्तव में कब्रों के लिए शॉर्टहैंड हैrepr()

— gnibbler 23

@gnibbler: कि `'हैलो' चल रहा है जब एक बहुत अधिक समझ में आता है। धन्यवाद!

— beary605 23

Answer 6

C # - 384 वर्ण

ठीक है, C # में फ़ंक्शनल-स्टाइल प्रोग्रामिंग इतनी छोटी नहीं है , लेकिन मुझे यह पसंद है! (ब्रूट-फोर्स एन्यूमरेशन का उपयोग करना, बेहतर कुछ नहीं है।)

using System;using System.Linq;class C{static void Main(){var d=Console.ReadLine().Split(' ').Select(s=>Int32.Parse(s)).ToArray();foreach(var s in Enumerable.Range(1,(1<<d.Length)-1).Select(p=>Enumerable.Range(0,d.Length).Where(i=>(p&1<<i)!=0)).Where(p=>d.Where((x,i)=>p.Contains(i)).Sum()==0).Select(p=>String.Join(" ",p.Select(i=>d[i].ToString()).ToArray())))Console.WriteLine(s);}}

अधिक पठनीयता के लिए प्रारूपित और टिप्पणी की गई:

using System;
using System.Linq;

class C
{
    static void Main()
    {
        // read the data from stdin, split by spaces, and convert to integers, nothing fancy
        var d = Console.ReadLine().Split(' ').Select(s => Int32.Parse(s)).ToArray();
        // loop through all solutions generated by the following LINQ expression
        foreach (var s in
            // first, generate all possible subsets; well, first just their numbers
            Enumerable.Range(1, (1 << d.Length) - 1)
            // convert the numbers to the real subsets of the indices in the original data (using the number as a bit mask)
            .Select(p => Enumerable.Range(0, d.Length).Where(i => (p & 1 << i) != 0))
            // and now filter those subsets only to those which sum to zero
            .Where(p => d.Where((x, i) => p.Contains(i)).Sum() == 0)
            // we have the list of solutions here! just convert them to space-delimited strings
            .Select(p => String.Join(" ", p.Select(i => d[i].ToString()).ToArray()))
        )
            // and print them!
            Console.WriteLine(s);
    }
}

Answer 7

एसडब्ल्यूआई-प्रस्ताव 84

यह संस्करण सूची को प्रिंट करता है, बजाय एक विधेय के एक शब्द के लिए एक उपयुक्त बंधन खोजने की कोशिश करता है।

s([],O):-O=[_|_],sum_list(O,0),print(O).
s([H|T],P):-s(T,[H|P]).
s([_|T],O):-s(T,O).

इनपुट विधि

s([8,-7,5,-3,-2,4],[]).

---

रिकॉर्ड के लिए, यह वह संस्करण है जो विधेय को संतुष्ट करने के लिए एक बंधन पाता है:

s(L,O):-s(L,0,O),O=[_|_].
s([],0,[]).
s([H|T],S,[H|P]):-R is H+S,s(T,R,P).
s([_|T],S,O):-s(T,S,O).

इनपुट विधि

s([8,-7,5,-3,-2,4],O).

पिछले संशोधन में एक अधूरा समाधान है जो खाली सेट को हटाने का प्रबंधन नहीं करता है।

Answer 8

गणितज्ञ 62 57 38

कोड

इनपुट, एक सरणी में पूर्णांक के रूप में प्रवेश किया x।

x

Grid@Select[Subsets@x[[1, 1]], Tr@# == 0 &]

---

उत्पादन

---

व्याख्या

x[[1, 1]] इनपुट को पूर्णांकों की सूची में परिवर्तित करता है।

Subsets पूर्णांक से सभी सबसेट उत्पन्न करता है।

Select....Tr@# == 0 उन सभी सबसेट को देता है जिनकी कुल संख्या 0 के बराबर होती है।

Grid स्थान-पृथक पूर्णांकों के रूप में चयनित सबसेट को प्रारूपित करता है।

Answer 9

जेली , 6 बाइट्स

ŒPḊSÐḟ

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

सिर्फ पूर्णता के लिए। ब्रेकीलॉग के समान, जेली भी चुनौती को स्थगित कर देती है, लेकिन अब तक, नई भाषाएँ सामान्य रूप से प्रतिस्पर्धा करती हैं।

ŒP       Power set.
  Ḋ      Dequeue, remove the first element (empty set).
    Ðḟ   Filter out the subsets with truthy (nonzero)...
   S       sum.

Answer 10

05AB1E , 5 बाइट्स

æ¦ʒO>

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

---

यदि इनपुट को सीमांकित किया जाना चाहिए, तो #इस उत्तर को प्रस्तुत करना केवल आवश्यक परिवर्तन है।

Answer 11

जम्मू, 57 53 51 49 वर्ण

>a:-.~(#:@i.@(2&^)@#<@":@(#~0=+/)@#"1 _])".1!:1[1

उपयोग:

   >a:-.~(#:@i.@(2&^)@#<@":@(#~0=+/)@#"1 _])".1!:1[1
8 _7 5 _3 _2 4
5 _3 _2
_7 5 _2 4
8 _7 _3 _2 4

Comments

ट्रेन को फिर (<@":@(#~0=+/)@#"1 _~2#:@i.@^#)से शुरू करने से 4 अक्षर बचते हैं ।

— एल्गोरिथमशार्क

Answer 12

स्टेक्स , 8 बाइट्स ^CP437

â±3╒yΣ╓à

भागो और डिबग ऑनलाइन!

व्याख्या

समझाने के लिए अनपैक्ड संस्करण (9 बाइट्स) का उपयोग करता है।

LS{|+!fmJ
L            Convert to list
 S           Powerset
  {   f      Filter with block
   |+!       Sum is zero
       mJ    Print each subset, joined by spaces

Comments

Given a list of space-delimited integers as input; आप हालांकि - इनपुट के रूप में एक सूची ले रहे हैं।

— जोनाथन फ्रीच

एक बाइट की कीमत पर तय करेगा।

— वीजुन झोउ

Answer 13

जे , 34 बाइट्स

(a:-.~](<@#~0=+/)@#~[:#:@i.2^#)@".

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

किस तरह

".इनपुट को सूची में परिवर्तित करता है। फिर:

a: -.~ ] (<@#~ (0 = +/))@#~ [: #:@i. 2 ^ #
                                  i.       NB. ints from 0 to...
                                     2 ^ # NB. 2 to the input len
                            [: #:@         NB. converted to binary masks
       ] (             ) #~                NB. filter the input using
                                           NB. using those masks, giving
                                           NB. us all subsets
         (             )@                  NB. and to each one...
         (  #~ (0 = +/))                   NB. return it if its sum is
                                           NB. 0, otherwise make it 
                                           NB. the empty list.
         (<@           )                   NB. and box the result.
                                           NB. now we have our answers
                                           NB. and a bunch of empty 
                                           NB. boxes, or aces (a:).
a: -.~                                     NB. remove the aces.

Answer 14

पर्ल 6 , 51 बाइट्स

*.words.combinations.skip.grep(!*.sum)>>.Bag.unique

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

अद्वितीय बैग की एक सूची लौटाता है जो 0. ए बैग के लिए एक भारित सेट है।

स्पष्टीकरण:

*.words                 # Split by whitespace
 .combinations          # Get the powerset
 .skip                  # Skip the empty list
 .grep(!*.sum)          # Select the ones that sum to 0
 >>.Bag                 # Map each to a weighted Set
 .unique                # And get the unique sets

Answer 15

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

a=gets.split.map &:to_i;b=[];(1...a.length).each{|c|a.permutation(c){|d|d.sum==0?b<<d:0}};p b.map(&:sort).uniq

बाद में TIO लिंक जोड़ेंगे।

संख्याओं की सूची के रूप में स्टडिन से इनपुट लेता है, जैसे 8 −7 5 −3 −2

यह कैसे काम करता है: यह इनपुट को संख्याओं की एक सरणी में परिवर्तित करता है। 1 से सरणी की लंबाई तक लंबाई के सभी क्रमचय प्राप्त करता है। यह उन्हें आउटपुट एरे में जोड़ता है यदि वे 0. के योग करते हैं। यह डुप्लिकेट के बिना एरे को आउटपुट करता है।

नमूना इनपुट के लिए आउटपुट: [[-3, -2, 5]]