एक संयोजन मान उत्पन्न करें जो लक्ष्य मान तक जोड़ता है

Question

चुनौती

मान लीजिए कि आपके पास संख्याओं की एक सूची है, और एक लक्ष्य मूल्य है। अपनी संख्या के सभी संयोजनों का सेट खोजें जो लक्ष्य मान तक जोड़ते हैं, उन्हें सूची सूचक के रूप में लौटाते हैं।

इनपुट और आउटपुट

इनपुट संख्याओं की सूची लेगा (आवश्यक नहीं) और लक्ष्य योग संख्या। आउटपुट गैर-रिक्त सूचियों का एक सेट होगा, प्रत्येक सूची जिसमें मूल इनपुट सूची में मानों की स्थिति के अनुरूप पूर्णांक मान होते हैं।

उदाहरण

Input: values = [1, 2, 1, 5], target = 8
Output: [ [0,1,3], [1,2,3] ]

Input: values = [4.8, 9.5, 2.7, 11.12, 10], target = 14.8
Output: [ [0,4] ]

Input: values = [7, 8, 9, -10, 20, 27], target = 17
Output: [ [1,2], [0,3,4], [3,5] ]

Input: values = [1, 2, 3], target = 7
Output: [ ]

स्कोरिंग

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

Comments

संबंधित , संभवतः एक डुबकी।

— ग्यूसेप

मुझे लगता है कि यह एक धोखा है, लेकिन मैं पुराने को बंद कर दूंगा क्योंकि यह पुराना है।

— पोस्ट रॉक गार्फ हंटर

क्या फ्लोटिंग पॉइंट नंबर वास्तव में चुनौती के लिए कुछ जोड़ते हैं? निश्चित नहीं है कि आम सहमति क्या है, लेकिन वे संभवतः कई भाषाओं में सटीक त्रुटियों को जन्म देंगे।

— अरनुलद

मैं फ़्लोटिंग पॉइंट्स के लिए अनुमति देने का इरादा कर रहा था, हाँ

— सपेरागैम

Bleh, सूचकांक? मुझे लगता है कि यह मूल्यों की सूची को लौटाने वाली एक अच्छी चुनौती होगी, हालांकि मुझे लगता है कि एक सवाल उठाता है कि कैसे दोहराया मूल्यों को सबसेट के साथ निपटाया जाता है।

— xnor

Answer 1

भूसी , 10 बाइट्स

ηλfo=¹ṁ⁰tṖ

1 अनुक्रमित। इसे ऑनलाइन आज़माएं!

व्याख्या

ηλfo=¹ṁ⁰tṖ  Inputs are a number n (explicit, accessed with ¹) and a list x (implicit).
η           Act on the incides of x
 λ          using this function:
         Ṗ   Take all subsets,
        t    remove the first one (the empty subset),
  f          and keep those that satisfy this:
      ṁ⁰      The sum of the corresponding elements of x
   o=¹        equals n.

यह भूसी के नवीनतम जोड़ का उपयोग करता है, η(सूचकांकों पर कार्य करता है)। विचार यह है कि ηएक उच्च क्रम फ़ंक्शन α(यहां इनलाइन लैम्ब्डा फ़ंक्शन) और एक सूची लेता है x, और (जो उपरोक्त कार्यक्रम में है) αके इंडेक्सिंग फ़ंक्शन और इंडेक्स पर कॉल xकरता है । उदाहरण के लिए, सूचकांकों का एक सबसेट लेता है, उन पर अनुक्रमणित करता है और परिणाम प्रस्तुत करता है।⁰xṁ⁰x

Answer 2

जावास्क्रिप्ट (ईएस 6), 96 बाइट्स

करी सिंटैक्स में इनपुट लेता है (list)(target)।

a=>s=>a.reduce((b,_,x)=>[...b,...b.map(y=>[...y,x])],[[]]).filter(b=>!b.reduce((p,i)=>p-a[i],s))

परीक्षण के मामलों

यह द्वितीय परीक्षण के मामले में विफल रहता है यदि 4.8 और 10 को IEEE 754 सटीक त्रुटि के कारण स्वैप किया गया - यानी 14.8 - 4.8 - 10 == 0लेकिन 14.8 - 10 - 4.8 != 0। मुझे लगता है कि यह ठीक है , हालांकि मेटा में कहीं अधिक प्रासंगिक संदर्भ हो सकता है।

let f =

a=>s=>a.reduce((b,_,x)=>[...b,...b.map(y=>[...y,x])],[[]]).filter(b=>!b.reduce((p,i)=>p-a[i],s))

console.log(JSON.stringify(f([1, 2, 1, 5])(8)))
console.log(JSON.stringify(f([4.8, 9.5, 2.7, 11.12, 10])(14.8)))
console.log(JSON.stringify(f([7, 8, 9, -10, 20, 27])(17)))
console.log(JSON.stringify(f([1, 2, 3])(7)))

टिप्पणी की गई

a => s =>                 // given an array a[] of length N and an integer s
  a.reduce((b, _, x) =>   // step #1: build the powerset of [0, 1, ..., N-1]
    [ ...b,               //   by repeatedly adding to the previous list b[]
      ...b                //   new arrays made of:
      .map(y =>           //     all previous entries stored in y[]
        [...y, x]         //     followed by the new index x
      )                   //   leading to:
    ],                    //   [[]] -> [[],[0]] -> [[],[0],[1],[0,1]] -> ...
    [[]]                  //   we start with a list containing an empty array
  )                       // end of reduce()
  .filter(b =>            // step #2: filter the powerset
    !b.reduce((p, i) =>   //   keeping only entries b
      p - a[i],           //     for which sum(a[i] for i in b)
      s                   //     is equal to s
    )                     //   end of reduce()
  )                       // end of filter()

Comments

एक नहीं बल्कि दो reduceएस? मैं इसे उभारने के लिए मिला हूं।

— नील

@ निल कम ज्ञात "कमपार्टरड्यूस"

— लॉर्ड

Answer 3

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

lambda a,n:[b for b in[[i for i in range(len(a))if j&1<<i]for j in range(2**len(a))]if sum(a[c]for c in b)==n]

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

Answer 4

आर , 85 84 बाइट्स

function(l,k){N=combn
o={}
for(i in I<-1:sum(l|1))o=c(o,N(I,i,,F)[N(l,i,sum)==k])
o}

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

1 अनुक्रमित।

combnआम तौर पर एक रिटर्न देता है matrix, लेकिन simplify=Fएक रिटर्न सेट करने के listबजाय, हमें cसभी परिणामों को एक साथ करने की अनुमति देता है । combn(I,i,,F)सूचकांकों के सभी संयोजनों को लौटाता है, और हम N(l,i,sum)==kउस सूची में एक सूचकांक के रूप में लेते हैं जो उन्हें निर्धारित करता है k।

Answer 5

जे , 32 31 बाइट्स

(=1#.t#])<@I.@#t=.1-[:i.&.#.1"0

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

                  1-[:i.&.#.1"0         Make a list of all masks
                                        for the input list. We flip the bits
                                        to turn the unnecessary (0...0)         
                                        into (1...1) that would be missing.
                                        Define it as t.

(=1#.t#])                               Apply the masks, sum and
                                        compare with the target

         <@I.@#                         Turn the matching masks into 
                                        lists of indices

Comments

मुझे लगता है कि एक स्पष्ट परिभाषा से रचनाओं में मदद मिलेगी, लेकिन दुर्भाग्य से मुझे केवल एक ही लंबाई मिली 4 :'<@I.t#~x=1#.y#~t=.#:}.i.2^#y':। इसे ऑनलाइन आज़माएं!

— कोल

Answer 6

जाप , 14 बाइट्स

m, à f_x!gU ¥V

इसे ऑनलाइन टेस्ट करें!

यह काम किस प्रकार करता है

m, à f_x!gU ¥V   Implicit: U = input array, V = target sum
m,               Turn U into a range [0, 1, ..., U.length - 1].
   à             Generate all combinations of this range.
     f_          Filter to only the combinations where
       x           the sum of
        !gU        the items at these indices in U
            ¥V     equals the target sum.
                 Implicit: output result of last expression

Comments

के साथ अच्छी चाल m,। मैं Êo à k@VnXx@gXउसी बाइट की गिनती के लिए था ।

— झबरा

Answer 7

क्लीन , 104 102 98 बाइट्स

import StdEnv
@n=[[]:[[i:b]\\i<-[0..n-1],b<- @i]]
?l n=[e\\e<-tl(@(length l))|sum(map((!!)l)e)==n]

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

Comments

[1, 2, -1, 5] 0 --> [[],[2,0]]गैर-रिक्त सूचियों का एक सेट आवश्यक है।

— फ्रॉनीफ्रॉग

@FrownyFrog फिक्स्ड

— Οurous

Answer 8

हास्केल , 76 बाइट्स

x#t=[i|i<-tail$concat<$>mapM(\z->[[],[z]])[0..length x-1],t==sum[x!!k|k<-i]]

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

Comments

[1, 2, -1, 5]#0 --> [[],[0,2]]गैर-रिक्त सूचियों का एक सेट आवश्यक है।

— फ्रॉन्फ्रोग में

@FrownyFrog धन्यवाद! फिक्स्ड।

— क्रिस्टियान लुपस्कु

Answer 9

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

ị³S=
JŒPçÐf

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

1 अनुक्रमित। 4 बाइट्स केवल तत्वों के बजाय खुद लौटने वाले सूचकांकों पर खर्च करते हैं।

-120 उपयोगकर्ता के लिए बाइट धन्यवाद -20
जोनाथन एलन के लिए बाइट धन्यवाद

Comments

12 बाइट्स

— user202729

@ user202729 कूल, धन्यवाद!

— हाइपरएन्यूट्रीनो

-1 बाइट: ⁴यदि आप çइसके बजाय उपयोग करते हैं तो यह अनावश्यक है Ç।

— जोनाथन एलन

@JonathanAllan ओ अच्छी पकड़ धन्यवाद!

— हाइपरनेत्रिनो

Answer 10

वोल्फ्राम भाषा (गणितज्ञ) , 43 बाइट्स

1 अनुक्रमित।

Pick[s=Subsets;s@Range@Tr[1^#],Tr/@s@#,#2]&

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

Answer 11

पायथन 3 , 144 बाइट्स

lambda a,t:[[e for e,_ in x]for r in range(len(a))for x in combinations(list(enumerate(a)),r+1)if sum(y for _,y in x)==t]
from itertools import*

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

0 अनुक्रमित। 44 बाइट्स केवल तत्वों के बजाय खुद लौटने वाले सूचकांकों पर खर्च करते हैं।

Answer 12

ब्रेकीलॉग , 18 15 बाइट्स

hiᶠ⊇Shᵐ+~t?∧Stᵐ

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

-3 बाइट्स क्योंकि यह अब एक जनरेटर के रूप में काम करता है । (यह संभवत: अधिक गोल्फ के लिए संभव है, लेकिन सूचकांकों का उपयोग करने की आवश्यकता के आसपास काम करना अजीब है।)

    S              The variable S
   ⊇               is a sublist of
  ᶠ                the list of all
 i                 pairs [element, index] from
h                  the first element of
                   the input;
     hᵐ            the first elements of each pair
       +           add up to
        ~t         the last element of
          ?        the input
           ∧       which isn't necessarily
            S      S,
             tᵐ    from which the last elements of each pair
                   are output.

Comments

hiᶠ⊇z+ʰXh~t?∧Xtएक ही लंबाई के लिए बाहर आता है।

— असंबंधित स्ट्रिंग

Answer 13

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

->\a,\b{grep {a[$_].sum==b},^a .combinations}

झसे आज़माओ

विस्तारित:

->
  \a, # input list
  \b, # input target
{

  grep

  {
      a[ $_ ].sum # use the list under test as indexes into ｢a｣
    ==
      b
  },

  ^a              # Range upto ｢a｣ (uses ｢a｣ as a number)
  .combinations   # get all of the combinations
}

Answer 14

एपीएल (एनएआरएस), 49 चार्ट, 98 बाइट्स

{∨/b←⍺=+/¨{∊⍵⊂w}¨n←{⍵⊤⍨k⍴2}¨⍳¯1+2*k←≢w←⍵:⍸¨b/n⋄⍬}

1 अनुक्रमित; परीक्षा:

  f←{∨/b←⍺=+/¨{∊⍵⊂w}¨n←{⍵⊤⍨k⍴2}¨⍳¯1+2*k←≢w←⍵:⍸¨b/n⋄⍬}
  ⎕fmt 8 f 1 2 1 5
┌2──────────────┐
│┌3────┐ ┌3────┐│
││2 3 4│ │1 2 4││
│└~────┘ └~────┘2
└∊──────────────┘
  ⎕fmt   14.8  f  4.8 9.5 2.7 11.12 10
┌1────┐
│┌2──┐│
││1 5││
│└~──┘2
└∊────┘
  ⎕fmt 17 f 7, 8, 9, ¯10, 20, 27
┌3──────────────────┐
│┌2──┐ ┌2──┐ ┌3────┐│
││4 6│ │2 3│ │1 4 5││
│└~──┘ └~──┘ └~────┘2
└∊──────────────────┘
  ⎕fmt 7 f 1 2 3
┌0┐
│0│
└~┘

टिप्पणी:

{∨/b←⍺=+/¨{∊⍵⊂w}¨n←{⍵⊤⍨k⍴2}¨⍳¯1+2*k←≢w←⍵:⍸¨b/n⋄⍬}
                             ⍳¯1+2*k←≢w←⍵         copy ⍵ in w, len(⍵) in k, return 1..2^(k-1) 
                 n←{⍵⊤⍨k⍴2}¨                     traslate in binary each element of  1..2^(k-1) and assign the result to n
          {∊⍵⊂w}¨                                for each binary element of n return the elemets of ⍵ in the place where there are the 1s
    b←⍺=+/¨                                       sum them and see if the sum is ⍺, that binary array saved in b
  ∨/                                     :⍸¨b/n   if or/b, get all the elements of n that are 1s for array b, and calculate each all indexs
                                               ⋄⍬ else return Zilde as void set

Answer 15

अजगर, 11 बाइट्स

fqvzs@LQTyU

इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

fqvzs@LQTyUQ   Implicit: Q=input 1 (list of numbers), z=input 2 (target value, as string)
               Trailing Q inferred
          UQ   Generate range [0-<length of Q>)
         y     Powerset of the above
f              Keep elements of the above, as T, when the following is truthy:
      L T        Map elements of T...
     @ Q         ... to the indicies in Q
    s            Take the sum
 q               Is the above equal to...
  vz             z as an integer
               Implicit print of the remaining results