একটি সেট দেওয়া হয়েছে
{0, 1, 2, 3}
আমি কীভাবে সাবসেটগুলি উত্পাদন করতে পারি:
[set(),
{0},
{1},
{2},
{3},
{0, 1},
{0, 2},
{0, 3},
{1, 2},
{1, 3},
{2, 3},
{0, 1, 2},
{0, 1, 3},
{0, 2, 3},
{1, 2, 3},
{0, 1, 2, 3}]
উত্তর:
পাইথন itertoolsপৃষ্ঠাতে এর ঠিক একটি powersetরেসিপি রয়েছে:
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)
return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
আউটপুট:
>>> list(powerset("abcd"))
[(), ('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')]
আপনি যদি শুরুতে এই খালি টিপলটি পছন্দ না করেন তবে 0-দৈর্ঘ্যের সংমিশ্রণ এড়াতে আপনি rangeবিবৃতিটি পরিবর্তন করতে পারেন range(1, len(s)+1)।
s = list(iterable)দরকার?
__len__প্রয়োগ করার প্রয়োজন হয় না ; powerset((n for n in range(3)))তালিকা মোড়ানো ছাড়া চেষ্টা করুন ।
powerset(range(3)) ভাল কাজ করবে । s = list(iterable)
পাওয়ারসেটের জন্য এখানে আরও কোড রয়েছে। এটি স্ক্র্যাচ থেকে লেখা হয়েছে:
>>> def powerset(s):
... x = len(s)
... for i in range(1 << x):
... print [s[j] for j in range(x) if (i & (1 << j))]
...
>>> powerset([4,5,6])
[]
[4]
[5]
[4, 5]
[6]
[4, 6]
[5, 6]
[4, 5, 6]
মার্ক রুশাকফের মন্তব্য এখানে প্রযোজ্য: "শুরুতে আপনি যদি এই খালি টিপলটি পছন্দ না করেন তবে চালু করুন।" 0-দৈর্ঘ্যের সংমিশ্রণটি এড়াতে আপনি কেবল পরিসীমা বিবৃতিটি (1, লেন (গুলি) +1) এ পরিবর্তন করতে পারবেন to ", আমার ক্ষেত্রে বাদে আপনি বদলে for i in range(1 << x)যান for i in range(1, 1 << x)।
এই বছর পরে ফিরে, আমি এখন এটি লিখতে হবে:
def powerset(s):
x = len(s)
masks = [1 << i for i in range(x)]
for i in range(1 << x):
yield [ss for mask, ss in zip(masks, s) if i & mask]
এবং তারপরে পরীক্ষার কোডটি দেখতে দেখতে এটি বলবে:
print(list(powerset([4, 5, 6])))
ব্যবহারের yieldঅর্থ হ'ল আপনার একক মেমরির সমস্ত ফলাফল গণনা করার দরকার নেই। প্রধান লুপের বাইরে মুখোশগুলি প্রাক্কলক করা একটি উপযুক্ত অপ্টিমাইজেশন হিসাবে ধরে নেওয়া হয়।
যদি আপনি একটি দ্রুত উত্তর খুঁজছেন, আমি কেবল গুগলে "পাইথন শক্তি সেট" অনুসন্ধান করেছি এবং এটি নিয়ে এসেছি: পাইথন পাওয়ার সেট জেনারেটর
এখানে সেই পৃষ্ঠাতে কোড থেকে একটি অনুলিপি-পেস্ট করুন:
def powerset(seq):
"""
Returns all the subsets of this set. This is a generator.
"""
if len(seq) <= 1:
yield seq
yield []
else:
for item in powerset(seq[1:]):
yield [seq[0]]+item
yield item
এটি এর মতো ব্যবহার করা যেতে পারে:
l = [1, 2, 3, 4]
r = [x for x in powerset(l)]
এখন r হল সমস্ত উপাদানগুলির একটি তালিকা যা আপনি চেয়েছিলেন এবং এটি বাছাই এবং মুদ্রণ করা যেতে পারে:
r.sort()
print r
[[], [1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 4], [1, 3], [1, 3, 4], [1, 4], [2], [2, 3], [2, 3, 4], [2, 4], [3], [3, 4], [4]]
[[][]], এটি ঠিক করার জন্য দৈর্ঘ্য পরীক্ষার জন্য কেসগুলি পৃথক করেif len(seq) == 0: yield [] elif len(seq) == 1: yield seq yield []
পাওয়ারসেটের সংশোধন রয়েছে:
def powerset(seq):
"""
Returns all the subsets of this set. This is a generator.
"""
if len(seq) <= 0:
yield []
else:
for item in powerset(seq[1:]):
yield [seq[0]]+item
yield item
আমি জানি আমি এর আগে একটি উত্তর যুক্ত করেছি তবে আমি আমার নতুন বাস্তবায়ন পছন্দ করি। আমি ইনপুট হিসাবে একটি সেট নিচ্ছি, তবে এটি আসলে কোনও পুনরাবৃত্ত হতে পারে এবং আমি সেটগুলির একটি সেট ফিরিয়ে দিচ্ছি যা ইনপুটটির পাওয়ার সেট। আমি এই পদ্ধতির পছন্দ করি কারণ এটি পাওয়ার সেট ( সমস্ত উপসর্গের সেট ) এর গাণিতিক সংজ্ঞার সাথে আরও জড়িত ।
def power_set(A):
"""A is an iterable (list, tuple, set, str, etc)
returns a set which is the power set of A."""
length = len(A)
l = [a for a in A]
ps = set()
for i in range(2 ** length):
selector = f'{i:0{length}b}'
subset = {l[j] for j, bit in enumerate(selector) if bit == '1'}
ps.add(frozenset(subset))
return ps
আপনি যদি নিজের উত্তরে পোস্ট করেছেন ঠিক আউটপুট চান তবে এটি ব্যবহার করুন:
>>> [set(s) for s in power_set({1, 2, 3, 4})]
[{3, 4},
{2},
{1, 4},
{2, 3, 4},
{2, 3},
{1, 2, 4},
{1, 2},
{1, 2, 3},
{3},
{2, 4},
{1},
{1, 2, 3, 4},
set(),
{1, 3},
{1, 3, 4},
{4}]
এটি জানা যায় যে পাওয়ার সেটটির উপাদানগুলির সংখ্যা 2 ** len(A), যাতে এটি স্পষ্টভাবে forলুপে দেখা যায় ।
আমাকে ইনপুটটিকে (আদর্শভাবে একটি সেট) একটি তালিকায় রূপান্তর করতে হবে কারণ একটি সেট দ্বারা অনন্য অর্ডারযুক্ত উপাদানগুলির একটি ডেটা স্ট্রাকচার এবং সাবসেটগুলি উত্পন্ন করার জন্য ক্রমটি গুরুত্বপূর্ণ be
selectorএই অ্যালগরিদমের মূল কী। নোট করুন যে selectorইনপুট সেট হিসাবে সমান দৈর্ঘ্য আছে, এবং এটি সম্ভব করার জন্য এটি প্যাডিং সহ একটি এফ-স্ট্রিং ব্যবহার করছে। মূলত, এটি আমাকে সেই উপাদানগুলি নির্বাচন করতে দেয় যা প্রতিটি পুনরাবৃত্তির সময় প্রতিটি উপসেটে যুক্ত হবে। ধরা যাক ইনপুট সেটে 3 টি উপাদান রয়েছে {0, 1, 2}, তাই নির্বাচক 0 এবং 7 (সমেত) এর মধ্যে মান গ্রহণ করবে, যা বাইনারিতে রয়েছে:
000 # 0
001 # 1
010 # 2
011 # 3
100 # 4
101 # 5
110 # 6
111 # 7
সুতরাং, প্রতিটি বিট সূচক হিসাবে পরিবেশন করতে পারে যদি মূল সেটটির কোনও উপাদান যুক্ত করা উচিত বা না থাকে। বাইনারি সংখ্যাগুলি দেখুন এবং প্রতিটি সংখ্যাকে কেবল সুপার সেটের একটি উপাদান হিসাবে ভাবেন যার 1অর্থ সূচকে কোনও উপাদান jযুক্ত করা উচিত এবং এর 0অর্থ এই উপাদানটি যুক্ত করা উচিত নয়।
আমি প্রতিটি পুনরাবৃত্তিতে একটি উপসেট তৈরি করার জন্য একটি সেট বোধগম্য ব্যবহার করছি এবং আমি এই উপসেটটিকে এমন রূপান্তর frozensetকরি যাতে আমি এটিকে ps(পাওয়ার সেট) যুক্ত করতে পারি। অন্যথায়, আমি এটিকে যুক্ত করতে পারব না কারণ পাইথনের একটি সেটটিতে কেবল অপরিবর্তনীয় বস্তু থাকে।
আপনি কিছু অজগর বোঝার সাহায্যে কোডটি সহজ করতে পারেন, যাতে আপনি লুপগুলির জন্য এগুলি থেকে মুক্তি পেতে পারেন। আপনি সূচক zipব্যবহার এড়াতেও ব্যবহার করতে পারেন এবং jকোডটি নিম্নলিখিত হিসাবে শেষ হবে:
def power_set(A):
length = len(A)
return {
frozenset({e for e, b in zip(A, f'{i:{length}b}') if b == '1'})
for i in range(2 ** length)
}
এটাই. আমি এই অ্যালগরিদমটির যা পছন্দ করি তা হ'ল এটি অন্যদের তুলনায় আরও স্পষ্ট এবং স্বজ্ঞাত কারণ এটি itertoolsপ্রত্যাশার মতো কাজ করলেও নির্ভর করতে বেশ জাদুর দেখাচ্ছে ical
def get_power_set(s):
power_set=[[]]
for elem in s:
# iterate over the sub sets so far
for sub_set in power_set:
# add a new subset consisting of the subset at hand added elem
power_set=power_set+[list(sub_set)+[elem]]
return power_set
উদাহরণ স্বরূপ:
get_power_set([1,2,3])
ফলন
[[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]
power_setএটি পরিচালনা করে এমন লুপে একটি লুপ ভেরিয়েবল ( ) পরিবর্তন করা একটি খুব প্রশ্নবিদ্ধ অনুশীলন। উদাহরণ স্বরূপ, ধরুন আপনি প্রস্তাবিত পরিবর্তনশীল-পরিবর্তন কোডের পরিবর্তে এই লিখেছিলেন: power_set += [list(sub_set)+[elem]]। তাহলে লুপটি শেষ হবে না।
আমি নীচের অ্যালগরিদম খুব স্পষ্ট এবং সহজ পেয়েছি:
def get_powerset(some_list):
"""Returns all subsets of size 0 - len(some_list) for some_list"""
if len(some_list) == 0:
return [[]]
subsets = []
first_element = some_list[0]
remaining_list = some_list[1:]
# Strategy: get all the subsets of remaining_list. For each
# of those subsets, a full subset list will contain both
# the original subset as well as a version of the subset
# that contains first_element
for partial_subset in get_powerset(remaining_list):
subsets.append(partial_subset)
subsets.append(partial_subset[:] + [first_element])
return subsets
পাওয়ারশিট উত্পন্ন করার আরেকটি উপায় হ'ল বিটযুক্ত সমস্ত বাইনারি সংখ্যা তৈরি করা n। একটি পাওয়ার সেট হিসাবে nঅঙ্ক সহ সংখ্যার পরিমাণ 2 ^ n। এই অ্যালগরিদমের মূলনীতিটি হল যে কোনও উপাদান উপসেটে উপস্থিত হতে পারে বা না হতে পারে কারণ বাইনারি অঙ্কটি এক বা শূন্য হতে পারে তবে উভয়ই হতে পারে না।
def power_set(items):
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
আমি এমআইটিএক্স: 00.০০.২x কমপিটেশনাল চিন্তাভাবনা এবং ডেটা সায়েন্সের পরিচিতি গ্রহণ করার সময় উভয়ই অ্যালগরিদম পেয়েছি এবং আমি দেখেছি এটি বোঝার জন্য এটি সবচেয়ে সহজ একটি অ্যালগরিদম হিসাবে বিবেচনা করে।
আমি কেবল সর্বাধিক বোধগম্য সমাধানটি সরবরাহ করতে চেয়েছিলাম, এন্টি কোড-গল্ফ সংস্করণ।
from itertools import combinations
l = ["x", "y", "z", ]
def powerset(items):
combo = []
for r in range(len(items) + 1):
#use a list to coerce a actual list from the combinations generator
combo.append(list(combinations(items,r)))
return combo
l_powerset = powerset(l)
for i, item in enumerate(l_powerset):
print "All sets of length ", i
print item
ফলাফলগুলো
দৈর্ঘ্যের সমস্ত সেট 0
[()]
দৈর্ঘ্যের সব সেট 1
[('x',), ('y',), ('z',)]
দৈর্ঘ্যের সব সেট 2
[('x', 'y'), ('x', 'z'), ('y', 'z')]
দৈর্ঘ্যের সব সেট 3
[('x', 'y', 'z')]
আরও তথ্যের জন্য ইটারটুলস ডক্স , পাওয়ার সেটগুলিতে উইকিপিডিয়া এন্ট্রিও দেখুন
মাত্র একটি দ্রুত শক্তি সেট রিফ্রেশার!
একটি সেট এক্সের পাওয়ার সেট, খালি সেট সহ এক্স এর সমস্ত উপসর্গের সেট
উদাহরণ সেট এক্স = (ক, খ, সি)
পাওয়ার সেট = {{এ, বি, সি}, {এ, বি}, {এ, সি}, {বি, সি}, {এ}, {বি}, {সি}, {}}
পাওয়ার সেটটি খুঁজে পাওয়ার আরও একটি উপায় এখানে রয়েছে:
def power_set(input):
# returns a list of all subsets of the list a
if (len(input) == 0):
return [[]]
else:
main_subset = [ ]
for small_subset in power_set(input[1:]):
main_subset += [small_subset]
main_subset += [[input[0]] + small_subset]
return main_subset
print(power_set([0,1,2,3]))
উত্স সম্পূর্ণ ক্রেডিট
একটি সহজ উপায় হ'ল 2 এর পরিপূরক গাণিতিকের অধীনে পূর্ণসংখ্যার অভ্যন্তরীণ উপস্থাপনাকে কাজে লাগানো।
পূর্ণসংখ্যার বাইনারি উপস্থাপনা 0 থেকে 7 অবধি সংখ্যার জন্য {000, 001, 010, 011, 100, 101, 110, 111 as হিসাবে সংখ্যার সাথে সংযুক্ত উপাদানের অন্তর্ভুক্তি হিসাবে 1 বিবেচনা করে একটি পূর্ণসংখ্যার পাল্টা মান হয় 1 বর্জন হিসাবে আমরা গণনা ক্রমের ভিত্তিতে উপসেটগুলি তৈরি করতে পারি। নাম্বার থেকে উত্পন্ন করা থাকতে হবে 0থেকে pow(2,n) -1যেখানে n বাইনারি প্রতিনিধিত্ব বিট অ্যারে অর্থাত সংখ্যা দৈর্ঘ্য হল।
এর উপর ভিত্তি করে একটি সাধারণ সাবসেট জেনারেটর ফাংশন নীচে লেখা যেতে পারে। এটি মূলত নির্ভর করে
def subsets(array):
if not array:
return
else:
length = len(array)
for max_int in range(0x1 << length):
subset = []
for i in range(length):
if max_int & (0x1 << i):
subset.append(array[i])
yield subset
এবং তারপরে এটি হিসাবে ব্যবহার করা যেতে পারে
def get_subsets(array):
powerset = []
for i in subsets(array):
powerser.append(i)
return powerset
পরীক্ষামূলক
স্থানীয় ফাইলে নিম্নলিখিত যুক্ত করা হচ্ছে
if __name__ == '__main__':
sample = ['b', 'd', 'f']
for i in range(len(sample)):
print "Subsets for " , sample[i:], " are ", get_subsets(sample[i:])
নিম্নলিখিত আউটপুট দেয়
Subsets for ['b', 'd', 'f'] are [[], ['b'], ['d'], ['b', 'd'], ['f'], ['b', 'f'], ['d', 'f'], ['b', 'd', 'f']]
Subsets for ['d', 'f'] are [[], ['d'], ['f'], ['d', 'f']]
Subsets for ['f'] are [[], ['f']]
এই উত্তরগুলির প্রায় সবগুলিই এর listপরিবর্তে ব্যবহার করে set, যা আমার কাছে কিছুটা প্রতারণার মতো মনে হয়েছিল। সুতরাং, কৌতূহলের বাইরে আমি একটি সাধারণ সংস্করণটি সত্যই চালু করার চেষ্টা করেছি setএবং অন্যান্য "পাইথনের কাছে নতুন" লোকদের সংক্ষিপ্তসার জানাতে চাই।
পাইথনের সেট প্রয়োগের সাথে মোকাবিলা করার ক্ষেত্রে কয়েকটি অদ্ভুততা খুঁজে পেয়েছি । আমার কাছে প্রধান আশ্চর্য হ'ল খালি সেটগুলি পরিচালনা করা। এটি রুবির সেট প্রয়োগের বিপরীতে , যেখানে আমি সহজভাবে করতে পারি Set[Set[]]এবং একটি Setখালি রাখতে পারি Set, তাই আমি এটি প্রাথমিকভাবে কিছুটা বিভ্রান্তি পেয়েছিলাম।
পর্যালোচনার জন্য, করছেন powersetসঙ্গে setএস, আমি দুটি সমস্যা সম্মুখীন হয়েছে:
set()একটি পুনরাবৃত্তযোগ্য লাগে, তাই set(set())ফিরে আসবে set() কারণ খালি সেট পুনরাবৃত্তি খালি (ডু আমার ধারণা :))set({set()})এবং set.add(set)কাজ করতে পারে না কারণ set() হ্যাশযোগ্য নয়উভয় সমস্যা সমাধানের জন্য, আমি এর ব্যবহার করেছি frozenset(), যার অর্থ আমি যা চাই তা বেশিরভাগই পাই না (টাইপটি আক্ষরিক অর্থে set) তবে সামগ্রিক setআন্তঃসংযোগটি ব্যবহার করি।
def powerset(original_set):
# below gives us a set with one empty set in it
ps = set({frozenset()})
for member in original_set:
subset = set()
for m in ps:
# to be added into subset, needs to be
# frozenset.union(set) so it's hashable
subset.add(m.union(set([member]))
ps = ps.union(subset)
return ps
নীচে আমরা frozensetআউটপুট হিসাবে 2² (16) গুলি সঠিকভাবে পাই :
In [1]: powerset(set([1,2,3,4]))
Out[2]:
{frozenset(),
frozenset({3, 4}),
frozenset({2}),
frozenset({1, 4}),
frozenset({3}),
frozenset({2, 3}),
frozenset({2, 3, 4}),
frozenset({1, 2}),
frozenset({2, 4}),
frozenset({1}),
frozenset({1, 2, 4}),
frozenset({1, 3}),
frozenset({1, 2, 3}),
frozenset({4}),
frozenset({1, 3, 4}),
frozenset({1, 2, 3, 4})}
সেখানে একটি আছে কোন উপায় হিসাবে setএর setপাইথন মধ্যে এস, এইসব চালু করতে চান যদি frozensetমধ্যে গুলি setগুলি, আপনি একটি সেগুলি মানচিত্রে ফিরুন হবে list( list(map(set, powerset(set([1,2,3,4]))))
) অথবা উপরে পরিবর্তন করুন।
সম্ভবত প্রশ্নটি পুরনো হচ্ছে, তবে আমি আশা করি আমার কোডটি কাউকে সহায়তা করবে।
def powSet(set):
if len(set) == 0:
return [[]]
return addtoAll(set[0],powSet(set[1:])) + powSet(set[1:])
def addtoAll(e, set):
for c in set:
c.append(e)
return set
powerset()প্যাকেজ থেকে ফাংশন ব্যবহার করুন more_itertools।
পুনরাবৃত্তযোগ্য সমস্ত সম্ভাব্য সাবসেটের ফলন দেয়
>>> list(powerset([1, 2, 3]))
[(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]
আপনি যদি সেট চান, ব্যবহার করুন:
list(map(set, powerset(iterable)))
পুনরাবৃত্তি সহ সমস্ত উপগ্রহ প্রাপ্তি। পাগল-গাধা এক-লাইনার
from typing import List
def subsets(xs: list) -> List[list]:
return subsets(xs[1:]) + [x + [xs[0]] for x in subsets(xs[1:])] if xs else [[]]
হাস্কেল সমাধানের ভিত্তিতে
subsets :: [a] -> [[a]]
subsets [] = [[]]
subsets (x:xs) = map (x:) (subsets xs) ++ subsets xs
NameError: name 'List' is not defined
Listআমদানি যুক্ত করেছি
def findsubsets(s, n):
return list(itertools.combinations(s, n))
def allsubsets(s) :
a = []
for x in range(1,len(s)+1):
a.append(map(set,findsubsets(s,x)))
return a
আপনি এটি এর মতো করতে পারেন:
def powerset(x):
m=[]
if not x:
m.append(x)
else:
A = x[0]
B = x[1:]
for z in powerset(B):
m.append(z)
r = [A] + z
m.append(r)
return m
print(powerset([1, 2, 3, 4]))
আউটপুট:
[[], [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]]
এটি বুনো কারণ এগুলির কোনও উত্তরই প্রকৃত পাইথন সেটটি প্রদান করে না। এখানে একটি অগোছালো বাস্তবায়ন যা একটি পাওয়ারসেট দেবে যা আসলে পাইথন set।
test_set = set(['yo', 'whatup', 'money'])
def powerset( base_set ):
""" modified from pydoc's itertools recipe shown above"""
from itertools import chain, combinations
base_list = list( base_set )
combo_list = [ combinations(base_list, r) for r in range(len(base_set)+1) ]
powerset = set([])
for ll in combo_list:
list_of_frozensets = list( map( frozenset, map( list, ll ) ) )
set_of_frozensets = set( list_of_frozensets )
powerset = powerset.union( set_of_frozensets )
return powerset
print powerset( test_set )
# >>> set([ frozenset(['money','whatup']), frozenset(['money','whatup','yo']),
# frozenset(['whatup']), frozenset(['whatup','yo']), frozenset(['yo']),
# frozenset(['money','yo']), frozenset(['money']), frozenset([]) ])
যদিও আমি আরও ভাল বাস্তবায়ন দেখতে চাই।
[*map(set, chain.from_iterable(combinations(s, r) for r in range(len(s)+1)))]; আপনি যদি পছন্দ করেন তবে ফাংশনটি আর্গ হতে mapপারে frozenset।
সংযুক্তিগুলি ব্যবহার করে তবে কেবল বিল্টইনগুলি ব্যবহার করে আমার দ্রুত বাস্তবায়ন এখানে দেওয়া হয়েছে।
def powerSet(array):
length = str(len(array))
formatter = '{:0' + length + 'b}'
combinations = []
for i in xrange(2**int(length)):
combinations.append(formatter.format(i))
sets = set()
currentSet = []
for combo in combinations:
for i,val in enumerate(combo):
if val=='1':
currentSet.append(array[i])
sets.add(tuple(sorted(currentSet)))
currentSet = []
return sets
পরিসীমা এন হিসাবে সমস্ত উপসেট সেট করা আছে:
n = int(input())
l = [i for i in range (1, n + 1)]
for number in range(2 ** n) :
binary = bin(number)[: 1 : -1]
subset = [l[i] for i in range(len(binary)) if binary[i] == "1"]
print(set(sorted(subset)) if number > 0 else "{}")
import math
def printPowerSet(set,set_size):
pow_set_size =int(math.pow(2, set_size))
for counter in range(pow_set_size):
for j in range(set_size):
if((counter & (1 << j)) > 0):
print(set[j], end = "")
print("")
set = ['a', 'b', 'c']
printPowerSet(set,3)
প্রশ্নের ভিন্নতা হ'ল "ডিসকভারিং কম্পিউটার সায়েন্স: ইন্টারডিসিপ্লিনারি প্রবলেমস, প্রিন্সিপালস, এবং পাইথন প্রোগ্রামিং। 2015 এডিশন" বইয়ের একটি অনুশীলন। 10.2.11 অনুশীলনে, ইনপুটটি কেবল একটি পূর্ণসংখ্যার সংখ্যা এবং আউটপুটটি পাওয়ার সেটগুলি হওয়া উচিত। এখানে আমার পুনরাবৃত্ত সমাধান (বেসিক পাইথন 3 ব্যতীত অন্য কিছু ব্যবহার করা হচ্ছে না)
def powerSetR(n):
assert n >= 0
if n == 0:
return [[]]
else:
input_set = list(range(1, n+1)) # [1,2,...n]
main_subset = [ ]
for small_subset in powerSetR(n-1):
main_subset += [small_subset]
main_subset += [ [input_set[-1]] + small_subset]
return main_subset
superset = powerSetR(4)
print(superset)
print("Number of sublists:", len(superset))
এবং আউটপুট হয়
[[], [4], [3], [4, 3], [2], [4, 2], [3, 2], [4, 3, 2], [1], [4, 1 ], [3, 1], [4, 3, 1], [2, 1], [4, 2, 1], [3, 2, 1], [4, 3, 2, 1]] সংখ্যা sublists: 16
আমি more_itertools.powersetফাংশনটি জুড়ে আসিনি এবং এটি ব্যবহার করার পরামর্শ দেব। আমি আউটপুটটির ডিফল্ট ক্রমটি ব্যবহার না করার পরামর্শ দিই itertools.combinations, প্রায়শই পরিবর্তে আপনি দূরত্বটি হ্রাস করতে চান অবস্থানগুলির মধ্যে এবং তাদের মধ্যে বৃহত্তর দূরত্বের আইটেমগুলির পূর্বে / এর মধ্যবর্তী সংক্ষিপ্ত দূরত্বে আইটেমগুলির সাবসেটগুলি সাজিয়ে রাখতে চান।
itertoolsরেসিপি পৃষ্ঠা এটি ব্যবহার করে শোchain.from_iterable
rএখানে দ্বিপদী সহগের নীচের অংশের জন্য মানক সংকেতের সাথে মেলে , এটি sসাধারণত nগণিতের পাঠ্য এবং ক্যালকুলেটরগুলিতে উল্লেখ করা হয় ("n বেছে নিন r")def powerset(iterable):
"powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
s = list(iterable)
return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
এখানে অন্যান্য উদাহরণগুলি পাওয়ারসেটটি [1,2,3,4]এমনভাবে দেয় যাতে 2-টিউপলগুলি "লিকিকোগ্রাফিক" ক্রমে তালিকাভুক্ত হয় (যখন আমরা সংখ্যার সংখ্যা হিসাবে মুদ্রণ করি)। যদি আমি এর সাথে সংখ্যার মধ্যবর্তী দূরত্বটি লিখি (অর্থাত্ পার্থক্য) তবে এটি আমার বক্তব্যটি দেখায়:
12 ⇒ 1
13 ⇒ 2
14 ⇒ 3
23 ⇒ 1
24 ⇒ 2
34 ⇒ 1
সাবটেটের জন্য সঠিক ক্রমটি সেই আদেশ হওয়া উচিত যা সর্বনিম্ন দূরত্বকে প্রথমে 'ক্লান্ত করে', এরকম:
12 ⇒ 1
23 ⇒ 1
34 ⇒ 1
13 ⇒ 2
24 ⇒ 2
14 ⇒ 3
এখানে সংখ্যা ব্যবহার করা এই ক্রমটিকে 'ভুল' দেখায়, তবে উদাহরণস্বরূপ অক্ষরগুলি বিবেচনা করুন ["a","b","c","d"]কেন এটি এই আদেশে পাওয়ারসেট পাওয়ার জন্য কার্যকর হতে পারে:
ab ⇒ 1
bc ⇒ 1
cd ⇒ 1
ac ⇒ 2
bd ⇒ 2
ad ⇒ 3
এই প্রভাবটি আরও আইটেমগুলির সাথে আরও সুস্পষ্টভাবে প্রকাশিত হয় এবং আমার উদ্দেশ্যগুলির জন্য এটি পাওয়ারেটের সূচকের সীমাটি অর্থপূর্ণভাবে বর্ণনা করতে সক্ষম হওয়ার মধ্যে পার্থক্য তৈরি করে।
( গ্রে কোডগুলিতে অনেক কিছুই লেখা আছে কম্বিনেটরেটিক্সে অ্যালগরিদমের আউটপুট ক্রমের জন্য ইত্যাদিতে , আমি এটিকে কোনও পার্শ্ব সমস্যা হিসাবে দেখছি না)।
আমি প্রকৃতপক্ষে একটি মোটামুটিভাবে জড়িত প্রোগ্রাম লিখেছি যা এই দ্রুত পূর্ণসংখ্যা পার্টিশন কোডটি যথাযথ ক্রমে মানগুলি আউটপুট করতে more_itertools.powersetব্যবহার করে , তবে আমি আবিষ্কার করেছি এবং বেশিরভাগ ব্যবহারের জন্য সম্ভবত ঠিক এই জাতীয় ফাংশনটি ব্যবহার করা ভাল:
from more_itertools import powerset
from numpy import ediff1d
def ps_sorter(tup):
l = len(tup)
d = ediff1d(tup).tolist()
return l, d
ps = powerset([1,2,3,4])
ps = sorted(ps, key=ps_sorter)
for x in ps:
print(x)
⇣
()
(1,)
(2,)
(3,)
(4,)
(1, 2)
(2, 3)
(3, 4)
(1, 3)
(2, 4)
(1, 4)
(1, 2, 3)
(2, 3, 4)
(1, 2, 4)
(1, 3, 4)
(1, 2, 3, 4)
আমি আরো কিছু জড়িত কোড যা পাওয়ারসেট চমত্কারভাবে প্রিন্ট হবে লিখেছেনঃ (চমত্কার ফাংশন আমি এখানে অন্তর্ভুক্ত করা হয় না থাকেন মুদ্রণের জন্য রেপো দেখুন: print_partitions, print_partitions_by_length, এবং pprint_tuple)।
pset_partitions.pyএটি বেশ সহজ সরল, তবে আপনি যদি এমন কিছু কোড চান যা আপনাকে পাওয়ারসেটের বিভিন্ন স্তরের অ্যাক্সেস করতে সোজা পেতে দেয় তবে এখনও কার্যকর হতে পারে:
from itertools import permutations as permute
from numpy import cumsum
# http://jeromekelleher.net/generating-integer-partitions.html
# via
# /programming/10035752/elegant-python-code-for-integer-partitioning#comment25080713_10036764
def asc_int_partitions(n):
a = [0 for i in range(n + 1)]
k = 1
y = n - 1
while k != 0:
x = a[k - 1] + 1
k -= 1
while 2 * x <= y:
a[k] = x
y -= x
k += 1
l = k + 1
while x <= y:
a[k] = x
a[l] = y
yield tuple(a[:k + 2])
x += 1
y -= 1
a[k] = x + y
y = x + y - 1
yield tuple(a[:k + 1])
# https://stackoverflow.com/a/6285330/2668831
def uniquely_permute(iterable, enforce_sort=False, r=None):
previous = tuple()
if enforce_sort: # potential waste of effort (default: False)
iterable = sorted(iterable)
for p in permute(iterable, r):
if p > previous:
previous = p
yield p
def sum_min(p):
return sum(p), min(p)
def partitions_by_length(max_n, sorting=True, permuting=False):
partition_dict = {0: ()}
for n in range(1,max_n+1):
partition_dict.setdefault(n, [])
partitions = list(asc_int_partitions(n))
for p in partitions:
if permuting:
perms = uniquely_permute(p)
for perm in perms:
partition_dict.get(len(p)).append(perm)
else:
partition_dict.get(len(p)).append(p)
if not sorting:
return partition_dict
for k in partition_dict:
partition_dict.update({k: sorted(partition_dict.get(k), key=sum_min)})
return partition_dict
def print_partitions_by_length(max_n, sorting=True, permuting=True):
partition_dict = partitions_by_length(max_n, sorting=sorting, permuting=permuting)
for k in partition_dict:
if k == 0:
print(tuple(partition_dict.get(k)), end="")
for p in partition_dict.get(k):
print(pprint_tuple(p), end=" ")
print()
return
def generate_powerset(items, subset_handler=tuple, verbose=False):
"""
Generate the powerset of an iterable `items`.
Handling of the elements of the iterable is by whichever function is passed as
`subset_handler`, which must be able to handle the `None` value for the
empty set. The function `string_handler` will join the elements of the subset
with the empty string (useful when `items` is an iterable of `str` variables).
"""
ps = {0: [subset_handler()]}
n = len(items)
p_dict = partitions_by_length(n-1, sorting=True, permuting=True)
for p_len, parts in p_dict.items():
ps.setdefault(p_len, [])
if p_len == 0:
# singletons
for offset in range(n):
subset = subset_handler([items[offset]])
if verbose:
if offset > 0:
print(end=" ")
if offset == n - 1:
print(subset, end="\n")
else:
print(subset, end=",")
ps.get(p_len).append(subset)
for pcount, partition in enumerate(parts):
distance = sum(partition)
indices = (cumsum(partition)).tolist()
for offset in range(n - distance):
subset = subset_handler([items[offset]] + [items[offset:][i] for i in indices])
if verbose:
if offset > 0:
print(end=" ")
if offset == n - distance - 1:
print(subset, end="\n")
else:
print(subset, end=",")
ps.get(p_len).append(subset)
if verbose and p_len < n-1:
print()
return ps
উদাহরণ হিসাবে, আমি একটি সি এল এল ডেমো প্রোগ্রাম লিখেছিলাম যা একটি কমান্ড লাইন আর্গুমেন্ট হিসাবে একটি স্ট্রিং নেয়:
python string_powerset.py abcdef
⇣
a, b, c, d, e, f
ab, bc, cd, de, ef
ac, bd, ce, df
ad, be, cf
ae, bf
af
abc, bcd, cde, def
abd, bce, cdf
acd, bde, cef
abe, bcf
ade, bef
ace, bdf
abf
aef
acf
adf
abcd, bcde, cdef
abce, bcdf
abde, bcef
acde, bdef
abcf
abef
adef
abdf
acdf
acef
abcde, bcdef
abcdf
abcef
abdef
acdef
abcdef
আপনি যদি সাবটাইটের কোনও নির্দিষ্ট দৈর্ঘ্য চান তবে এটি এটি করতে পারেন:
from itertools import combinations
someSet = {0, 1, 2, 3}
([x for i in range(len(someSet)+1) for x in combinations(someSet,i)])
সাধারণভাবে সালিসি দৈর্ঘ্যের সাবসেটগুলির জন্য আপনি পরিসীমা যুক্তিটি সংশোধন করতে পারেন। আউটপুট হয়
[(), (0,), (1,), (2,), (3,), (0, 1), (0, 2), (0, 3), (1, 2), (1 , 3), (2, 3), (0, 1, 2), (0, 1, 3), (0, 2, 3), (1, 2, 3), (0, 1, 2, 3) )]
পাইথন 3.5 বা ততোধিক ক্ষেত্রে , আপনি yield fromবিবৃতিটি itertools.combitions সহ ব্যবহার করতে পারেন :
def subsets(iterable):
for n in range(len(iterable)):
yield from combinations(iterable, n + 1)
def powerset(some_set):
res = [(a,b) for a in some_set for b in some_set]
return res