ด้วยชุดของ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 ... ) เป็นอินพุตและเอาต์พุตเช่นกัน
• ห้ามใช้ฟังก์ชันในตัวที่เกี่ยวข้องกับชุดค่าผสมและพีชคณิต
• รหัสที่สั้นที่สุดชนะ (ในแง่ของไบต์)
• Tiebreaker: คะแนนโหวต
• ระยะเวลา: 1 สัปดาห์

ป.ล. ระมัดระวังเกี่ยวกับอินพุทสุดขีดเช่นจำนวนลบ, 0, เป็นต้น

Haskell - 57 46 ไบต์

นำมาไว้บน golfscripters

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

ใช้กรณี (ฟังก์ชั่นเดียวกันทำงาน polymorphicaly):

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

3% "cheat" ➔ ["che", "cha", "cht", "cea", "cet", "cat", "hea", "het", "het", "eat"]

2% ["Charlie", "Alice", "Daniel", "Bob"] ➔ [["Charlie", "Alice"], ["Charlie", "Daniel"], ["Charlie", "Bob"] [ "อลิซ", "แดเนียล"], [ "อลิซ", "บ๊อบ"], [ "แดเนียล", "บ๊อบ"]]

Python (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 นั้นเป็นการละเมิดกฎที่ว่า "รหัสควรทำงานในตัวแปรอินพุตจำนวนเท่าใดก็ได้" เนื่องจากข้อ จำกัด การเรียกซ้ำฉันจะทราบว่าการใช้งานแบบหลามของ Stacklessไม่มีข้อ จำกัด การเรียกซ้ำ รหัสนี้ด้วย)

สาธิต:

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 chars

เป็นเพียงคำแปลของคำตอบของ Haskell

_~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

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

จะได้รับการเรียงสับเปลี่ยนทั้งหมดของรายการและกรองสิ่งที่มีความยาว k

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

แรงบันดาลใจจากคำตอบ Charcoal ของ@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 ถ้าอินพุตอัลฟาออกจากช่วง; ถ้าอัลฟ่าเป็น 1 มันจะคืนค่าองค์ประกอบทั้งหมดในชุด (ถูกต้องหรือไม่);

ด้านล่างนี้ดูเหมือนว่าถ่านสองตัวน้อยกว่า แต่ช้ากว่าสองเท่า:

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)

(<source code>) (['Bob', 'Sally', 'Jonah'], 2)

     [[ 'โจนาห์', 'แซลลี่'] [ 'โจนาห์', 'บ๊อบ'] [ 'แซลลี่', 'บ๊อบ']]

ความบ้าคลั่งของอาเรย์วิธี

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

ลองออนไลน์!