Défi

Supposons que vous ayez une liste de nombres et une valeur cible. Trouvez l'ensemble de toutes les combinaisons de vos nombres qui s'ajoutent à la valeur cible, en les renvoyant sous forme d'indices de liste.

Entrée et sortie

L'entrée prendra une liste de nombres (pas nécessairement uniques) et un numéro de sommation cible. La sortie sera un ensemble de listes non vides, chaque liste contenant des valeurs entières correspondant à la position des valeurs dans la liste d'entrée d'origine.

Exemples

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: [ ]

Notation

C'est le code-golf , donc le code le plus court gagne!

Husk , 10 octets

ηλfo=¹ṁ⁰tṖ

1 indexé. Essayez-le en ligne!

Explication

ηλ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.

Cela utilise le dernier ajout à Husk, η(agir sur les indices). L'idée est que ηprend une fonction d'ordre supérieur α(ici la fonction lambda en ligne) et une liste x, et fait appel αà la fonction d'indexation dex (qui est ⁰dans le programme ci-dessus) et les indices de x. Par exemple, ṁ⁰prend un sous-ensemble d'index, mappe l'indexation xsur eux et additionne les résultats.

JavaScript (ES6), 96 octets

Prend une entrée dans la syntaxe de curry (list)(target) .

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

Cas de test

Cela échouerait sur le 2ème cas de test si 4,8 et 10 étaient échangés en raison d'une erreur de précision IEEE 754 - c'est-à-dire 14.8 - 4.8 - 10 == 0mais 14.8 - 10 - 4.8 != 0. Je pense que c'est bien , bien qu'il puisse y avoir une référence plus pertinente quelque part dans la méta.

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

Commenté

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

Python 2 , 110 octets

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]

Essayez-le en ligne!

R , 85 84 octets

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}

Essayez-le en ligne!

1 indexé.

combnrenvoie généralement un matrix, mais le paramètre simplify=Frenvoie un à la listplace, ce qui nous permet de cconcaténer tous les résultats ensemble. combn(I,i,,F)renvoie toutes les combinaisons d'indices, et nous prenons N(l,i,sum)==kcomme index dans cette liste pour déterminer ceux qui sont égaux k.

J , 32 31 octets

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

Essayez-le en ligne!

                  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

Japt , 14 octets

m, à f_x!gU ¥V

Testez-le en ligne!

Comment ça fonctionne

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

Nettoyer , 104 102 98 octets

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

Essayez-le en ligne!

Haskell , 76 octets

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

Essayez-le en ligne!

Gelée , 11 octets

ị³S=
JŒPçÐf

Essayez-le en ligne!

1 indexé. 4 octets dépensés pour renvoyer des indices plutôt que juste les éléments eux-mêmes.

-1 octet grâce à user202729
-1 octet grâce à Jonathan Allan

Wolfram Language (Mathematica) , 43 octets

1 indexé.

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

Essayez-le en ligne!

Python 3 , 144 octets

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*

Essayez-le en ligne!

0 indexé. 44 octets dépensés pour renvoyer des indices plutôt que seulement les éléments eux-mêmes.

Brachylog , 18 15 octets

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

Essayez-le en ligne!

-3 octets car il fonctionne désormais comme un générateur . (Il est probablement possible de jouer davantage au golf, mais contourner la nécessité d'utiliser des indices est difficile.)

    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.

Perl 6 , 45 octets

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

Essaye-le

Étendu:

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

APL (NARS), 49 caractères, 98 octets

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

1 indexé; tester:

  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│
└~┘

commentaire:

{∨/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

Pyth, 11 octets

fqvzs@LQTyU

Essayez-le en ligne ici ou vérifiez tous les cas de test en même temps ici .

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