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"]

ルール（編集済み）

• 出力の順序は任意です。
• 入力は、どのタイプのデータでもかまいません。ただし、出力は入力と同じタイプでなければなりません。入力が整数のリストである場合、出力も整数のリストである必要があります。入力が文字列（文字の配列）の場合、出力も文字列でなければなりません。
• コードは、任意の数の入力変数で機能する必要があります。
• 任意のプログラミング言語を使用できます。
• 答えは、何でも（文字列、int、double ...）を入力および出力として使用できるはずです。
• 組み合わせと順列に関連する組み込み関数は禁止されています。
• 最短のコードが優先されます（バイト単位）。
• タイブレーカー：投票。
• 期間：1週間。

PS 負の数、0などの極端な入力に注意してください。

Haskell- 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％ "チート"➔["チェ"、 "チャ"、 "cht"、 "cea"、 "cet"、 "cat"、 "hea"、 "het"、 "hat"、 "eat"]

2％["Charlie"、 "Alice"、 "Daniel"、 "Bob"]➔[["Charlie"、 "Alice"]、["Charlie"、 "Daniel"]、["Charlie"、 "Bob"] 、["Alice"、 "Daniel"]、["Alice"、 "Bob"]、["Daniel"、 "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:]ですが、リストを使いすぎているようです。

再帰制限があるため、このようなPythonソリューションが異論を先取りするために、「コードは任意の数の入力変数で機能する必要がある」というルールに違反します。StacklessPython実装には再帰制限がないことに注意します（実際にはテストしていません）それとこのコード）。

デモンストレーション：

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

Mathematica 10、70文字

Haskellの回答の単なる翻訳。

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

使用法：

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

Python、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]]

リストsのすべての順列を取得し、長さ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のCharcoalの回答に触発されたので、必ず賛成してください！

オンラインそれを試してみたり、さらにいくつかのテストケースを検証します。

ビルトインが許可された場合、これは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 setを返します。alphaが1の場合、セット内のすべての要素を返します（正しいですか？）。

これは、以下のように2、3倍少ないようですが、上記の2倍遅くなります。

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

JS-117 188

(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＃Interactive Compiler）、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);

オンラインでお試しください！