तत्वों के संयोजन को एक सेट में सूचीबद्ध करें

Question

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

नियम (संपादित)

• आउटपुट का क्रम आपकी पसंद का है।
• इनपुट किसी भी प्रकार का डेटा हो सकता है। लेकिन आउटपुट इनपुट के समान होना चाहिए। यदि इनपुट पूर्णांकों की सूची है, तो आउटपुट पूर्णांकों की सूची भी होनी चाहिए। यदि इनपुट एक स्ट्रिंग (वर्णों का सरणी) है, तो आउटपुट एक स्ट्रिंग भी होना चाहिए।
• कोड किसी भी इनपुट चर के साथ काम करना चाहिए।
• आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं।
• उत्तर कुछ भी (स्ट्रिंग, इंट, डबल ...) इनपुट और आउटपुट के रूप में उपयोग करने में सक्षम होना चाहिए।
• कोई भी अंतर्निहित कार्य जो संयोजन और क्रमपरिवर्तन से संबंधित है, निषिद्ध है।
• सबसे छोटा कोड जीतता है (बाइट के संदर्भ में)।
• टाईब्रेकर: वोट।
• अवधि: 1 सप्ताह।

PS अत्यधिक संख्याओं जैसे कि नकारात्मक संख्या, 0, आदि के बारे में सावधान रहें ।

Comments

हालांकि कोडगॉल्फ.स्टैकएक्सचेंज.com/questions/6380/… में एक अतिरिक्त प्रतिबंध है, लेकिन इसके उत्तरों को अपरिवर्तित कॉपी किया जा सकता है और फिर भी हराना मुश्किल होगा।

— पीटर टेलर

इनपुट द्वारा किसी भी प्रकार का डेटा हो सकता है। क्या आपका मतलब किसी भी प्रकार के चलने योग्य डेटा या किसी भी प्रकार के डेटा से भरा है? जैसे है combos('ab', 1) -> ['a', 'b']मान्य है?

— केल्विन के

यदि इनपुट ऋणात्मक है तो आउटपुट क्या होना चाहिए?

— य्प्निपन

मैं नहीं देखता कि यह प्रश्न "पुनरावृत्ति के बिना संयोजन उत्पन्न करना" का एक डुप्लिकेट है जब लगभग हर उत्तर अब तक पुनरावृत्ति का उपयोग करता है।

— xnor

एक प्रतिबंध को हटाने के लिए एक महत्वपूर्ण परिवर्तन नहीं है। इसके अलावा, मौजूदा उत्तरों का उपयोग करना यह निर्धारित करने के लिए कि क्या है या एक डुप्लिकेट नहीं है एक अच्छा विचार नहीं है, क्योंकि आप डुप्लिकेट की पहचान करने में असमर्थ होंगे जब तक कि वे पहले से ही उत्तर नहीं दिए गए थे। कभी-कभी आपको बस अपने सिर का उपयोग करना पड़ता है।

— रेनबोल्ट

Answer 1

हास्केल - 57 46 बाइट्स

इसे गोल्फ खिलाड़ी पर ले आओ।

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

मामले का उपयोग करें (एक ही काम करता है बहुरूपता):

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

3% "धोखा" ➔ ["चे", "चा", "चीट", "सीआ", "केट", "कैट", "हेय", "हेट", "हैट", "ईट"]

2% ["चार्ली", "एलिस", "डैनियल", "बॉब"] [[["चार्ली", "एलिस"], ["चार्ली", "डेनियल"], ["चार्ली", "बॉब"] , [ "ऐलिस", "डैनियल"], [ "ऐलिस", "बॉब"], [ "डैनियल", "बॉब"]]

Comments

धन्यवाद मार्क, मैं भी इसे infix बनाने पर विचार नहीं किया।

— चेस

संयोग से, आपकी बोली में "इस पर" क्या है? खदान में यह एक चुनौती का अर्थ है, लेकिन यह संदर्भ में कोई मतलब नहीं रखता है क्योंकि इस डुप्लिकेट के प्रश्न में आपका अंतिम संस्करण अभी भी मेरे प्रारंभिक संस्करण से अधिक लंबा है ।

— पीटर टेलर

Answer 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:], लेकिन यह सूची का बहुत अधिक उपभोग करता है।

इस तरह के पायथन सॉल्यूशन पर आपत्ति जताने के लिए नियम यह कहता है कि "कोड को किसी भी संख्या में इनपुट चर में काम करना चाहिए" पुनरावृत्ति सीमा के कारण, मैं नोट करूंगा कि स्टैकलेस पायथन कार्यान्वयन में कोई पुनरावृत्ति सीमा नहीं है (हालांकि वास्तव में परीक्षण नहीं किया गया है) इसके साथ यह कोड)।

प्रदर्शन:

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

Answer 3

गणितज्ञ 10, 70 वर्ण

बस हास्केल जवाब का अनुवाद।

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

उपयोग:

[१] में: = एफ [{१, =, ४}, २]

बाहर [1] = {{7, 1}, {4, 1}, {4, 7}}

Answer 4

चारकोल , 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

Answer 5

अजगर - 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)

Answer 6

अजगर, 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 ([5, 6, 7], 2) => [[6, 7], [5, 7], [5, 6]]

यह सूची s के सभी क्रमपरिवर्तन प्राप्त करता है और लंबाई k वाले लोगों को फ़िल्टर करता है।

Answer 7

अजगर , २,

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

यह (भारी) हास्केल उत्तर पर आधारित है।

स्पष्टीकरण:

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)

नोट: जबकि, पाइथ के सबसे हाल के संस्करण, 1.0.9 को आज रात जारी किया गया था, और इसलिए इस चुनौती के लिए अयोग्य है, वही कोड 1.0.8 में ठीक काम करता है।

Answer 8

हास्केल + डाटा.लिस्ट , 44 बाइट्स

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

इसे ऑनलाइन आज़माएं!

---

46 बाइट जवाब सुंदर हरा करना मुश्किल है लेकिन अगर आपके पास tailsसे Data.Listआप 44 बाइट्स कर सकते हैं।

Answer 9

05AB1E , 14 13 बाइट्स

goLε¹ybRÏ}ʒgQ

@ नील के चारकोल जवाब से प्रेरित है , इसलिए उसे उभारना सुनिश्चित करें!

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

यदि बिल्डरों को अनुमति दी जाती है तो यह 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)

Answer 10

एपीएल (एनएआरएस), 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│
└~─┘

उत्पादन ठीक लगता है ... लेकिन बग संभव है ...

व्यवहार में यह शून्य को शून्य के रूप में सेट करता है यदि इनपुट अल्फा सीमा से बाहर है; यदि अल्फ़ा 1 है, तो वह अपने सेट में सभी तत्वों को वापस करता है (क्या यह सही है?);

यह नीचे चार का एक जोड़ा लगता है, लेकिन ऊपर 2x धीमा:

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

Answer 11

जेएस - 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)

(<स्रोत कोड>) (['बॉब', 'सैली', 'जोनाह'], २)

     [[ 'जोनाह', 'सैली'] [ 'जोनाह', 'बॉब'] [ 'सैली', 'बॉब']]

एरे विधि पागलपन

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

Answer 12

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 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 / मोनो सामान्य प्रकार 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);

इसे ऑनलाइन आज़माएं!