def main():
"""Start timer, sort, stop timer. write result to file"""
#sizes = [10,50,100,500,1000,5000,10000,50000,100000,500000,1000000]
b_times = []
i_times = []
m_times = []
q_times = []
size = 50000
#for size in sizes:
for num in range(1,101):
l = getlist("../lists/size" + str(size) + "/list" + str(num))
start = time.time()
bubblesort(l)
b_times.append((size,time.time() - start))
start = time.time()
insertionsort(l)
i_times.append((size,time.time() - start))
start = time.time()
mergesort(l)
m_times.append((size,time.time() - start))
start = time.time()
quicksort(l)
q_times.append((size,time.time() - start))
csv = "n,bubble,insertion,merge,quick\n"
#for size in sizes:
for i in range(100):
csv += str(b_times[i][0]) + ',' + str(b_times[i][1]) + ','
csv += str(i_times[i][1]) + ',' + str(m_times[i][1]) + ','
csv += str(m_times[i][1]) + '\n'
f = open("size50000-python.csv", 'w')
f.write(csv)
f.close()
def test_quickSort(self):
#Test with random ints
songs = []
for i in range(50):
songs.append(Song("", "", "", randint(0, 5)))
quicksort(songs)
for s in range(0, len(songs) - 1):
self.assertTrue(songs[s].occ <= songs[s + 1].occ)
#Test with identical ints
songs2 = []
for i in range(50):
songs.append(Song("", "", "", 1))
quicksort(songs)
for s in range(0, len(songs2) - 1):
self.assertTrue(songs2[s].occ <= songs2[s + 1].occ)
def test_quickSort(self):
#Test with random ints
songs = []
for i in range(50):
songs.append(Song("","","",randint(0,5)))
quicksort(songs)
for s in range(0, len(songs)-1):
self.assertTrue(songs[s].occ <= songs[s+1].occ)
#Test with identical ints
songs2 = []
for i in range(50):
songs.append(Song("","","",1))
quicksort(songs)
for s in range(0, len(songs2)-1):
self.assertTrue(songs2[s].occ <= songs2[s+1].occ)
def quicksort(l): if len(l) <= 1: return l pivot = l[0].arg lesser = [] greater = [] for i in range(1, len(l)): x = l[i] if x.arg < pivot: lesser.append(x) else: greater.append(x) return quicksort(lesser) + [pivot] + quicksort(greater)
def common_items(list_x, list_y):
"""Returns a list containing all the items in x that are also in y.
The resulting list should be in order.
Clashes need only be listed once.
Returns an empty list if there are none.
>>> common_items([0,1,2,3],[0,0,2,4])
[0, 2]
>>> common_items([0,1,2,3],[1,2,3,4])
[1, 2, 3]
>>> common_items([0,1,2,3],[3,2,1,0])
[0, 1, 2, 3]
>>> common_items([0,1,2,3],[5,6,7,8])
[]
>>> common_items([],[5,6,7,8])
[]
>>> common_items([1,2,3,4],[])
[]
>>> common_items([],[])
[]
"""
common = []
pos1 = 0
pos2 = 0
x = len(list_x)
y = len(list_y)
a = quicksort(list_x, style='Mo3-pivot')
b = quicksort(list_y, style='Mo3-pivot')
count = 0
if x < 1 or y < 1:
return common
while pos1 < x and pos2 < y:
first = b[pos1]
second = a[pos2]
count += 1
if first == second:
common.append(second)
pos1 += 1
pos2 += 1
else:
count += 1
if first < second:
pos1 += 1
else:
pos2 += 1
return common, count
def main():
"""Try all of the size10 lists"""
for i in range(1,101):
l = getlist("../lists/size10/list" + str(i))
assert(sorted(l) == quicksort(l))
assert(sorted(l) == mergesort(l))
assert(sorted(l) == bubblesort(l))
assert(sorted(l) == insertionsort(l))
print("done")
def test_sort(self):
for i in range(50):
l = self.make_list()
l2 = l[:]
self.assertTrue(quicksort(l) == sorted(l2))
for i in range(50):
l = self.make_list()
l2 = l[:]
quicksort_inplace(l)
self.assertTrue(l == sorted(l2))
def save_time(i, list):
start = time.clock()
time_bubble[i] = bubblesort(list[0]) # Tempo do bubblesort
time_quick[i] = quicksort(list[1]) # Tempo do quicksort
time_insert[i] = insertionsort(list[2]) # Tempo do insertionsort
time_shell[i] = shellsort(list[3]) # Tempo do shellsort
time_select[i] = selectionsort(list[4]) # Tempo do selectionsort
time_heap[i] = heapsort(list[5]) # Tempo do heapsort
time_merge[i] = mergesort(list[6]) # Tempo do merge
end = time.clock()
actualtime = end - start
print "Tamanho de lista: {0} | Tempo para a execucao de todos algoritmos: {1}s".format(len(list[0]), actualtime)
return # forca a saida
def test_left_1000(self):
A = load1000()
q = quicksort(A, 0, 1000, 'left')
self.assertEqual(10297, q)
self.assertSequenceEqual(range(1, 1001), A)
def testQuicksorts(self):
aLists = [[], [5], [6, 7], [2, 4, 3]]
for aList in aLists:
quicksort(aList)
self.assertEquals(aList, sorted(aList[:]))
# Maxine Liu
# 10/22/2018
# COSC 1
# creates files cities_alpha.txt, cities_population.txt, and cities_latitude.txt.
from quicksort import *
from list_of_cities import *
# creates file cities_alpha.txt where city objects are ranked by instance variables self.name in the City class.
alphabetical = open("cities_alpha.txt", "w")
# sorting by city name alphabetically
City.__le__ = City.compare_name
quicksort(list_all_cities)
# deposit city objects in text with a new life for each city
for city in list_all_cities:
alphabetical.write(str(city) + "\n")
alphabetical.close()
# creates file cities_population.txt where city objects are ranked by instance variables self.pop in the City class.
population = open("cities_population.txt", "w")
# sorting by city population in decreasing order.
City.__le__ = City.compare_population
def sortarray(self):
self.array = quicksort(self.array)
def test_double_input(self):
data = rand_list(count=2)
quicksort(data)
self.assertLessEqual(data[0], data[1])
def test_zero_input(self):
data = []
quicksort(data)
self.assertEqual(data, [])
def test_sorted(self):
original = [1, 2, 1, 2, 2, 1, 4, 1, 2, 3]
correct = original[:]
quicksort(original)
self.assertListEqual(quicksort(original), sorted(correct))
def test_quicksort2(self):
testlist = [random.randrange(0, 10000) for _ in range(2001)]
self.assertEqual(quicksort(testlist), sorted(testlist))
from quicksort import *
def binsearch(arr, q):
low = 0
high = len(arr) - 1
while low <= high:
mid = (high + low) // 2
if arr[mid] > q:
high = mid - 1
elif arr[mid] < q:
low = mid + 1
else:
return mid
return -1
print(binsearch(quicksort(test, 0, (len(test) - 1)), 24))
def test_quicksort(self):
l = [2, 1, 6, 11, 2, 3, 2]
quicksort(l, 0, 6)
self.assertEqual(l, [1, 2, 2, 2, 3, 6, 11])
def test_quicksort(self):
testlist = [3, 4, 2, 1, 8, 7]
self.assertEqual(quicksort(testlist), sorted(testlist))
def test_all_same_input(self):
single_val = rand_list(count=1)[0]
data = [single_val]*100
quicksort(data)
for i in range(0, 100):
self.assertEqual(single_val, data[i])
def test_all_zero_input(self):
data = [0]*100
quicksort(data)
for i in range(0, 100):
self.assertEqual(data[i], 0)
def test_array_input(self):
data = rand_list()
quicksort(data)
for i in range(1, len(data)):
self.assertLessEqual(data[i-1], data[i])
def test_right_1000(self):
A = load1000()
q = quicksort(A, 0, 1000, 'right')
self.assertEqual(10184, q)
self.assertSequenceEqual(range(1, 1001), A)
from quicksort import * from mergesort import * test = [99,14,17,2,8,19,52,36,100] print "Test array: " + str(test) print "Mergesort: " + str(mergesort(test)) print "Quicksort: " + str(quicksort(test))
def test_median_1000(self):
A = load1000()
q = quicksort(A, 0, 1000, 'median')
self.assertEqual(8921, q)
self.assertSequenceEqual(range(1, 1001), A)
import numpy as np
import argparse
from quicksort import *
parser = argparse.ArgumentParser()
parser.add_argument("arq_vetor",
help="nome do arquivo contendo o vetor de teste")
args = parser.parse_args()
# Lê o arquivo contendo o vetor e passado na linha de comando como um
# vetor do Numpy.
vet = np.loadtxt(args.arq_vetor)
quicksort(vet)
def test_empty(self):
self.assertTrue(quicksort([]) == [])
self.assertTrue(quicksort([1]) == [1])
self.assertTrue(quicksort_inplace([]) == [])
self.assertTrue(quicksort_inplace([1]) == [1])
window.blit(sort_image, frame)
update_draw()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
quit()
if cursor(bubblesort_frame, bubblesort_btn, bubblesortConfig_btn):
bubblesort(speed, listlength)
setTitle() # Reset
setBoxes()
elif cursor(quicksort_frame, quicksort_btn, quicksortConfig_btn):
quicksort(speed, listlength)
setTitle() # Reset
setBoxes()
elif cursor(mergesort_frame, mergesort_btn, mergesortConfig_btn):
mergesort(speed, listlength)
setTitle() # Reset
setBoxes()
elif cursor(insertionsort_frame, insertionsort_btn,
insertionsortConfig_btn): # Algorithm not done
# insertionsort()
setTitle() # Reset
setBoxes()
'''
# Cursor in bubblesort
bubblesortChange = False
if bubblesort_frame[0]+sortingBoxes_size_w > mouse_pos[0] > bubblesort_frame[0] and bubblesort_frame[1]+sortingBoxes_size_h > mouse_pos[1] > bubblesort_frame[1]:
def test_random(self):
original = [1, 4, 2, 6, 7, 8, 3]
correct = original[:]
quicksort(original)
self.assertListEqual(quicksort(original), sorted(correct))
import time, random
from quicksort import *
from matplotlib import pyplot
list_of_ns = range(40, 800, 40)
n_trials = 100
avg_times_sorted = []
for n in list_of_ns:
total_time_sorted = 0
for i in range(n_trials):
x = range(n)
start = time.clock()
s = quicksort(x, 'left-pivot')
end = time.clock()
time_taken = end - start
total_time_sorted += time_taken
avg_time_sorted = total_time_sorted / n_trials
avg_times_sorted.append(avg_time_sorted)
pyplot.plot(list_of_ns, avg_times_sorted, 'bo')
pyplot.title("Time vs. List size, average of {0} trials".format(n_trials))
pyplot.xlabel('n')
pyplot.ylabel('Average Time per sort')
pyplot.show()
[[1988, 385000],[2004, 1380000]]]
>>> print("The house at %s was built in %d." % (prop[0], prop[4][0][0])
The house at 355 Noe Street was built in 1988.
>>> cto = ("Will Shulman", 154000, "BSCS Stanford, 1997")
>>> cto[0]
'Will Shulman'
>>> cto[2]
'BSCS Stanford, 1997'
>>> cto[1:2]
(154000,)
>>> cto[0:2]
('Will Shulman', 154000)
>>> cto[1:2] = 158000
>>> import divisors
>>> divisors.gatherDivisors(54)
[1, 2, 3, 6, 9, 18, 27]
>>> gatherDivisors(216)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'gatherDivisors' is not defined
>>> from divisors import gatherDivisors
>>> gatherDivisors(216)
[1, 2, 3, 4, 6, 8, 9, 12, 18, 24, 27, 36, 54, 72, 108]
>>> "neat"
'neat'
>>> from quicksort import quicksort
>>> quicksort([5, 3, 6, 1, 2, 9])
[1, 2, 3, 5, 6, 9]
>>> quicksort(["g", "b", "z", "k", "e", "a", "y", "s"])
['a', 'b', 'e', 'g', 'k', 's', 'y', 'z']
def test_single_input(self):
data = rand_list(count=1)
data_cp = data[:]
quicksort(data)
self.assertEqual(data, data_cp)
7,
1,
1,
9,
9,
0,
4,
4,
4,
5,
4,
5,
7,
1,
]
if __name__ == "__main__":
test_cases = {
'Números aleatórios': any_numbers,
'Já ordenados': already_sorted,
'Ordem inversa': inversed,
'Elementos repetidos': repeated
}
print("*******************************")
for name, lista in test_cases.items():
print("\nCaso de teste: {}".format(name))
print(lista)
quicksort(lista)
print("\n Ordenado:")
print(lista)
print("*******************************")
import quicksort print quicksort list = [1,2,3] quicksort(list)
