def bubble_sort(boxes): initial_color = "#2299AB" comparision_color = "#8D00FF" final_color = "#00FFCE" animation_speed = 1 # Set all boxes color to initial color for box in boxes: set_color(box, initial_color, canvas) n = len(boxes) for i in range(n - 1): for j in range(n - i - 1): if boxes[j] > boxes[j + 1]: set_color(boxes[j], comparision_color, canvas) set_color(boxes[j + 1], comparision_color, canvas) swap(boxes[j], boxes[j + 1], animation_speed, canvas, tk) boxes[j], boxes[j + 1] = boxes[j + 1], boxes[j] time.sleep(0.1) set_color(boxes[j], initial_color, canvas) set_color(boxes[j + 1], initial_color, canvas) set_color(boxes[j + 1], final_color, canvas) set_color(boxes[0], final_color, canvas)
def _bubble_up(self, i): parent_idx = self._get_parent_index(i) while parent_idx is not None: if self.heap[i] < self.heap[parent_idx]: swap(self.heap, i, parent_idx) i = parent_idx parent_idx = self._get_parent_index(parent_idx)
def evolve(self, init, max_gen, k_opt=2): x = init gen = 0 tabu_list = [0] * self.tabu_size while gen < max_gen: print('gen %d...' % gen, end='') x_neighbors, rules = get_neighbors_and_rules(x, k_opt) # 2-opt is usually better dists = list(map(lambda x : distance(self.distance_matrix, x), x_neighbors)) sorted_dists, sorted_index = sort(dists) min_dist = sorted_dists[0] min_id = sorted_index[0] min_rule = rules[min_id] if min_dist < distance(self.distance_matrix, x): # aspiration # update tabu list tabu_list.insert(0, min_rule) tabu_list.pop() x = swap(x, min_rule) else: while min_rule in tabu_list: sorted_index.pop(0) min_id = sorted_index[0] min_rule = rules[min_id] # update tabu list tabu_list.insert(0, min_rule) tabu_list.pop() x = swap(x, min_rule) gen += 1 print('done!') return tabu_list, x, distance(self.distance_matrix, x)
def credential_manager(): os.system('find -name encrypted.txt | cut -b 3- >> hasname.txt') if utils.swap('hasname.txt', True).pop() == 'encrypted.txt': uname = 'pi' os.system('echo $(python aes.py -d) >> passd.txt') passwd = utils.swap('passd.txt', True).pop().split('Result: ')[1] return uname, passwd
def greedyLocalSearch(distances, type): number_of_all = distances.shape[0] number_of_half = int(np.ceil(number_of_all / 2)) path, not_path = utils.make_random_path(number_of_half, number_of_all) actions = utils.swap_actions(number_of_half, type) result_of_itertools_product = itertools.product( np.arange(path.shape[0]), np.arange(not_path.shape[0])) exchange_actions = np.array(list(result_of_itertools_product), 'int') swapLen, exchangeLen = len(actions), len(exchange_actions) swapWithNoImprovement, exchangeWithNoImprovement = 0, 0 np.random.shuffle(exchange_actions) np.random.shuffle(actions) while True: if swapLen <= swapWithNoImprovement and exchangeLen <= exchangeWithNoImprovement: break elif np.random.random() < 0.5 and swapLen > swapWithNoImprovement: action = actions[np.random.randint(len(actions)), :] delta = utils.calculate_swap_delta(action, path, distances, type) if delta > 0: utils.swap(path, action, type) swapWithNoImprovement = 0 else: swapWithNoImprovement += 1 else: exchange_action = actions[np.random.randint(len(actions)), :] delta = utils.calculate_exchange_delta(exchange_action, path, not_path, distances) if delta > 0: utils.exchange_vertices(path, not_path, exchange_action) exchangeWithNoImprovement = 0 else: exchangeWithNoImprovement += 1 return np.append(path, path[0])
def insertion_sort(a): i = 0 while i < len(a) - 1: j = i + 1 while j > 0 and a[j] < a[j - 1]: swap(a, j - 1, j) j -= 1 i += 1
def insertion_sort(arr): for n in xrange(1, len(arr)): for m in xrange(n, 0, -1): if arr[m] < arr[m - 1]: utils.swap(arr, m, m - 1) else: break return arr
def selection_sort(a): for i in range(len(a)): min_index = i for j in range(i + 1, len(a)): if a[j] < a[min_index]: min_index = j if min_index != i: swap(a, min_index, i)
def selection_sort(arr): for x in xrange(0, len(arr)): mini = x for y in xrange(x, len(arr)): if arr[y] < arr[mini]: mini = y swap(arr, x, mini) return arr
def sort(A): heap_size = len(A) build_max_heap(A) for i in range(len(A) - 1, 0, -1): swap(A, 0, i) heap_size -= 1 max_heapify(A, 0, heap_size)
def bubble_sort(arr): in_order = False while not in_order: in_order = True for x in xrange(0, len(arr) - 1): if arr[x] > arr[x + 1]: swap(arr, x, x + 1) in_order = False return arr
def bubble(collection): n = len(collection) for i in range(0, n - 1): no_change = True for j in range(0, n - i - 1): if collection[j + 1] < collection[j]: swap(collection, j, j + 1) no_change = False if no_change: return
def SWAP3(tau, LTG, LTG1, LTG2, C, Q, EG, V, SPL, QFilter_type): QFilter = Q_Filter(tau, LTG, LTG1, C, Q, EG) if QFilter_type == '9': #no filter is used QF1, QF2, QF3 = QFilter[0], QFilter[0], QFilter[0] elif QFilter_type == '0': #only Q1-filter (note in the paper this is called Q0-filter) QF1, QF2, QF3 = QFilter[1], QFilter[1], QFilter[1] elif QFilter_type == '01': #Q1-filter for the first layer and Q2-filter for the rest (Q0+Q1-filter in the paper) QF1, QF2, QF3 = QFilter[1], QFilter[2], QFilter[2] elif QFilter_type == '01x': #Q1-filter for the first layer and (Q1+Q2)-filter for the rest (Q0+weak_Q1-filter QF1, QF2, QF3 = QFilter[1], QFilter[3], QFilter[3] elif QFilter_type == '1x': #only Q2x-filter QF1, QF2, QF3 = QFilter[3], QFilter[3], QFilter[3] else: #'01y' QF1, QF2, QF3 = QFilter[3], QFilter[1], QFilter[1] SWAP3 = [] rhat = R_hat_3(tau, LTG, LTG1, LTG2, C, V, SPL) for edge_1 in EG: p, q = edge_1 if tau[p] not in QF1 and tau[q] not in QF1: continue tau1 = swap(tau, p, q, EG) rhat1 = R_hat_3(tau1, LTG, LTG1, LTG2, C, V, SPL) if rhat1 > rhat: continue x1 = [[edge_1], tau1] if x1 not in SWAP3: SWAP3.append(x1) for edge_2 in EG: if edge_1 == edge_2: continue p, q = edge_2 if tau1[p] not in QF2 and tau1[q] not in QF2: continue tau2 = swap(tau1, p, q, EG) rhat2 = R_hat_3(tau2, LTG, LTG1, LTG2, C, V, SPL) if rhat2 > rhat1: continue x2 = [[edge_1, edge_2], tau2] if x2 not in SWAP3: SWAP3.append(x2) for edge_3 in EG: if edge_3 in {edge_1, edge_2}: continue p, q = edge_3 if tau2[p] not in QF3 and tau2[q] not in QF3: continue tau3 = swap(tau2, p, q, EG) mdg3 = min_gate_dist(tau3, LTG, C, V, SPL) if mdg3 > 1: continue '''//Compare with the above, i.e., mdg3''' #2.6155@729"(rhat3) vs 2.6179@746(mdg3) vs 2.6155@789" (sycamore) #3.1494@466"(rhat3) vs.3.1415@441"(mdg3) vs 3.1494@438" (rochester) # rhat3 = R_hat_3(tau3, LTG, LTG1, LTG2, C, V, SPL) # if rhat3 > rhat2: continue x3 = [[edge_1, edge_2, edge_3], tau3] if x3 not in SWAP3: SWAP3.append(x3) return SWAP3
def partition(A, lo, hi): p = select_pivot(A, lo, hi) i = lo + 1 for j in xrange(i, hi + 1): if A[j] < A[p]: swap(A, i, j) i += 1 swap(A, i-1, p) return i-1
def partition(arr, l, r): pivot = l i = pivot + 1 j = i while i < r: if arr[i] < arr[pivot]: swap(arr, i, j) j += 1 i += 1 swap(arr, pivot, j-1) return j-1
def heapsort(A: list): n = len(A) mid = n // 2 - 1 for l in range(mid, -1, -1): sift(A, l, n - 1) for r in (n - 1, 1, -1): swap(A, pos1=0, pos2=r) sift(A, 1, r) A.reverse()
def insert_second(self, data): n = len(self._list) self._list.append(data) i = first_size while i > 0: swap(self._list, n - 1, n) n -= 1 i -= 1 second_size += 1
def bubbleSort(A): n_swap, n_compare = 0, 0 for i in range(len(A) - 1): for j in range(i, len(A) - 1): n_compare += 1 if A[j] > A[j + 1]: swap(A, j, j + 1) n_swap += 1 benchmarks = {'n_compare': n_compare, 'n_swap': n_swap} return A, benchmarks return A
def partition(arr, low, high): pivotIndex = low low = low + 1 for x in xrange(low, high + 1): if arr[x] < arr[pivotIndex]: swap(arr, x, low) low = low + 1 swap(arr, pivotIndex, low - 1) return low - 1
def initialize(self): os.system('ls KB/ >> topics.txt') known_subjects = utils.swap('topics.txt', True) for subj in known_subjects: topic = subj.split('_result.txt')[0].replace('_', "") self.kb[topic] = utils.swap('KB/' + subj, False) sz = len(self.kb[topic]) print 'Importing Knowledge of subject\t%s\033[1m\t\b%d lines\033[0m' % ( topic, sz) vocabulary = utils.swap('words.txt', False) print '\033[1m\033[34m%d Words Added to Vocabulary\033[0m' % ( len(vocabulary))
def insert_kp(arr, kp, idx): if len(arr) < num_per_blk: arr.append(idx) elif kps_all[arr[-1]].response < kp.response: arr[-1] = idx else: return for kk in range(-1, -len(arr), -1): if kps_all[arr[kk - 1]].response >= kp.response: break swap(arr, kk, kk - 1)
def SWAP3(tau, LTG, LTG1, C, Q, EG, V, SPL, QFilter_type): QFilter = Q_Filter(tau, LTG, LTG1, C, Q, EG) if QFilter_type == '9': #no filter is used QF1, QF2, QF3 = QFilter[0], QFilter[0], QFilter[0] elif QFilter_type == '0': #only Q1-filter (note in the paper this is called Q0-filter) QF1, QF2, QF3 = QFilter[1], QFilter[1], QFilter[1] elif QFilter_type == '01': #Q1-filter for the first layer and Q2-filter for the rest (Q0+Q1-filter in the paper) QF1, QF2, QF3 = QFilter[1], QFilter[2], QFilter[2] elif QFilter_type == '01x': #Q1-filter for the first layer and (Q1+Q2)-filter for the rest (Q0+weak_Q1-filter QF1, QF2, QF3 = QFilter[1], QFilter[3], QFilter[3] elif QFilter_type == '1x': #only Q2x-filter QF1, QF2, QF3 = QFilter[3], QFilter[3], QFilter[3] else: #'01y' QF1, QF2, QF3 = QFilter[3], QFilter[1], QFilter[1] SWAP3 = [] rhat = R_hat_1(tau, LTG, C, V, SPL) for edge_1 in EG: p, q = edge_1 #skip if both p, q are irrelevant phy. qubits w.r.t. TG if tau[p] not in QF1 and tau[q] not in QF1: continue tau1 = swap(tau, p, q, EG) rhat1 = R_hat_1(tau1, LTG, C, V, SPL) if rhat1 > rhat: continue x1 = [[edge_1], tau1] if x1 not in SWAP3: SWAP3.append(x1) for edge_2 in EG: if edge_1 == edge_2: continue p, q = edge_2 if tau1[p] not in QF2 and tau1[q] not in QF2: continue tau2 = swap(tau1, p, q, EG) rhat2 = R_hat_1(tau2, LTG, C, V, SPL) if rhat2 > rhat1: continue x2 = [[edge_1, edge_2], tau2] if x2 not in SWAP3: SWAP3.append(x2) for edge_3 in EG: if edge_3 in {edge_1, edge_2}: continue p, q = edge_3 if tau2[p] not in QF3 and tau2[q] not in QF3: continue tau3 = swap(tau2, p, q, EG) mdg3 = min_gate_dist(tau3, LTG, C, V, SPL) '''If GVal, we aim to solve at least one gate.''' if mdg3 > 1: continue x3 = [[edge_1, edge_2, edge_3], tau3] if x3 not in SWAP3: SWAP3.append(x3) return SWAP3
def selectionSort(A): n_compare, n_swap = 0, 0 for i in range(len(A)): least_ix = len(A) - 1 for j in range(i, len(A)): n_compare += 1 if A[j] < A[least_ix]: least_ix = j swap(A, i, least_ix) n_swap += 1 benchmarks = {'n_compare': n_compare, 'n_swap': n_swap} return A, benchmarks
def selectionSort(lyst): i = 0 while i < len(lyst) - 1: minIndex = i j = i + 1 while j < len(lyst): if lyst[j] < lyst[minIndex]: minIndex = j j += 1 if minIndex != i: swap(lyst, minIndex, i) i += 1 time.sleep(0.1) return lyst
def max_heapify(A, i, heap_size): l = (i << 1) + 1 r = l + 1 largest = i if l < heap_size and A[l] > A[i]: largest = l if r < heap_size and A[r] > A[largest]: largest = r if largest != i: swap(A, i, largest) max_heapify(A, largest, heap_size)
def bfs(self, u): visited = [False] * (len(self.__edges)) tree = [] queue = [u] visited[u] = True while queue: s = queue.pop(0) print(f"{s}", end=" ") for e in self.__edges[s]: if visited[e] is False: visited[e] = True queue.append(e) tree.append([e, s]) utils.swap(tree) print(f"\n{tree}")
def load_training_data(): raw_data_in = [] for table_data in utils.swap('unlabeled_training_data.txt', False): raw_data_in.append(table_data) print '[*] %d lines of unlabeled training data loaded [%ss Elapsed]' % \ (len(raw_data_in), str(time.time() - tic)) return raw_data_in
def solve_n_queens_problem(number_of_queens, population_size=10**3, max_iterations=10**4): assert 0 < number_of_queens < 256 indices = numpy.arange(number_of_queens) # def swap_2_random_rows(population, all_rows=indices): # perm, rand_rows = sample(population, 1)[0], sample(all_rows, 2) # new_perm = perm.copy() # new_perm[rand_rows[::-1]] = perm[rand_rows[0]], perm[rand_rows[1]] # return new_perm swap_2_random_rows = lambda population, all_rows=indices: swap(sample(population, 1)[0], sample(all_rows, 2)) numb_of_parents = 2 chromo_length = number_of_queens/numb_of_parents slices = tuple(imap( apply, repeat(slice), izip_longest(*imap(xrange, (0, chromo_length), repeat(number_of_queens - 1), repeat(chromo_length))), )) def merge_2_random_solutions(population): return permutation_from_inversion( # merge two solutions by merging their inversion sequence ... numpy.fromiter( chain.from_iterable( imap( # get inversion sequence from each donor parent ... item, imap(tuple, imap(permutation_inversion, sample(population, numb_of_parents))), slices ) ), count=number_of_queens, dtype=board_element_type ) ) operators = merge_2_random_solutions, swap_2_random_rows def genetic_operators(population, sample_size, prob_of_mutation=.3): return sorted( imap(apply, imap(operators.__getitem__, random(sample_size) < prob_of_mutation), repeat((population,))), key=fitness_function, reverse=True ) return genetic_algorithm( sorted( starmap( sample, repeat((numpy.arange(number_of_queens, dtype=board_element_type), number_of_queens), population_size) ), key=fitness_function, reverse=True ), selection, genetic_operators, sort_population, lambda perm: len(perm) - fitness_function(perm), max_iterations=max_iterations )
def main(): if '-gen' in sys.argv: A = int(sys.argv[2]) B = int(sys.argv[3]) ip_block(A, B) # Create a way to run this distributed from python elif '-multi-setup' in sys.argv: import network workers = [] peers = {} # Determine which nodes are available to work for n in network.get_node_names(): name = n.split('/')[-1].split('.')[0] h, i, p, m = utils.load_credentials(name, False) peers[name] = [h, i, p, m] # check if online if network.check_connected(h, i, p): workers.append(name) else: print '%s@%s offline' % (name, i) # Now distribute the assignments print '[*] %d Workers Available' % len(workers) for w in workers: # give them the latest copy of this program H, I, P, M = peers[w] rpath = '/home/%s/Documents/PoolParty/code/0.6/' % H if utils.remote_file_exists(H, I, P, rpath + 'trace.py'): utils.ssh_exec('rm %strace.py' % rpath, I, H, P, False) utils.put_file('trace.py', rpath, H, I, P, False) # Now give them a ip_space.txt file and a script to run trace.py utils.ssh_exec('rm %shops.txt' % rpath, I, H, P, True) # c = 'cd %s; python trace.py 0>&-' % rpath # put this in a .sh script and transfer, then execute # utils.ssh_exec('cd %s; python trace.py 0>&-' % rpath,H,I,P,False) elif '-multi-view' in sys.argv: import tracewatch print('[*] Monitoring Traces...') else: ips = list(utils.swap('ip_space.txt', False)) if not os.path.isfile(os.getcwd() + '/hops.txt'): os.system('touch hops.txt') random.shuffle(ips) pool = multiprocessing.Pool(10) for ip in ips: try: event = pool.apply_async(func=trace, args=(ip, False)) hopdata, nhops = event.get(timeout=60) print ' - %d hops to %s' % (nhops, ip) open('hops.txt', 'a').write('%s:%d\n' % (ip, nhops)) except multiprocessing.TimeoutError: open('hops.txt', 'a').write('%s:?\n' % ip) pass
def double_gate(self, T, i, j=None): """Apply the double-qubit transformation T to the ith and jth qubits, or ith and i+1th if j is not specified >>> qs = QSystem(3) >>> qs.single_gate(H, 0) >>> qs.double_gate(CNOT, 0) >>> qs (0.707106781187+0j)|000> + 0j|001> + 0j|010> + 0j|011> + 0j|100> + 0j|101> + (0.707106781187+0j)|110> + 0j|111> >>> qs = QSystem(3) >>> qs.single_gate(H, 0) >>> qs.double_gate(CNOT, 0, 2) >>> qs (0.707106781187+0j)|000> + 0j|001> + 0j|010> + 0j|011> + 0j|100> + (0.707106781187+0j)|101> + 0j|110> + 0j|111> """ if i < 0 or i >= self.N - 1: raise ValueError("Invalid qubit: " + str(i)) # self.N - 1 transformations because T acts on 2 qubits transforms = [I] * (self.N - 1) transforms[i] = T # Switch the order of the qubits so i and j are adjacent # i.g. i = 0, j = 2 # ___ # 0 ________| |_______ # | T | # 1 ___ ___| |__ ___ # \/ |___| \/ # 2 ___/\__________/\___ if j: S = utils.swap(self.N, i + 1, j) self._state = S.dot(self._state) e = None try: self.transform(transforms) except ValueError as v: e = v # Switch back if j: S = utils.swap(self.N, i + 1, j) self._state = S.dot(self._state) if e: # make sure the system is switched back if there is an error raise e
def process_hops(): maximum = 0 n_traces = 0 for line in utils.swap('hops.txt', True): hstr = line.replace('\n', '').split(':')[1] if hstr != '?': hops = int(line.replace('\n', '').split(':')[1]) if hops > maximum: maximum = hops n_traces += 1 return maximum, n_traces
def partition(a, start, end): pivot = start left = start + 1 right = end done = False while not done: while left <= right and a[left] <= a[pivot]: left += 1 while left <= right and a[right] >= a[pivot]: right -= 1 if right < left: done = True else: swap(a, left, right) swap(a, pivot, right) return right
def parse_scan(filename): scan = {} ports = [] for line in utils.swap(filename, False): try: scan['ip'] = line.split(' scan report for ')[1].split(' ')[0] except IndexError: pass try: # Including Filtered as well if ('open' or 'filtered') in line.split(' '): ports.append(line.split(' open ')[1].replace(' ', '')) except IndexError: pass scan['open'] = ports return scan
def permutation_function(current_solution, row_indices=numpy.arange(number_of_queens)): return swap(current_solution, sample(row_indices, 2)) # swap two random rows.