def test_singles(self): """ Tests the case where both lists have a single element.""" self.assertEqual(merge([1], [1]), [1, 1]) self.assertEqual(merge([1], [2]), [1, 2]) self.assertEqual(merge([2], [1]), [1, 2]) self.assertEqual(merge([-100], [1]), [-100, 1]) self.assertEqual(merge([100], [1]), [1, 100])
def timsort(arr): runs, sorted_runs = [], [] length = len(arr) if length == 0: return arr new_run = [arr[0]] for i in range(1, length): if i == length - 1: new_run.append(arr[i]) runs.append(new_run) break if arr[i] < arr[i - 1]: if new_run is None: runs.append(new_run) new_run = [] else: runs.append([arr[i]]) new_run.append(arr[i]) else: new_run.append(arr[i]) for collection in runs: sorted_runs.append(insertion(collection)) sorted_array = [] for run in sorted_runs: sorted_array = merge(sorted_array, run) return sorted_array
def test_both_multiple(self): """ Tests the case where both lists have multiple elements.""" self.assertEqual(merge([1, 2], [3, 4]), [1, 2, 3, 4]) self.assertEqual(merge([1, 4], [2, 3]), [1, 2, 3, 4]) self.assertEqual(merge([-100, 1], [-1, 2]), [-100, -1, 1, 2]) self.assertEqual(merge([1, 3, 5], [2, 4]), [1, 2, 3, 4, 5]) self.assertEqual(merge([1, 2, 3], [1, 2, 3]), [1, 1, 2, 2, 3, 3]) self.assertEqual(merge([1, 2, 3], [4, 5, 6]), [1, 2, 3, 4, 5, 6]) self.assertEqual(merge([1, 3, 5], [2, 4, 6]), [1, 2, 3, 4, 5, 6])
def inversions(arr): """Count the number of inversions in an array (i.e. the number of permutations to get a sorted array). Algorithm: - split array in two - call function for each half - call merge function to count the inversions between the two halves - the number of inversions in the array is number of inversions from each half plus the number of inversions between them Returns: (i, L) - number of inversions and sorted list. """ n = len(arr) if n == 1: return (0, arr) ra, A = inversions(arr[: n // 2]) rb, B = inversions(arr[n // 2 :]) r, L = mergesort.merge(A, B, count=True) return (ra + rb + r, L)
def merger(partials): merged = [] failed = [] terminated = [] while partials or terminated: terminated += [p for p in partials if p.ready()] partials = purge(terminated, partials) failed += [p for p in partials if p.failed()] if failed: raise Exception('%d tasks failed' % (len(failed))) partials = purge(failed, partials) if len(terminated) >= 1: sublist = terminated.pop(0).result if not merged: merged = sublist else: merged = merge(merged, sublist) gevent.sleep(0) return merged
def merge_pl(posting_lists): sorted_pls = [] for pl in posting_lists: pl = ms.mergesort(pl) sorted_pls.append(pl) while len(sorted_pls) > 1: pl1 = sorted_pls.pop(0) pl2 = sorted_pls.pop(0) pl_combined = ms.merge(pl1, pl2) sorted_pls.append(pl_combined) posting_list = [] last_entry = [None] while len(sorted_pls[0]) > 0: new_entry = sorted_pls[0].pop(0) if last_entry[0] != new_entry[0]: if last_entry != [None]: posting_list.append(last_entry) last_entry = new_entry else: new_docs = last_entry[1]+new_entry[1] last_entry = [last_entry[0], new_docs] if last_entry != [None]: posting_list.append(last_entry) return posting_list
def test_merge_unbalanced(self): self.assertEqual(merge([1, 3, 5], [4]), [1, 3, 4, 5])
def test_merge_balanced(self): self.assertEqual(merge([1, 3, 5], [2, 4, 6]), [1, 2, 3, 4, 5, 6])
def test_merge_trivial_1(self): self.assertEqual(merge([2], [1]), [1, 2])
def test_merge(self): self.assertEqual(merge([6], [5]), [5,6]) self.assertEqual(merge([7,8],[2,4]), [2,4,7,8]) self.assertEqual(merge([1,3,5,6], [2,4,7,8]), [1,2,3,4,5,6,7,8]) self.assertEqual(merge([1,2],[3]),[1,2,3]) self.assertEqual(merge([6,7,8,9], [1,2,3,4,5]), [1,2,3,4,5,6,7,8,9])
def cmergesort(nums): return m.merge(nums)
def test_both_lists_empty(self): """ Tests the case where both lists are empty.""" self.assertEqual(merge([], []), [])
def test_one_list_empty(self): """ Tests the case where one of the lists is empty.""" self.assertEqual(merge([], [1]), [1]) self.assertEqual(merge([2], []), [2])
t0 = time.time() # Split the sequence in a number of chunks and process those # independently. n = 4 l = len(sequence) // n subseqs = [sequence[i * l:(i + 1) * l] for i in range(n - 1)] subseqs.append(sequence[(n - 1) * l:]) # Ask the Celery workers to sort each sub-sequence. # Use a group to run the individual independent tasks as a unit of work. partials = group(sort.s(seq) for seq in subseqs)().get() # Merge all the individual sorted sub-lists into our final result. result = partials[0] for partial in partials[1:]: result = merge(result, partial) dt = time.time() - t0 print('Distributed mergesort took %.02fs' % (dt)) # Do the same thing locally and compare the times. t0 = time.time() truth = sort(sequence) dt = time.time() - t0 print('Local mergesort took %.02fs' % (dt)) # Final sanity checks. assert result == truth assert result == sorted(sequence)
def test_merge_trivial_1(self): self.assertEqual(merge([], []), [])
import mergesort import BinarySearchIndex A = mergesort.inp() A = mergesort.merge(A) # Sorting the set find = int(input("Enter the number to be searched :")) res = BinarySearchIndex.binary_search(A, find, 0) print("element found at index : ") print(res)
def test_merge(self): left = [1, 2, 3, 9] right = [4, 5, 6, 7, 8] self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8, 9], mergesort.merge(left, right))
def test1_merge(self): """test merge""" self.assertEqual(mergesort.merge([2], [1]), [1,2]); self.assertEqual(mergesort.merge([2,4], [1,2]), [1,2,2,4]); self.assertEqual(mergesort.merge([3], [1,2,3,4,5]), [1,2,3,3,4,5]); self.assertEqual(mergesort.merge([1,2,3,4,5], [3]), [1,2,3,3,4,5]);
if ok is True and toprint: print(str(c) + " is " + str(status.split("|")[0])) if status == "ready" and conta < len( subs ): # checks if the slave is ready for a task and if there is tasks avaliable c.send(bytes(",".join([str(i) for i in subs[conta]]), "utf-8")) # sends the next task conta += 1 ok = True elif str( status.split("|")[0] ) == "done": # if the slave is done, it means it finished a task and is returning the result data #gathers the data and puts into the ordered dict resultsorted = [int(i) for i in status.split("|")[1].split(",")] if toprint: print("Received a sorted list") thelis = mergesort.merge(thelis, resultsorted) ok = True else: c.send( bytes("wait", "utf-8") ) #if the status is ready but there is no task, it orders the slave to wait and closes the connection, proceeding to process the next slave and so on ok = False except Exception as e: print("An error ocurred") print(str(e)) print("----------") print("The ordering is finished") if toprintresult: print(thelis) print("---------") saida = input("Type enter to exit")
import time #from heapq import merge #from merge import merge from mergesort import merge import random def randomlist(length): L = [] for _ in range(length): L.append(random.randrange(1000000)) return L lastTime = 0 for i in range(1,10): length = 1 << i x = randomlist(length) y = randomlist(length) startTime = time.time() z = merge(x,y) timeUsed = time.time() - startTime print "Length", length, "time", timeUsed if lastTime > 0: print "Ratio", timeUsed / lastTime lastTime = timeUsed
from mergesort import mergesort, merge left = [1, 3, 5, 7, 9] right = [2, 4, 6, 7, 8, 9] print(left, right) res = merge(left, right) print(res) print("=" * 40) arr = [5, 3, 8, 4, 2, 6, 1, 7, 9] print(arr) print(mergesort(arr))
import mergesort A = [] num = int(input("Enter the number of elements in sequence")) for y in range(0, num): A.append(int(input())) A = mergesort.merge(A) print(A) def binary_search(arr, x): mid = (0 + len(arr)) // 2 if arr[mid] == x: return True elif mid == 0: return False elif arr[mid] > x: return binary_search(arr[:mid], x) elif arr[mid] < x: return binary_search(arr[mid:], x) while True: try: find = int( input("Enter number to be searched : (or other key to exit)")) print(binary_search(A, find))
def test_merge(self): res = self.a[:] + self.b[:] res.sort() self.assertEqual(res, merge(self.a, self.b))