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