Đưa ra một tập hợp các nphần tử, thách thức là viết một hàm liệt kê tất cả các kết hợp các kphần tử trong tập hợp này.

Thí dụ

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

Thí dụ

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

Quy tắc (Đã chỉnh sửa)

• Thứ tự của đầu ra là sự lựa chọn của bạn.
• Đầu vào có thể là bất kỳ loại dữ liệu. Nhưng đầu ra phải cùng loại với đầu vào. Nếu đầu vào là một danh sách các số nguyên, thì đầu ra cũng phải là một danh sách các số nguyên. Nếu đầu vào là một chuỗi (mảng ký tự), thì đầu ra cũng phải là một chuỗi.
• Mã phải hoạt động với bất kỳ số lượng biến đầu vào.
• Bạn có thể sử dụng bất kỳ ngôn ngữ lập trình.
• Câu trả lời sẽ có thể sử dụng mọi thứ (chuỗi, int, double ...) làm đầu vào và đầu ra.
• Bất kỳ chức năng tích hợp nào có liên quan đến kết hợp và hoán vị đều bị cấm.
• Mã ngắn nhất sẽ thắng (tính theo byte).
• Tiebreaker: phiếu bầu.
• Thời gian: 1 tuần.

PS Hãy cẩn thận về các đầu vào cực đoan như số âm, 0, v.v.

Haskell - 57 46 byte

Mang nó vào, người chơi golf.

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

Ca sử dụng (cùng chức năng hoạt động đa hình):

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

3% "gian lận" ➔ ["che", "cha", "cht", "cea", "cet", "mèo", "mũ", "het", "mũ", "ăn"]

2% ["Charlie", "Alice", "Daniel", "Bob"] ➔ [["Charlie", "Alice"], ["Charlie", "Daniel"], ["Charlie", "Bob"] , ["Alice", "Daniel"], ["Alice", "Bob"], ["Daniel", "Bob"]]

Con trăn (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)

Chức năng fmất một danh sách Svà số kvà trả về một danh sách tất cả các danh sách con của chiều dài kcủa S. Thay vì liệt kê tất cả các tập hợp con và sau đó lọc theo kích thước, tôi chỉ nhận được các tập hợp con có kích thước cần thiết ở mỗi bước.

Tôi muốn S.pop()đi làm để kết hợp S[:1]với việc vượt qua S[1:]sau này, nhưng dường như tiêu thụ quá nhiều danh sách.

Để tránh sự phản đối bất kỳ giải pháp Python nào như vậy sẽ phá vỡ quy tắc rằng "Mã phải hoạt động trong bất kỳ số lượng biến đầu vào nào" vì giới hạn đệ quy, tôi sẽ lưu ý rằng việc triển khai Stackless Python không có giới hạn đệ quy (mặc dù tôi chưa thực sự kiểm tra mã này với nó).

Trình diễn:

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

Toán học 10, 70 ký tự

Chỉ là một bản dịch của câu trả lời Haskell.

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

Sử dụng:

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

Hết [1] = {{7, 1}, {4, 1}, {4, 7}}

Than , 23 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

    ²                   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

Con trăn - 129

s là một danh sách, k là kích thước của các kết hợp để tạo ra.

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)

Con trăn, 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]

Gọi c để chạy:

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

Nó nhận được tất cả các hoán vị của danh sách và lọc những cái có độ dài k.

Bình thường , 28

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

Đây là (rất nhiều) dựa trên câu trả lời của Haskell.

Giải trình:

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)

Lưu ý: Mặc dù phiên bản mới nhất của Pyth, 1.0.9, đã được phát hành tối nay và do đó không đủ điều kiện cho thử thách này, cùng một mã hoạt động tốt trong 1.0.8.

Haskell + Data.List , 44 byte

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

Hãy thử trực tuyến!

Câu trả lời 46 byte là khá khó để đánh bại nhưng nếu bạn có tailstừ Data.Listbạn có thể làm 44 byte.

05AB1E , 14 13 byte

goLε¹ybRÏ}ʒgQ

Lấy cảm hứng từ câu trả lời Char than của @Neil , vì vậy hãy đảm bảo nâng cao anh ấy!

Hãy thử trực tuyến hoặc xác minh một vài trường hợp thử nghiệm .

Nếu nội dung được cho phép thì đây có thể là 2 byte :

.Æ

Hãy thử trực tuyến hoặc xác minh một vài trường hợp thử nghiệm .

Giải trình:

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 ký tự, 160 byte

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

kiểm tra và cách sử dụng nó:

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

đầu ra có vẻ ổn ... nhưng lỗi là có thể ...

Trong thực tế, nó trả về void được đặt là Zilde nếu đầu vào alpha nằm ngoài phạm vi; nếu alpha là 1, nó trả về các phần tử tất cả một trong tập hợp của nó (có đúng không?);

Điều này bên dưới có vẻ như một vài char ít hơn nhưng chậm hơn gấp 2 lần ở trên:

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

Mã số - 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)

(<mã nguồn>) (['Bob', 'Sally', 'Jonah'], 2)

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

Phương pháp mảng điên rồ

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 # (Trình biên dịch tương tác Visual C #) , 141 byte

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)

Đáng buồn thay, Tio / Mono dường như không hỗ trợ khai báo loại T chung chung , vì vậy tôi buộc phải mất một vài byte với loại đối tượng thay thế.

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

Hãy thử trực tuyến!