Враховуючи набір 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, подвійний ...) як вхід, так і вихід.
• Будь-які вбудовані функції, пов'язані з комбінаціями та перестановками, заборонені.
• Найкоротший виграш коду (у перерахунку на байти).
• Злодій: голоси.
• Тривалість: 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% "чит" ➔ ["че", "ча", "чт", "cea", "цет", "кіт", "хе", "хет", "капелюх", "з'їсти"]

2% ["Чарлі", "Аліса", "Даніель", "Боб"] ➔ [["Чарлі", "Аліса"], ["Чарлі", "Даніель"], ["Чарлі", "Боб"] , ["Аліса", "Даніель"], ["Аліса", "Боб"], ["Даніель", "Боб"]]

Пітон (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 Python не має обмежень рекурсії (хоча я фактично не перевіряв цей код із ним).

Демонстрація:

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]

Вихід [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]]

Він отримує всі перестановки списку 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 , тому не забудьте підтримати його!

Спробуйте в Інтернеті або перевірте ще кілька тестових випадків .

Якщо вбудовані дозволені, це могло бути 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)

(<вихідний код>) (['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);

Спробуйте в Інтернеті!