def test_avg_case_quick_sort():
data = gen_random_u_array()
sorted_data = SortedList(data)
quick_sort(data, 0, len(data) - 1)
assert np.array_equal(data, sorted_data)
def test_none(self):
array = None
# one way to test for exceptions using a context manager
with self.assertRaises(TypeError):
quick_sort(array)
# another way to test for exceptions using a function
self.assertRaises(TypeError, quick_sort, array)
def test_worst_case_quick_sort():
data = gen_sorted_array()
sorted_data = SortedList(data)
quick_sort(data, 0, len(data) - 1)
assert np.array_equal(data, sorted_data)
def quick_sort(arr, low, high):
if low < high:
# 用mid进行划分(避免顺序或逆序时最坏复杂度)
mid = (low + high) // 2
arr[low], arr[mid] = arr[mid], arr[low]
pivot_pos = partition(arr, low, high)
quick_sort(arr, low, pivot_pos - 1)
quick_sort(arr, pivot_pos + 1, high)
def test_sort():
"""Simple test"""
arr1 = [5, -10, 50, 2, 0, 11]
arr2 = [0, 0, 0, 1]
arr3 = [-100, 0, 100]
assert quick_sort(arr1.copy()) == sorted(arr1.copy())
assert quick_sort(arr2.copy()) == sorted(arr2.copy())
assert quick_sort(arr3.copy()) == sorted(arr3.copy())
def visualize_quick_sort(lst, vis):
start_time = time.perf_counter_ns()
sort.quick_sort(lst, 0, len(lst) - 1, vis)
end_time = time.perf_counter_ns()
vis.replay(0)
vis.reset()
print('Quick Sort')
print(f'Time: {end_time - start_time:,}ns\n')
def main():
strategy = sys.argv[1] if len(sys.argv) > 1 else 'first'
numbers = [int(l.strip()) for l in sys.stdin.readlines() if l.strip()]
assert numbers[0] == 2148
assert numbers[-1] == 9269
cost = quick_sort(numbers, strategy=strategy)
print(cost)
def item_cf(file_path, n=-1):
"""
Making recommendation via item_cf.
This function try to return a recommendation like:
rec={
user:{
item:pred
}
}
"""
if n == 0:
return {{}}
#load data
data_model = RecDataModel(file_path)
data_model.load_item_model()
data_model.load_user_model()
data_model.avg_item_model()
item_list = data_model.get_item_list()
#compute item similarity
item_sim = {}
for i in item_list:
item_sim[i] = {}
for i in range(len(item_list)):
item_i = item_list[i]
for j in range(i, len(item_list)):
item_j = item_list[j]
rate_i, rate_j = data_model.get_item_union(item_i, item_j)
acos = adjust_cos(rate_i, rate_j)
if i == j: acos = 0.0
item_sim[item_i][item_j] = acos
item_sim[item_j][item_i] = acos
#make rec
rec = {}
user_list = data_model.get_user_list()
for u in user_list:
rec_u = {}
rate_u = data_model.get_user_vec(u)
for i in item_list:
if i not in rate_u:
i_sim = item_sim[i]
fenzi = 0.0
fenmu = 0.0
for ui in rate_u:
fenzi += rate_u[ui] * i_sim[ui]
fenmu += i_sim[ui]
if fenmu != 0:
rec_u[i] = fenzi / fenmu
else:
rec_u[i] = 0.0
if n != -1:
items, pred = quick_sort(rec_u, r=True)
rec_u = {}
for i in range(n):
rec_u[items[i]] = pred[i]
rec[u] = rec_u
return rec
def test_sort(self):
# Set up array to sort
array_len = 1024
max_value = 1024
x = [random.randint(0, max_value) for i in range(array_len)]
# Insertion sort
self.assertEqual(sort.insertion_sort(x), sorted(x))
# Merge sort
self.assertEqual(sort.merge_sort(x), sorted(x))
# Selection sort
self.assertEqual(sort.selection_sort(x), sorted(x))
# Bubble sort
self.assertEqual(sort.bubble_sort(x), sorted(x))
# Heap sort
self.assertEqual(sort.heap_sort(x), sorted(x))
# Quick sort
self.assertEqual(sort.quick_sort(x), sorted(x))
# Quick sort v2
self.assertEqual(sort.quick_sort_v2(x), sorted(x))
def item_cf(file_path, n=-1):
"""
Making recommendation via item_cf.
This function try to return a recommendation like:
rec={
user:{
item:pred
}
}
"""
if n == 0:
return {{}}
#load data
data_model = RecDataModel(file_path)
data_model.load_item_model()
data_model.load_user_model()
data_model.avg_item_model()
item_list = data_model.get_item_list()
#compute item similarity
item_sim = {}
for i in item_list:
item_sim[i] = {}
for i in range(len(item_list)):
item_i = item_list[i]
for j in range(i, len(item_list)):
item_j = item_list[j]
rate_i, rate_j = data_model.get_item_union(item_i, item_j)
acos = adjust_cos(rate_i, rate_j)
if i == j: acos = 0.0
item_sim[item_i][item_j] = acos
item_sim[item_j][item_i] = acos
#make rec
rec = {}
user_list = data_model.get_user_list()
for u in user_list:
rec_u = {}
rate_u = data_model.get_user_vec(u)
for i in item_list:
if i not in rate_u:
i_sim = item_sim[i]
fenzi = 0.0
fenmu = 0.0
for ui in rate_u:
fenzi += rate_u[ui] * i_sim[ui]
fenmu += i_sim[ui]
if fenmu != 0:
rec_u[i] = fenzi / fenmu
else:
rec_u[i] = 0.0
if n != -1:
items, pred = quick_sort(rec_u, r=True)
rec_u = {}
for i in range(n):
rec_u[items[i]] = pred[i]
rec[u] = rec_u
return rec
def test_quick_sort():
print "\nQuick sort test begin"
count = random.randint(100, 1000)
for _ in range(count):
length = random.randint(5, 30)
source = tool.random_list(0, 100, length)
target = sort.quick_sort(source)
if tool.list_is_ascend(target) is False:
print source
print target
print ""
assert (tool.list_is_ascend(target))
print "Quick sort success in {0} times.\n".format(count)
def slope_one(file_path, n=-1):
"""
Making recommendation via slope one.
This function try to return a recommendation like:
rec={
user:{
item:pred
}
}
"""
#load data model
data_model = RecDataModel(file_path)
data_model.load_user_model()
data_model.load_item_model()
item_list = list(data_model.get_item_list())
user_list = list(data_model.get_user_list())
#compute dev(i,j)
dev = {}
tmp = {}
for i in item_list:
tmp[i] = (0.0, 0)
for i in item_list:
dev[i] = tmp
for i in range(len(item_list)):
rate_i = data_model.get_item_vec(item_list[i])
if rate_i and len(rate_i) > 0:
for j in range(i, len(item_list)):
if i != j:
rate_j = data_model.get_item_vec(item_list[j])
if rate_j and len(rate_j) > 0:
dev_ij = 0.0
dev_count = 0
for iu in rate_i:
if iu in rate_j:
dev_ij += rate_i[iu] - rate_j[iu]
dev_count += 1
if dev_count > 0:
dev_ij /= dev_count
dev[item_list[i]][item_list[j]] = (dev_ij, dev_count)
dev[item_list[j]][item_list[i]] = (dev_ij, dev_count)
#make rec
rec = {}
for u in user_list:
print u
rate_u = data_model.get_user_vec(u)
rec_u = {}
for i in item_list:
if i not in rate_u:
pred = 0.0
count = 0.0
i_dev = dev.get(i)
for iu in rate_u:
dev_ij, dev_count = i_dev[iu]
pred += (rate_u.get(iu) - dev_ij) * dev_count
count += dev_count
if count > 0:
rec_u[i] = pred / count
else:
rec_u[i] = 0.0
if n != -1:
items, pred = quick_sort(rec_u, r=True)
rec_u = {}
for i in range(n):
rec_u[items[i]] = pred[i]
rec[u] = rec_u
return rec
def user_cf(file_path, k=100, n=-1):
"""
Making recommendation via user_cf.
:param k use for set the length of similar user set.
:param n use for top-n rec, default is -1, while n equals -1 show all recommended result .
"""
if n == 0:
return {{}}
#Load data.
data_model = RecDataModel(file_path)
data_model.load_user_model()
data_model.load_item_model()
#Get similar user set.
user_list = data_model.get_user_list()
similarity_set = {}
for i in user_list:
tmp_set = {}
for j in user_list:
if i != j:
a, b = data_model.get_corate(i, j)
tmp_set[j] = pearson(a, b)
users, similarity = quick_sort(tmp_set, r=True)
tmp_set = {}
for u in range(k):
tmp_set[users[u]] = similarity[u]
similarity_set[i] = tmp_set
#make rec.
rec = {}
for u in similarity_set:
rate_u = data_model.get_user_vec(u)
rec_par = {}
rec_u = {}
tmp_set = similarity_set.get(u)
for su in tmp_set:
rate_su = data_model.get_user_vec(su)
for item in rate_su:
if item not in rate_u:
if item not in rec_par:
#su rate, su avg, similarity
param = [(rate_su.get(item), data_model.get_user_avg(su), tmp_set.get(su))]
rec_par[item] = param
else:
param = rec_par.get(item)
param.append((rate_su.get(item), data_model.get_user_avg(su), tmp_set.get(su)))
rec_par[item] = param
for item in rec_par:
avg_item = data_model.get_item_avg(item)
fenzi = 0.0
fenmu = 0.0
for su_rate, avg_su, simi in rec_par.get(item):
fenzi += (su_rate - avg_su) * simi
fenmu += simi
fenmu += 1
rec_u[item] = avg_item + fenzi / fenmu
if n != -1:
items, pred = quick_sort(rec_u, r=True)
rec_u = {}
for i in range(n):
rec_u[items[i]] = pred[i]
rec[u] = rec_u
return rec
def main():
win = gp.GraphWin('sortpy', WINDOW_X, WINDOW_Y, autoflush=False)
win.setBackground(color=gp.color_rgb(43, 137, 164))
print_logo()
first_input = True
while 1:
clear_screen(win)
ds = sort.generate_dataset(sort.DATA_NUM, repeat=False)
bars = []
draw_bars(ds, win, bars)
sort.playback_list = []
valid_command = False
if first_input:
command = input('Type help to view commands\n')
first_input = False
else:
command = input('')
while not valid_command:
if command == 'help':
print_header('Sorting algorithms')
print_subheader('Bubble sorts')
print_command('bubble', 'Bubble sort')
print_command('cocktail', 'Cocktail shaker sort')
print_command('comb', 'Comb sort')
print_command('oddeven', 'Odd-even sort')
print_subheader('Insertion sorts')
print_command('insertion', 'Insertion sort')
print_command('shell', 'Shellsort')
print_command('gnome', 'Gnome sort')
print_subheader('Divide and conquer')
print_command('merge', 'Merge sort')
print_command('quick', 'Quicksort')
print_subheader('Other')
print_command('selection', 'Selection sort')
print_command('stooge', 'Stooge sort')
print_header('Options')
print_command('quit', 'Exit sortpy')
print('\n')
print('Click on the window after sorting finishes to select a new algorithm')
command = input('\n')
elif command == 'bubble':
valid_command = True
elif command == 'cocktail':
valid_command = True
elif command == 'comb':
valid_command = True
elif command == 'oddeven':
valid_command = True
elif command == 'insertion':
valid_command = True
elif command == 'shell':
valid_command = True
elif command == 'gnome':
valid_command = True
elif command == 'merge':
valid_command = True
elif command == 'quick':
valid_command = True
elif command == 'selection':
valid_command = True
elif command == 'stooge':
valid_command = True
elif command == 'quit':
win.close()
return
else:
print('Command not found - type help to view commands')
command = input('\n')
sort.playback_list.append(ds[:])
if command == 'insertion':
sort.insertion_sort(ds)
elif command == 'bubble':
sort.bubble_sort(ds)
elif command == 'cocktail':
sort.cocktail_sort(ds)
elif command == 'selection':
sort.selection_sort(ds)
elif command == 'merge':
sort.merge_sort(ds, 0, sort.DATA_NUM - 1)
elif command == 'quick':
sort.quick_sort(ds, 0, sort.DATA_NUM - 1)
elif command == 'shell':
sort.shell_sort(ds)
elif command == 'gnome':
sort.gnome_sort(ds)
elif command == 'oddeven':
sort.odd_even_sort(ds)
elif command == 'comb':
sort.comb_sort(ds)
elif command == 'stooge':
sort.stooge_sort(ds, 0, sort.DATA_NUM - 1)
sort.playback_list = remove_duplicates(sort.playback_list)
play_animation(ds, win, bars)
win.getMouse()
def test_sort_odd_elements(self):
array = [6, 2, 5, 8, 1, 3, 7, 4, 0]
self.assertEqual(quick_sort(array), list(range(9)))
print ("я║тЯеепРсцй╠: % s" %(time.clock() - time_start) )
# ╡ЕхКеепР
random.shuffle(ls)
time_start = time.clock()
sort.insert_sort(ls)
print ("╡ЕхКеепРсцй╠: % s" %(time.clock() - time_start) )
# оё╤ШеепР
random.shuffle(ls)
time_start = time.clock()
sort.shell_sort(ls)
print ("оё╤ШеепРсцй╠: % s" %(time.clock() - time_start) )
# ╧И╡╒еепР
random.shuffle(ls)
time_start = time.clock()
sort.merge_sort(ls)
print ("╧И╡╒еепРсцй╠: % s" %(time.clock() - time_start) )
# ©ЛкыеепР
random.shuffle(ls)
time_start = time.clock()
sort.quick_sort(ls)
print ("©ЛкыеепРсцй╠: % s" %(time.clock() - time_start) )
# ╤яеепР
random.shuffle(ls)
time_start = time.clock()
sort.heap_sort(ls)
print ("╤яеепРсцй╠: % s" %(time.clock() - time_start) )
def cpu_bounded_func_quick(n=CPU_FUNC_NUMBER):
return quick_sort(n)
def get_po(po):
if po not in data:
abort(404)
to_sort = data[po]['lines']
sorted = sort.quick_sort(to_sort, 0, len(to_sort) - 1)
return jsonify(sorted)
list_large = []
for i in range(50000):
list_large.append(random.randint(1, 100))
print 'size:50000, for the faster ones'
timer.get_time(time.clock(), False) #update time
print 'merge sort\n'
list = sort.merge_sort(list_large[:])
assert sort.check_sorted(list)
timer.get_time(time.clock())
print ''
print 'quick sort\n'
list = sort.quick_sort(list_large[:])
assert sort.check_sorted(list)
timer.get_time(time.clock())
print ''
print 'quick sort rand\n'
list = sort.quick_sort(list_large[:], rand=True)
assert sort.check_sorted(list)
timer.get_time(time.clock())
print ''
print 'counting sort\n'
list = sort.counting_sort(list_large[:])
assert sort.check_sorted(list)
timer.get_time(time.clock())
print ''
def test_single_item_array(self):
array = [6]
self.assertEqual(quick_sort(array), array)
def test_sort_four_elements(self):
array = [6, 2, 4, 9]
self.assertEqual(quick_sort(array), [2, 4, 6, 9])
def test_sort_three_elements(self):
array = [6, 2, 4]
self.assertEqual(quick_sort(array), [2, 4, 6])
def test_sort_two_elements(self):
array = [6, 2]
self.assertEqual(quick_sort(array), [2, 6])
print("я║тЯеепРсцй╠: % s" % (time.clock() - time_start))
# ╡ЕхКеепР
random.shuffle(ls)
time_start = time.clock()
sort.insert_sort(ls)
print("╡ЕхКеепРсцй╠: % s" % (time.clock() - time_start))
# оё╤ШеепР
random.shuffle(ls)
time_start = time.clock()
sort.shell_sort(ls)
print("оё╤ШеепРсцй╠: % s" % (time.clock() - time_start))
# ╧И╡╒еепР
random.shuffle(ls)
time_start = time.clock()
sort.merge_sort(ls)
print("╧И╡╒еепРсцй╠: % s" % (time.clock() - time_start))
# ©ЛкыеепР
random.shuffle(ls)
time_start = time.clock()
sort.quick_sort(ls)
print("©ЛкыеепРсцй╠: % s" % (time.clock() - time_start))
# ╤яеепР
random.shuffle(ls)
time_start = time.clock()
sort.heap_sort(ls)
print("╤яеепРсцй╠: % s" % (time.clock() - time_start))
def test_quicksort(self):
sort.quick_sort(0, len(self.list), self.list)
self.assertTrue(self.in_order(self.list))
def tests_quick_sort(self):
""" Test Quick Sort. read sort.py for instructions. """
sample = [3, 1, 10, 654, 45, 5, 8, 5, 31, 123]
sorted_sample = [1, 3, 5, 5, 8, 10, 31, 45, 123, 654]
self.assertEqual(sorted_sample, sort.quick_sort(sample))
def test_sort(self):
array = [6, 2, 5, 8, 1, 3, 7, 9, 4, 0]
self.assertEqual(quick_sort(array), list(range(10)))
from sort import seletion_sort, bubble_sort, quick_sort arr = [2, 42, 84, 5, 113, 4, 6, 33, 65, 756] sorted = [2, 4, 5, 6, 33, 42, 65, 84, 113, 756] reversed = [756, 113, 84, 65, 42, 33, 6, 5, 4, 2] sorted_arr = seletion_sort(arr) assert (sorted_arr == sorted) reversed_arr = seletion_sort(arr, True) assert (reversed_arr == reversed) sorted_arr = bubble_sort(arr) assert (sorted_arr == sorted) reversed_arr = bubble_sort(arr, True) assert (reversed_arr == reversed) sorted_arr = quick_sort(arr) assert (sorted_arr == sorted) reversed_arr = quick_sort(arr, True) assert (reversed_arr == reversed)
# 用mid进行划分(避免顺序或逆序时最坏复杂度)
mid = (low + high) // 2
arr[low], arr[mid] = arr[mid], arr[low]
pivot_pos = partition(arr, low, high)
quick_sort(arr, low, pivot_pos - 1)
quick_sort(arr, pivot_pos + 1, high)
from random import randint
from time import clock
l = []
for i in range(100000):
l.append(randint(0, 100000))
t = clock()
quick_sort(l, 0, 100000 - 1) # python
print(clock() - t)
print(l[:100])
l = []
for i in range(100000):
l.append(randint(0, 100000))
t = clock()
l.sort() # python-stable
print(clock() - t)
print(l[:100])
from sort import quick_sort
l = []
for i in range(100000):
import sort
import Student
import read_file
import time
student_list = read_file.read_class_file(input("Enter file nime:\n"))
start_time = time.time()
sort.buble_sort(student_list)
print("Time: ", time.time() - start_time, "\nResult:")
for i in student_list:
print(i, "\n")
print("------------------------------------------")
start_time = time.time()
sort.quick_sort(0, len(student_list), student_list)
print()
print("QuickSort \nComparasion times: ", sort.comparasion_times,
"\nSwap times: ", sort.swap_times, "\nTime: ",
time.time() - start_time, "\nResult:")
for i in student_list:
print(i, "\n")
def _sort_list(list_):
return quick_sort(list_)
def test_quick_sort(self):
array = [7, 5, 1, 8, 3, 4, 4, 7, 3, 6, 2, 1, 8, 9, 0, 6]
assert sort.quick_sort(array) == [0, 1, 1, 2, 3, 3, 4, 4, 5, 6, 6, 7, 7, 8, 8, 9]
#再帰条件の変更
import sys
sys.setrecursionlimit(100000)
l = list(range(3000))
random.shuffle(l)
start_time = time.time()
sorted_list = sort.bubble_sort(l)
print('time:{0:.3f}'.format(time.time()-start_time))
start_time = time.time()
sorted_list = sort.selection_sort(l)
print('time:{0:.3f}'.format(time.time()-start_time))
start_time = time.time()
sorted_list = sort.insertion_sort(l)
print('time:{0:.3f}'.format(time.time()-start_time))
start_time = time.time()
sorted_list = sort.heap_sort(l)
print('time:{0:.3f}'.format(time.time()-start_time))
start_time = time.time()
sorted_list = sort.merge_sort(l)
#print(sorted_list)
print('time:{0:.3f}'.format(time.time()-start_time))
start_time = time.time()
sorted_list = sort.quick_sort(l)
print('time:{0:.3f}'.format(time.time()-start_time))
def test_quick_sort():
arr = [9, 4, 2, 4, 6, 7, 2, 3, 4, 5, 1, 1, 2]
assert quick_sort(arr, 0, len(arr) - 1) == sorted(arr)
def slope_one(file_path, n=-1):
"""
Making recommendation via slope one.
This function try to return a recommendation like:
rec={
user:{
item:pred
}
}
"""
#load data model
data_model = RecDataModel(file_path)
data_model.load_user_model()
data_model.load_item_model()
item_list = list(data_model.get_item_list())
user_list = list(data_model.get_user_list())
#compute dev(i,j)
dev = {}
tmp = {}
for i in item_list:
tmp[i] = (0.0, 0)
for i in item_list:
dev[i] = tmp
for i in range(len(item_list)):
rate_i = data_model.get_item_vec(item_list[i])
if rate_i and len(rate_i) > 0:
for j in range(i, len(item_list)):
if i != j:
rate_j = data_model.get_item_vec(item_list[j])
if rate_j and len(rate_j) > 0:
dev_ij = 0.0
dev_count = 0
for iu in rate_i:
if iu in rate_j:
dev_ij += rate_i[iu] - rate_j[iu]
dev_count += 1
if dev_count > 0:
dev_ij /= dev_count
dev[item_list[i]][item_list[j]] = (dev_ij,
dev_count)
dev[item_list[j]][item_list[i]] = (dev_ij,
dev_count)
#make rec
rec = {}
for u in user_list:
print u
rate_u = data_model.get_user_vec(u)
rec_u = {}
for i in item_list:
if i not in rate_u:
pred = 0.0
count = 0.0
i_dev = dev.get(i)
for iu in rate_u:
dev_ij, dev_count = i_dev[iu]
pred += (rate_u.get(iu) - dev_ij) * dev_count
count += dev_count
if count > 0:
rec_u[i] = pred / count
else:
rec_u[i] = 0.0
if n != -1:
items, pred = quick_sort(rec_u, r=True)
rec_u = {}
for i in range(n):
rec_u[items[i]] = pred[i]
rec[u] = rec_u
return rec
