Bir dizi neleman verildiğinde , zorluk kbu setteki tüm eleman kombinasyonlarını listeleyen bir fonksiyon yazmaktır .

Misal

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

Misal

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

Kurallar (Düzenlendi)

• Çıktı sırası sizin seçiminizdir.
• Giriş, herhangi bir veri türü olabilir. Ancak çıktı, girdi ile aynı türde olmalıdır. Giriş bir tamsayılar listesiyse, çıktı da bir tamsayılar listesi olmalıdır. Giriş bir dize (karakter dizisi) ise, çıktı da bir dize olmalıdır.
• Kod, herhangi bir sayıda giriş değişkeni ile çalışmalıdır.
• Herhangi bir programlama dilini kullanabilirsiniz.
• Cevap, girdi ve çıktı olarak da her şeyi (string, int, double ...) kullanabilmelidir.
• Kombinasyonlar ve permütasyonlarla ilgili yerleşik fonksiyonlar yasaktır.
• En kısa kod kazanır (bayt cinsinden).
• Tiebreaker: oylar.
• Süre: 1 hafta.

PS: Negatif sayılar, 0 vb. Gibi aşırı girdilere dikkat edin .

Haskell - 57 46 bayt

Getirin, golfcripterler.

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

Kullanım örneği (aynı işlev polimorfik olarak çalışır):

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

% 3 "hile" ➔ ["che", "cha", "cht", "cea", "cet", "kedi", "hea", "het", "şapka", "yemek"]

% 2 ["Charlie", "Alice", "Daniel", "Bob"] ➔ [["Charlie", "Alice"], ["Charlie", "Daniel"], ["Charlie", "Bob"] [ "Alice", "Daniel"], [ "Alice", "Bob"], [ "Daniel", "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)

Fonksiyon flistesini alır Sve numara kve uzunluğu her sublists bir listesini döndürür kait S. Tüm alt kümeleri listelemek ve ardından boyuta göre filtrelemek yerine, her adımda yalnızca gerekli boyuttaki alt kümeleri alıyorum.

Daha sonra geçmeyi S.pop()birleştirmek için çalışmak istiyorum , ancak listeyi çok fazla tüketiyor gibi görünüyor.S[:1]S[1:]

İtirazı önlemek için böyle bir Python çözümü, özyineleme sınırlarından dolayı "kod herhangi bir sayıda girdi değişkeninde çalışmalıdır" kuralını bozarsa , Stackless Python uygulamasının özyineleme sınırları olmadığını (aslında test etmedim) bu kodu onunla birlikte).

gösteri:

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 karakter

Sadece Haskell cevabının bir çevirisi.

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

Kullanımı:

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

Çıkış [1] = {{7, 1}, {4, 1}, {4, 7}}

Kömür , 23 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

    ²                   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 bir listedir, k üretilecek kombinasyonların boyutudur.

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]

Çalıştırmak için c'yi arayın:

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

Listenin tüm permütasyonlarını alır ve k uzunluğundaki filtreleri filtreler.

Pyth , 28

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

Bu (ağır) Haskell cevabına dayanmaktadır.

Açıklama:

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)

Not: Pyth'in en son sürümü olan 1.0.9 bu gece piyasaya sürüldü ve bu nedenle bu meydan okuma için uygun değilken, aynı kod 1.0.8'de iyi çalışıyor.

Haskell + Veri Listesi , 44 bayt

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

Çevrimiçi deneyin!

46 bayt cevap yenmek için oldukça zor ama varsa tailsdan Data.Listsen 44 bayt yapabilirsiniz.

05AB1E , 14 13 bayt

goLε¹ybRÏ}ʒgQ

@Neil'in Kömür cevabından esinlenerek , onu oyladığınızdan emin olun!

Çevrimiçi deneyin veya birkaç test vakasını doğrulayın .

Yerleşiklere izin verildiyse, bu 2 bayt olabilir :

.Æ

Çevrimiçi deneyin veya birkaç test vakasını doğrulayın .

Açıklama:

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 karakter, 160 bayt

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

test ve nasıl kullanılır:

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

çıktı iyi görünüyor ... ama hata mümkündür ...

Pratikte, giriş alfa aralığın dışındaysa, Zilde olarak ayarlanmış boşluğu döndürür; alfa 1 ise, kümesindeki öğelerin tümünü döndürür (doğru mu?);

Bu aşağıda birkaç karakter daha az ama 2 kat daha yavaş görünüyor:

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)

(<kaynak kodu>) (['Bob', 'Sally', 'Jonah'], 2)

     [[ 'Yunus', 'Hülya'nın] [ 'Yunus', 'Bob'] [Sally', 'Bob']]

Dizi yöntemi deliliği

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 # Etkileşimli Derleyici) , 141 bayt

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)

Ne yazık ki, Tio / Mono genel tip T bildirimini desteklemiyor gibi görünüyor , bunun yerine nesne türü ile birkaç bayt kaybetmek zorunda kalıyorum .

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

Çevrimiçi deneyin!