def allcombinations(orgset, k):
"""
returns all combinations of orgset with up to k items
:param orgset: the list to be iterated
:param k: the maxcardinality of the subsets
:return: an iterator of the subsets
example:
>>> c = allcombinations([1,2,3,4],2)
>>> for s in c:
... print(s)
(1,)
(2,)
(3,)
(4,)
(1, 2)
(1, 3)
(1, 4)
(2, 3)
(2, 4)
(3, 4)
"""
return itertools.chain(*[combination(orgset, i) for i in range(1, k + 1)])
def __shortestpathPrecomputed__(seedlist1):
if precomputedPaths == []:
precomputedPaths = __get_precomputed_paths__()
G = nx.Graph()
G.add_edges_from(precomputedPaths[frozenset(x)]
for x in it.combination(seedlist1))
return G
def combinationSum3_2(self, k, n):
import itertools
res = []
combs = itertools.combination(list(range(1, 10)), k)
for i in combs:
if sum(i) == n:
res.append(i)
return res
import unittest
def familia(pal):
return list(combination(pal))
import itertools
N, M = list(map(int, input().split()))
# matrix = [[0 for i in range(N + 1)] for j in range(N + 1)]
matrix = []
for i in range(N):
matrix.append(list(map(int, input().split())))
p = []
p = list(map(int, input().split()))
print(matrix)
print(p)
for i in range(N):
comb = itertools.combination(matrix[i], 2)
def default_combination_checker(iterable, r):
return len(itertools.combination(iterable, r))
3. Chain(iter1,iter2,....) ==> used to print all values
4. We need to import itertools
= itertools.accumulate(list1)
= itertools.chain(list4) #list1+list2+list = list4
= itertools.chain.from_iterable(list3) #list3=[list1,list2]
= itertools.dropwhile() ==> This iterator start printing the characters only after the function in argument.Return false for first time.
= itertools.filterfalse(func,seq) ==> As the name suggest, this iterator prints only values that return false for passed function.
= itertools.isslice(iterable,start,stop,step)
= itertools.starmap(function,tuplelist)
= itertools.starmap(max,list)
= itertools.starmap(min,list)
= itertools.takewhile(func,iterator)
= itertools.tee(func,iterable)
= itertools.product(iter1,iter2)
= itertools.permutation(iter1,group=size)
= itertools.combination(iter1,group=size)
= itertools.combination_with_replacement(iter1,group=size)
= itertools.count(start,stop)
= itertools.cycle(iterable)
= itertools.repeat(val,num)
=====================================
import itertools
import operator
li1 = [1, 4, 5, 7]
li2 = [1, 6, 5, 9]
li3 = [8, 10, 5, 4]
print ("The sum after each iteration is : ",end="")
print (list(itertools.accumulate(li1)))
print ("The product after each iteration is : ",end="")
print (list(itertools.accumulate(li1,operator.mul)))
print ("All values in mentioned chain are : ",end="")
def findKeyLength(s): res = len(41) for k in range(2,40): blocks = [s[i:i+k] for i in range(0,len(s),k)] pairs = list(itertools.combination(blocks,2))
3. Chain(iter1,iter2,....) --> used to print all values
4. We need to import itertools
- itertools.accumulate(list1)
- itertools.chain(list4) #list1+list2+list = list4
- itertools.chain.from_iterable(list3) #list3=[list1,list2]
- itertools.dropwhile() --> This iterator start printing the characters only after the function in argument.Return false for first time.
- itertools.filterfalse(func,seq) --> As the name suggest, this iterator prints only values that return false for passed function.
- itertools.isslice(iterable,start,stop,step)
- itertools.starmap(function,tuplelist)
- itertools.starmap(max,list)
- itertools.starmap(min,list)
- itertools.takewhile(func,iterator)
- itertools.tee(func,iterable)
- itertools.product(iter1,iter2)
- itertools.permutation(iter1,group-size)
- itertools.combination(iter1,group-size)
- itertools.combination_with_replacement(iter1,group-size)
- itertools.count(start,stop)
- itertools.cycle(iterable)
- itertools.repeat(val,num)
=====================================
import itertools
import operator
li1 = [1, 4, 5, 7]
li2 = [1, 6, 5, 9]
li3 = [8, 10, 5, 4]
print ("The sum after each iteration is : ",end="")
print (list(itertools.accumulate(li1)))
print ("The product after each iteration is : ",end="")
print (list(itertools.accumulate(li1,operator.mul)))
print ("All values in mentioned chain are : ",end="")
import itertools
n, m = map(int, input().split())
hyoka = [""] * n
for i in range(n):
hyoka[i] = input().split()
for i in range(n):
hyoka[i] = [int(s) for s in hyoka[i]]
hyou = [""]
for iroiro in list(itertools.combination(hyoka, m)):
sum_1 = sum[beau[1] for beau in iroiro]
sum_1 = abs(sum_1)
sum_2 = sum[beau[2] for beau in iroiro]
sum_2 = abs(sum_2)
sum_3 = sum[beau[3] for beau in iroiro]
sum_3 = abs(sum_3)
som = sum_1 + sum_2 + sum_3
hyou = hyou.append(som)
print(max(hyou))
def default_combination_checker(iterable, r):
return len(itertools.combination(iterable, r))
def projection_1(self, kmax=1):
"""Projection of a coarse quad mesh to the closest two-colourable sub-spaces.
Parameters
----------
mesh : CoarseQuadMesh
A coarse quad mesh.
Returns
-------
results : dict
The combination pointing to the its result. If the combination is valid, the result is a tuple of the the two-colourable mesh, the two-colourable network, and the network vertex colors.
References
----------
.. [1] Oval et al., *Topology Finding of Two-Colourable Quad-Mesh Patterns in Structural Design*. Submitted.
"""
mesh = self.quad_mesh
n = mesh.number_of_strips()
vertices, edges = mesh.strip_graph()
if is_adjacency_two_colorable(adjacency_from_edges(edges)) is not None:
self.results = True
return True
relation = {}
for k in range(n):
for combination in itertools.combination(mesh.strips(), k):
other_strips = list(mesh.strips())
for skey in combination:
del other_strips[skey]
downsteam_combinations = itertools.combination(
mesh.strips(), k)
relation[combination] = []
results = {}
t0 = time.time()
k = 0
current_pool = [[skey] for skey in mesh.strips()]
while k < kmax:
k += 1
next_pool = []
#print(current_pool)
for combination in current_pool:
if len(combination) > 1:
combination = list(
set([i for item in combination for i in item]))
else:
combination = list(set(combination))
if len(collateral_strip_deletions(mesh, combination)) > 0:
continue
if len(total_boundary_deletions(mesh, combination)) > 0:
continue
# delete strips in mesh and check validity
copy_mesh = mesh.copy()
delete_strips(copy_mesh, combination, preserve_boundaries=True)
topological_validity = copy_mesh.is_manifold(
) and copy_mesh.euler() == mesh.euler()
if not topological_validity:
pass
# delete strip vertices in network and check colourability
else:
new_vertices = {
vkey: xyz
for vkey, xyz in vertices.items()
if vkey not in combination
}
new_edges = [
(u, v) for u, v in edges
if u not in combination and v not in combination
]
two_colourability = is_adjacency_two_colorable(
adjacency_from_edges(new_edges))
if not two_colourability:
next_pool.append(combination)
else:
results[tuple(combination)] = (copy_mesh,
(new_vertices,
new_edges),
two_colourability)
current_pool = itertools.combinations(next_pool, 2)
t1 = time.time()
print(t1 - t0)
self.results = results
