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))