একটি সেটে উপাদানগুলির সংমিশ্রণগুলি তালিকাভুক্ত করুন

10

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 সপ্তাহ

পিএস চরম ইনপুট যেমন negativeণাত্মক সংখ্যা, 0 ইত্যাদি সম্পর্কে সতর্ক থাকুন careful

code-golf 
— padawan
সূত্র
1
যদিও কোডগল্ফ.স্ট্যাকেক্সেঞ্জারভিউ / প্রশ্নস / 8063৮০/২ এর অতিরিক্ত বাধা রয়েছে, এর উত্তরগুলি অপরিবর্তিতভাবে অনুলিপি করা যেতে পারে এবং এখনও বীট করা শক্ত হবে।
— পিটার টেইলর
1
ইনপুট দ্বারা যে কোনও ধরণের ডেটা হতে পারে। আপনি কি কোনও ধরণের পুনরাবৃত্ত ডেটা বা কোনও ধরণের ডেটা দিয়ে পুনরাবৃত্তিযোগ্য বলতে চান? যেমন combos('ab', 1) -> ['a', 'b']বৈধ?
— ক্যালভিনের শখ 0
1
ইনপুট নেতিবাচক হলে আউটপুটটি কী হওয়া উচিত?
— Ypnypn
5
এখন পর্যন্ত প্রায় প্রতিটি উত্তর পুনরাবৃত্তি ব্যবহার করে যখন এই প্রশ্নটি "পুনরাবৃত্তি ছাড়াই সংযোজনগুলি সংযোজন" এর সদৃশ হয় তা আমি দেখতে পাচ্ছি না।
— xnor
2
কোনও বিধিনিষেধ অপসারণ একটি উল্লেখযোগ্য পরিবর্তন নয়। এছাড়াও, নকলটি কী বা কী নয় তা নির্ধারণের জন্য বিদ্যমান উত্তরগুলি ব্যবহার করা ভাল ধারণা নয়, কারণ নকলগুলি ইতিমধ্যে উত্তর না দেওয়া পর্যন্ত আপনি সনাক্ত করতে পারবেন না। কখনও কখনও আপনাকে কেবল আপনার মাথা ব্যবহার করতে হবে।
— রেইনবোল্ট

উত্তর:

13

হাস্কেল - 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% "ঠকাই" ➔ ["চে", "চ", "চ্যাট", "সিএ", "সিট", "বিড়াল", "হিয়া", "হিট", "টুপি", "খাওয়া"]

2% ["চার্লি", "অ্যালিস", "ড্যানিয়েল", "বব"] ➔ [["চার্লি", "অ্যালিস"], ["চার্লি", "ড্যানিয়েল"], ["চার্লি", "বব"] , [ "এলিস", "ড্যানিয়েল"], [ "এলিস", "বব"], [ "ড্যানিয়েল", "বব"]]

— ChaseC
সূত্র
1
থ্যাঙ্কস মার্ক, আমি এটিকে ইনফিক্স করে তোলার কথা ভাবিনি।
— চ্যাসি
ঘটনাক্রমে, আপনার উপভাষায় "এটিকে আনার" অর্থ কী? আমার ক্ষেত্রে এটি একটি চ্যালেঞ্জ বোঝায়, তবে এটি প্রসঙ্গে অর্থবোধ করে না কারণ আপনার চূড়ান্ত সংস্করণটি এই অনুলিপিটির প্রশ্নটিতে আমার প্রাথমিক সংস্করণের চেয়ে এখনও দীর্ঘ is
— পিটার টেলর
7

পাইথন (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 []
— xnor
সূত্র
3

গণিত 10, 70 অক্ষর

হাস্কেল উত্তরের কেবল একটি অনুবাদ।

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

ব্যবহার:

[1] এ: = চ [{1, 7, 4}, 2]

[1] = {{7, 1}, {4, 1}, {4, 7}

— alephalpha
সূত্র
3

কাঠকয়লা , 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
— নিল
সূত্র
2

পাইথন - 129

s একটি তালিকা, কে উত্পাদন করার সংমিশ্রণের আকার।

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)
— CesiumLifeJacket
সূত্র
2

পাইথন, 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]

চালানোর জন্য সি কল করুন:

সি ([৫,,,]], ২) => [[6,]], [৫,]], [৫,]]]

এটি তালিকার সমস্ত অনুমোদন পায় এবং দৈর্ঘ্যের কে সহ ফিল্টার করে।

— ক্যালভিনের শখ
সূত্র
2

পাইথ , 28

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)

দ্রষ্টব্য: পাইথের সর্বাধিক সাম্প্রতিক সংস্করণ, ০.০.৯, আজ রাতে প্রকাশিত হয়েছিল এবং তাই এই চ্যালেঞ্জের জন্য অযোগ্য, একই কোডটি ০.০.৮. এ দুর্দান্ত কাজ করে।

— isaacg
সূত্র
2

05 এ বি 1 ই , 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)
— কেভিন ক্রুইজসেন
সূত্র
2

এপিএল (এনএআরএস), 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←⍵}
— RosLuP
সূত্র
1

জেএস - 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]))
— Bebe
সূত্র
1

সি # (ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক) , 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)

দুঃখের বিষয়, টিও / মনো জেনেরিক ধরণের টি ঘোষণাকে সমর্থন করছে বলে মনে হয় না , সুতরাং আমি তার পরিবর্তে অবজেক্ট টাইপের সাথে কয়েকটি বাইট হারাতে বাধ্য হই ।

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

এটি অনলাইন চেষ্টা করুন!

— Innat3
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.