def test_sort(self): lists = [] for l in self.lists: sort(l) lists.append(self.is_sorted(l)) print("All {0} lists are sorted: {1}".format(self.nSorts, all(lists))) self.assertTrue(all(lists))
def sort(a): if(len(a) < 7): return insert.sort(a) mid = len(a)/2 left = merge.sort(a[:mid]) right = merge.sort(a[mid:]) return merge.merge(left,right)
def test_sort(): assert sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5] assert sort([1, 5, 2, 4, 3]) == [1, 2, 3, 4, 5] assert sort([4, 3, 2, 1]) == [1, 2, 3, 4] assert sort([3, 3, 3]) == [3, 3, 3] assert sort([2, 1]) == [1, 2] assert sort([1]) == [1] assert sort([]) == []
def test_sort(self): tests = ( ( # kinda randomized numbers, as well as an odd number of elements [4, 1, 6, 5, 7, 8, 13, 12, 10, 11, 2, 3, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]), ( # completely backwards list [10, 9, 8, 7, 6, 5, 4, 3, 2, 1], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), ( # repeated elements [5, 5, 5, 5, 5], [5, 5, 5, 5, 5]), ( # just a single element [1], [1]), ( # no elements [], [])) for notSorted, nowSorted in tests: self.assertEqual(sort(notSorted), nowSorted)
def test_sorting(): '''Test if Array is being sorted''' array = [2, 5, 1] merge.sort(array) assert all(array[x] <= array[x + 1] for x in range(len(array) - 1))
x = setupAsc(i) elif j == 4: x = setupA(i) #print(x) # tablica przed posortowaniem before = round(time.time_ns() / (10**9), 10) if s == 0: x = bubble.sort(x) elif s == 1: x = insertion.sort(x) elif s == 2: x = selection.sort(x) elif s == 3: x = counting.sort(x, i, maxNumber) elif s == 4: x = heap.sort(x) elif s == 5: x = quickRight.sort(x, 0, i - 1) elif s == 6: x = quickRandom.sort(x, 0, i - 1) elif s == 7: x = shell.sort(x) elif s == 8: x = merge.sort(x, 0, len(x) - 1) after = round(time.time_ns() / (10**9), 10) #print(x) # tablica po sortowaniu tmpTime += ';' + str(after - before) print(after - before) f.write(tmpTime + "\n") print(tmpTime) f.write('\n') f.close()
def choose_order(): while True: try: order = input('[0] ascend, [1] descend -> ') if order == 0 or order == 1: return order else: print 'Invalid input!!' except ValueError: print 'ValueError! Please try again!' def sort_order(order='ascend'): if order == 'ascend': return lambda x, y: x > y elif order == 'descend': return lambda x, y: x < y if __name__ == '__main__': A = input_data() if choose_order() == 0: order = sort_order('ascend') else: order = sort_order('descend') print 'Selection: ' + str(selection.sort(copy.deepcopy(A), order)) print 'Insertion: ' + str(insertion.sort(copy.deepcopy(A), order)) print ' Shell: ' + str(shell.sort(copy.deepcopy(A), order)) print ' Merge: ' + str(merge.sort(copy.deepcopy(A), 0, len(A)-1, order)) print ' Bogo: ' + str(bogo.sort(copy.deepcopy(A), order))
from lecture_02_27.elapsedtime import ElapsedTime import random num = 100000 with ElapsedTime("built in"): array = [random.randint(0, 1000) for _ in range(num)] array.sort() with ElapsedTime("merge"): import merge array = [random.randint(0, 1000) for _ in range(num)] merge.sort(array)
def test_single_entry(): '''Handling 1 number''' array = [2] merge.sort(array) assert all(array[x] <= array[x + 1] for x in range(len(array) - 1))
#bubble calls bubble_elapsed_time = time.time() - bubble_start data = [random.randint(0, size) for i in range(size)] insertion_start = time.time() InsertionSort.serialInsertionSort(data) insertion_elapsed_time = time.time() - insertion_start data = [random.randint(0, size) for i in range(size)] quick_start = time.time() quickSort.quickSort(data, 0, len(data) - 1) quick_elapsed_time = time.time() - quick_start data = [random.randint(0, size) for i in range(size)] merge_start = time.time() merge.sort(data, 0, size - 1) merge_elapsed_time = time.time() - merge_start selection_start = time.time() #selection calls selection_elapsed_time = time.time() - selection_start print("Time to for multiprocessed bubble sort: ", mp_bubble_elapsed_time) print("Time to for multiprocessed insertion sort: ", mp_insertion_elapsed_time) print("Time to for multiprocessed quick sort: ", mp_quick_elapsed_time) print("Time to for multiprocessed merge sort: ", mp_merge_elapsed_time) print("Time to for multiprocessed selection sort: ", mp_selection_elapsed_time) print("Time to for bubble sort: ", bubble_elapsed_time) print("Time to for insertion sort: ", insertion_elapsed_time)
def test_sorted(self, first_value, second_value): self.assertEqual(sort(first_value), second_value)
def test_reversed(self): self.input.reverse() actual = merge.sort(self.input) self.assertEqual(list(sorted(actual)), actual)
def test_oneoff(self): self.input[0], self.input[1] = self.input[1], self.input[0] actual = merge.sort(self.input) self.assertEqual(list(sorted(actual)), actual)
def test_sorted(self): actual = merge.sort(self.input) self.assertEqual(list(sorted(actual)), actual)
def test_random(self): random.shuffle(self.input) actual = merge.sort(self.input) self.assertEqual(list(sorted(actual)), actual)
def test_negative(): '''Handling of negative numbers''' array = [2, -5, 1] merge.sort(array) assert all(array[x] <= array[x + 1] for x in range(len(array) - 1))
def test_double_entry(): '''Handling of repeating numbers''' array = [2, 5, 2] merge.sort(array) assert all(array[x] <= array[x + 1] for x in range(len(array) - 1))
order = input('[0] ascend, [1] descend -> ') if order == 0 or order == 1: return order else: print 'Invalid input!!' except ValueError: print 'ValueError! Please try again!' def sort_order(order='ascend'): if order == 'ascend': return lambda x, y: x > y elif order == 'descend': return lambda x, y: x < y if __name__ == '__main__': A = input_data() if choose_order() == 0: order = sort_order('ascend') else: order = sort_order('descend') print 'Selection: ' + str(selection.sort(copy.deepcopy(A), order)) print 'Insertion: ' + str(insertion.sort(copy.deepcopy(A), order)) print ' Shell: ' + str(shell.sort(copy.deepcopy(A), order)) print ' Merge: ' + str( merge.sort(copy.deepcopy(A), 0, len(A) - 1, order)) print ' Bogo: ' + str(bogo.sort(copy.deepcopy(A), order))
def test_doubles(): '''Handling of double values''' array = [3.1, 2.9, 2.4] merge.sort(array) assert all(array[x] <= array[x + 1] for x in range(len(array) - 1))
def test_sort(self): list = generate_list(1000) x = merge.sort(list) self.assertTrue(x == sorted_list(list))
print(next(g)) >> module is importable code >> if __name__ != '__main__' then program is called form somewhere else as module LISTS >> Arrays vs List :: hetro and h**o :: fixed and dynamic >> list = [] for empty list >> seq operation are applicable lst[2,20,2] :: len(lst) :: lst1+lst2 :: lst1*10 :: x in lst1 :: for i in lst1 >> lst = list[range[1,100,2] >> lst.append(), del lst[1],lst.reverse(), >> lst1 = lst2 will make both list to point to same memory address >> to clone we should us lst1 = lst2[:] OR lst1=lst2.copy() >> List Methods :: index(x), append(x), insert(i,x), list.copy(), extend(lst1), count(x), remove(x), pop(x), sort(reverse = True),reverse(), clear(), min(), max() >> st1 = set(list) .. and set1.intersection(set2) >> Nested list can be used as arrays or matrices >> List comprehension ******* sqr = [x**2 for x in range(1,11) if x%2 == 0] lst = [i+j for i in x for j in y] lst = [w[0] for w in words] lst = [i for i in num1 if i not in num2] sorted(my_list) will use TimSort. Timsort is a hybrid sorting algorithm, derived from merge sort and insertion sort, designed to perform well on many kinds of real-world data comparator >> data = sorted(data, cmp=Students.comparator) where data is list of type class Student TUPLES >> tuples are similar to list except they are immutable
def m_sort(a): before = time.time() merge.sort(a) after = time.time() return (after - before)