def test_binary_search(self):
arr1 = [-9, -8, -6, -4, -3, -2, 0, 1, 2, 3, 5, 7, 8, 9]
arr2 = []
self.assertEqual(binary_search(arr1, -8, 0, len(arr1)-1), 1)
self.assertEqual(binary_search(arr1, 0, 0, len(arr1)-1), 6)
self.assertEqual(binary_search(arr2, 6, 0, len(arr2)-1), -1)
self.assertEqual(binary_search(arr2, 0, 0, len(arr2)-1), -1)
def test_binary_search(self):
for test_array in self.test_arrays:
array = test_array()
for test_search_item in self.test_search_items:
search_item = test_search_item()
self.assertEqual(
binary_search(array, search_item),
self.index_of(array, search_item),
)
def test_search(self):
array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
testData = [{
'element': 1,
'index': 0
}, {
'element': 10,
'index': 9
}, {
'element': 4,
'index': 3
}, {
'element': 100,
'index': -1
}]
for data in testData:
self.assertEqual(data['index'],
linear_search(array, data['element']))
self.assertEqual(data['index'],
binary_search(array, data['element']))
self.assertEqual(data['index'],
interpolation_search(array, data['element']))
from searching import binary_search list1 = [] print(binary_search(list1, -8, 0, len(list1) - 1))
def test_binary_search_not_in_list(self):
search_result = binary_search(self.test_list, 25)
self.assertEqual(search_result, -1)
# if tree.contains(name_2):
# duplicates.append(name_2)
# STRETCH SOLUTION
# Basically I want to search names_1 for each name_2, and add to
# "duplicates" if I find it.
# The most efficient search with arrays is a Binary Search,
# so I'll import my code for that.
import sys
sys.path.append('../../Sorting/src/searching')
from searching import binary_search
# To do a binary search, you first have to sort the search array.
names_1.sort()
for name_2 in names_2:
# binary_search returns a -1 when the item isn't found,
# so append to duplicates whenever the result isn't -1.
if binary_search(names_1, name_2) != -1:
duplicates.append(name_2)
# The runtime for this ended up being about 0.8 seconds on my computer--
# better than the Binary Search Tree!
end_time = time.time()
print(f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n")
print(f"runtime: {end_time - start_time} seconds")
# ---------- Stretch Goal -----------
# Python has built-in tools that allow for a very efficient approach to this problem
# What's the best time you can accomplish? Thare are no restrictions on techniques or data
# structures, but you may not import any additional libraries that you did not write yourself.
def test_binary_search_in_list(self):
search_result = binary_search(self.test_list, 15)
self.assertEqual(search_result, 4)
def test_binary_search_first(arr):
assert binary_search(arr, 2) == 0
assert binary_search_recursive(arr, 2) == 0
def test_binary_search(self):
self.assertEqual(searching.binary_search(self.list_even, 2), 2)
self.assertEqual(searching.binary_search(self.list_even, 5), 5)
self.assertEqual(searching.binary_search(self.list_even, 4), 4)
self.assertEqual(searching.binary_search(self.list_even, 7), 7)
self.assertEqual(searching.binary_search(self.list_even, 9), None)
self.assertEqual(searching.binary_search(self.list_odd, 2), 2)
self.assertEqual(searching.binary_search(self.list_odd, 5), 5)
self.assertEqual(searching.binary_search(self.list_odd, 7), 7)
self.assertEqual(searching.binary_search(self.list_odd, 9), None)
self.assertEqual(searching.binary_search(self.list_one, 1), 1)
self.assertEqual(searching.binary_search(self.list_one, 2), None)
def test_binary_search_smaller_than_first(arr):
assert binary_search(arr, -3) == -1
assert binary_search_recursive(arr, -3) == -1
def test_binary_search_greater_than_last(arr):
assert binary_search(arr, 60) == -1
assert binary_search_recursive(arr, 60) == -1
def test_binary_search_end(arr):
assert binary_search(arr, 57) == 5
assert binary_search_recursive(arr, 57) == 5
def test_binary_search_mid(arr):
assert binary_search(arr, 20) == 3
assert binary_search_recursive(arr, 20) == 3
def test_binary2(self):
assert searching.binary_search(searching.arr, 11) == "Not-Found"
def test_binary1(self):
assert searching.binary_search(searching.arr, 5) == 5
# search_lab.py
# In this lab, you will be using two searching algorithms we covered in class to
# search for a word in dictionary. Compare the performance for each algorithm.
# You will have to output the number of steps for both algorithms when used for
# searching for the same word. (case-insensitive)
# Your output should look like this.
# Demo output
# Search word: {"orange"}
# Linear Search: found at {0}, took {0} steps
# Binary Search: found at {0}, took {0} steps
from searching.linear_search import *
from searching.binary_search import *
with open("words") as f: # open the file (words)
lines = f.readlines() # read all lines as a list of lines
# strip off the newline character for each word in the list
# "list comprehension" (syntax) - python specific
# stripped = []
# for line in lines:
# stripped.append(line.strip().lower())
lines = [line.strip().lower() for line in lines]
target = input("Search word: ").lower()
li = linear_search(lines, target)
bi = binary_search(lines, target)
print(f"Linear Search: found at {li[0]}, took {li[1]} steps")
print(f"Binary Search: found at {bi[0]}, took {bi[1]} steps")