def is_unique(keys):
"""
Implement an algorithm to determine if a string has all unique characters.
What if you cannot use additional data structures?
"""
merge_sort(list(keys), 0, len(keys))
prev = keys[0]
for i in range(1, len(keys)):
if keys[i] == prev:
return False
prev = keys[i]
return True
def find_repeated_elements(arr):
"""
Find all numbers that repeat twice.
"""
arr_length = len(arr)
merge_sort(arr, 0, arr_length)
repeated_elements = set()
prev = arr[0]
for i in range(1, arr_length):
if arr[i] == prev:
repeated_elements.add(arr[i])
prev = arr[i]
return repeated_elements
def is_there_sum_of_two_elements(keys, v):
"""
Write a function that, given an array of n numbers and another number x,
determines whether or not there exist two elements in the array whose sum is
exactly x.
"""
keys_length = len(keys)
leftmost_index = 0
rightmost_index = keys_length - 1
merge_sort(keys, leftmost_index, rightmost_index)
while leftmost_index < rightmost_index:
if keys[leftmost_index] + keys[rightmost_index] == v:
return True
elif keys[leftmost_index] + keys[rightmost_index] < v:
leftmost_index += 1
else:
rightmost_index -= 1
return False
def sort():
global data
timer = set_sort_speed()
if menu.get() == 'bogo_sort':
bogo_sort(data, drawBars, timer)
elif menu.get() == 'bubble_sort':
bubble_sort(data, drawBars, timer)
elif menu.get() == 'insertion_sort':
insertion_sort(data, drawBars, timer)
elif menu.get() == 'quick_sort':
quick_sort(data, 0, len(data) - 1, drawBars, timer)
elif menu.get() == 'merge_sort':
merge_sort(data, 0, len(data) - 1, drawBars, timer)
def visualize_algorithm(self, name: str = 'insertion_sort'):
""" Visualizes a specific algorithm """
options = {
'insertion_sort': insertion_sort(self.data),
'bubble_sort': bubble_sort(self.data),
'selection_sort': selection_sort(self.data),
'quick_sort': quick_sort(self.data, 0,
len(self.data) - 1),
'merge_sort': merge_sort(self.data, 0, len(self.data))
}
algorithm = options[name]
plt.title(name)
self.ani = animation.FuncAnimation(self.fig,
func=self._update_animation,
frames=algorithm,
interval=1,
repeat=False)
plt.show()
def test_none(self):
self.assertEqual(merge_sort(None), None)
def test_sorted(self):
self.assertEqual(merge_sort([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
def test_many(self):
self.assertEqual(merge_sort([9, 4, 1, 7, 3, 0, 6, 8, 2, 5]),
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
def test_two(self):
self.assertEqual(merge_sort([2, 1]), [1, 2])
def test_one(self):
self.assertEqual(merge_sort([9]), [9])
def test_wrong_type(self):
self.assertEqual(merge_sort(238), 238)
def test_unordered():
assert merge_sort([1, 0, 2]) == [0, 1, 2]
def test_merge_sort(self, numbers):
merged_list = merge_sort(numbers)
sorted_list = sorted(numbers)
self.assertEqual(merged_list, sorted_list)
def test_merge_sort():
keys = [6, 7, 9, 12, 0, 1, 2]
expected_res = sorted(keys)
merge_sort(keys, 0, len(keys))
assert keys == expected_res
def test_merge_sort():
assert [merge.merge_sort(prob1[:]), merge.merge_sort(prob2[:])] == [solution, solution]
def test_singleton():
assert merge_sort([0]) == [0]
def test_empty():
assert merge_sort([]) == []
def test_unordered_longer():
assert merge_sort([100, -1, 1, 0, 2, 0.5, 0.01]) == [-1, 0, 0.01, 0.5, 1, 2, 100]
def test_ordered():
assert merge_sort([0, 1]) == [0, 1]
def test_reversed():
assert merge_sort([1, 0]) == [0, 1]
