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)
def test_merge(self): retlist = mergesort.sort(self.unsorted) self.assertEqual(retlist, self.expected)
def do_mergesort(strings):
return mergesort.sort(strings)
