def test_search_algorithms():
''' Times the execution of the three search functions '''
import time
the_list = range(1000000)
# --- Run and time linear search implemented with a for loop --- #
t1 = time.clock()
index = search.linear_search_for(the_list, 750000)
t2 = time.clock()
# Convert from seconds to milliseconds
exec_time = (t2-t1)*1000
print "Linear search: %.4f ms (with for loop)" % exec_time
print "Element found in index %d" % index
# --- Run and time linear search implemented with a while loop --- #
t1 = time.clock()
index = search.linear_search_while(the_list, 750000)
t2 = time.clock()
# Convert from seconds to milliseconds
exec_time = (t2-t1)*1000
print "\nLinear search: %.4f ms (with while loop)" % exec_time
print "Element found in index %d" % index
# --- Run and time binary search --- #
t1 = time.clock()
index = search.binary_search(the_list, 750000)
t2 = time.clock()
# Convert from seconds to milliseconds
exec_time = (t2-t1)*1000
print "\nBinary search: %.4f ms" % exec_time
print "Element found in index %d" % index
def test_binary_search():
assert_equal(binary_search([1, 2, 3], 2), 1)
assert_equal(binary_search([1, 5, 7, 8, 16, 34, 35], 34), 5)
assert_equal(binary_search([23, 24, 25, 55, 67, 89], 23), 0)
assert_equal(binary_search([23, 24, 25, 55, 67, 89], 89), 5)
assert_equal(binary_search([23, 24, 25, 55, 67, 89], 57), -1)
assert_equal(binary_search([], 57), -1)
assert_equal(binary_search(None, 57), -1)
def main():
limit = 1000000
prime_numbers = primes(limit)
prime_sums = [0]
for prime_number in prime_numbers:
prime_sum = prime_sums[-1] + prime_number
if prime_sum < limit:
prime_sums.append(prime_sum)
else:
break
chain_length = -1
result = -1
for prime_sum in prime_sums[::-1]:
index_adjustment = 0
index = binary_search(prime_sums, prime_sum)
for prime_number in prime_numbers:
if binary_search(prime_numbers, prime_sum) != -1:
current_chain_length = index - index_adjustment
if current_chain_length > chain_length:
chain_length = current_chain_length
result = prime_sum
if current_chain_length < chain_length:
break
else:
prime_sum = prime_sum - prime_number
index_adjustment += 1
if prime_sum < 0 or index - index_adjustment < chain_length:
break
return result
def test_binary_search_with_items_in_list(self):
# binary search requires list values to be in sorted order
names = ['Winnie', 'Alex', 'Nick', 'Brian', 'Julia', 'Kojin', 'Nabil']
# binary search should return the index of each item in the list
assert binary_search(names, 'Alex') == 0
assert binary_search(names, 'Brian') == 1
assert binary_search(names, 'Julia') == 2
assert binary_search(names, 'Kojin') == 3
assert binary_search(names, 'Nabil') == 4
assert binary_search(names, 'Nick') == 5
assert binary_search(names, 'Winnie') == 6
def test_binary_search():
"""Binary search on sequences of different types"""
arr = [1, 3, 5, 7]
assert binary_search(arr, 7) == 7
assert binary_search(arr, 1) == 1
assert binary_search(arr, 100) is None
arr1 = [1, 10]
assert binary_search(arr1, 1) == 1
assert binary_search(arr1, 10) == 10
arr2 = ["a", "b", "c", "d", "e"]
assert binary_search(arr2, "a") == "a"
assert binary_search(arr2, "e") == "e"
assert binary_search(arr2, "b") == "b"
def test_search(self):
# Set up array to search
array_len = 1024
max_value = 1024
# With duplicate values (needs stable binary search)
#x = sorted([random.randint(0, max_value) for i in range(array_len)])
# Without duplicate values (doesn't need stable binary search)
x = range(max_value + 1)
# Pick a random value to search for
v = random.choice(x[1:-1])
idx = x.index(v)
# Binary search
# --- value found
self.assertEqual(search.binary_search(x, v), idx)
# (Edge cases)
self.assertEqual(search.binary_search(x, x[0]), 0)
self.assertEqual(search.binary_search(x, x[array_len - 1]), array_len - 1)
# --- value not found
self.assertEqual(search.binary_search(x, max_value + 1), -1)
def worstCaseBinarySearch(self):
self.clearData()
items = 1000000
while items <= self.max_:
data = random.sample(range(self.max_), items)
data.sort()
start = time()
index = binary_search(data, data[len(data) - 1])
end = time()
elapsed = end - start
print(f"Elapsed Time for {items} datas: {elapsed}")
self.plotdatas.append((items, elapsed))
items = int(items * 1.5)
self.displayData("Worst case of Binary Search", 'blue')
def find_course(self, to_add): #O(log(n))
#Creates a list of course "ids"
li = [x.title + x.dept + str(x.number) for x in self.course_list]
#Creates id for thing to look for
item = to_add.title + to_add.dept + str(to_add.number)
#print(li, item)
#Search
#This has O(log(n)) complexity
x = search.binary_search(sorter.mergesort(li), \
len(li)//2, len(li), 0, item)
if x:
return to_add
else:
print("Attempted to add a course not in the master list")
return None
def test_binary_search_with_items_not_in_list(self):
# binary search requires list values to be in sorted order
names = [
'Alex', 'Brian', 'Julia', 'Kojin', 'Nabil', 'Nick', 'Winnie',
'Zack'
]
# binary search should return None for any item not in the list
assert binary_search(names, 'Jeremy') is None
assert binary_search(names, 'nobody') is None
assert binary_search(names, 'Aardvark') is None
assert binary_search(names, 'Kai') is None
assert binary_search(names, 'Mark') is None
assert binary_search(names, 'Sam') is None
def test_search_at_end():
gen = make_data()
data = next(gen)
start = time.perf_counter()
result = binary_search(data, data[-1])
fastest = time.perf_counter() - start
assert result
start = time.perf_counter()
result = linear_search(data, data[-1])
slowest = time.perf_counter() - start
assert result
assert fastest * 10000 < slowest * 10000
start = time.perf_counter()
result = jump_search(data, data[-1])
fastest = time.perf_counter() - start
assert result
assert fastest * 10000 < slowest * 10000
def generateForBinary():
binary_result = {
"input_array": [],
"exec_best": [],
"exec_worst": [],
"exec_avg": [],
}
dataset = range(100000)
for i in range(10, 100000, 250):
data = sorted(sample(dataset, i))
binary_result["input_array"].append(i)
dataMiddle = data[(i - 1) // 2]
start = time()
# best case
binary_search(data, dataMiddle, 0, i - 1)
elapsed = time() - start
binary_result["exec_best"].append(elapsed)
start = time()
# worst case
binary_search(data, -1, 0, i - 1)
elapsed = time() - start
binary_result["exec_worst"].append(elapsed)
random = choice(data)
start = time()
binary_search(data, random, 0, i - 1)
elapsed = time() - start
binary_result["exec_avg"].append(elapsed)
df = pd.DataFrame.from_dict(binary_result)
df.to_csv('binary_data.csv', index=False)
plt.figure(1, figsize=(14, 12))
plt.title("Input size vs Exec time")
plt.xlabel('Input size')
plt.ylabel('Exec time')
plt.plot(binary_result["input_array"],
binary_result["exec_best"],
c='green',
label="Best case")
plt.plot(binary_result["input_array"],
binary_result["exec_worst"],
c='red',
label="Worst case")
plt.plot(binary_result["input_array"],
binary_result["exec_avg"],
c='blue',
label="Avg case")
plt.legend()
plt.show()
def main():
name = sys.argv[1];
for i in xrange(1, 11):
fname = '../data/%d_catalog.txt' % i
#read the catalog and load to a list
phonebook = []
append = phonebook.append
with open(fname, 'r') as f:
for l in f:
if l:
append(Entry.fromline(l))
#print 'phonebook contains %d entries' % len(phonebook)
name_idx = BinarySearchTree()
for i, e in enumerate(phonebook):
name_idx.add(e.name, i)
start = time.time()
idxs = name_idx.get(name)
bstelapsed = (time.time() - start) * 1000
# let's sort the entries by name
phonebook.sort(key=lambda e: e.name)
# let' search for a non existing name using naive search
start = time.time()
idx = search.naive(phonebook, name)
nelapsed = (time.time() - start) * 1000
# the same using binary search
bstart = time.time()
idx = search.binary_search(phonebook, name)
bselapsed = (time.time() - bstart) * 1000
print '%d - naive: %g - binary: %g - bst: %g'\
% (len(phonebook), nelapsed, bselapsed, bstelapsed)
def test_binary_search():
alist = range(10)
assert search.binary_search(alist, 5)
assert not search.binary_search(alist, 11)
def test_search_player_found(self):
result = binary_search(self.players, self.player1)
self.assertEqual(result, 0)
def test_not_found(self):
self.assertEqual(binary_search(self.data, 35), None)
def test_search_not_found(self):
result = binary_search(self.test_players, 'Jack')
self.assertEqual(result, None)
def test_binary_search_empty(self):
self.assertEqual(binary_search([], 0), -1)
def test_smaller(self):
self.assertEqual(binary_search(self.data, 1000), None)
def test_searchChar(self):
data = ['t', 'a', 'b', 'l', 'e', 'c', 'h', 'i', 'r']
self.assertEqual(binary_search(data, 0, len(data)-1, 'a'), 1)
def test_binary_search(self):
self.assertEqual(binary_search(self.list_in1, self.item2), None)
self.assertEqual(binary_search(self.list_in1, self.item3), None)
self.assertEqual(binary_search(self.list_in2, self.item1), 0)
self.assertEqual(binary_search(self.list_in3, self.item1), 0)
def test_binary_search(self):
"""Test Binary Search method."""
test = sorted([1, 2, 32, 8, 17, 19, 42, 13, 0])
self.assertFalse(binary_search([], 1))
self.assertTrue(binary_search(test, 13))
self.assertFalse(binary_search(test, 3))
def test_searchChar(self):
data = ['a', 'b', 'e', 'l', 't']
self.assertEqual(binary_search(data, 'a'), 0)
self.assertEqual(linear_search(data, 'u'), -1)
def test_binary_search_with_none_list(self):
names = None
assert binary_search(names, 'Trap') is None
from search import binary_search elements = [1, 5, 7, 8, 9, 10, 11, 12, 13] print(binary_search(12, elements)) print(binary_search(78, elements))
def test_binary_search_non_empty(self):
for i in range(1, 5):
key = i - 1
self.assertEqual(binary_search(range(i), key), key)
def test_binary_search_find_23():
assert (binary_search(data.good_data, 23) == 23)
def test_search_found(self):
result = binary_search(self.test_players, 'Petersen')
self.assertEqual(result, self.player4)
def test_binary_search_find_777():
assert (binary_search(data.good_data, 777) is None)
def test_larger(self):
self.assertEqual(binary_search(self.data, -10), None)
def test_search(self):
data = [1, 2, 3, 5, 6, 12, 7, 4, 8]
self.assertEqual(binary_search(data, 0, len(data)-1, 6), 4)
self.assertEqual(binary_search(data, 0, len(data)-1, 10), -1)
def test_binary_search_not_found(self):
values = [1, 2, 3, 4, 5]
self.assertEqual(binary_search(values, -1), -1)
def test_search(self):
for i, v in enumerate(self.data):
with self.subTest(i=i):
self.assertEqual(binary_search(self.data, v), i)
import random
from search import binary_search
from datetime import datetime
data = random.sample(range(10000000), 1000000)
data = sorted(data)
middle = data[(len(data) - 1) // 2]
binaryStartBest = datetime.now()
binaryIndexBest = binary_search(data, 0, len(data) - 1, middle)
binaryEndBest = datetime.now()
binaryTimeBest = binaryEndBest - binaryStartBest
binaryStartAvg = datetime.now()
binaryIndexAvg = binary_search(data, 0, len(data) - 1, data[24000])
binaryEndAvg = datetime.now()
binaryTimeAvg = binaryEndAvg - binaryStartAvg
binaryStartWorst = datetime.now()
binaryIndexWorst = binary_search(data, 0, len(data) - 1, -1)
binaryEndWorst = datetime.now()
binaryTimeWorst = binaryEndWorst - binaryStartWorst
print(
f'For Index of {binaryIndexBest}.Time taken by binary search {binaryTimeBest}'
)
print(
f'For Index of {binaryIndexAvg}.Time taken by binary search {binaryTimeAvg}'
)
print(
f'For Index of {binaryIndexWorst}.Time taken by binary search {binaryTimeWorst}'
)
def test_banary_search_with_empty_list(self):
names = []
assert binary_search(names, 'No one') is None
import random
from search import linear_search, binary_search
from datetime import datetime
data = random.sample(range(1000000000), 1000000)
linear_start = datetime.now()
linear_index = linear_search(data, data[-1])
linear_end = datetime.now()
linear_elapsed = linear_end - linear_start
data = sorted(data)
binary_start = datetime.now()
binary_index = binary_search(data, 0, len(data) - 1, data[-1])
binary_end = datetime.now()
binary_elapsed = binary_end - binary_start
print(f'Found at {linear_index}.Time taken by linear search {linear_elapsed}')
print(f'Found at {binary_index}.Time taken by binary search {binary_elapsed}')
def test_search(self):
data = [1, 2, 3, 4, 5, 6, 7, 8, 12]
self.assertEqual(binary_search(data, 9), -1)
self.assertEqual(binary_search(data, 3), 2)
self.assertEqual(binary_search(data, 1), 0)
self.assertEqual(binary_search(data, 7), 6)
def test_search() -> None:
"""Simple test for binary_search."""
assert binary_search([0, 5, 10, 15, 20, 25, 30, 35, 40], 5) == -1
def test_search():
"""Simple test for binary_search."""
assert binary_search(XXXX, XXXX) == XXXX
from search import binary_search
arr = ['B', 'E', 'K', 'J', 'A', 'U', 'P']
element = 'J'
def insert_sort (arr):
# symbols sorted base on ord(ascii symbols)
for i in range(1, len(arr)):
j = i
while j >0 and arr[j] <= arr[j-1]:
arr[j], arr[j-1] = arr[j-1], arr[j]
j-=1
return arr
sorted_arr = insert_sort(arr)
index = binary_search(sorted_arr, element)
print(index)
