def _do_match(string, query, kmp_table): j, k = 0, 0 positions = DynamicOneDimensionalArray(int, 0) while j < len(string): if query[k] == string[j]: j = j + 1 k = k + 1 if k == len(query): positions.append(j - k) k = kmp_table[k] else: k = kmp_table[k] if k < 0: j = j + 1 k = k + 1 return positions
def _rabin_karp(text, query): t = len(text) q = len(query) positions = DynamicOneDimensionalArray(int, 0) if q == 0 or t == 0: return positions query_hash = _hash_str(query) text_hash = OneDimensionalArray(int, t + 1) text_hash.fill(0) p_pow = _p_pow(t) for i in range(t): text_hash[i + 1] = (text_hash[i] + ord(text[i]) * p_pow[i]) % MOD for i in range(t - q + 1): curr_hash = (text_hash[i + q] + MOD - text_hash[i]) % MOD if curr_hash == (query_hash * p_pow[i]) % MOD: positions.append(i) return positions
def test_BinaryHeap(): max_heap = BinaryHeap(heap_property="max") assert raises(IndexError, lambda: max_heap.extract()) max_heap.insert(100, 100) max_heap.insert(19, 19) max_heap.insert(36, 36) max_heap.insert(17, 17) max_heap.insert(3, 3) max_heap.insert(25, 25) max_heap.insert(1, 1) max_heap.insert(2, 2) max_heap.insert(7, 7) assert str(max_heap) == \ ("[(100, 100, [1, 2]), (19, 19, [3, 4]), " "(36, 36, [5, 6]), (17, 17, [7, 8]), " "(3, 3, []), (25, 25, []), (1, 1, []), " "(2, 2, []), (7, 7, [])]") assert max_heap.extract().key == 100 expected_sorted_elements = [36, 25, 19, 17, 7, 3, 2, 1] l = max_heap.heap[0].left l = max_heap.heap[0].right sorted_elements = [] for _ in range(8): sorted_elements.append(max_heap.extract().key) assert expected_sorted_elements == sorted_elements elements = [ TreeNode(7, 7), TreeNode(25, 25), TreeNode(100, 100), TreeNode(1, 1), TreeNode(2, 2), TreeNode(3, 3), TreeNode(17, 17), TreeNode(19, 19), TreeNode(36, 36) ] min_heap = BinaryHeap(elements=elements, heap_property="min") assert min_heap.extract().key == 1 expected_sorted_elements = [2, 3, 7, 17, 19, 25, 36, 100] sorted_elements = [min_heap.extract().key for _ in range(8)] assert expected_sorted_elements == sorted_elements non_TreeNode_elements = [(7, 7), TreeNode(25, 25), TreeNode(100, 100), TreeNode(1, 1), (2, 2), TreeNode(3, 3), TreeNode(17, 17), TreeNode(19, 19), TreeNode(36, 36)] assert raises( TypeError, lambda: BinaryHeap(elements=non_TreeNode_elements, heap_property='min')) non_TreeNode_elements = DynamicOneDimensionalArray(int, 0) non_TreeNode_elements.append(1) non_TreeNode_elements.append(2) assert raises( TypeError, lambda: BinaryHeap(elements=non_TreeNode_elements, heap_property='min')) non_heapable = "[1, 2, 3]" assert raises( ValueError, lambda: BinaryHeap(elements=non_heapable, heap_property='min'))
def longest_increasing_subsequence(array, **kwargs): """ Returns the longest increasing subsequence (as a OneDimensionalArray) that can be obtained from a given OneDimensionalArray. A subsequence of an array is an ordered subset of the array's elements having the same sequential ordering as the original array. Here, an increasing sequence stands for a strictly increasing sequence of numbers. Parameters ========== array: OneDimensionalArray The given array in the form of a OneDimensionalArray backend: pydatastructs.Backend The backend to be used. Optional, by default, the best available backend is used. Returns ======= output: OneDimensionalArray Returns the longest increasing subsequence that can be obtained from the given array Examples ======== >>> from pydatastructs import lower_bound, OneDimensionalArray as ODA >>> from pydatastructs import longest_increasing_subsequence as LIS >>> array = ODA(int, [2, 5, 3, 7, 11, 8, 10, 13, 6]) >>> longest_inc_subsequence = LIS(array) >>> str(longest_inc_subsequence) '[2, 3, 7, 8, 10, 13]' >>> array2 = ODA(int, [3, 4, -1, 5, 8, 2, 2 ,2, 3, 12, 7, 9, 10]) >>> longest_inc_subsequence = LIS(array2) >>> str(longest_inc_subsequence) '[-1, 2, 3, 7, 9, 10]' """ raise_if_backend_is_not_python(longest_increasing_subsequence, kwargs.get('backend', Backend.PYTHON)) n = len(array) dp = OneDimensionalArray(int, n) dp.fill(0) parent = OneDimensionalArray(int, n) parent.fill(-1) length = 0 for i in range(1, n): if array[i] <= array[dp[0]]: dp[0] = i elif array[dp[length]] < array[i]: length += 1 dp[length] = i parent[i] = dp[length - 1] else: curr_array = [array[dp[i]] for i in range(length)] ceil = lower_bound(curr_array, array[i]) dp[ceil] = i parent[i] = dp[ceil - 1] ans = DynamicOneDimensionalArray(int, 0) last_index = dp[length] while last_index != -1: ans.append(array[last_index]) last_index = parent[last_index] n = ans._last_pos_filled + 1 ans_ODA = OneDimensionalArray(int, n) for i in range(n): ans_ODA[n - 1 - i] = ans[i] return ans_ODA