কোনও তালিকার উপাদানগুলির সমস্ত সম্ভাব্য সংমিশ্রণ কীভাবে পাবেন?

Question

আমার 15 টি সংখ্যার সাথে একটি তালিকা রয়েছে এবং আমাকে এমন কিছু কোড লিখতে হবে যা এই সংখ্যার সমস্ত 32,768 সংমিশ্রণ তৈরি করে।

আমি এমন কিছু কোড পেয়েছি (গুগলিংয়ের মাধ্যমে) যা আমি যা দেখছি তা স্পষ্টভাবেই করে তবে আমি কোডটি মোটামুটি অস্বচ্ছ দেখতে পেয়েছি এবং এটি ব্যবহার থেকে সতর্ক রয়েছি। আরও আমার আরও অনুভূতি আছে যে আরও একটি মার্জিত সমাধান থাকতে হবে।

আমার কাছে ঘটে যাওয়া একমাত্র জিনিসটি হ'ল কেবলমাত্র দশমিক পূর্ণসংখ্যার 1-232768 লুপ করে সেগুলিকে বাইনারিতে রূপান্তর করা এবং বাইনারি উপস্থাপনাটিকে ফিল্টার হিসাবে উপযুক্ত নম্বরগুলি বেছে নিতে ব্যবহার করা।

কেউ কি আরও ভাল উপায় জানেন? ব্যবহার করছেন map(), সম্ভবত?

Comments

পাঠকদের লক্ষ করা উচিত যে তালিকার আইটেমগুলি অনন্য কিনা তা অত্যন্ত গুরুত্বপূর্ণ বিবেচনাযোগ্য, কারণ অনেকগুলি অ্যালগরিদমগুলি তখন কিছু উপসেটকে ছাড়িয়ে যায় (যেমন 'abccc' -> ['', 'এ', 'বি', 'সি', 'সি' , 'সি', 'এসি', 'এসি', 'এসি', ...] ... একটি সহজ কাজ হ'ল সমস্ত উপাদানগুলির অনুমতি পাওয়ার আগে

— সেটগুলিতে কেবল সেভ করা যায় n

@ নিনজাগেকো সেট লাইব্রেরি ব্যবহার করা দক্ষ নয় কারণ প্রত্যেকে ও (এন) সেরা at সুতরাং একটি সেটে এন ফাংশন যুক্ত করা আসলে ও (এন ^ 2)!

— স্কট বিগস

প্রশ্নটি মনোযোগ সহকারে পড়া থেকে মনে হয়, ওপি সমস্ত সংমিশ্রণ নয়, তার 15 সংখ্যার তালিকার পাওয়ারসেটের জন্য জিজ্ঞাসা করছে । আমি মনে করি এই কারণেই উত্তরগুলি পুরো জায়গা জুড়ে রয়েছে।

— স্কট বিগস

@ স্কট বিগস: আপনি কি নিশ্চিত যে আপনি এখানে পাইথন নিয়ে যাচ্ছেন? সেট সন্নিবেশ এবং অনুসন্ধানগুলি হ'ল হে (1) গড় কেস। এগুলি অভিধানের মতো। তারা হ্যাশিং ব্যবহার করে। পাইথনের একটি বিশেষ সেট লাইব্রেরি নেই (এটি স্ট্যান্ডার্ড লাইব্রেরিতে রয়েছে)। আমরা এখানে সংখ্যা সন্নিবেশ করছি ফাংশন নয়। (O (2 memory n) মেমরিটি ব্যবহার করা এখনও অকার্যকর হবে; product

— পাওয়ারশেটের

Answer 1

Itertools.combitions এ একবার দেখুন :

itertools.combinations(iterable, r)

ইনপুটটি পুনরাবৃত্তযোগ্য থেকে উপাদানগুলির দৈর্ঘ্যের উপগোত্রগুলি ফেরত দিন।

সংমিশ্রণগুলি ডিক্সিকোগ্রাফিক সাজানোর ক্রমে নির্গত হয়। সুতরাং, যদি ইনপুট পুনরাবৃত্তিযোগ্য বাছাই করা হয় তবে সংমিশ্রণ টিপলগুলি সাজানো ক্রমে উত্পাদিত হবে।

২.6 থেকে ব্যাটারি অন্তর্ভুক্ত!

Comments

আপনি কেবল এটি সব তালিকাভুক্ত করতে পারেন। list(itertools.combinations(iterable, r))

— সিলগন

এমন কিছু কি আছে যা প্রয়োজন হয় না r, অর্থাৎ উপাদানগুলির দৈর্ঘ্যের অনুচ্ছেদগুলির সংমিশ্রণ।

— mLstudent33

Answer 2

এই উত্তর একটি দিক মিস হয়েছে: ওপিতে সমস্ত সংমিশ্রণের জন্য জিজ্ঞাসা করা হয়েছে ... কেবল "আর" দৈর্ঘ্যের সংমিশ্রণ নয়।

সুতরাং আপনি হয় সমস্ত দৈর্ঘ্য "এল" মাধ্যমে লুপ করতে হবে:

import itertools

stuff = [1, 2, 3]
for L in range(0, len(stuff)+1):
    for subset in itertools.combinations(stuff, L):
        print(subset)

অথবা - আপনি যদি বিব্রত হতে চান (বা আপনার পরে আপনার কোডটি যে পড়েন তার মস্তিষ্ককে বাঁকানো) - আপনি "সংমিশ্রণ ()" জেনারেটরের শৃঙ্খলা তৈরি করতে পারেন এবং এর মাধ্যমে পুনরাবৃত্তি করতে পারেন:

from itertools import chain, combinations
def all_subsets(ss):
    return chain(*map(lambda x: combinations(ss, x), range(0, len(ss)+1)))

for subset in all_subsets(stuff):
    print(subset)

Comments

সমর্থনের জন্য ধন্যবাদ! উপরের উত্তরটি পোস্ট করার কয়েক সপ্তাহের মধ্যে আমি খুঁজে পেয়েছি যে বেন যা খুঁজছেন তার ধারণার নামটি হ'ল 15 আইটেমের মূল সেটটির "পাওয়ারসেট"। প্রকৃতপক্ষে, স্ট্যান্ডার্ড পাইথন "ইটার্তুলস" ডক পৃষ্ঠায় একটি উদাহরণ প্রয়োগ করা হয়: ডকস.পাইথন.আর.গ্রিবারি / সাইটোউলস্ হিটটিএমএল ("পাওয়ারসেট" এর জন্য গ্রেপ )।

— ড্যান এইচ

এখন পর্যন্ত যে কারও পক্ষে এটি পড়ছেন: ডকুমেন্টেশনেরpowerset() রেসিপি বিভাগে জেনারেটরের কাজটি সহজ, সম্ভাব্যভাবে কম মেমরি ব্যবহার করে এবং সম্ভবত এখানে প্রদর্শিত বাস্তবায়নটির চেয়ে দ্রুততর faster itertools

— martineau

লেক্সোগ্রাফিকাল ক্রমে সমস্ত সংমিশ্রণ তৈরি করা কি সম্ভব?

— guik

@ গুইক: আমি 99% নিশ্চিত যে itertools.combinationsআইটেম অর্ডারটি যে ফলন করে তা সংরক্ষণ করে। সুতরাং, যদি ইনপুটটি বর্ণিতভাবে সাজানো হয়, তবে প্রতিটি আউটপুটও হবে।

— ড্যান এইচ

হ্যাঁ, itertools.combinationsঅভিধানের ক্রমের সাথে n এর মধ্যে k এর সংমিশ্রণ উত্পন্ন করে, তবে n এর মধ্যে k পর্যন্ত সমস্ত সংমিশ্রণ নয় । কে পর্যন্তpowerset সমস্ত সংমিশ্রণ উত্পন্ন করে , তবে আমি যতদূর বুঝতে পেরেছি তেমন অভিধানে নয়: পাওয়ারসেট ([1,2]) -> [(), (1,), (2,), (1, 2)] । এটি হওয়া উচিত নয়: [(), (1,), (1, 2), (2,)]?

— guik

Answer 3

এখানে একটি অলস ওয়ান-লাইনার রয়েছে, এটি ইরটুলগুলি ব্যবহার করে:

from itertools import compress, product

def combinations(items):
    return ( set(compress(items,mask)) for mask in product(*[[0,1]]*len(items)) )
    # alternative:                      ...in product([0,1], repeat=len(items)) )

এই উত্তরের পিছনে মূল ধারণা: এখানে 2 ^ N সংমিশ্রণ রয়েছে - দৈর্ঘ্যের এন বাইনারি স্ট্রিংয়ের সংখ্যার সমান। প্রতিটি বাইনারি স্ট্রিংয়ের জন্য, আপনি একটি "1" এর সাথে সম্পর্কিত সমস্ত উপাদান বেছে নিন।

items=abc * mask=###
 |
 V
000 -> 
001 ->   c
010 ->  b
011 ->  bc
100 -> a
101 -> a c
110 -> ab
111 -> abc

বিবেচনা করার বিষয়গুলি:

• এটির জন্য আপনাকে কল করতে len(...)হবে items(কার্যতালিকা: যদি itemsকোনও জেনারেটরের মতো পুনরাবৃত্ত হওয়ার মতো কিছু হয় তবে প্রথমে এটি তালিকায় পরিণত করুন items=list(_itemsArg))
• এটির প্রয়োজন আছে যে পুনরাবৃত্তির itemsক্রমটি এলোমেলো নয় (কার্যতালিকা: উন্মাদ হবেন না)
• এই প্রয়োজন যে আইটেম অনন্য, অথবা অন্য হয় {2,2,1}এবং {2,1,1}হবে উভয় পতন {2,1}(কার্যসংক্রান্ত: ব্যবহার collections.Counterএকটি ড্রপ-এ জন্য পরিবর্তে setএটা মূলত একটি multiset আছে ... যদিও আপনি পরে ব্যবহার করার প্রয়োজন হতে পারে tuple(sorted(Counter(...).elements()))যদি আপনি এটি প্রয়োজন hashable হতে)

---

ডেমো

>>> list(combinations(range(4)))
[set(), {3}, {2}, {2, 3}, {1}, {1, 3}, {1, 2}, {1, 2, 3}, {0}, {0, 3}, {0, 2}, {0, 2, 3}, {0, 1}, {0, 1, 3}, {0, 1, 2}, {0, 1, 2, 3}]

>>> list(combinations('abcd'))
[set(), {'d'}, {'c'}, {'c', 'd'}, {'b'}, {'b', 'd'}, {'c', 'b'}, {'c', 'b', 'd'}, {'a'}, {'a', 'd'}, {'a', 'c'}, {'a', 'c', 'd'}, {'a', 'b'}, {'a', 'b', 'd'}, {'a', 'c', 'b'}, {'a', 'c', 'b', 'd'}]

Answer 4

@ ড্যান এইচ দ্বারা উচ্চ আপত্তিকৃত উত্তরের মন্তব্যে, ডকুমেন্টেশনেpowerset() রেসিপিটির উল্লেখ করা হয়েছে - ড্যান নিজেই এটির একটি সহ । তবে , এখনও পর্যন্ত এটি উত্তর হিসাবে কেউ পোস্ট করেনি। যেহেতু সমস্যাটির পক্ষে সর্বোত্তম পদ্ধতির না হলে এটি সম্ভবত সবচেয়ে ভাল — এবং অন্য মন্তব্যকারীর কাছ থেকে কিছুটা উত্সাহ দেওয়া হয়েছে , এটি নীচে দেখানো হয়েছে। ফাংশনটি প্রতিটি দৈর্ঘ্যের তালিকা উপাদানের সমস্ত অনন্য সংমিশ্রণ তৈরি করে (শূন্য এবং সমস্ত উপাদানযুক্তগুলি সহ)।itertools

নোট : চতুরভাবে ভিন্ন, লক্ষ্য অনন্য উপাদানের শুধুমাত্র সমন্বয় প্রাপ্ত হয়, তাহলে লাইন পরিবর্তন s = list(iterable)করতে s = list(set(iterable))কোনো সদৃশ উপাদান বাছা। নির্বিশেষে, এই পরিণামটি iterableশেষ পর্যন্ত কোনও listউপায়ে রূপান্তরিত হয়েছে এটি জেনারেটরগুলির সাথে কাজ করবে (অন্যান্য উত্তরগুলির তুলনায় বেশ কয়েকটি)।

from itertools import chain, combinations

def powerset(iterable):
    "powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
    s = list(iterable)  # allows duplicate elements
    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))

stuff = [1, 2, 3]
for i, combo in enumerate(powerset(stuff), 1):
    print('combo #{}: {}'.format(i, combo))

আউটপুট:

combo #1: ()
combo #2: (1,)
combo #3: (2,)
combo #4: (3,)
combo #5: (1, 2)
combo #6: (1, 3)
combo #7: (2, 3)
combo #8: (1, 2, 3)

Comments

list()প্রথম স্থানে রূপান্তর কী ?

— এএমসি

@ আলেকজান্ডার: পুনরাবৃত্তির দৈর্ঘ্য নির্ধারণের জন্য।

— মার্টিনিউ

Answer 5

পুনরাবৃত্তি ব্যবহার করে এখানে একটি:

>>> import copy
>>> def combinations(target,data):
...     for i in range(len(data)):
...         new_target = copy.copy(target)
...         new_data = copy.copy(data)
...         new_target.append(data[i])
...         new_data = data[i+1:]
...         print new_target
...         combinations(new_target,
...                      new_data)
...                      
... 
>>> target = []
>>> data = ['a','b','c','d']
>>> 
>>> combinations(target,data)
['a']
['a', 'b']
['a', 'b', 'c']
['a', 'b', 'c', 'd']
['a', 'b', 'd']
['a', 'c']
['a', 'c', 'd']
['a', 'd']
['b']
['b', 'c']
['b', 'c', 'd']
['b', 'd']
['c']
['c', 'd']
['d']

Comments

এটি কি মুদ্রণের পরিবর্তে তালিকার একটি তালিকা ফেরত পরিবর্তন করতে পারে?

— জেমস ভিকারি

@ জেমসভিকেরি হ্যাঁ, আপনি ফাংশনের বাইরে কোনও তালিকা তৈরি করতে এবং তাতে সংযোজন করতে পারেন, বা (আরও ভাল) ফাংশনটিকে একটি জেনারেটর তৈরি করতে পারেন, 'ফলন' কীওয়ার্ডটি দেখুন :)

— ড্যানজারক্রো

new_data = copy.copy(data)- এই সারিটি যতদূর আমি দেখতে পাচ্ছি, এটি কোনও কিছুর উপর প্রভাব ফেলবে না

— দিমিত্রি ফিয়ালকোভস্কি

Answer 6

এই ওয়ান-লাইনারটি আপনাকে সমস্ত সংমিশ্রণ দেয় ( মূল তালিকায় যদি / সেটগুলিতে আলাদা আলাদা উপাদান থাকে তবে এর মধ্যে 0এবং nআইটেমগুলি থাকে n) এবং স্থানীয় পদ্ধতিটি ব্যবহার করে itertools.combinations:

পাইথন 2

from itertools import combinations

input = ['a', 'b', 'c', 'd']

output = sum([map(list, combinations(input, i)) for i in range(len(input) + 1)], [])

পাইথন ঘ

from itertools import combinations

input = ['a', 'b', 'c', 'd']

output = sum([list(map(list, combinations(input, i))) for i in range(len(input) + 1)], [])

---

আউটপুটটি হবে:

[[],
 ['a'],
 ['b'],
 ['c'],
 ['d'],
 ['a', 'b'],
 ['a', 'c'],
 ['a', 'd'],
 ['b', 'c'],
 ['b', 'd'],
 ['c', 'd'],
 ['a', 'b', 'c'],
 ['a', 'b', 'd'],
 ['a', 'c', 'd'],
 ['b', 'c', 'd'],
 ['a', 'b', 'c', 'd']]

---

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

http://ideone.com/COghfX

Comments

এটি একটি

— অনুচ্ছেদে

@ অ্যাডহোমেনিম: না, তা নয়। এটি সমস্ত সংমিশ্রনের একটি তালিকা। অনুক্রমের মধ্যে যেমন অন্তর্ভুক্ত থাকবে ['b', 'a']।

— nnot101

TypeError: can only concatenate list (not "map") to list

— 0x48 পিরাজ

@ 0x48 পিরাজ: লক্ষ্য করার জন্য আপনাকে ধন্যবাদ, ফলস্বরূপ আমি আমার উত্তর সম্পাদনা করেছি!

— ম্যাথিউ রডিক

Answer 7

আমি ড্যান এইচ এর সাথে একমত যে বেন সত্যই সমস্ত সংমিশ্রণের জন্য বলেছিল । itertools.combinations()সমস্ত সংমিশ্রণ দেয় না।

আর একটি সমস্যা হ'ল, যদি ইনপুটটি পুনরাবৃত্তিযোগ্য বড় হয় তবে তালিকার সমস্ত কিছুর পরিবর্তে জেনারেটর ফেরত দেওয়া ভাল:

iterable = range(10)
for s in xrange(len(iterable)+1):
  for comb in itertools.combinations(iterable, s):
    yield comb

Comments

চমৎকার উদাহরণ। আমি জেনারেটরগুলিকে ভালবাসি ... এবং পাইথনকে ভালবাসি তাদের থাকার কারণে! এই উদাহরণটিতে একবারে কেবল একটি সংমিশ্রণ () অবজেক্ট থাকে এবং সময়টিতে একটি সংমিশ্রণ দেয়। (সম্ভবত আপনি এর চারপাশে ডিএফ ব্লকটি যুক্ত করতে চান - ব্যবহারের উদাহরণ হিসাবে।) নোট করুন যে আমার বাস্তবায়ন (উপরে দেওয়া চেইন () সহ) খুব বেশি খারাপ নয়: সত্য যে এটি সমস্ত লেন (পুনরাবৃত্ত) জেনারেটর তৈরি করে একবার ... তবে এটি একবারে সমস্ত 2 ** লেন (পুনরাবৃত্ত) সংমিশ্রণ তৈরি করে না, যেমন - আমার বোধ অনুযায়ী - চেনটি পরবর্তী জেনারেটরগুলি আঁকার আগে প্রথম জেনারেটর "ব্যবহার" করে "

— ড্যান এইচ

Answer 8

এটি এমন একটি পদ্ধতির যা পুনরাবৃত্তি সমর্থনকারী সমস্ত প্রোগ্রামিং ভাষায় সহজেই স্থানান্তরিত হতে পারে (কোনও তাত্পর্য নয়, ফলন নেই, কোনও তালিকা উপলব্ধি নেই) :

def combs(a):
    if len(a) == 0:
        return [[]]
    cs = []
    for c in combs(a[1:]):
        cs += [c, c+[a[0]]]
    return cs

>>> combs([1,2,3,4,5])
[[], [1], [2], [2, 1], [3], [3, 1], [3, 2], ..., [5, 4, 3, 2, 1]]

Answer 9

আপনি এই সাধারণ কোডটি ব্যবহার করে পাইথনের তালিকার সমস্ত সংমিশ্রণ তৈরি করতে পারেন

import itertools

a = [1,2,3,4]
for i in xrange(0,len(a)+1):
   print list(itertools.combinations(a,i))

ফলাফল হবে:

[()]
[(1,), (2,), (3,), (4,)]
[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
[(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]
[(1, 2, 3, 4)]

Comments

এই কোডে বাগ করুন: খালি সেটটি দেয় না। মেনেজ এক্সরেঞ্জ (0, ...) তবে পরীক্ষা করা যায়নি। সম্পাদনা করুন : আমি এগিয়ে গিয়েছিলাম এবং এটি ঠিক করার জন্য আপনার উত্তর সম্পাদনা করেছি।

— নিনজাগেকো

Answer 10

আমি ভেবেছিলাম যে ইরোটুলগুলি বা অন্য কোনও অতিরিক্ত লাইব্রেরি আমদানি না করে উত্তর চাইছেন তাদের জন্য আমি এই ফাংশনটি যুক্ত করব।

def powerSet(items):
    """
    Power set generator: get all possible combinations of a list’s elements

    Input:
        items is a list
    Output:
        returns 2**n combination lists one at a time using a generator 

    Reference: edx.org 6.00.2x Lecture 2 - Decision Trees and dynamic programming
    """

    N = len(items)
    # enumerate the 2**N possible combinations
    for i in range(2**N):
        combo = []
        for j in range(N):
            # test bit jth of integer i
            if (i >> j) % 2 == 1:
                combo.append(items[j])
        yield combo

সাধারণ ফলন জেনারেটর ব্যবহার:

for i in powerSet([1,2,3,4]):
    print (i, ", ",  end="")

উপরের ব্যবহারের উদাহরণ থেকে আউটপুট:

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

Comments

আমি মনে করি এটি খুব ঝরঝরে সমাধান।

— গ্রীনটেক

Answer 11

এখানে আরও একটি সমাধান রয়েছে (ওয়ান-লাইনার), itertools.combinationsফাংশনটি ব্যবহার করে জড়িত , তবে এখানে আমরা একটি ডাবল তালিকার বোঝাপড়াটি ব্যবহার করব (লুপ বা যোগফলের বিপরীতে):

def combs(x):
    return [c for i in range(len(x)+1) for c in combinations(x,i)]

---

ডেমো:

>>> combs([1,2,3,4])
[(), 
 (1,), (2,), (3,), (4,), 
 (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4), 
 (1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4), 
 (1, 2, 3, 4)]

Answer 12

from itertools import permutations, combinations


features = ['A', 'B', 'C']
tmp = []
for i in range(len(features)):
    oc = combinations(features, i + 1)
    for c in oc:
        tmp.append(list(c))

---

আউটপুট

[
 ['A'],
 ['B'],
 ['C'],
 ['A', 'B'],
 ['A', 'C'],
 ['B', 'C'],
 ['A', 'B', 'C']
]

Answer 13

নীচে একটি "স্ট্যান্ডার্ড পুনরাবৃত্ত উত্তর", অন্য অনুরূপ উত্তর https://stackoverflow.com/a/23743696/711085 এর অনুরূপ । (আমাদের স্ট্যাক স্পেস শেষ হয়ে যাওয়ার বিষয়ে চিন্তা করার দরকার নেই যেহেতু আমরা সমস্ত এন প্রক্রিয়াজাতকরণ প্রক্রিয়া করতে পারি না!)

এটি প্রতিটি উপাদান ঘুরে দেখা যায় এবং হয় তা নেয় বা ছেড়ে দেয় (আমরা সরাসরি এই অ্যালগরিদম থেকে 2 ^ N কার্ডিনালটি দেখতে পারি)।

def combs(xs, i=0):
    if i==len(xs):
        yield ()
        return
    for c in combs(xs,i+1):
        yield c
        yield c+(xs[i],)

---

ডেমো:

>>> list( combs(range(5)) )
[(), (0,), (1,), (1, 0), (2,), (2, 0), (2, 1), (2, 1, 0), (3,), (3, 0), (3, 1), (3, 1, 0), (3, 2), (3, 2, 0), (3, 2, 1), (3, 2, 1, 0), (4,), (4, 0), (4, 1), (4, 1, 0), (4, 2), (4, 2, 0), (4, 2, 1), (4, 2, 1, 0), (4, 3), (4, 3, 0), (4, 3, 1), (4, 3, 1, 0), (4, 3, 2), (4, 3, 2, 0), (4, 3, 2, 1), (4, 3, 2, 1, 0)]

>>> list(sorted( combs(range(5)), key=len))
[(), 
 (0,), (1,), (2,), (3,), (4,), 
 (1, 0), (2, 0), (2, 1), (3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (4, 3), 
 (2, 1, 0), (3, 1, 0), (3, 2, 0), (3, 2, 1), (4, 1, 0), (4, 2, 0), (4, 2, 1), (4, 3, 0), (4, 3, 1), (4, 3, 2), 
 (3, 2, 1, 0), (4, 2, 1, 0), (4, 3, 1, 0), (4, 3, 2, 0), (4, 3, 2, 1), 
 (4, 3, 2, 1, 0)]

>>> len(set(combs(range(5))))
32

Answer 14

তালিকা বোঝার ব্যবহার:

def selfCombine( list2Combine, length ):
    listCombined = str( ['list2Combine[i' + str( i ) + ']' for i in range( length )] ).replace( "'", '' ) \
                     + 'for i0 in range(len( list2Combine ) )'
    if length > 1:
        listCombined += str( [' for i' + str( i ) + ' in range( i' + str( i - 1 ) + ', len( list2Combine ) )' for i in range( 1, length )] )\
            .replace( "', '", ' ' )\
            .replace( "['", '' )\
            .replace( "']", '' )

    listCombined = '[' + listCombined + ']'
    listCombined = eval( listCombined )

    return listCombined

list2Combine = ['A', 'B', 'C']
listCombined = selfCombine( list2Combine, 2 )

আউটপুট হবে:

['A', 'A']
['A', 'B']
['A', 'C']
['B', 'B']
['B', 'C']
['C', 'C']

Comments

এই প্রস্তাবটি সেট আপগুলি তৈরি করার জন্য স্ট্রিং ম্যাঙ্গেলিং করার জন্য?!?!?! পবিত্র কাক .... এবং: এটি পাওয়ারসেটটি ফিরিয়ে দিচ্ছে না, বরং সংমিশ্রণ_বিহীন স্থান () এর মতো কিছু। ( ডকস.পিথন.আর. / লাইবারি /… দেখুন )

— ড্যান এইচ

এটি প্রকৃতপক্ষে কম্বিনেশন_উইট_প্লেসমেন্ট () এর মতোই কাজ করে তবে আমার বাক্সে এটি অন্তত ইটেরটোলগুলির চেয়ে কিছুটা দ্রুত চলে । আমি কী বলতে পারি, আমি তালিকার বোধগম্যতা পছন্দ করি।

— zmk

উত্তরের জন্য ধন্যবাদ! বিপরীত তালিকা যেমন ['এ', 'এ'], ['এ', 'বি'], ['এ', 'সি'], ['বি', 'এ'], [ 'বি', 'বি'], ['বি', 'সি'], ['সি', 'এ'], ['সি', 'বি'] এবং ['সি', 'সি'] এর মধ্যে রয়েছে সবকিছু?

— Karyo

খুব আকর্ষণীয়, তবে আমার অজগরটি এখানে সূক্ষ্মতা বোঝার পক্ষে যথেষ্ট নয়। বিভিন্ন স্কোপগুলিতে লিঙ্ককোমাইন্ড ব্যবহার এবং লুপের জন্য লুপ সবই এক লাইনে রয়েছে এই বিষয়টি সম্পর্কে কি বিশেষ কিছু আছে? আমি এটিকে সামান্য ভাগ্যের সাথে জাভাতে পোর্ট করার চেষ্টা করছি।

— স্কট বিগস

Answer 15

এই কোডে নেস্টেড তালিকাগুলি সহ একটি সাধারণ অ্যালগরিদম নিয়োগ করেছে ...

# FUNCTION getCombos: To generate all combos of an input list, consider the following sets of nested lists...
#
#           [ [ [] ] ]
#           [ [ [] ], [ [A] ] ]
#           [ [ [] ], [ [A],[B] ],         [ [A,B] ] ]
#           [ [ [] ], [ [A],[B],[C] ],     [ [A,B],[A,C],[B,C] ],                   [ [A,B,C] ] ]
#           [ [ [] ], [ [A],[B],[C],[D] ], [ [A,B],[A,C],[B,C],[A,D],[B,D],[C,D] ], [ [A,B,C],[A,B,D],[A,C,D],[B,C,D] ], [ [A,B,C,D] ] ]
#
#  There is a set of lists for each number of items that will occur in a combo (including an empty set).
#  For each additional item, begin at the back of the list by adding an empty list, then taking the set of
#  lists in the previous column (e.g., in the last list, for sets of 3 items you take the existing set of
#  3-item lists and append to it additional lists created by appending the item (4) to the lists in the
#  next smallest item count set. In this case, for the three sets of 2-items in the previous list. Repeat
#  for each set of lists back to the initial list containing just the empty list.
#

def getCombos(listIn = ['A','B','C','D','E','F'] ):
    listCombos = [ [ [] ] ]     # list of lists of combos, seeded with a list containing only the empty list
    listSimple = []             # list to contain the final returned list of items (e.g., characters)

    for item in listIn:
        listCombos.append([])   # append an emtpy list to the end for each new item added
        for index in xrange(len(listCombos)-1, 0, -1):  # set the index range to work through the list
            for listPrev in listCombos[index-1]:        # retrieve the lists from the previous column
                listCur = listPrev[:]                   # create a new temporary list object to update
                listCur.append(item)                    # add the item to the previous list to make it current
                listCombos[index].append(listCur)       # list length and append it to the current list

                itemCombo = ''                          # Create a str to concatenate list items into a str
                for item in listCur:                    # concatenate the members of the lists to create
                    itemCombo += item                   # create a string of items
                listSimple.append(itemCombo)            # add to the final output list

    return [listSimple, listCombos]
# END getCombos()

Comments

সুতরাং এই কোডটি যা করছে তা হ'ল প্রত্যাবর্তন [listOfCombitions, listOfCombitionsGroupedBySize]। দুর্ভাগ্যক্রমে যখন ডেমো ইনপুট দিয়ে চালানো হয় তখন এটি 64 এর পরিবর্তে 63 টি উপাদান দেয়; মনে হচ্ছে এটি খালি সেটটি হারিয়ে যাচ্ছে (এই ক্ষেত্রে, খালি স্ট্রিং "")।

— নিনজাগেকো

Answer 16

আমি জানি যে সমস্ত সংমিশ্রণ পেতে এটির ব্যবহারের জন্য আরও অনেক বেশি ব্যবহারিক , তবে আপনি যদি ইচ্ছা করতে চান তবে আপনি কেবল কোড বোধগম্যতার সাথে আংশিকভাবে এটি অর্জন করতে পারেন তবে আপনি অনেক কোড করতে চান তবে

দুটি জোড়া সংমিশ্রনের জন্য:

    lambda l: [(a, b) for i, a in enumerate(l) for b in l[i+1:]]

এবং, তিনটি জোড়ার সংমিশ্রণের জন্য, এটি এতটা সহজ:

    lambda l: [(a, b, c) for i, a in enumerate(l) for ii, b in enumerate(l[i+1:]) for c in l[i+ii+2:]]

---

ফলাফলটি itertools.combitions ব্যবহারের অনুরূপ:

import itertools
combs_3 = lambda l: [
    (a, b, c) for i, a in enumerate(l) 
    for ii, b in enumerate(l[i+1:]) 
    for c in l[i+ii+2:]
]
data = ((1, 2), 5, "a", None)
print("A:", list(itertools.combinations(data, 3)))
print("B:", combs_3(data))
# A: [((1, 2), 5, 'a'), ((1, 2), 5, None), ((1, 2), 'a', None), (5, 'a', None)]
# B: [((1, 2), 5, 'a'), ((1, 2), 5, None), ((1, 2), 'a', None), (5, 'a', None)]

Answer 17

ইটারটুলগুলি ব্যবহার না করে:

def combine(inp):
    return combine_helper(inp, [], [])


def combine_helper(inp, temp, ans):
    for i in range(len(inp)):
        current = inp[i]
        remaining = inp[i + 1:]
        temp.append(current)
        ans.append(tuple(temp))
        combine_helper(remaining, temp, ans)
        temp.pop()
    return ans


print(combine(['a', 'b', 'c', 'd']))

Answer 18

এখানে দুটি বাস্তবায়ন রয়েছে itertools.combinations

একটি যে একটি তালিকা ফেরত দেয়

def combinations(lst, depth, start=0, items=[]):
    if depth <= 0:
        return [items]
    out = []
    for i in range(start, len(lst)):
        out += combinations(lst, depth - 1, i + 1, items + [lst[i]])
    return out

একজন জেনারেটর ফেরত দেয়

def combinations(lst, depth, start=0, prepend=[]):
    if depth <= 0:
        yield prepend
    else:
        for i in range(start, len(lst)):
            for c in combinations(lst, depth - 1, i + 1, prepend + [lst[i]]):
                yield c

দয়া করে মনে রাখবেন যে এগুলিতে সহায়তাকারী ফাংশন সরবরাহ করার পরামর্শ দেওয়া হচ্ছে কারণ প্রিপেন্ড আর্গুমেন্ট স্থির এবং প্রতিটি কলের সাথে পরিবর্তিত হচ্ছে না

print([c for c in combinations([1, 2, 3, 4], 3)])
# [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]

# get a hold of prepend
prepend = [c for c in combinations([], -1)][0]
prepend.append(None)

print([c for c in combinations([1, 2, 3, 4], 3)])
# [[None, 1, 2, 3], [None, 1, 2, 4], [None, 1, 3, 4], [None, 2, 3, 4]]

এটি একটি অতি পৃষ্ঠপোষক ক্ষেত্রে তবে দুঃখিতের চেয়ে নিরাপদ থাকুন

Answer 19

এটি কীভাবে .. তালিকার পরিবর্তে একটি স্ট্রিং ব্যবহার করেছে তবে একই জিনিস .. স্ট্রিংটি পাইথনের তালিকার মতো বিবেচনা করা যেতে পারে:

def comb(s, res):
    if not s: return
    res.add(s)
    for i in range(0, len(s)):
        t = s[0:i] + s[i + 1:]
        comb(t, res)

res = set()
comb('game', res) 

print(res)

Answer 20

ইটারটুলগুলি থেকে সংমিশ্রণ

import itertools
col_names = ["aa","bb", "cc", "dd"]
all_combinations = itertools.chain(*[itertools.combinations(col_names,i+1) for i,_ in enumerate(col_names)])
print(list(all_combinations))

ধন্যবাদ

Answer 21

itertoolsপাইথন 3 ছাড়া আপনি এই জাতীয় কিছু করতে পারেন:

def combinations(arr, carry):
    for i in range(len(arr)):
        yield carry + arr[i]
        yield from combinations(arr[i + 1:], carry + arr[i])

যেখানে প্রথমদিকে carry = "".

Answer 22

3 ফাংশন:

1. এন উপাদানগুলির তালিকার সমস্ত সংমিশ্রণ
2. n উপাদানগুলির সমস্ত সংমিশ্রণের তালিকা যেখানে ক্রম পৃথক নয়
3. সমস্ত আদেশ

import sys

def permutations(a):
    return combinations(a, len(a))

def combinations(a, n):
    if n == 1:
        for x in a:
            yield [x]
    else:
        for i in range(len(a)):
            for x in combinations(a[:i] + a[i+1:], n-1):
                yield [a[i]] + x

def combinationsNoOrder(a, n):
    if n == 1:
        for x in a:
            yield [x]
    else:
        for i in range(len(a)):
            for x in combinationsNoOrder(a[:i], n-1):
                yield [a[i]] + x

if __name__ == "__main__":
    for s in combinations(list(map(int, sys.argv[2:])), int(sys.argv[1])):
        print(s)

Comments

আমি এটা বেশ পছন্দ করি!!! ধন্যবাদ!!! পাইথনের সংযুক্তি ফাংশনগুলি যদিও খানিকটা অদ্ভুত। গণিতে "কম্বিনেশন" ফাংশনটি ভেরিয়েশন হতে পারে এবং "কম্বিনেশনন অর্ডার" আসলে সংমিশ্রণ। আমি অনুমান করব যে গণিতের শাখা থেকে অজগরকে আগত লোকগুলিকে বিভ্রান্ত করে, যেমনটি আমার সাথে এবার হয়েছিল। যাইহোক, একটি দুর্দান্ত সমাধান, অনেক অনেক ধন্যবাদ!

— Đوميć ব্রানিসিলভ

Answer 23

এটি আমার বাস্তবায়ন

    def get_combinations(list_of_things):
    """gets every combination of things in a list returned as a list of lists

    Should be read : add all combinations of a certain size to the end of a list for every possible size in the
    the list_of_things.

    """
    list_of_combinations = [list(combinations_of_a_certain_size)
                            for possible_size_of_combinations in range(1,  len(list_of_things))
                            for combinations_of_a_certain_size in itertools.combinations(list_of_things,
                                                                                         possible_size_of_combinations)]
    return list_of_combinations

Comments

এখানে পোস্ট করা পূর্ববর্তী বাস্তবায়নগুলির চেয়ে আপনার বাস্তবায়ন কী সমাধান করছে।

— ব্যবহারকারী 1767754

Answer 24

আপনি দুর্দান্ত প্যাকেজ থেকে পাওয়ারসেট ফাংশনটিও ব্যবহার করতে পারেন more_itertools।

from more_itertools import powerset

l = [1,2,3]
list(powerset(l))

# [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]

আমরা এটিও ওপির প্রয়োজনীয়তা পূরণ করতে পারি, যাচাই করতে পারি

from more_itertools import ilen

assert ilen(powerset(range(15))) == 32_768

Answer 25

def combinations(iterable, r):
# combinations('ABCD', 2) --> AB AC AD BC BD CD
# combinations(range(4), 3) --> 012 013 023 123
pool = tuple(iterable)
n = len(pool)
if r > n:
    return
indices = range(r)
yield tuple(pool[i] for i in indices)
while True:
    for i in reversed(range(r)):
        if indices[i] != i + n - r:
            break
    else:
        return
    indices[i] += 1
    for j in range(i+1, r):
        indices[j] = indices[j-1] + 1
    yield tuple(pool[i] for i in indices)


x = [2, 3, 4, 5, 1, 6, 4, 7, 8, 3, 9]
for i in combinations(x, 2):
    print i

Comments

যদি আমি ঠিকই বলে থাকি তবে পাইথন ডকুমেন্টেশন [ ডকস.পাইথন.আর.৩.৩ ./ / লাইব্রেরি / ট্রিটলস html ] থেকে অনুলিপি করা ঠিক কোডটি । যদি তা হয় তবে দয়া করে উত্সটি রেফ করুন।

— গ্যাব্রিয়েলচু

আকর্ষণীয় পদ্ধতির

— পেলো

Answer 26

যদি কেউ বিপরীত তালিকার সন্ধান করে তবে আমি যেমন ছিলাম:

stuff = [1, 2, 3, 4]

def reverse(bla, y):
    for subset in itertools.combinations(bla, len(bla)-y):
        print list(subset)
    if y != len(bla):
        y += 1
        reverse(bla, y)

reverse(stuff, 1)

Answer 27

flag = 0
requiredCals =12
from itertools import chain, combinations

def powerset(iterable):
    s = list(iterable)  # allows duplicate elements
    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))

stuff = [2,9,5,1,6]
for i, combo in enumerate(powerset(stuff), 1):
    if(len(combo)>0):
        #print(combo , sum(combo))
        if(sum(combo)== requiredCals):
            flag = 1
            break
if(flag==1):
    print('True')
else:
    print('else')