def remove(self, key):
i = binary_search(self.keys, key)
if i < 0:
return False
del self.keys[i]
del self.values[i]
return True
def get_node(self, key):
i = binary_search(self.keys, key)
if i < 0:
i = ~i
if i > 0:
i -= 1
return (i, self.values[i])
def _move_to(self, nodes, key, node):
if node.is_internal:
next_index, next_node = node.get_node(key)
nodes.append((next_index, node))
self._move_to(nodes, key, next_node)
else:
i = binary_search(node.keys, key)
nodes.append((i, node))
def add(self, key, value):
i = binary_search(self.keys, key)
if i >= 0:
self.values[i] = value
return True
if len(self.keys) == NodeSize:
return False
i = ~i
self.keys.insert(i, key)
self.values.insert(i, value)
return True
def interpolate(self, times_to_interpolate):
"""
Produces new TimeSeries with linearly interpolated values using
piecewise-linear functions with stationary boundary conditions
Parameters:
-----------
self: TimeSeries instance
times_to_interpolate: sorted sequence of times to be interpolated
Returns:
--------
TimeSeries instance with interpolated times
Examples:
--------
>>> ts = TimeSeries(times=[0,1,2],values=[40,20,30])
>>> ts.interpolate([0.5,1.5,3])
TimeSeries(Length: 3, Times: [0.5, 1.5, 3], Values: [30.0, 25.0, 30])
"""
tms = []
interpolated_values = []
for t in times_to_interpolate:
tms.append(t)
# if the time is less than all the times we have
if t <= self._times[0]:
interpolated_values.append(self._values[0])
# if the time is greater than all the times we have
elif t >= self._times[-1]:
interpolated_values.append(self._values[-1])
else:
idx = binary_search(self._times, t)
if type(idx) == tuple:
left_idx, right_idx = idx
m = float(self._values[right_idx] - self._values[left_idx]
) / (self._times[right_idx] -
self._times[left_idx])
interpolated_values.append((t - self._times[left_idx]) *
m + self._values[left_idx])
else:
interpolated_values.append(self._values[idx])
return self.__class__(times=tms, values=interpolated_values)
def galloping_search(array, target):
if array[0] == target:
return (0, 1)
comparisons = 1
# Stage 1 - Find the large index
size = len(array)
jump = 1
cursor = 0
while cursor < size and array[cursor] < target:
comparisons += 1
jump *= 2
cursor += jump
# Stage 2 - slice the array and run the binary search
array = array[(cursor // 2):min(cursor, size) + 1]
sub_search = binary_search(array, target)
return ((cursor // 2) + sub_search[0] - 1, sub_search[1] + comparisons)
count = 1
v = []
d = {}
for r in f:
s = r.split("<SEP>")
#print("s = ",s)
#print("namn = ",namn)
låt = songdata(s[0], s[1], s[2], s[3])
v.append(låt)
d[låt.artistnamn] = låt
#print("artistnamn = ",låt.artistnamn)
count = count + 1
if count > 100:
break
return v, d
v, d = readfile("unique_tracks.txt")
n = len(v)
sista = v[n - 4]
testartistnamn = sista.artistnamn
print("testartistnamn = ", testartistnamn)
quicksort(v)
print(v[0].artistnamn)
print(v[1].artistnamn)
print(v[2].artistnamn)
print(v[99].artistnamn)
x = binary_search(v, testartistnamn)
print("x = ", v[x].artistnamn)
while lista[i].artistnamn != artistnamn:
i = i + 1
return i
n = len(v)
sista = v[n - 1]
testartistnamn = sista.artistnamn
print("För N =", N)
# Linjärsökning osorterad lista
t1 = timeit.timeit(stmt=lambda: linsok(v, testartistnamn), number=m) / m
print("Linjärsökningen osorterad lista tog", round(t1, 4), "sekunder")
# Quicksort
t3 = timeit.timeit(stmt=lambda: quicksort(v), number=1)
print("Sortering av en lista tog", round(t3, 4), "sekunder")
# Linjärsökning sorterad lista
t2 = timeit.timeit(stmt=lambda: linsok(v, testartistnamn), number=m) / m
print("Linjärsökningen i sorterad lista tog", round(t2, 4), "sekunder")
# Binärsökning
ind = binary_search(v, testartistnamn)
t4 = timeit.timeit(stmt=lambda: binary_search(v2, testartistnamn),
number=m) / m
print("Binärsökningen i sorterad lista tog", round(t4, 4), "sekunder")
#Slår upp element med Pythons dictionary
t5 = timeit.timeit(stmt=lambda: d[testartistnamn], number=m) / m
print("Uppslag i en dictionary tog", round(t5, 8), "sekunder")
def test_inserts_at_beginning():
assert binary_search([1, 2, 3], -1) == 0
def test_inserts_at_end():
assert binary_search([1, 2, 3], 5) == 3
def test_sorted(self):
self.assertEqual(binary_search([2, 1, 5, 3, 6], 3), (1, 2))
def test_binary_search(self):
result = binary_search(self.lst, 4)
self.assertEqual(3, result)
result = binary_search(self.lst, 1)
self.assertEqual(0, result)
# Linjärsökning i osorterad lista
t1=timeit.timeit(stmt = lambda: linsok(v,testlåt), number = k)/k
#print("Linjärsökningen osorterad lista tog", round(1, 4) , "sekunder")
# Linjärsökning i sorterad lista
quicksort(v)#sorterar listan
t2=timeit.timeit(stmt = lambda: linsok(v,testlåt), number = k)/k
#print("Linjärsökningen i sorterad lista tog", round(t, 4) , "sekunder")
# Quicksort
t3=timeit.timeit(stmt = lambda: quicksort(v2), number = 3)/3
#print("Sortering av en lista tog", round(t, 4) , "sekunder")
# Binärsökning
indx = binary_search(v,testlåt)
print("v[indx].låttitel = ",v[indx].låttitel)
t4=timeit.timeit(stmt = lambda: binary_search(v,testlåt), number = k)/k
#print("Binärsökningen i sorterad lista tog", round(t, 4) , "sekunder")
#Slår upp element med Pythons dictionary
t5=timeit.timeit(stmt = lambda: d[testlåt], number = k)/k
#print("Uppslag i en dictionary tog", round(t5, 6) , "sekunder")
print(N)
print(t1)
print(t2)
print(t3)
print(t4)
print(t5)
def test_non_numeric_nan(self):
self.assertEqual(binary_search(
[1, 2, float('NaN'), float('NaN')], 2), 1)
def test_chr(self):
self.assertEqual(binary_search(['a', 'b', 'c', 'd'], 'c'), 2)
def test_non_numeric_str(self):
with self.assertRaises(TypeError):
binary_search(['l', 'ol'], 2)
def test_not_array(self):
with self.assertRaises(TypeError):
binary_search(1, 2)
def test_empty(self):
self.assertEqual(binary_search([], 1), (-1, 0))
sorted_array = ins.insertion_sort(inp_arr)
elif sel == 3:
sorted_array = bs.bubble_sort(inp_arr)
elif sel == 4:
sorted_array, invcount = ms.merge_sort(inp_arr, 0)
elif sel == 5:
qs.quick_sort(inp_arr, 0, len(inp_arr) - 1)
elif sel == 6:
is_sort = input("Is the input already sorted(Y/N): ")
if not is_sort.upper().strip() == "Y":
sorted_arr, x = ms.merge_sort(inp_arr, 0)
start_time - time.time()
num = int(input("Enter number to search:"))
idx, found = bins.binary_search(inp_arr, int(num), 0)
if found:
print(f"{num} is found at location {idx} in the input array")
else:
print(
f"{num} is not found in array, closest match at location {idx} is {inp_arr[idx]}"
)
elif sel == 7 or sel == 8:
stat = 0
while True:
stat = int(input("Enter order of statistic to search: "))
if stat < 1 or stat > len(inp_arr):
print(f"Enter number between 1 and {len(inp_arr)}")
def get(self, key):
i = binary_search(self.keys, key)
if i >= 0:
return self.values[i]
return None
def main():
rows = []
b_total = 0
g_total = 0
b_total_compars = 0
g_total_compars = 0
num_tests = 50
num_items = 1000
print("Test | Num_items | Binary Time | | Galloping Time | |")
for test in range(0, num_tests):
array = [randint(0, num_items) for item in range(0, num_items)]
array.sort()
# Best Case (Non-Trivial)
#target = array[10]
# Worst Case
#target = array[-10]
# Average Case
target = choice(array)
# Run the binary search
b_start = datetime.now()
b = binary_search(array, target)
b_subtotal = (datetime.now() - b_start).microseconds
b_total += b_subtotal
b_compars = b[1]
b_total_compars += b_compars
# Run the galloping search
g_start = datetime.now()
g = galloping_search(array, target)
g_subtotal = (datetime.now() - g_start).microseconds
g_total += g_subtotal
g_compars = g[1]
g_total_compars += g_compars
print("{:4} | {:9} | {:11} | {:3} | {:14} | {:3} |".format(test, num_items, b_subtotal, b_compars, g_subtotal, g_compars))
rows.append([num_items, b_compars, 'Binary Search'])
rows.append([num_items, g_compars, 'Galloping Search'])
num_items += 1000
print("Binary Search Average: {}".format(b_total // num_tests))
print("Galloping Search Average: {}".format(g_total // num_tests))
print("Binary Search Comparisons Average: {}".format(b_total_compars // num_tests))
print("Galloping Search Comparisons Average: {}".format(g_total_compars // num_tests))
df = pd.DataFrame(rows, columns=('N', 'C', 'Class'))
g = sns.lmplot(x='N', y='C', ci=0, hue='Class', data=df, logx=True, size=5)
g.savefig('out.png')
def test_non_numeric_inf(self):
self.assertEqual(binary_search([1, 2, np.inf], np.inf), 2)
def test_binary_search_not_found(self):
with self.assertRaises(ValueError):
binary_search(self.lst, 6)
with self.assertRaises(ValueError):
binary_search(self.lst, 0)
def test_inserts_at_smallest_point():
assert binary_search([1, 2, 2, 3], 2) == 1
def test_binary_search_does_not_crash(ls, value):
binary_search(ls, value)
# Linjärsökning osorterad lista
t1 = timeit.timeit(stmt=lambda: linsok(v, "John Williams"), number=N)
#print("Linjärsökningen osorterad lista tog", round(1, 4) , "sekunder")
# Linjärsökning sorterad lista
quicksort(v)
t2 = timeit.timeit(stmt=lambda: linsok(v2, "John Williams"), number=N)
#print("Linjärsökningen i sorterad lista tog", round(t, 4) , "sekunder")
# Quicksort
t3 = timeit.timeit(stmt=lambda: quicksort(v2), number=N)
#print("Sortering av en lista tog", round(t, 4) , "sekunder")
# Binärsökning
ind = binary_search(v, "Hall Of Fame")
t4 = timeit.timeit(stmt=lambda: binary_search(v, "Hall Of Fame"), number=N)
#print("Binärsökningen i sorterad lista tog", round(t, 4) , "sekunder")
#Slår upp element med Pythons dictionary
t5 = timeit.timeit(stmt=lambda: d["John Williams"], number=N)
#print("Uppslag i en dictionary tog", round(t5, 6) , "sekunder")
print(N)
print(t1)
print(t2)
print(t3)
print(t4)
print(t5)
print(v[ind].artistnamn)
from binarysearch import binary_search
def selection_sort(arr):
# iterate through the array to find the smallest element in the
# unsorted portion of the array
# swap the smallest element with the front of the unsorted buffer
for i in range(len(arr)):
# in this loop, i is the index of the boundary
# find the smallest element to the RIGHT of the boundary
mindex = i
for j in range(i, len(arr)):
if arr[j] < arr[mindex]:
mindex = j
# then swap
arr[i], arr[mindex] = arr[mindex], arr[i]
return arr
x = [3, 76, 34, 52, 19, 305, 0, 0, 0, 34, -3, 1, 42, 0]
print(x)
selection_sort(x)
print(x)
print(binary_search(x, 0))
