도전

숫자 목록과 목표 값이 있다고 가정하십시오. 목표 값에 더해 숫자를 목록 인덱스로 반환하는 모든 숫자 조합 세트를 찾으십시오.

입력과 출력

입력은 숫자 목록 (고유 할 필요는 없음)과 목표 합계 번호를 갖습니다. 출력은 비어 있지 않은 목록으로 구성되며 각 목록은 원래 입력 목록의 값 위치에 해당하는 정수 값을 포함합니다.

예

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

채점

이것은 code-golf 이므로 가장 짧은 코드가 승리합니다!

껍질 , 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.

이것은 Husk의 최신 추가 기능을 사용합니다 η(지수에 영향을 미침). 아이디어는 η고차 함수 α(여기서는 인라인 람다 함수)와 목록 을 취하고 ( 위의 프로그램 에있는) 인덱싱 함수와의 인덱스를 x호출 α하는 것 입니다 . 예를 들어, 인덱스의 하위 집합을 가져 와서 그 위에 인덱싱을 매핑 하고 결과를 합산합니다.x⁰xṁ⁰x

자바 스크립트 (ES6), 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 정밀도 오류로 교체 된 경우는 2 차 테스트 케이스에 실패 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()

파이썬 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]

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

R , 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.

J , 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

apt , 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

면도 , 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]

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

하스켈 , 76 바이트

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

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

젤리 , 11 바이트

ị³S=
JŒPçÐf

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

1- 색인. 4 바이트는 요소 자체가 아닌 인덱스를 반환하는 데 소비되었습니다.

-1 바이트는 user202729 덕분에
-1 바이트는 Jonathan Allan 덕분에

Wolfram Language (Mathematica) , 43 바이트

1- 색인.

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

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

파이썬 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 바이트는 요소 자체가 아닌 인덱스를 반환하는 데 소비되었습니다.

Brachylog , 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.

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

APL (NARS), 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

Pyth, 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