n요소 집합이 주어지면 과제는 k이 집합에있는 요소의 모든 조합을 나열하는 함수를 작성하는 것입니다 .

예

Set: [1, 7, 4]
Input: 2
Output: [1,7], [1,4], [7,4]

예

Set: ["Charlie", "Alice", "Daniel", "Bob"]
Input: 2
Output ["Daniel", "Bob"], ["Charlie", "Alice"], ["Alice", "Daniel"], ["Charlie", "Daniel"], ["Alice", "Bob"], ["Charlie",  "Bob"]

규칙 (편집)

• 출력 순서가 선택됩니다.
• 입력은 모든 유형의 데이터 일 수 있습니다. 그러나 출력은 입력과 동일한 유형이어야합니다. 입력이 정수 목록 인 경우 출력도 정수 목록이어야합니다. 입력이 문자열 (문자 배열) 인 경우 출력도 문자열이어야합니다.
• 코드는 여러 입력 변수와 함께 작동해야합니다.
• 모든 프로그래밍 언어를 사용할 수 있습니다.
• 대답은 무엇이든 (string, int, double ...)을 입력 및 출력으로 사용할 수 있어야합니다.
• 조합 및 순열과 관련된 모든 내장 함수는 금지됩니다.
• 가장 짧은 코드가 승리합니다 (바이트 단위).
• 타이 브레이커 : 투표.
• 기간 : 1 주

PS 음수, 0 등과 같은 극한 입력에 주의하십시오 .

하스켈 -57 46 바이트

골퍼에게 가져와

0%_=[[]]
n%(x:y)=map(x:)((n-1)%y)++n%y
_%_=[]

유스 케이스 (동일한 함수가 다형성으로 작동) :

2 % [1,2,3,4] ➔ [[1,2], [1,3], [1,4], [2,3], [2,4], [3,4]]

3 % "속임수"➔ [ "che", "cha", "cht", "cea", "cet", "cat", "hea", "het", "hat", "eat"]

2 % [ "Charlie", "Alice", "Daniel", "Bob"] ➔ [[ "Charlie", "Alice"], [ "Charlie", "Daniel"], [ "Charlie", "Bob"] , [ "앨리스", "다니엘"], [ "앨리스", "밥"], [ "다니엘", "밥"]]

파이썬 (72)

f=lambda S,k:S and[T+S[:1]for T in f(S[1:],k-1)]+f(S[1:],k)or[[]]*(k==0)

이 함수 f는 목록 S과 숫자를 가져와 k길이 k가 모든 하위 목록의 목록을 반환합니다 S. 모든 하위 집합을 나열한 다음 크기별로 필터링하는 대신 각 단계에서 필요한 크기의 하위 집합 만 가져옵니다.

나중에 통과와 S.pop()결합하기 위해 일하고 싶지만 목록을 너무 많이 소비하는 것 같습니다.S[:1]S[1:]

이러한 파이썬 솔루션 때문에 재귀 제한의 "코드는 입력 변수의 수에서 작동한다"는 규칙을 나누기 이의를 선점하기 위해, 나는주의 것 스택리스 파이썬 구현이 실제로 테스트하지 않았습니다 불구하고 (더 재귀 제한이 없습니다 이 코드와 함께).

데모:

S = [1, 2, 6, 8]
for i in range(-1,6):print(i, f(S,i))

#Output:    
-1 []
0 [[]]
1 [[1], [2], [6], [8]]
2 [[2, 1], [6, 1], [8, 1], [6, 2], [8, 2], [8, 6]]
3 [[6, 2, 1], [8, 2, 1], [8, 6, 1], [8, 6, 2]]
4 [[8, 6, 2, 1]]
5 []

매스 매 티카 10, 70 자

하스켈 답변의 번역입니다.

_~f~_={};_~f~0={{}};{x_,y___}~f~n_:=Join[Append@x/@f[{y},n-1],{y}~f~n]

용법:

에서 [1] : = f [{1, 7, 4}, 2]

Out [1] = {{7, 1}, {4, 1}, {4, 7}}

숯 , 23 바이트

ＥΦＥＸ²Ｌθ⮌↨ι²⁼ΣιηΦ…θＬι§ιμ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

    ²                   Literal 2
   Ｘ                    Raised to power
     Ｌ                  Length of
      θ                 Input array
  Ｅ                     Mapped over implicit range
         ι              Current index
        ↨               Converted to base
          ²             Literal 2
       ⮌                Reversed
 Φ                      Filtered on
            Σ           Digital sum of
             ι          Current base 2 value
           ⁼            Equal to
              η         Input `k`
Ｅ                       Mapped to
                 θ      Input array
                …       Chopped to length
                  Ｌ     Length of
                   ι    Current base 2 value
               Φ        Filtered on
                     ι  Current base 2 value
                    §   Indexed by
                      μ Current index

파이썬-129

s는리스트이고, k는 생성 할 조합의 크기입니다.

def c(s, k):
    if k < 0: return []
    if len(s) == k: return [s]
    return list(map(lambda x: [s[0]]+x, c(s[1:], k-1))) + c(s[1:], k)

파이썬, 102

p=lambda s:p(s[1:])+[x+[s[0]]for x in p(s[1:])]if s else[s];c=lambda s,k:[x for x in p(s)if len(x)==k]

다음을 실행하려면 c를 호출하십시오.

c ([5, 6, 7], 2) => [[6, 7], [5, 7], [5, 6]]

목록의 모든 순열을 가져오고 길이가 k 인 항목을 필터링합니다.

피 이스 , 28

DcGHR?+m+]'HdctGtHcGtHH*]Y!G

이것은 Haskell의 답변을 기반으로합니다.

설명:

DcGH                           def c(G,H):
    R                          return
     ?                         Python's short circuiting _ if _ else _
       m+]'Hd                  map to [head(H)]+d
             ctGtH             c(G-1,tail(H))
       m+]'HdctGtH             map [head(H)]+d for d in c(tail(G),tail(H))
      +m+]'HdctGtHcGtH         (the above) + c(G,tail(H))
     ?                H        (the above) if H else (the below)
                       *]Y!G   [[]]*(not G)

참고 : 최신 버전의 Pyth 1.0.9가 오늘 밤에 출시되었으므로이 과제에 적합하지 않지만 동일한 코드가 1.0.8에서 제대로 작동합니다.

Haskell + Data.List , 44 바이트

0%_=[[]]
n%y=do{a:b<-tails y;(a:)<$>(n-1)%b}

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

46 바이트의 대답은 이길 꽤 어렵다하지만이 경우 tails에서 Data.List당신은 44 바이트를 할 수 있습니다.

05AB1E , 14 13 바이트

goLε¹ybRÏ}ʒgQ

@Neil 의 차콜 답변 에서 영감을 얻었 으므로 그를 찬성해야합니다!

온라인으로 시도 하거나 몇 가지 테스트 사례를 확인하십시오 .

내장이 허용되면 2 바이트 일 수 있습니다 .

.Æ

온라인으로 시도 하거나 몇 가지 테스트 사례를 확인하십시오 .

설명:

g              # Get the length of the first (implicit) input-list
 o             # Take 2 to the power this length
  L            # Create a list in the range [1, 2**length]
   ε           # Map each integer `y` to:
    ¹          #  Push the first input-list again
     ybR       #  Convert integer `y` to binary, and reverse it
        Ï      #  And only keep values at truthy indices of `y` (so where the bit is a 1)
         }ʒ    # After the map: filter the list of lists by:
           g   #  Where the length of the inner list
            Q  #  Is equal to the (implicit) input-integer
               # (then the result is output implicitly)

.Æ             # Get all `b`-element combinations in list `a`,
               # where `b` is the first (implicit) input-integer,
               # and `a` is the second (implicit) input-list
               # (then the result is output implicitly)

APL (NARS), 80 자, 160 바이트

{h←{0=k←⍺-1:,¨⍵⋄(k<0)∨k≥i←≢w←⍵:⍬⋄↑,/{w[⍵],¨k h w[(⍳i)∼⍳⍵]}¨⍳i-k}⋄1≥≡⍵:⍺h⍵⋄⍺h⊂¨⍵}

테스트 및 사용 방법 :

  f←{h←{0=k←⍺-1:,¨⍵⋄(k<0)∨k≥i←≢w←⍵:⍬⋄↑,/{w[⍵],¨k h w[(⍳i)∼⍳⍵]}¨⍳i-k}⋄1≥≡⍵:⍺h⍵⋄⍺h⊂¨⍵}
  o←⎕fmt
  o 5 f 1 2 3 4
┌0─┐
│ 0│
└~─┘
  o 4 f 1 2 3 4 
┌1─────────┐
│┌4───────┐│
││ 1 2 3 4││
│└~───────┘2
└∊─────────┘
  o 3 f 1 2 3 4
┌4──────────────────────────────────┐
│┌3─────┐ ┌3─────┐ ┌3─────┐ ┌3─────┐│
││ 1 2 3│ │ 1 2 4│ │ 1 3 4│ │ 2 3 4││
│└~─────┘ └~─────┘ └~─────┘ └~─────┘2
└∊──────────────────────────────────┘
  o 2 f 1 2 3 4
┌6────────────────────────────────────────┐
│┌2───┐ ┌2───┐ ┌2───┐ ┌2───┐ ┌2───┐ ┌2───┐│
││ 1 2│ │ 1 3│ │ 1 4│ │ 2 3│ │ 2 4│ │ 3 4││
│└~───┘ └~───┘ └~───┘ └~───┘ └~───┘ └~───┘2
└∊────────────────────────────────────────┘
  o 1 f 1 2 3 4
┌4──────────────────┐
│┌1─┐ ┌1─┐ ┌1─┐ ┌1─┐│
││ 1│ │ 2│ │ 3│ │ 4││
│└~─┘ └~─┘ └~─┘ └~─┘2
└∊──────────────────┘
  o 0 f 1 2 3 4
┌0─┐
│ 0│
└~─┘
  o ¯1 f 1 2 3 4
┌0─┐
│ 0│
└~─┘
  o 3 f (0 0)(1 2)(3 ¯4)(4 ¯5)
┌4────────────────────────────────────────────────────────────────────────────────────────────────┐
│┌3────────────────────┐ ┌3────────────────────┐ ┌3─────────────────────┐ ┌3─────────────────────┐│
││┌2───┐ ┌2───┐ ┌2────┐│ │┌2───┐ ┌2───┐ ┌2────┐│ │┌2───┐ ┌2────┐ ┌2────┐│ │┌2───┐ ┌2────┐ ┌2────┐││
│││ 0 0│ │ 1 2│ │ 3 ¯4││ ││ 0 0│ │ 1 2│ │ 4 ¯5││ ││ 0 0│ │ 3 ¯4│ │ 4 ¯5││ ││ 1 2│ │ 3 ¯4│ │ 4 ¯5│││
││└~───┘ └~───┘ └~────┘2 │└~───┘ └~───┘ └~────┘2 │└~───┘ └~────┘ └~────┘2 │└~───┘ └~────┘ └~────┘2│
│└∊────────────────────┘ └∊────────────────────┘ └∊─────────────────────┘ └∊─────────────────────┘3
└∊────────────────────────────────────────────────────────────────────────────────────────────────┘
  o 4 f (0 0)(1 2)(3 ¯4)(4 ¯5)
┌1──────────────────────────────┐
│┌4────────────────────────────┐│
││┌2───┐ ┌2───┐ ┌2────┐ ┌2────┐││
│││ 0 0│ │ 1 2│ │ 3 ¯4│ │ 4 ¯5│││
││└~───┘ └~───┘ └~────┘ └~────┘2│
│└∊────────────────────────────┘3
└∊──────────────────────────────┘
  o 1 f (0 0)(1 2)(3 ¯4)(4 ¯5)
┌4────────────────────────────────────┐
│┌1─────┐ ┌1─────┐ ┌1──────┐ ┌1──────┐│
││┌2───┐│ │┌2───┐│ │┌2────┐│ │┌2────┐││
│││ 0 0││ ││ 1 2││ ││ 3 ¯4││ ││ 4 ¯5│││
││└~───┘2 │└~───┘2 │└~────┘2 │└~────┘2│
│└∊─────┘ └∊─────┘ └∊──────┘ └∊──────┘3
└∊────────────────────────────────────┘
  o 2 f ('Charli')('Alice')('Daniel')('Bob')
┌6──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│┌2─────────────────┐ ┌2──────────────────┐ ┌2───────────────┐ ┌2─────────────────┐ ┌2──────────────┐ ┌2───────────────┐│
││┌6──────┐ ┌5─────┐│ │┌6──────┐ ┌6──────┐│ │┌6──────┐ ┌3───┐│ │┌5─────┐ ┌6──────┐│ │┌5─────┐ ┌3───┐│ │┌6──────┐ ┌3───┐││
│││ Charli│ │ Alice││ ││ Charli│ │ Daniel││ ││ Charli│ │ Bob││ ││ Alice│ │ Daniel││ ││ Alice│ │ Bob││ ││ Daniel│ │ Bob│││
││└───────┘ └──────┘2 │└───────┘ └───────┘2 │└───────┘ └────┘2 │└──────┘ └───────┘2 │└──────┘ └────┘2 │└───────┘ └────┘2│
│└∊─────────────────┘ └∊──────────────────┘ └∊───────────────┘ └∊─────────────────┘ └∊──────────────┘ └∊───────────────┘3
└∊──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
  o ¯2 f ('Charli')('Alice')('Daniel')('Bob')
┌0─┐
│ 0│
└~─┘

출력은 괜찮은 것처럼 보이지만 버그는 가능합니다 ...

실제로 입력 알파가 범위를 벗어나면 Zilde로 설정된 void를 반환합니다. 알파가 1이면 요소를 세트에 모두 반환합니다 (맞습니까?).

아래의 문자는 두 문자는 적지 만 두 배는 느립니다.

f←{(⍺>≢⍵)∨⍺≤0:⍬⋄1=⍺:,¨⍵⋄{w[⍵]}¨k/⍨{∧/</¨¯1↓{⍵,¨1⌽⍵}⍵}¨k←,⍳⍺⍴≢w←⍵}

JS- 117188

(a,b,c=[])=>((d=(e,f,g=[])=>f*e?g.push(e)+d(e-1,f-1,g)+g.pop
()+d(e-1,f,g):f||c.push(g.map(b=>a[b-1])))(a.length,b),c)

(<소스 코드>) ([ 'Bob', 'Sally', 'Jonah'], 2)

     [[ 'Jonah', 'Sally'] [ 'Jonah', 'Bob'] [ 'Sally', 'Bob']]

배열 방법 광기

combination = (arr, k) =>
    Array
        .apply(0, { length: Math.pow(k+1, arr.length) })
        .map(Number.call, Number)
        .map(a => a
              .toString(arr.length)
              .split('')
              .sort()
              .filter((a, b, c) => c.indexOf(a) == b)
              .join(''))
        .filter((a, b, c) => a.length == k && c.indexOf(a) == b)
        .map(x => x.split('').map(y => arr[+y]))

C # (Visual C # 대화식 컴파일러) , 141 바이트

l=>l.Any()?A(l.Skip(1)).Select(x=>l.Take(1).Union(x)).Union(A(l.Skip(1))):new object[][]{new object[]{}};B=(n,l)=>A(l).Where(x=>x.Count()==n)

슬프게도 Tio / Mono는 일반 유형 T 선언 을 지원하지 않는 것 같으므로 대신 객체 유형 으로 몇 바이트를 잃게 됩니다.

//returns a list of all the subsets of a list
A=l=>l.Any()?A(l.Skip(1)).Select(x=>l.Take(1).Union(x)).Union(A(l.Skip(1))):new object[][]{new object[]{}};

//return the subsets of the required size
B=(n,l)=>A(l).Where(x=>x.Count()==n);

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