def test_opposite(self): A = [2, 1] ms.sort(A) self.assertEqual(A, [1, 2]) A = [5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5] ms.sort(A) self.assertEqual(A, [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5])
def test_HugeArray(self): A = np.random.randint(low=-1_000, high=1_000, size=1_000_000).tolist() B = np.copy(A).tolist() startA = time.time() A = algorithm.sort(A) endA = time.time() startB = time.time() B = baseline.sort(B) endB = time.time() self.assertSequenceEqual(A, B) d = (endA - startA) / (endB - startB) self.assertGreater(d, .5) self.assertLess(d, 5)
def test_sort_no_change(self): A = [1, 2] ms.sort(A) self.assertEqual(A, [1, 2]) A = [1, 2, 3] ms.sort(A) self.assertEqual(A, [1, 2, 3]) A = [1, 2, 3, 4, 5] ms.sort(A) self.assertEqual(A, [1, 2, 3, 4, 5]) A = [1, 2, 3, 4, 5, 6, 7, 8] ms.sort(A) self.assertEqual(A, [1, 2, 3, 4, 5, 6, 7, 8])
def find_segments(points, length): """ Finds and returns a list of line segments that connect at least length collinear points TODO: Implement sliding window technique rather than for loop for further performance gain """ segments = [] # Loop through all points for i in range(len(points) - 1): # Set origin to the current point collinears = [] origin = points[i] # Create a list of tuples (slope from origin, point) for all points slopes = [(origin.slope_to(point), point) for point in points] # Sort the tuples by slope from origin using Merge Sort mergesort.sort(slopes, 0, len(points) - 1, lambda a, b: a[0] < b[0]) # Loop through all points, apart from origin, in the sorted list of slopes for j in range(1, len(slopes) - 1): found = 0 k = 0 # Check the slopes at j and j + k, and increment number of collinears found if equal # Because the list of slopes is sorted, we can simply stop looping if the next slope # doesn't match the current slope, and go to the next point. while j + k < len(slopes) and slopes[j][0] == slopes[j + k][0]: found += 1 k += 1 # If we have found at least length - 1 collinears, we loop through them # and add each one to our list if found >= length - 1: collinears = [origin] for x in range(0, found): collinears.append(slopes[j + x][1]) # If we have found enough collinears, collinears won't be None and we append them to our found segments if collinears: segments.append(collinears) return segments
def test_z_breaking_1(self): A = [1, 3, 2] ms.sort(A) self.assertEqual(A, [1, 2, 3]) A = [0, 1, 3, 2, 4] ms.sort(A) self.assertEqual(A, list(range(5))) A = [0, 4, 1, 3, 2] ms.sort(A) self.assertEqual(A, list(range(5)))
def test_sort_len_small(self): A = [] ms.sort(A) self.assertEqual(A, []) A = [1] ms.sort(A) self.assertEqual(A, [1]) A = [2, 1] ms.sort(A) self.assertEqual(A, [1, 2])
def test_sort_random(self): for _ in range(100): A = list(range(5)) shuffle(A) ms.sort(A) self.assertEqual(A, list(range(5))) A = list(range(10)) shuffle(A) ms.sort(A) self.assertEqual(A, list(range(10))) A = list(range(20)) shuffle(A) ms.sort(A) self.assertEqual(A, list(range(20))) A = list(range(1000)) shuffle(A) ms.sort(A) self.assertEqual(A, list(range(1000)))
def test_sort5(self): testcase = [5,1,3,0] expected = [0,1,3,5] self.assertEqual(sort(testcase), expected)
import unittest import mergesort numbers = [3, 5, 2, 9, 10, 8, 1, 4, 6, 7] sorted = mergesort.sort([3, 5, 2, 9, 10, 8, 1, 4, 6, 7]) class IterativeSearchTests(unittest.TestCase): """Tests for the iterative.binary_search() function""" def test_1(self): """sorted list should have 1 at index 0""" self.assertEqual(1, sorted[0]) def test_2(self): """sorted list should have 2 at index 1""" self.assertEqual(2, sorted[1]) def test_3(self): """sorted list have 5 at index 4""" self.assertEqual(5, sorted[4]) def test_4(self): """sorted list have 10 at index 9""" self.assertEqual(10, sorted[9]) if __name__ == '__main__': unittest.main()
import mergesort li = mergesort.sort(mergesort.li) def binsearch(l,i): n = len(l) if n == 1: return i == l[0] elif i < l[n/2]: return binsearch(l[:n/2],i) else: return binsearch(l[n/2:],i) print binsearch(li,91) print binsearch(li,82)
def test_merge(self): retlist = mergesort.sort(self.unsorted) self.assertEqual(retlist, self.expected)
def test_sort(self): unsorted = [1, 9, 4, 3, 8, 7, 2, 5, 0, 6] mergesorted = mergesort.sort(unsorted) self.assertEqual(mergesorted, sorted(unsorted))
heapsort.sort(list) print(list) list = qsortlist qsort.sort(list) print(list) list = simpleselectsortlist simpleselectsort.sort(list) print(list) bubblesort.sort(bubblesortlist) print(bubblesortlist) mergesort.sort(mergesortlist) print(mergesortlist) list = [] for i in range(1, 1000 * 10): list.append(i) random_list(list) print(list[0:29]) list2 = list.copy() list3 = list.copy() list4 = list.copy() list5 = list.copy() list6 = list.copy()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((HOST, PORT)) # Receives arraystring in chunks arraystring = '' print('Receiving data...') while 1: data = s.recv(4096).decode() # Receives data in chunks # print data arraystring += data # Adds data to array string if ']' in data: # When end of data is received break array = json.loads(arraystring) print('Data received, sorting array... ') # Sorts the array which it is allocated array = sort(array) print('Array sorted, sending data...') # Converts array into string to be sent back to server arraystring = json.dumps(array).encode('utf-8') s.sendall(arraystring) # Sends array string print('Data sent.') s.close()
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 = [sort.delay(seq) for seq in subseqs] # Merge all the individual sorted sub-lists into our final result. m = gevent.spawn(merger, partials) gevent.joinall([ m, ]) result = m.value 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. try: assert result == truth except: print(result) raise assert result == sorted(sequence)
def test_sort3(self): testcase = [5,1] expected = [1,5] self.assertEqual(sort(testcase), expected)
def test_sort2(self): testcase = [3,2] expected = [2,3] self.assertEqual(sort(testcase), expected)
def test_mergesort6(self): testcase = [3,2,1] expected = [1,2,3] self.assertEqual(sort(testcase), expected)
def test_mergesort1(self): testcase = [1,3,8,2,9,2,5,6] expected = [1,2,2,3,5,6,8,9] self.assertEqual(sort(testcase), expected)
def do_mergesort(strings): return mergesort.sort(strings)
def test_sort1(self): testcase = [3] expected = [3] self.assertEqual(sort(testcase), expected)