def test_quicksort():
A = np.array([3, 5, 4, 2, 6, 7, 1, 8])
assert np.array_equal(np.array(algs.quicksort(A)),
np.array([1, 2, 3, 4, 5, 6, 7, 8]))
#Empty array
empty = np.array([])
assert np.array_equal(np.array(algs.quicksort(empty)), np.array([]))
#Duplication array
duplication = np.array([4, 4, 5, 5, 7, 7, 1, 1])
assert np.array_equal(np.array(algs.quicksort(duplication)),
np.array([1, 1, 4, 4, 5, 5, 7, 7]))
#list with odd number of elements
odd = np.array([1, 3, 2, 4, 9])
assert np.array_equal(np.array(algs.quicksort(odd)),
np.array([1, 2, 3, 4, 9]))
#list with characters
a = np.array(['apple', 'banana', 'zebra', 'red'])
assert np.array_equal(np.array(algs.quicksort(a)),
np.array(['apple', 'banana', 'red', 'zebra']))
def test_quicksort():
w, x, y, z = np.array([1, 2, 4, 0, 1]), np.array([]), np.array(
[0]), np.array([2, 1, 0, -1, -2])
assert np.array_equal(algs.quicksort(w, 0, len(w) - 1, 0, 0)[0], sorted(w))
assert np.array_equal(algs.quicksort(x, 0, len(x) - 1, 0, 0)[0], sorted(x))
assert np.array_equal(algs.quicksort(y, 0, len(y) - 1, 0, 0)[0], sorted(y))
assert np.array_equal(algs.quicksort(z, 0, len(z) - 1, 0, 0)[0], sorted(z))
def test_quicksort():
# test some known list
x = [1,2,4,0,1]
assert np.array_equal(algs.quicksort(x), np.array([0, 1, 1, 2, 4]))
# check on zero- and one-length input
x = []
assert np.array_equal(algs.quicksort(x), x)
x = [1]
assert np.array_equal(algs.quicksort(x), x)
# check on even- and odd-length input
x = np.random.rand(10)
assert np.array_equal(algs.quicksort(x), sorted(x))
x = np.random.rand(9)
assert np.array_equal(algs.quicksort(x), sorted(x))
# check on repeats
x = np.random.randint(0, 3, 10)
assert np.array_equal(algs.quicksort(x), sorted(x))
x = [1] * 10
assert np.array_equal(algs.quicksort(x), x)
# check on only strings. sort by ascii order, as in canonical sort.
x = ["a", "B", "A", "b"]
assert np.array_equal(algs.quicksort(x), sorted(x))
# check that mixed strings throws a TypeError.
try:
x = ["1", 1]
algs.quicksort(x)
except TypeError:
pass
else:
assert False
def test_quicksort():
x = []
sorted, assign, cond = algs.quicksort(x, 0, len(x) - 1, 0, 0)
assert sorted == []
x = [1]
sorted, assign, cond = algs.quicksort(x, 0, len(x) - 1, 0, 0)
assert sorted == [1]
x = [2, 5, 1, 0, 2]
sorted, assign, cond = algs.quicksort(x, 0, len(x) - 1, 0, 0)
assert sorted == [0, 1, 2, 2, 5]
def test_quicksort():
x = [9, 8, 7, 6, 5, 4, 3, 2, 1] #regular list
x1 = [] #empty list
x2 = ["b", "c", "a", "d", "z", "a", "c", "h"] #will it sort characters?
x3 = [5, 7, 1, 5, 0, 2, 5, 7, 5, 5, 5,
8657] #how does it handle duplicates?
# for now, just attempt to call the quicksort function, should
# actually check output
assert algs.quicksort(x) == [1, 2, 3, 4, 5, 6, 7, 8, 9]
assert algs.quicksort(x1) == []
assert algs.quicksort(x2) == ['a', 'a', 'b', 'c', 'c', 'd', 'h', 'z']
assert algs.quicksort(x3) == [0, 1, 2, 5, 5, 5, 5, 5, 5, 7, 7, 8657]
def test_quicksort():
A = [1, 2, 4, 0, 1] #odd length
B = [] #empty vector
C = [2] #single element vector
D = [23, 23, 42, 1, 32, 2] # Duplicated elements
E = [1, 2, 4, 0] #even length
# for now, just attempt to call the quicksort function, should
# actually check output
assert algs.quicksort(A, 0, len(A) - 1, 0, 0)[0] == sorted(A)
assert algs.quicksort(B, 0, len(B) - 1, 0, 0)[0] == sorted(B)
assert algs.quicksort(C, 0, len(C) - 1, 0, 0)[0] == sorted(C)
assert algs.quicksort(D, 0, len(D) - 1, 0, 0)[0] == sorted(D)
assert algs.quicksort(E, 0, len(E) - 1, 0, 0)[0] == sorted(E)
def test_quicksort():
# Negatives, even
(sortedL, con, asg) = algs.quicksort(np.array([-2, 2, -51, 0]))
assert (np.array_equal(sortedL, np.array([-51, -2, 0, 2])))
# Odd
(sortedL, con, asg) = algs.quicksort(np.array([-2, 2, -51]))
assert (np.array_equal(sortedL, np.array([-51, -2, 2])))
# Duplicates
(sortedL, con, asg) = algs.quicksort(np.array([1, 1, 1]))
assert (np.array_equal(sortedL, np.array([1, 1, 1])))
# Empty
(sortedL, con, asg) = algs.quicksort(np.array([]))
assert (np.array_equal(sortedL, np.array([])))
# Characters
(sortedL, con, asg) = algs.quicksort(np.array(['a', 'd', 'b', 'c', 'a']))
assert (np.array_equal(sortedL, np.array(['a', 'a', 'b', 'c', 'd'])))
# Sorted
(sortedL, con, asg) = algs.quicksort(np.array([1, 2, 3]))
assert (np.array_equal(sortedL, np.array([1, 2, 3])))
# Reverse Sorted
(sortedL, con, asg) = algs.quicksort(np.array([3, 2, 1]))
assert (np.array_equal(sortedL, np.array([1, 2, 3])))
def test_quicksort():
TestOdd = np.array([1, 2, 4, 0, 1])
Test_Empty = np.array([])
Test_Ordered = np.array([1, 2, 3, 4, 5, 6, 7, 8])
Test_Reversed = np.array([8, 7, 6, 5, 4, 3, 2, 1])
Test_Char = np.array(['cat', 'Dog', 'elephant', 'Snake', 'bird'])
# Empty
assert np.array_equal(algs.quicksort(Test_Empty), np.array([]))
# Odd
assert np.array_equal(algs.quicksort(TestOdd), np.array([0, 1, 1, 2, 4]))
# Ordered array
assert np.array_equal(algs.quicksort(Test_Ordered),
np.array([1, 2, 3, 4, 5, 6, 7, 8]))
# Reversed array
assert np.array_equal(algs.quicksort(Test_Reversed),
np.array([1, 2, 3, 4, 5, 6, 7, 8]))
# Character
assert np.array_equal(
algs.quicksort(Test_Char),
np.array(['Dog', 'Snake', 'bird', 'cat', 'elephant']))
# Run function on range of length
X = np.arange(100, 1100, 100)
for i in X:
Array = np.random.rand(i)
algs.quicksort(Array)[0]
def test_quicksort():
# test odd length
x = np.array([1,2,4,0,3])
assert np.array_equal(algs.quicksort(x)['sorted'],np.array([0,1,2,3,4]))
# test even length
x = np.array([1,2,4,0])
assert np.array_equal(algs.quicksort(x)['sorted'], np.array([0,1,2,4]))
# test empty vector
x = np.array([])
assert np.array_equal(algs.quicksort(x)['sorted'],np.array([]))
# test single element vector
x = np.array([7])
assert np.array_equal(algs.quicksort(x)['sorted'],np.array([7]))
# test duplicated elements
x = np.array([1,1,1,1])
#assert np.array_equal(algs.quicksort(x)['sorted'],np.array([1,1,1,1]))
# test characters
x = np.array(['b','d','a','c'])
assert np.array_equal(algs.quicksort(x)['sorted'],np.array(['a','b','c','d']))
def test_bubblesort():
# Actually test bubblesort here. It might be useful to think about
# some edge cases for your code, where it might fail. Some things to
# think about: (1) does your code handle 0-element arrays without
# failing, (2) does your code handle characters?
l = num_arrays()
for x in l:
algs.bubblesort(x)
assert all(x[i] <= x[i + 1] for i in range(0, len(x) - 1))
m = alph_arrays()
algs.bubblesort(m)
assert all(m[i] <= m[i + 1] for i in range(0, len(m) - 1))
b = bad_arrays()
with pytest.raises(ValueError):
for i in b:
algs.quicksort(i)
def test_quicksort():
print('\n############Quicksort############')
# # multi test for inputs
x = [np.array([]),
np.array([2]),
np.array(['a']),
np.array([2,2,2,2]),
np.array([2,2,'a',2]),
np.array([2,2,6,4,5]),
np.array([2.4,2.1,6.7,4.7,5.0,10.1])]
# # # single large test
# x = [np.random.randint(0,10000,10000)]
# multi large test
# x = [np.random.rand(100,i) for i in [(i + 1) * 100 for i in list(range(10))]]
# multi smallish test
# x = [np.random.rand(i) for i in [(i + 1) * 10 for i in list(range(50))]]
#test
accounts = []
for i in x:
if i.ndim == 1:
ans = algs.quicksort(i)
accounts.append((len(i),ans))
elif i.ndim == 2:
for j in i:
ans = algs.quicksort(j)
accounts.append((len(j),ans))
else:
None
# speed testing
# for i in [(i + 1) * 100 for i in list(range(10))]:
# a = np.random.rand(100,i)
# algs.bubblesort(a)
return accounts
def test_quicksort():
x = np.array([1,2,4,0,1])
empty = []
single = [11]
dup = [3, 12, 7, 7, -6, 9]
odd = np.random.rand(11)
even = np.random.rand(12)
# for now, just attempt to call the quicksort function, should
# actually check output
#algs.quicksort(x)
# testing the quicksort is sorting array x correctly
assert np.array_equal(algs.quicksort(x), [0,1,1,2,4])
# testing additional edge cases; empty, single element, duplicated
# element, odd and even length vectors
assert np.array_equal(algs.quicksort(x), [0,1,1,2,4])
assert np.array_equal(algs.quicksort(empty), [])
assert np.array_equal(algs.quicksort(single), [11])
assert np.array_equal(algs.quicksort(dup), [-6, 3, 7, 7, 9, 12])
algs.quicksort(odd)
assert odd[0] < odd[10]
algs.quicksort(even)
assert even[0] < even[11]
def test_quicksort():
l = num_arrays()
for x in l:
algs.quicksort(x)
print(x)
assert all(x[i] <= x[i + 1] for i in range(0, len(x) - 1))
m = alph_arrays()
with pytest.raises(ValueError):
algs.quicksort(m)
b = bad_arrays()
with pytest.raises(ValueError):
for i in b:
algs.quicksort(i)
def test_quicksort():
x = np.array([1, 2, 4, 0, 1])
s, conds, assigns = algs.quicksort(x)
assert np.array_equal(s, np.array([0, 1, 1, 2, 4]))
### Test negative elements
xneg = np.array([-1, 0, 5, 2, -10])
s, conds, assigns = algs.quicksort(xneg)
assert np.array_equal(s, np.array([-10, -1, 0, 2, 5]))
### test duplicated elements
xdup = np.array([1, 1, 0, 5, 10])
s, conds, assigns = algs.quicksort(xdup)
assert np.array_equal(s, np.array([0, 1, 1, 5, 10]))
### test even length vectors
xeven = np.array([0, 1, 5, 0, 2, -1])
s, conds, assigns = algs.quicksort(xeven)
assert np.array_equal(s, np.array([-1, 0, 0, 1, 2, 5]))
### Test empty length vector
xempty = np.array([])
s, conds, assigns = algs.quicksort(xempty)
assert np.array_equal(s, np.array([]))
### test character arrays
xchar = np.array(["c", "a", "d", "b", "a"])
s, conds, assigns = algs.quicksort(xchar)
assert np.array_equal(s, np.array(["a", "a", "b", "c", "d"]))
### Test word arrays
xwords = np.array(["apple", "aardvark", "banana", "accentuate", "down"])
s, conds, assigns = algs.quicksort(xwords)
assert np.array_equal(
s, np.array(["aardvark", "accentuate", "apple", "banana", "down"]))
def test_quicksort():
#Empty vector
x = []
#check
if algs.only_integers(x) == x:
assert np.array_equal(algs.quicksort(x), sorted(x))
else:
print(algs.only_integers(x))
#One entry
x = [1]
#check
if algs.only_integers(x) == x:
assert np.array_equal(algs.quicksort(x), sorted(x))
else:
print(algs.only_integers(x))
#Character entry
x = ["a", 1, 2]
#check
if algs.only_integers(x) == x:
assert np.array_equal(algs.quicksort(x), sorted(x))
else:
print(algs.only_integers(x))
#Non-integer entry
x = [0.5, 1, 2]
#check
if algs.only_integers(x) == x:
assert np.array_equal(algs.quicksort(x), sorted(x))
else:
print(algs.only_integers(x))
#Repeating entry (case 1)
x = [6, 1, 3, 6]
#check
if algs.only_integers(x) == x:
assert np.array_equal(algs.quicksort(x), sorted(x))
else:
print(algs.only_integers(x))
#Repeating entry (case 2)
x = [8, 9, 8, 9]
#check
if algs.only_integers(x) == x:
assert np.array_equal(algs.quicksort(x), sorted(x))
else:
print(algs.only_integers(x))
#Odd length entry
x = [7, 4, 5]
#check
if algs.only_integers(x) == x:
assert np.array_equal(algs.quicksort(x), sorted(x))
else:
print(algs.only_integers(x))
#Even length entry
x = [7, 4, 5, 1]
#check
if algs.only_integers(x) == x:
assert np.array_equal(algs.quicksort(x), sorted(x))
else:
print(algs.only_integers(x))
def test_quicksort():
# generate random vector of length 100
x = np.random.rand(100)
algs.quicksort(x, 0, int(len(x) - 1))
def test_quicksort():
# for now, just attempt to call the quicksort function, should
# actually check output
algs.quicksort(odd)
algs.quicksort(even)
algs.quicksort(test2)
algs.quicksort(blank)
algs.quicksort(single)
algs.quicksort(duplicate)
algs.quicksort(duplicate2)
def test_quicksort():
x = np.array([1, 2, 4, 0, 1])
# for now, just attempt to call the quicksort function, should
# actually check output
algs.quicksort(x)