SYMBOL INDEX (1859 symbols across 404 files)

FILE: algorithms/array/delete_nth.py
  function delete_nth_naive (line 23) | def delete_nth_naive(array: list[int], n: int) -> list[int]:
  function delete_nth (line 44) | def delete_nth(array: list[int], n: int) -> list[int]:

FILE: algorithms/array/flatten.py
  function flatten (line 20) | def flatten(input_arr: Iterable[Any], output_arr: list[Any] | None = Non...
  function flatten_iter (line 44) | def flatten_iter(iterable: Iterable[Any]) -> Generator[Any, None, None]:

FILE: algorithms/array/garage.py
  function garage (line 18) | def garage(initial: list[int], final: list[int]) -> tuple[int, list[list...

FILE: algorithms/array/josephus.py
  function josephus (line 20) | def josephus(items: list[Any], skip: int) -> Generator[Any, None, None]:

FILE: algorithms/array/limit.py
  function limit (line 17) | def limit(

FILE: algorithms/array/longest_non_repeat.py
  function longest_non_repeat_v1 (line 17) | def longest_non_repeat_v1(string: str) -> int:
  function longest_non_repeat_v2 (line 43) | def longest_non_repeat_v2(string: str) -> int:
  function get_longest_non_repeat_v1 (line 69) | def get_longest_non_repeat_v1(string: str) -> tuple[int, str]:
  function get_longest_non_repeat_v2 (line 98) | def get_longest_non_repeat_v2(string: str) -> tuple[int, str]:
  function get_longest_non_repeat_v3 (line 127) | def get_longest_non_repeat_v3(string: str) -> tuple[int, str]:

FILE: algorithms/array/max_ones_index.py
  function max_ones_index (line 17) | def max_ones_index(array: list[int]) -> int:

FILE: algorithms/array/merge_intervals.py
  class Interval (line 17) | class Interval:
    method __init__ (line 25) | def __init__(self, start: int = 0, end: int = 0) -> None:
    method __repr__ (line 29) | def __repr__(self) -> str:
    method __iter__ (line 32) | def __iter__(self):
    method __getitem__ (line 35) | def __getitem__(self, index: int) -> int:
    method __len__ (line 40) | def __len__(self) -> int:
    method __contains__ (line 43) | def __contains__(self, item: int) -> bool:
    method __eq__ (line 46) | def __eq__(self, other: object) -> bool:
    method as_list (line 51) | def as_list(self) -> list[int]:
    method merge (line 60) | def merge(intervals: list[Interval]) -> list[Interval]:
    method print_intervals (line 82) | def print_intervals(intervals: list[Interval]) -> str:
  function merge_intervals (line 101) | def merge_intervals(intervals: list[list[int]]) -> list[list[int]] | None:

FILE: algorithms/array/missing_ranges.py
  function missing_ranges (line 17) | def missing_ranges(array: list[int], low: int, high: int) -> list[tuple[...

FILE: algorithms/array/move_zeros.py
  function move_zeros (line 19) | def move_zeros(array: list[Any]) -> list[Any]:

FILE: algorithms/array/n_sum.py
  function n_sum (line 21) | def n_sum(

FILE: algorithms/array/plus_one.py
  function plus_one_v1 (line 17) | def plus_one_v1(digits: list[int]) -> list[int]:
  function plus_one_v2 (line 46) | def plus_one_v2(digits: list[int]) -> list[int]:
  function plus_one_v3 (line 69) | def plus_one_v3(num_arr: list[int]) -> list[int]:

FILE: algorithms/array/remove_duplicates.py
  function remove_duplicates (line 20) | def remove_duplicates(array: list[Any]) -> list[Any]:

FILE: algorithms/array/rotate.py
  function rotate_v1 (line 18) | def rotate_v1(array: list[int], k: int) -> list[int]:
  function rotate_v2 (line 42) | def rotate_v2(array: list[int], k: int) -> list[int]:
  function rotate_v3 (line 72) | def rotate_v3(array: list[int] | None, k: int) -> list[int] | None:

FILE: algorithms/array/summarize_ranges.py
  function summarize_ranges (line 17) | def summarize_ranges(array: list[int]) -> list[tuple[int, ...]]:

FILE: algorithms/array/three_sum.py
  function three_sum (line 17) | def three_sum(array: list[int]) -> set[tuple[int, int, int]]:

FILE: algorithms/array/top_1.py
  function top_1 (line 19) | def top_1(array: list[Any]) -> list[Any]:

FILE: algorithms/array/trimmean.py
  function trimmean (line 17) | def trimmean(array: list[float], percentage: float) -> float:

FILE: algorithms/array/two_sum.py
  function two_sum (line 17) | def two_sum(array: list[int], target: int) -> tuple[int, int] | None:

FILE: algorithms/backtracking/add_operators.py
  function add_operators (line 18) | def add_operators(digits: str, target: int) -> list[str]:
  function _dfs (line 39) | def _dfs(

FILE: algorithms/backtracking/anagram.py
  function anagram (line 17) | def anagram(first: str, second: str) -> bool:

FILE: algorithms/backtracking/array_sum_combinations.py
  function array_sum_combinations (line 20) | def array_sum_combinations(
  function unique_array_sum_combinations (line 78) | def unique_array_sum_combinations(

FILE: algorithms/backtracking/combination_sum.py
  function combination_sum (line 18) | def combination_sum(candidates: list[int], target: int) -> list[list[int]]:
  function _dfs (line 38) | def _dfs(

FILE: algorithms/backtracking/factor_combinations.py
  function get_factors (line 17) | def get_factors(number: int) -> list[list[int]]:
  function recursive_get_factors (line 42) | def recursive_get_factors(number: int) -> list[list[int]]:

FILE: algorithms/backtracking/find_words.py
  function find_words (line 18) | def find_words(board: list[list[str]], words: list[str]) -> list[str]:
  function _backtrack (line 55) | def _backtrack(

FILE: algorithms/backtracking/generate_abbreviations.py
  function generate_abbreviations (line 17) | def generate_abbreviations(word: str) -> list[str]:
  function _backtrack (line 35) | def _backtrack(

FILE: algorithms/backtracking/generate_parenthesis.py
  function generate_parenthesis_v1 (line 17) | def generate_parenthesis_v1(count: int) -> list[str]:
  function _add_pair_v1 (line 38) | def _add_pair_v1(
  function generate_parenthesis_v2 (line 54) | def generate_parenthesis_v2(count: int) -> list[str]:
  function _add_pair_v2 (line 75) | def _add_pair_v2(

FILE: algorithms/backtracking/letter_combination.py
  function letter_combinations (line 17) | def letter_combinations(digits: str) -> list[str]:

FILE: algorithms/backtracking/minimax.py
  function minimax (line 15) | def minimax(

FILE: algorithms/backtracking/palindrome_partitioning.py
  function palindromic_substrings (line 19) | def palindromic_substrings(text: str) -> list[list[str]]:
  function palindromic_substrings_iter (line 43) | def palindromic_substrings_iter(text: str) -> Generator[list[str], None,...

FILE: algorithms/backtracking/pattern_match.py
  function pattern_match (line 18) | def pattern_match(pattern: str, string: str) -> bool:
  function _backtrack (line 37) | def _backtrack(

FILE: algorithms/backtracking/permute.py
  function permute (line 18) | def permute(elements: list | str) -> list:
  function permute_iter (line 40) | def permute_iter(elements: list | str) -> Generator:
  function permute_recursive (line 61) | def permute_recursive(nums: list[int]) -> list[list[int]]:
  function _dfs (line 79) | def _dfs(

FILE: algorithms/backtracking/permute_unique.py
  function permute_unique (line 17) | def permute_unique(nums: list[int]) -> list[list[int]]:

FILE: algorithms/backtracking/subsets.py
  function subsets (line 17) | def subsets(nums: list[int]) -> list[list[int]]:
  function _backtrack (line 35) | def _backtrack(
  function subsets_v2 (line 51) | def subsets_v2(nums: list[int]) -> list[list[int]]:

FILE: algorithms/backtracking/subsets_unique.py
  function subsets_unique (line 17) | def subsets_unique(nums: list[int]) -> list[tuple[int, ...]]:
  function _backtrack (line 35) | def _backtrack(

FILE: algorithms/bit_manipulation/add_bitwise_operator.py
  function add_bitwise_operator (line 17) | def add_bitwise_operator(first: int, second: int) -> int:

FILE: algorithms/bit_manipulation/binary_gap.py
  function binary_gap (line 18) | def binary_gap(number: int) -> int:

FILE: algorithms/bit_manipulation/bit_operation.py
  function get_bit (line 17) | def get_bit(number: int, position: int) -> int:
  function set_bit (line 39) | def set_bit(number: int, position: int) -> int:
  function clear_bit (line 59) | def clear_bit(number: int, position: int) -> int:
  function update_bit (line 80) | def update_bit(number: int, position: int, bit: int) -> int:

FILE: algorithms/bit_manipulation/bytes_int_conversion.py
  function int_to_bytes_big_endian (line 19) | def int_to_bytes_big_endian(number: int) -> bytes:
  function int_to_bytes_little_endian (line 39) | def int_to_bytes_little_endian(number: int) -> bytes:
  function bytes_big_endian_to_int (line 59) | def bytes_big_endian_to_int(byte_string: bytes) -> int:
  function bytes_little_endian_to_int (line 79) | def bytes_little_endian_to_int(byte_string: bytes) -> int:

FILE: algorithms/bit_manipulation/count_flips_to_convert.py
  function count_flips_to_convert (line 18) | def count_flips_to_convert(first: int, second: int) -> int:

FILE: algorithms/bit_manipulation/count_ones.py
  function count_ones_recur (line 17) | def count_ones_recur(number: int) -> int:
  function count_ones_iter (line 37) | def count_ones_iter(number: int) -> int:

FILE: algorithms/bit_manipulation/find_difference.py
  function find_difference (line 17) | def find_difference(original: str, shuffled: str) -> str:

FILE: algorithms/bit_manipulation/find_missing_number.py
  function find_missing_number (line 18) | def find_missing_number(nums: list[int]) -> int:
  function find_missing_number2 (line 43) | def find_missing_number2(nums: list[int]) -> int:

FILE: algorithms/bit_manipulation/flip_bit_longest_sequence.py
  function flip_bit_longest_seq (line 17) | def flip_bit_longest_seq(number: int) -> int:

FILE: algorithms/bit_manipulation/gray_code.py
  function gray_code (line 12) | def gray_code(n: int) -> list[int]:
  function gray_to_binary (line 26) | def gray_to_binary(gray: int) -> int:

FILE: algorithms/bit_manipulation/has_alternative_bit.py
  function has_alternative_bit (line 17) | def has_alternative_bit(number: int) -> bool:
  function has_alternative_bit_fast (line 46) | def has_alternative_bit_fast(number: int) -> bool:

FILE: algorithms/bit_manipulation/insert_bit.py
  function insert_one_bit (line 16) | def insert_one_bit(number: int, bit: int, position: int) -> int:
  function insert_mult_bits (line 43) | def insert_mult_bits(number: int, bits: int, length: int, position: int)...

FILE: algorithms/bit_manipulation/power_of_two.py
  function is_power_of_two (line 18) | def is_power_of_two(number: int) -> bool:

FILE: algorithms/bit_manipulation/remove_bit.py
  function remove_bit (line 17) | def remove_bit(number: int, position: int) -> int:

FILE: algorithms/bit_manipulation/reverse_bits.py
  function reverse_bits (line 16) | def reverse_bits(number: int) -> int:

FILE: algorithms/bit_manipulation/single_number.py
  function single_number (line 17) | def single_number(nums: list[int]) -> int:

FILE: algorithms/bit_manipulation/single_number2.py
  function single_number2 (line 18) | def single_number2(nums: list[int]) -> int:

FILE: algorithms/bit_manipulation/single_number3.py
  function single_number3 (line 18) | def single_number3(nums: list[int]) -> list[int]:

FILE: algorithms/bit_manipulation/subsets.py
  function subsets (line 17) | def subsets(nums: list[int]) -> set[tuple[int, ...]]:

FILE: algorithms/bit_manipulation/swap_pair.py
  function swap_pair (line 17) | def swap_pair(number: int) -> int:

FILE: algorithms/common/graph.py
  class Graph (line 15) | class Graph:
    method unweighted (line 40) | def unweighted(cls, adj: dict[str, list[str]], directed: bool = True) ...
    method nodes (line 61) | def nodes(self) -> set[str]:
    method add_edge (line 78) | def add_edge(self, source: str, target: str, weight: float = 1) -> None:

FILE: algorithms/common/list_node.py
  class ListNode (line 15) | class ListNode:

FILE: algorithms/common/tree_node.py
  class TreeNode (line 14) | class TreeNode:

FILE: algorithms/compression/elias.py
  function _log2 (line 20) | def _log2(x: int | float) -> float:
  function _binary (line 32) | def _binary(x: int, length: int = 1) -> str:
  function _unary (line 46) | def _unary(x: int) -> str:
  function _elias_generic (line 58) | def _elias_generic(
  function elias_gamma (line 81) | def elias_gamma(x: int) -> str:
  function elias_delta (line 99) | def elias_delta(x: int) -> str:

FILE: algorithms/compression/huffman_coding.py
  class Node (line 21) | class Node:
    method __init__ (line 24) | def __init__(
    method __lt__ (line 36) | def __lt__(self, other: Node) -> bool:
    method __gt__ (line 39) | def __gt__(self, other: Node) -> bool:
    method __eq__ (line 42) | def __eq__(self, other: object) -> bool:
    method __str__ (line 47) | def __str__(self) -> str:
    method __repr__ (line 50) | def __repr__(self) -> str:
  class HuffmanReader (line 54) | class HuffmanReader:
    method __init__ (line 57) | def __init__(self, file: object) -> None:
    method get_number_of_additional_bits_in_the_last_byte (line 62) | def get_number_of_additional_bits_in_the_last_byte(self) -> int:
    method load_tree (line 71) | def load_tree(self) -> Node:
    method _fill_tree (line 100) | def _fill_tree(self, leaves_queue: deque[Node]) -> None:
    method _load_byte (line 112) | def _load_byte(self, buff_limit: int = 8) -> bool:
    method get_bit (line 129) | def get_bit(self, buff_limit: int = 8) -> str | int:
    method get_byte (line 142) | def get_byte(self) -> str | int:
  class HuffmanWriter (line 155) | class HuffmanWriter:
    method __init__ (line 158) | def __init__(self, file: object) -> None:
    method write_char (line 163) | def write_char(self, char: str) -> None:
    method write_int (line 171) | def write_int(self, num: int) -> None:
    method write_bits (line 180) | def write_bits(self, bits: str) -> None:
    method save_tree (line 193) | def save_tree(self, tree: Node) -> None:
    method _save_information_about_additional_bits (line 218) | def _save_information_about_additional_bits(self, additional_bits: int...
    method close (line 231) | def close(self) -> None:
  class TreeFinder (line 239) | class TreeFinder:
    method __init__ (line 242) | def __init__(self, tree: Node) -> None:
    method find (line 247) | def find(self, bit: str) -> bool:
    method _reset (line 269) | def _reset(self, found: int | str = "") -> None:
  class HuffmanCoding (line 279) | class HuffmanCoding:
    method __init__ (line 282) | def __init__(self) -> None:
    method decode_file (line 286) | def decode_file(file_in_name: str, file_out_name: str) -> None:
    method _decode_and_write_signs_to_file (line 302) | def _decode_and_write_signs_to_file(
    method encode_file (line 334) | def encode_file(file_in_name: str, file_out_name: str) -> None:
    method _encode_and_write_signs_to_file (line 357) | def _encode_and_write_signs_to_file(
    method _get_char_frequency (line 374) | def _get_char_frequency(file: object) -> dict[int, int]:
    method _generate_codes (line 396) | def _generate_codes(tree: Node) -> dict[int, str]:
    method _create_tree (line 410) | def _create_tree(signs_frequency: dict[int, int]) -> Node:
    method _go_through_tree_and_create_codes (line 438) | def _go_through_tree_and_create_codes(

FILE: algorithms/compression/rle_compression.py
  function encode_rle (line 18) | def encode_rle(data: str) -> str:
  function decode_rle (line 52) | def decode_rle(data: str) -> str:

FILE: algorithms/data_structures/avl_tree.py
  class AvlTree (line 6) | class AvlTree:
    method __init__ (line 11) | def __init__(self):
    method insert (line 17) | def insert(self, key):
    method re_balance (line 33) | def re_balance(self):
    method update_heights (line 59) | def update_heights(self, recursive=True):
    method update_balances (line 74) | def update_balances(self, recursive=True):
    method rotate_right (line 90) | def rotate_right(self):
    method rotate_left (line 102) | def rotate_left(self):
    method in_order_traverse (line 114) | def in_order_traverse(self):

FILE: algorithms/data_structures/b_tree.py
  class Node (line 18) | class Node:
    method __init__ (line 27) | def __init__(self) -> None:
    method __repr__ (line 31) | def __repr__(self) -> str:
    method is_leaf (line 40) | def is_leaf(self) -> bool:
  class BTree (line 49) | class BTree:
    method __init__ (line 62) | def __init__(self, t_val: int = 2) -> None:
    method _split_child (line 67) | def _split_child(self, parent: Node, child_index: int) -> None:
    method insert_key (line 88) | def insert_key(self, key: int) -> None:
    method _insert_to_nonfull_node (line 103) | def _insert_to_nonfull_node(self, node: Node, key: int) -> None:
    method find (line 123) | def find(self, key: int) -> bool:
    method remove_key (line 151) | def remove_key(self, key: int) -> None:
    method _remove_key (line 159) | def _remove_key(self, node: Node, key: int) -> bool:
    method _repair_tree (line 192) | def _repair_tree(self, node: Node, child_index: int) -> bool:
    method _rotate_left (line 227) | def _rotate_left(self, parent_node: Node, child_index: int) -> None:
    method _rotate_right (line 243) | def _rotate_right(self, parent_node: Node, child_index: int) -> None:
    method _merge (line 259) | def _merge(
    method _remove_from_nonleaf_node (line 281) | def _remove_from_nonleaf_node(
    method _find_largest_and_delete_in_left_subtree (line 304) | def _find_largest_and_delete_in_left_subtree(self, node: Node) -> int:
    method _find_largest_and_delete_in_right_subtree (line 323) | def _find_largest_and_delete_in_right_subtree(self, node: Node) -> int:
    method traverse_tree (line 342) | def traverse_tree(self) -> list:
    method _traverse_tree (line 358) | def _traverse_tree(self, node: Node, result: list) -> None:

FILE: algorithms/data_structures/bst.py
  class Node (line 18) | class Node:
    method __init__ (line 19) | def __init__(self, data: int) -> None:
  class BST (line 25) | class BST:
    method __init__ (line 26) | def __init__(self) -> None:
    method get_root (line 29) | def get_root(self) -> Node | None:
    method size (line 32) | def size(self) -> int:
    method _recur_size (line 36) | def _recur_size(self, root: Node | None) -> int:
    method search (line 41) | def search(self, data: int) -> bool:
    method _recur_search (line 45) | def _recur_search(self, root: Node | None, data: int) -> bool:
    method insert (line 55) | def insert(self, data: int) -> bool:
    method _recur_insert (line 67) | def _recur_insert(self, root: Node, data: int) -> bool:
    method preorder (line 83) | def preorder(self, root: Node | None) -> list[int]:
    method inorder (line 92) | def inorder(self, root: Node | None) -> list[int]:
    method postorder (line 101) | def postorder(self, root: Node | None) -> list[int]:

FILE: algorithms/data_structures/fenwick_tree.py
  class Fenwick_Tree (line 30) | class Fenwick_Tree:  # noqa: N801
    method __init__ (line 31) | def __init__(self, freq):
    method get_sum (line 35) | def get_sum(self, bit_tree, i):
    method update_bit (line 56) | def update_bit(self, bit_tree, i, v):
    method construct (line 74) | def construct(self):

FILE: algorithms/data_structures/graph.py
  class Node (line 11) | class Node:
    method __init__ (line 14) | def __init__(self, name: str) -> None:
    method get_name (line 18) | def get_name(obj: object) -> str:
    method __eq__ (line 33) | def __eq__(self, obj: object) -> bool:
    method __repr__ (line 36) | def __repr__(self) -> str:
    method __hash__ (line 39) | def __hash__(self) -> int:
    method __ne__ (line 42) | def __ne__(self, obj: object) -> bool:
    method __lt__ (line 45) | def __lt__(self, obj: object) -> bool:
    method __le__ (line 48) | def __le__(self, obj: object) -> bool:
    method __gt__ (line 51) | def __gt__(self, obj: object) -> bool:
    method __ge__ (line 54) | def __ge__(self, obj: object) -> bool:
    method __bool__ (line 57) | def __bool__(self) -> bool:
  class DirectedEdge (line 61) | class DirectedEdge:
    method __init__ (line 64) | def __init__(self, node_from: Node, node_to: Node) -> None:
    method __eq__ (line 68) | def __eq__(self, obj: object) -> bool:
    method __repr__ (line 73) | def __repr__(self) -> str:
  class DirectedGraph (line 77) | class DirectedGraph:
    method __init__ (line 80) | def __init__(self, load_dict: dict[str, list[str]] | None = None) -> N...
    method add_node (line 101) | def add_node(self, node_name: str) -> Node:
    method add_edge (line 117) | def add_edge(self, node_name_from: str, node_name_to: str) -> None:

FILE: algorithms/data_structures/hash_table.py
  class HashTable (line 18) | class HashTable:
    method __init__ (line 31) | def __init__(self, size: int = 11) -> None:
    method put (line 42) | def put(self, key: int, value: object) -> None:
    method get (line 70) | def get(self, key: int) -> object | None:
    method del_ (line 90) | def del_(self, key: int) -> None:
    method hash (line 110) | def hash(self, key: int) -> int:
    method _rehash (line 121) | def _rehash(self, old_hash: int) -> int:
    method __getitem__ (line 132) | def __getitem__(self, key: int) -> object | None:
    method __delitem__ (line 135) | def __delitem__(self, key: int) -> None:
    method __setitem__ (line 138) | def __setitem__(self, key: int, value: object) -> None:
    method __len__ (line 141) | def __len__(self) -> int:
  class ResizableHashTable (line 145) | class ResizableHashTable(HashTable):
    method __init__ (line 157) | def __init__(self) -> None:
    method put (line 160) | def put(self, key: int, value: object) -> None:
    method _resize (line 171) | def _resize(self) -> None:

FILE: algorithms/data_structures/heap.py
  class AbstractHeap (line 20) | class AbstractHeap(metaclass=ABCMeta):
    method __init__ (line 23) | def __init__(self) -> None:  # noqa: B027
    method perc_up (line 27) | def perc_up(self, index: int) -> None:
    method insert (line 35) | def insert(self, val: int) -> None:
    method perc_down (line 43) | def perc_down(self, index: int) -> None:
    method min_child (line 51) | def min_child(self, index: int) -> int:
    method remove_min (line 62) | def remove_min(self) -> int:
  class BinaryHeap (line 70) | class BinaryHeap(AbstractHeap):
    method __init__ (line 81) | def __init__(self) -> None:
    method perc_up (line 86) | def perc_up(self, index: int) -> None:
    method insert (line 102) | def insert(self, val: int) -> None:
    method min_child (line 112) | def min_child(self, index: int) -> int:
    method perc_down (line 127) | def perc_down(self, index: int) -> None:
    method remove_min (line 142) | def remove_min(self) -> int:

FILE: algorithms/data_structures/iterative_segment_tree.py
  class SegmentTree (line 26) | class SegmentTree:
    method __init__ (line 27) | def __init__(self, arr, function):
    method build_tree (line 33) | def build_tree(self):
    method update (line 37) | def update(self, p, v):
    method query (line 44) | def query(self, left, r):

FILE: algorithms/data_structures/kd_tree.py
  class KDNode (line 14) | class KDNode:
    method __init__ (line 19) | def __init__(
  class KDTree (line 32) | class KDTree:
    method __init__ (line 40) | def __init__(self, points: list[tuple[float, ...]]) -> None:
    method _build (line 44) | def _build(self, points: list[tuple[float, ...]], depth: int) -> KDNod...
    method nearest (line 57) | def nearest(self, target: tuple[float, ...]) -> tuple[float, ...]:
    method _nearest (line 63) | def _nearest(
  function _sq_dist (line 82) | def _sq_dist(a: tuple[float, ...], b: tuple[float, ...]) -> float:

FILE: algorithms/data_structures/linked_list.py
  class SinglyLinkedListNode (line 17) | class SinglyLinkedListNode:
    method __init__ (line 25) | def __init__(self, value: object) -> None:
  class DoublyLinkedListNode (line 30) | class DoublyLinkedListNode:
    method __init__ (line 39) | def __init__(self, value: object) -> None:

FILE: algorithms/data_structures/priority_queue.py
  class PriorityQueueNode (line 21) | class PriorityQueueNode:
    method __init__ (line 29) | def __init__(self, data: Any, priority: Any) -> None:
    method __repr__ (line 33) | def __repr__(self) -> str:
  class PriorityQueue (line 42) | class PriorityQueue:
    method __init__ (line 53) | def __init__(
    method __repr__ (line 72) | def __repr__(self) -> str:
    method size (line 80) | def size(self) -> int:
    method push (line 88) | def push(self, item: Any, priority: Any = None) -> None:
    method pop (line 103) | def pop(self) -> Any:

FILE: algorithms/data_structures/queue.py
  class AbstractQueue (line 20) | class AbstractQueue(metaclass=ABCMeta):
    method __init__ (line 23) | def __init__(self) -> None:
    method __len__ (line 26) | def __len__(self) -> int:
    method is_empty (line 29) | def is_empty(self) -> bool:
    method enqueue (line 38) | def enqueue(self, value: object) -> None:
    method dequeue (line 42) | def dequeue(self) -> object:
    method peek (line 46) | def peek(self) -> object:
    method __iter__ (line 50) | def __iter__(self) -> Iterator[object]:
  class ArrayQueue (line 54) | class ArrayQueue(AbstractQueue):
    method __init__ (line 64) | def __init__(self, capacity: int = 10) -> None:
    method __iter__ (line 75) | def __iter__(self) -> Iterator[object]:
    method enqueue (line 83) | def enqueue(self, value: object) -> None:
    method dequeue (line 95) | def dequeue(self) -> object:
    method peek (line 112) | def peek(self) -> object:
    method _expand (line 125) | def _expand(self) -> None:
  class QueueNode (line 130) | class QueueNode:
    method __init__ (line 133) | def __init__(self, value: object) -> None:
  class LinkedListQueue (line 138) | class LinkedListQueue(AbstractQueue):
    method __init__ (line 148) | def __init__(self) -> None:
    method __iter__ (line 153) | def __iter__(self) -> Iterator[object]:
    method enqueue (line 161) | def enqueue(self, value: object) -> None:
    method dequeue (line 176) | def dequeue(self) -> object:
    method peek (line 196) | def peek(self) -> object:

FILE: algorithms/data_structures/red_black_tree.py
  class RBNode (line 6) | class RBNode:
    method __init__ (line 7) | def __init__(self, val, is_red, parent=None, left=None, right=None):
  class RBTree (line 15) | class RBTree:
    method __init__ (line 16) | def __init__(self):
    method left_rotate (line 19) | def left_rotate(self, node):
    method right_rotate (line 40) | def right_rotate(self, node):
    method insert (line 61) | def insert(self, node):
    method fix_insert (line 85) | def fix_insert(self, node):
    method transplant (line 142) | def transplant(self, node_u, node_v):
    method maximum (line 159) | def maximum(self, node):
    method minimum (line 170) | def minimum(self, node):
    method delete (line 181) | def delete(self, node):
    method delete_fixup (line 208) | def delete_fixup(self, node):
    method inorder (line 271) | def inorder(self):

FILE: algorithms/data_structures/segment_tree.py
  class SegmentTree (line 8) | class SegmentTree:
    method __init__ (line 9) | def __init__(self, arr, function):
    method make_tree (line 15) | def make_tree(self, i, left, r):
    method __query (line 25) | def __query(self, i, low, high, left, r):
    method query (line 41) | def query(self, low, high):

FILE: algorithms/data_structures/separate_chaining_hash_table.py
  class _Node (line 17) | class _Node:
    method __init__ (line 26) | def __init__(
  class SeparateChainingHashTable (line 37) | class SeparateChainingHashTable:
    method __init__ (line 54) | def __init__(self, size: int = 11) -> None:
    method put (line 64) | def put(self, key: object, value: object) -> None:
    method get (line 84) | def get(self, key: object) -> object | None:
    method del_ (line 101) | def del_(self, key: object) -> None:
    method hash (line 120) | def hash(self, key: object) -> int:
    method __len__ (line 131) | def __len__(self) -> int:
    method __getitem__ (line 134) | def __getitem__(self, key: object) -> object | None:
    method __delitem__ (line 137) | def __delitem__(self, key: object) -> None:
    method __setitem__ (line 140) | def __setitem__(self, key: object, value: object) -> None:

FILE: algorithms/data_structures/sqrt_decomposition.py
  class SqrtDecomposition (line 26) | class SqrtDecomposition:
    method __init__ (line 45) | def __init__(self, arr: list[int | float]) -> None:
    method update (line 60) | def update(self, index: int, value: int | float) -> None:
    method query (line 84) | def query(self, left: int, right: int) -> int | float:

FILE: algorithms/data_structures/stack.py
  class AbstractStack (line 20) | class AbstractStack(metaclass=ABCMeta):
    method __init__ (line 23) | def __init__(self) -> None:
    method __len__ (line 26) | def __len__(self) -> int:
    method __str__ (line 29) | def __str__(self) -> str:
    method is_empty (line 33) | def is_empty(self) -> bool:
    method __iter__ (line 42) | def __iter__(self) -> Iterator[object]:
    method push (line 46) | def push(self, value: object) -> None:
    method pop (line 50) | def pop(self) -> object:
    method peek (line 54) | def peek(self) -> object:
  class ArrayStack (line 58) | class ArrayStack(AbstractStack):
    method __init__ (line 68) | def __init__(self, size: int = 10) -> None:
    method __iter__ (line 77) | def __iter__(self) -> Iterator[object]:
    method push (line 85) | def push(self, value: object) -> None:
    method pop (line 96) | def pop(self) -> object:
    method peek (line 111) | def peek(self) -> object:
    method _expand (line 124) | def _expand(self) -> None:
  class StackNode (line 129) | class StackNode:
    method __init__ (line 132) | def __init__(self, value: object) -> None:
  class LinkedListStack (line 137) | class LinkedListStack(AbstractStack):
    method __init__ (line 147) | def __init__(self) -> None:
    method __iter__ (line 151) | def __iter__(self) -> Iterator[object]:
    method push (line 159) | def push(self, value: object) -> None:
    method pop (line 170) | def pop(self) -> object:
    method peek (line 186) | def peek(self) -> object:

FILE: algorithms/data_structures/trie.py
  class TrieNode (line 11) | class TrieNode:
    method __init__ (line 12) | def __init__(self):
  class Trie (line 17) | class Trie:
    method __init__ (line 18) | def __init__(self):
    method insert (line 21) | def insert(self, word):
    method search (line 27) | def search(self, word):
    method starts_with (line 35) | def starts_with(self, prefix):

FILE: algorithms/data_structures/union_find.py
  class Union (line 17) | class Union:
    method __init__ (line 33) | def __init__(self) -> None:
    method add (line 38) | def add(self, element: object) -> None:
    method root (line 48) | def root(self, element: object) -> object:
    method unite (line 62) | def unite(self, element1: object, element2: object) -> None:

FILE: algorithms/data_structures/veb_tree.py
  class VEBTree (line 20) | class VEBTree:
    method __init__ (line 32) | def __init__(self, universe_size):
    method _validate_key (line 64) | def _validate_key(self, x):
    method high (line 77) | def high(self, x):
    method low (line 89) | def low(self, x):
    method index (line 101) | def index(self, high, low):
    method empty_insert (line 114) | def empty_insert(self, x):
    method insert (line 123) | def insert(self, x):
    method member (line 154) | def member(self, x):
    method successor (line 175) | def successor(self, x):
    method delete (line 212) | def delete(self, x):
    method minimum (line 256) | def minimum(self):
    method maximum (line 265) | def maximum(self):

FILE: algorithms/dynamic_programming/bitmask.py
  function tsp (line 17) | def tsp(dist: list[list[float]]) -> float:

FILE: algorithms/dynamic_programming/buy_sell_stock.py
  function max_profit_naive (line 21) | def max_profit_naive(prices: list[int]) -> int:
  function max_profit_optimized (line 43) | def max_profit_optimized(prices: list[int]) -> int:

FILE: algorithms/dynamic_programming/climbing_stairs.py
  function climb_stairs (line 21) | def climb_stairs(steps: int) -> int:
  function climb_stairs_optimized (line 42) | def climb_stairs_optimized(steps: int) -> int:

FILE: algorithms/dynamic_programming/coin_change.py
  function count (line 17) | def count(coins: list[int], value: int) -> int:

FILE: algorithms/dynamic_programming/combination_sum.py
  function _helper_topdown (line 21) | def _helper_topdown(nums: list[int], target: int, dp: list[int]) -> int:
  function combination_sum_topdown (line 42) | def combination_sum_topdown(nums: list[int], target: int) -> int:
  function combination_sum_bottom_up (line 61) | def combination_sum_bottom_up(nums: list[int], target: int) -> int:

FILE: algorithms/dynamic_programming/count_paths_dp.py
  function count_paths_recursive (line 14) | def count_paths_recursive(m: int, n: int) -> int:
  function count_paths_memo (line 21) | def count_paths_memo(m: int, n: int) -> int:
  function count_paths_dp (line 33) | def count_paths_dp(m: int, n: int) -> int:

FILE: algorithms/dynamic_programming/edit_distance.py
  function edit_distance (line 17) | def edit_distance(word_a: str, word_b: str) -> int:

FILE: algorithms/dynamic_programming/egg_drop.py
  function egg_drop (line 19) | def egg_drop(n: int, k: int) -> int:

FILE: algorithms/dynamic_programming/fib.py
  function fib_recursive (line 24) | def fib_recursive(n: int) -> int:
  function fib_list (line 44) | def fib_list(n: int) -> int:
  function fib_iter (line 65) | def fib_iter(n: int) -> int:

FILE: algorithms/dynamic_programming/hosoya_triangle.py
  function hosoya (line 17) | def hosoya(height: int, width: int) -> int:
  function hosoya_testing (line 42) | def hosoya_testing(height: int) -> list[int]:

FILE: algorithms/dynamic_programming/house_robber.py
  function house_robber (line 17) | def house_robber(houses: list[int]) -> int:

FILE: algorithms/dynamic_programming/int_divide.py
  function int_divide (line 17) | def int_divide(decompose: int) -> int:

FILE: algorithms/dynamic_programming/job_scheduling.py
  class Job (line 17) | class Job:
    method __init__ (line 20) | def __init__(self, start: int, finish: int, profit: int) -> None:
  function _binary_search (line 26) | def _binary_search(job: list[Job], start_index: int) -> int:
  function schedule (line 51) | def schedule(job: list[Job]) -> int:

FILE: algorithms/dynamic_programming/k_factor.py
  function find_k_factor (line 18) | def find_k_factor(length: int, k_factor: int) -> int:

FILE: algorithms/dynamic_programming/knapsack.py
  class Item (line 17) | class Item:
    method __init__ (line 20) | def __init__(self, value: int, weight: int) -> None:
  function get_maximum_value (line 25) | def get_maximum_value(items: list[Item], capacity: int) -> int:

FILE: algorithms/dynamic_programming/longest_common_subsequence.py
  function longest_common_subsequence (line 16) | def longest_common_subsequence(s_1: str, s_2: str) -> int:

FILE: algorithms/dynamic_programming/longest_increasing.py
  function longest_increasing_subsequence (line 23) | def longest_increasing_subsequence(sequence: list[int]) -> int:
  function longest_increasing_subsequence_optimized (line 45) | def longest_increasing_subsequence_optimized(sequence: list[int]) -> int:
  function longest_increasing_subsequence_optimized2 (line 91) | def longest_increasing_subsequence_optimized2(sequence: list[int]) -> int:

FILE: algorithms/dynamic_programming/matrix_chain_order.py
  function matrix_chain_order (line 19) | def matrix_chain_order(array: list[int]) -> tuple[list[list[int]], list[...

FILE: algorithms/dynamic_programming/max_product_subarray.py
  function max_product (line 22) | def max_product(nums: list[int]) -> int:
  function subarray_with_max_product (line 45) | def subarray_with_max_product(arr: list[int]) -> tuple[int, list[int]]:

FILE: algorithms/dynamic_programming/max_subarray.py
  function max_subarray (line 16) | def max_subarray(array: list[int]) -> int:

FILE: algorithms/dynamic_programming/min_cost_path.py
  function min_cost (line 20) | def min_cost(cost: list[list[int]]) -> int:

FILE: algorithms/dynamic_programming/num_decodings.py
  function num_decodings (line 17) | def num_decodings(enc_mes: str) -> int:
  function num_decodings2 (line 47) | def num_decodings2(enc_mes: str) -> int:

FILE: algorithms/dynamic_programming/planting_trees.py
  function planting_trees (line 20) | def planting_trees(trees: list[int], length: int, width: int) -> float:

FILE: algorithms/dynamic_programming/regex_matching.py
  function is_match (line 17) | def is_match(str_a: str, str_b: str) -> bool:

FILE: algorithms/dynamic_programming/rod_cut.py
  function cut_rod (line 19) | def cut_rod(price: list[int]) -> int:

FILE: algorithms/dynamic_programming/word_break.py
  function word_break (line 17) | def word_break(word: str, word_dict: set[str]) -> bool:

FILE: algorithms/graph/a_star.py
  function a_star (line 20) | def a_star(

FILE: algorithms/graph/all_factors.py
  function get_factors (line 17) | def get_factors(n: int) -> list[list[int]]:
  function get_factors_iterative1 (line 47) | def get_factors_iterative1(n: int) -> list[list[int]]:
  function get_factors_iterative2 (line 72) | def get_factors_iterative2(n: int) -> list[list[int]]:

FILE: algorithms/graph/all_pairs_shortest_path.py
  function all_pairs_shortest_path (line 19) | def all_pairs_shortest_path(

FILE: algorithms/graph/bellman_ford.py
  function bellman_ford (line 18) | def bellman_ford(graph: dict[str, dict[str, float]], source: str) -> bool:
  function _initialize_single_source (line 58) | def _initialize_single_source(

FILE: algorithms/graph/blossom.py
  function max_matching (line 17) | def max_matching(n: int, edges: list[tuple[int, int]]) -> list[tuple[int...
  function _augment (line 75) | def _augment(parent: list[int], match: list[int], u: int, v: int) -> None:

FILE: algorithms/graph/check_bipartite.py
  function check_bipartite (line 18) | def check_bipartite(adj_list: list[list[int]]) -> bool:

FILE: algorithms/graph/check_digraph_strongly_connected.py
  class Graph (line 20) | class Graph:
    method __init__ (line 23) | def __init__(self, vertex_count: int) -> None:
    method add_edge (line 32) | def add_edge(self, source: int, target: int) -> None:
    method dfs (line 41) | def dfs(self) -> bool:
    method _dfs_util (line 47) | def _dfs_util(self, source: int, visited: list[bool]) -> None:
    method reverse_graph (line 59) | def reverse_graph(self) -> Graph:
    method is_strongly_connected (line 71) | def is_strongly_connected(self) -> bool:

FILE: algorithms/graph/clone_graph.py
  class UndirectedGraphNode (line 19) | class UndirectedGraphNode:
    method __init__ (line 22) | def __init__(self, label: int) -> None:
    method shallow_copy (line 26) | def shallow_copy(self) -> UndirectedGraphNode:
    method add_neighbor (line 34) | def add_neighbor(self, node: UndirectedGraphNode) -> None:
  function clone_graph1 (line 43) | def clone_graph1(node: UndirectedGraphNode | None) -> UndirectedGraphNod...
  function clone_graph2 (line 70) | def clone_graph2(node: UndirectedGraphNode | None) -> UndirectedGraphNod...
  function clone_graph (line 97) | def clone_graph(node: UndirectedGraphNode | None) -> UndirectedGraphNode...
  function _dfs (line 114) | def _dfs(

FILE: algorithms/graph/count_connected_number_of_component.py
  function count_components (line 16) | def count_components(adjacency_list: list[list[int]], size: int) -> int:
  function _dfs (line 40) | def _dfs(

FILE: algorithms/graph/count_islands_bfs.py
  function count_islands (line 20) | def count_islands(grid: list[list[int]]) -> int:

FILE: algorithms/graph/count_islands_dfs.py
  function num_islands (line 17) | def num_islands(grid: list[list[int]]) -> int:
  function _dfs (line 39) | def _dfs(grid: list[list[int]], i: int, j: int) -> None:

FILE: algorithms/graph/count_islands_unionfind.py
  function num_islands (line 20) | def num_islands(positions: list[list[int]]) -> list[int]:

FILE: algorithms/graph/cycle_detection.py
  class TraversalState (line 19) | class TraversalState(Enum):
  function is_in_cycle (line 27) | def is_in_cycle(
  function contains_cycle (line 52) | def contains_cycle(graph: dict[str, list[str]]) -> bool:

FILE: algorithms/graph/dijkstra.py
  class Dijkstra (line 17) | class Dijkstra:
    method __init__ (line 20) | def __init__(self, vertex_count: int) -> None:
    method min_distance (line 31) | def min_distance(self, dist: list[float], min_dist_set: list[bool]) ->...
    method dijkstra (line 51) | def dijkstra(self, src: int) -> list[float]:

FILE: algorithms/graph/dijkstra_heapq.py
  function dijkstra (line 22) | def dijkstra(

FILE: algorithms/graph/find_all_cliques.py
  function find_all_cliques (line 17) | def find_all_cliques(edges: dict[str, set[str]]) -> list[list[str]]:

FILE: algorithms/graph/find_path.py
  function find_path (line 17) | def find_path(
  function find_all_path (line 52) | def find_all_path(
  function find_shortest_path (line 89) | def find_shortest_path(

FILE: algorithms/graph/kahns_algorithm.py
  class Solution (line 19) | class Solution:
    method topological_sort (line 22) | def topological_sort(

FILE: algorithms/graph/markov_chain.py
  function _choose_state (line 21) | def _choose_state(state_map: dict[Any, float]) -> Any | None:
  function next_state (line 39) | def next_state(chain: dict[Any, dict[Any, float]], current_state: Any) -...
  function iterating_markov_chain (line 58) | def iterating_markov_chain(

FILE: algorithms/graph/maximum_flow.py
  function _dfs (line 20) | def _dfs(
  function ford_fulkerson (line 57) | def ford_fulkerson(capacity: list[list[int]], source: int, sink: int) ->...
  function edmonds_karp (line 85) | def edmonds_karp(capacity: list[list[int]], source: int, sink: int) -> int:
  function _dinic_bfs (line 136) | def _dinic_bfs(
  function _dinic_dfs (line 168) | def _dinic_dfs(
  function dinic (line 207) | def dinic(capacity: list[list[int]], source: int, sink: int) -> int:

FILE: algorithms/graph/maximum_flow_bfs.py
  function maximum_flow_bfs (line 21) | def maximum_flow_bfs(adjacency_matrix: list[list[int]]) -> int:

FILE: algorithms/graph/maximum_flow_dfs.py
  function maximum_flow_dfs (line 20) | def maximum_flow_dfs(adjacency_matrix: list[list[int]]) -> int:

FILE: algorithms/graph/maze_search_bfs.py
  function maze_search (line 18) | def maze_search(maze: list[list[int]]) -> int:

FILE: algorithms/graph/maze_search_dfs.py
  function find_path (line 16) | def find_path(maze: list[list[int]]) -> int:
  function _dfs (line 33) | def _dfs(

FILE: algorithms/graph/minimum_spanning_tree.py
  class Edge (line 17) | class Edge:
    method __init__ (line 20) | def __init__(self, source: int, target: int, weight: int) -> None:
  class DisjointSet (line 26) | class DisjointSet:
    method __init__ (line 29) | def __init__(self, size: int) -> None:
    method merge_set (line 38) | def merge_set(self, node1: int, node2: int) -> None:
    method find_set (line 55) | def find_set(self, node: int) -> int:
  function kruskal (line 69) | def kruskal(vertex_count: int, edges: list[Edge], forest: DisjointSet) -...

FILE: algorithms/graph/pacific_atlantic.py
  function pacific_atlantic (line 18) | def pacific_atlantic(matrix: list[list[int]]) -> list[list[int]]:
  function _dfs (line 53) | def _dfs(

FILE: algorithms/graph/path_between_two_vertices_in_digraph.py
  class Graph (line 17) | class Graph:
    method __init__ (line 20) | def __init__(self, vertex_count: int) -> None:
    method add_edge (line 30) | def add_edge(self, source: int, target: int) -> None:
    method _dfs (line 39) | def _dfs(self, source: int, target: int) -> None:
    method _dfs_util (line 49) | def _dfs_util(self, visited: list[bool], source: int, target: int) -> ...
    method is_reachable (line 65) | def is_reachable(self, source: int, target: int) -> bool:

FILE: algorithms/graph/prims_minimum_spanning.py
  function prims_minimum_spanning (line 20) | def prims_minimum_spanning(

FILE: algorithms/graph/satisfiability.py
  function _dfs_transposed (line 20) | def _dfs_transposed(
  function _dfs (line 41) | def _dfs(
  function _add_edge (line 64) | def _add_edge(graph: dict[Any, list[Any]], vertex_from: Any, vertex_to: ...
  function _scc (line 77) | def _scc(graph: dict[Any, list[Any]]) -> dict[Any, int]:
  function _build_graph (line 111) | def _build_graph(
  function solve_sat (line 137) | def solve_sat(

FILE: algorithms/graph/shortest_distance_from_all_buildings.py
  function shortest_distance (line 19) | def shortest_distance(grid: list[list[int]]) -> int:
  function _bfs (line 53) | def _bfs(

FILE: algorithms/graph/strongly_connected_components_kosaraju.py
  class Kosaraju (line 17) | class Kosaraju:
    method dfs (line 20) | def dfs(
    method kosaraju (line 45) | def kosaraju(self, vertices: int, adj: list[list[int]]) -> int:

FILE: algorithms/graph/sudoku_solver.py
  class Sudoku (line 17) | class Sudoku:
    method __init__ (line 20) | def __init__(
    method _possible_values (line 38) | def _possible_values(self) -> dict[tuple[int, int], list[str]]:
    method solve (line 63) | def solve(self) -> bool:
    method _valid_one (line 80) | def _valid_one(
    method _undo (line 111) | def _undo(
    method __str__ (line 129) | def __str__(self) -> str:

FILE: algorithms/graph/tarjan.py
  class Tarjan (line 18) | class Tarjan:
    method __init__ (line 21) | def __init__(self, dict_graph: dict[str, list[str]]) -> None:
    method _strongconnect (line 39) | def _strongconnect(self, vertex: object, sccs: list[list]) -> None:

FILE: algorithms/graph/topological_sort_bfs.py
  function topological_sort (line 19) | def topological_sort(vertices: int, edges: list[tuple[int, int]]) -> lis...

FILE: algorithms/graph/topological_sort_dfs.py
  function top_sort_recursive (line 21) | def top_sort_recursive(graph: dict[str, list[str]]) -> list[str]:
  function top_sort (line 59) | def top_sort(graph: dict[str, list[str]]) -> list[str]:

FILE: algorithms/graph/transitive_closure_dfs.py
  class Graph (line 17) | class Graph:
    method __init__ (line 20) | def __init__(self, vertices: int) -> None:
    method add_edge (line 30) | def add_edge(self, source: int, target: int) -> None:
    method _dfs_util (line 42) | def _dfs_util(self, source: int, target: int) -> None:
    method transitive_closure (line 55) | def transitive_closure(self) -> list[list[int]]:

FILE: algorithms/graph/traversal.py
  function dfs_traverse (line 18) | def dfs_traverse(graph: dict[Any, list[Any]], start: Any) -> set[Any]:
  function bfs_traverse (line 44) | def bfs_traverse(graph: dict[Any, list[Any]], start: Any) -> set[Any]:
  function dfs_traverse_recursive (line 70) | def dfs_traverse_recursive(

FILE: algorithms/graph/walls_and_gates.py
  function walls_and_gates (line 17) | def walls_and_gates(rooms: list[list[int]]) -> None:
  function _dfs (line 33) | def _dfs(rooms: list[list[int]], i: int, j: int, depth: int) -> None:

FILE: algorithms/graph/word_ladder.py
  function ladder_length (line 20) | def ladder_length(begin_word: str, end_word: str, word_list: list[str]) ...
  function _word_range (line 66) | def _word_range(word: str) -> Iterator[str]:

FILE: algorithms/greedy/gale_shapley.py
  function gale_shapley (line 18) | def gale_shapley(

FILE: algorithms/greedy/max_contiguous_subsequence_sum.py
  function max_contiguous_subsequence_sum (line 17) | def max_contiguous_subsequence_sum(arr: list[int]) -> int:

FILE: algorithms/heap/k_closest_points.py
  function k_closest (line 20) | def k_closest(
  function _distance (line 49) | def _distance(point: tuple[int, int], origin: tuple[int, int] = (0, 0)) ...

FILE: algorithms/heap/merge_sorted_k_lists.py
  class ListNode (line 19) | class ListNode:
    method __init__ (line 26) | def __init__(self, val: int) -> None:
  function merge_k_lists (line 31) | def merge_k_lists(lists: list[ListNode | None]) -> ListNode | None:

FILE: algorithms/heap/skyline.py
  function get_skyline (line 19) | def get_skyline(lrh: list[list[int]]) -> list[list[int]]:

FILE: algorithms/heap/sliding_window_max.py
  function max_sliding_window (line 19) | def max_sliding_window(nums: list[int], k: int) -> list[int]:

FILE: algorithms/linked_list/add_two_numbers.py
  class Node (line 18) | class Node:
    method __init__ (line 19) | def __init__(self, x: int) -> None:
  function add_two_numbers (line 24) | def add_two_numbers(left: Node, right: Node) -> Node:
  function convert_to_list (line 59) | def convert_to_list(number: int) -> Node | None:
  function convert_to_str (line 88) | def convert_to_str(node: Node | None) -> str:

FILE: algorithms/linked_list/copy_random_pointer.py
  class RandomListNode (line 19) | class RandomListNode:
    method __init__ (line 22) | def __init__(self, label: int) -> None:
  function copy_random_pointer_v1 (line 28) | def copy_random_pointer_v1(head: RandomListNode | None) -> RandomListNod...
  function copy_random_pointer_v2 (line 57) | def copy_random_pointer_v2(head: RandomListNode | None) -> RandomListNod...

FILE: algorithms/linked_list/delete_node.py
  class Node (line 17) | class Node:
    method __init__ (line 18) | def __init__(self, x: int) -> None:
  function delete_node (line 23) | def delete_node(node: Node | None) -> None:

FILE: algorithms/linked_list/first_cyclic_node.py
  class Node (line 17) | class Node:
    method __init__ (line 18) | def __init__(self, x: object) -> None:
  function first_cyclic_node (line 23) | def first_cyclic_node(head: Node | None) -> Node | None:

FILE: algorithms/linked_list/intersection.py
  class Node (line 17) | class Node:
    method __init__ (line 18) | def __init__(self, val: object = None) -> None:
  function intersection (line 23) | def intersection(h1: Node, h2: Node) -> Node | None:

FILE: algorithms/linked_list/is_cyclic.py
  class Node (line 17) | class Node:
    method __init__ (line 18) | def __init__(self, x: object) -> None:
  function is_cyclic (line 23) | def is_cyclic(head: Node | None) -> bool:

FILE: algorithms/linked_list/is_palindrome.py
  function is_palindrome (line 17) | def is_palindrome(head: object | None) -> bool:
  function is_palindrome_stack (line 52) | def is_palindrome_stack(head: object | None) -> bool:
  function is_palindrome_dict (line 85) | def is_palindrome_dict(head: object | None) -> bool:

FILE: algorithms/linked_list/is_sorted.py
  function is_sorted (line 17) | def is_sorted(head: object | None) -> bool:

FILE: algorithms/linked_list/kth_to_last.py
  class Node (line 17) | class Node:
    method __init__ (line 18) | def __init__(self, val: object = None) -> None:
  function kth_to_last_eval (line 23) | def kth_to_last_eval(head: Node, k: int) -> Node | bool:
  function kth_to_last_dict (line 54) | def kth_to_last_dict(head: Node | None, k: int) -> Node | bool:
  function kth_to_last (line 80) | def kth_to_last(head: Node | None, k: int) -> Node | bool:

FILE: algorithms/linked_list/merge_two_list.py
  class Node (line 17) | class Node:
    method __init__ (line 18) | def __init__(self, x: int) -> None:
  function merge_two_list (line 23) | def merge_two_list(l1: Node | None, l2: Node | None) -> Node | None:
  function merge_two_list_recur (line 53) | def merge_two_list_recur(l1: Node | None, l2: Node | None) -> Node | None:

FILE: algorithms/linked_list/partition.py
  class Node (line 17) | class Node:
    method __init__ (line 18) | def __init__(self, val: object = None) -> None:
  function partition (line 23) | def partition(head: Node | None, x: int) -> None:

FILE: algorithms/linked_list/remove_duplicates.py
  class Node (line 18) | class Node:
    method __init__ (line 19) | def __init__(self, val: object = None) -> None:
  function remove_dups (line 24) | def remove_dups(head: Node | None) -> None:
  function remove_dups_wothout_set (line 51) | def remove_dups_wothout_set(head: Node | None) -> None:

FILE: algorithms/linked_list/remove_range.py
  function remove_range (line 17) | def remove_range(head: object | None, start: int, end: int) -> object | ...

FILE: algorithms/linked_list/reverse.py
  function reverse_list (line 17) | def reverse_list(head: object | None) -> object | None:
  function reverse_list_recursive (line 41) | def reverse_list_recursive(head: object | None) -> object | None:

FILE: algorithms/linked_list/rotate_list.py
  function rotate_right (line 17) | def rotate_right(head: object | None, k: int) -> object | None:

FILE: algorithms/linked_list/swap_in_pairs.py
  class Node (line 17) | class Node:
    method __init__ (line 18) | def __init__(self, x: int) -> None:
  function swap_pairs (line 23) | def swap_pairs(head: Node | None) -> Node | None:

FILE: algorithms/map/is_anagram.py
  function is_anagram (line 17) | def is_anagram(s: str, t: str) -> bool:

FILE: algorithms/map/is_isomorphic.py
  function is_isomorphic (line 18) | def is_isomorphic(s: str, t: str) -> bool:

FILE: algorithms/map/longest_common_subsequence.py
  function max_common_sub_string (line 17) | def max_common_sub_string(s1: str, s2: str) -> str:

FILE: algorithms/map/longest_palindromic_subsequence.py
  function longest_palindromic_subsequence (line 17) | def longest_palindromic_subsequence(s: str) -> int:

FILE: algorithms/map/randomized_set.py
  class RandomizedSet (line 20) | class RandomizedSet:
    method __init__ (line 33) | def __init__(self) -> None:
    method insert (line 38) | def insert(self, val: int) -> bool:
    method remove (line 53) | def remove(self, val: int) -> bool:
    method get_random (line 70) | def get_random(self) -> int:

FILE: algorithms/map/valid_sudoku.py
  function is_valid_sudoku (line 17) | def is_valid_sudoku(board: list[list[str]]) -> bool:

FILE: algorithms/map/word_pattern.py
  function word_pattern (line 17) | def word_pattern(pattern: str, string: str) -> bool:

FILE: algorithms/math/base_conversion.py
  function int_to_base (line 19) | def int_to_base(num: int, base: int) -> str:
  function base_to_int (line 53) | def base_to_int(str_to_convert: str, base: int) -> int:

FILE: algorithms/math/chinese_remainder_theorem.py
  function solve_chinese_remainder (line 20) | def solve_chinese_remainder(nums: list[int], rems: list[int]) -> int:
  function _check_coprime (line 59) | def _check_coprime(list_to_check: list[int]) -> bool:

FILE: algorithms/math/combination.py
  function combination (line 17) | def combination(n: int, r: int) -> int:
  function combination_memo (line 38) | def combination_memo(n: int, r: int) -> int:

FILE: algorithms/math/cosine_similarity.py
  function _l2_distance (line 20) | def _l2_distance(vec: list[float]) -> float:
  function cosine_similarity (line 36) | def cosine_similarity(vec1: list[float], vec2: list[float]) -> float:

FILE: algorithms/math/decimal_to_binary_ip.py
  function decimal_to_binary_util (line 17) | def decimal_to_binary_util(val: str) -> str:
  function decimal_to_binary_ip (line 43) | def decimal_to_binary_ip(ip: str) -> str:

FILE: algorithms/math/diffie_hellman_key_exchange.py
  function _prime_check (line 21) | def _prime_check(num: int) -> bool:
  function _find_order (line 44) | def _find_order(a: int, n: int) -> int:
  function _euler_totient (line 64) | def _euler_totient(n: int) -> int:
  function _find_primitive_root (line 84) | def _find_primitive_root(n: int) -> list[int]:
  function alice_private_key (line 106) | def alice_private_key(p: int) -> int:
  function alice_public_key (line 118) | def alice_public_key(a_pr_k: int, a: int, p: int) -> int:
  function bob_private_key (line 132) | def bob_private_key(p: int) -> int:
  function bob_public_key (line 144) | def bob_public_key(b_pr_k: int, a: int, p: int) -> int:
  function alice_shared_key (line 158) | def alice_shared_key(b_pu_k: int, a_pr_k: int, p: int) -> int:
  function bob_shared_key (line 172) | def bob_shared_key(a_pu_k: int, b_pr_k: int, p: int) -> int:
  function diffie_hellman_key_exchange (line 186) | def diffie_hellman_key_exchange(a: int, p: int, option: int | None = Non...

FILE: algorithms/math/distance_between_two_points.py
  function distance_between_two_points (line 19) | def distance_between_two_points(x1: float, y1: float, x2: float, y2: flo...

FILE: algorithms/math/euler_totient.py
  function euler_totient (line 17) | def euler_totient(n: int) -> int:

FILE: algorithms/math/extended_gcd.py
  function extended_gcd (line 17) | def extended_gcd(num1: int, num2: int) -> tuple[int, int, int]:

FILE: algorithms/math/factorial.py
  function factorial (line 17) | def factorial(n: int, mod: int | None = None) -> int:
  function factorial_recur (line 50) | def factorial_recur(n: int, mod: int | None = None) -> int:

FILE: algorithms/math/fft.py
  function fft (line 19) | def fft(x: list[complex]) -> list[complex]:

FILE: algorithms/math/find_order_simple.py
  function find_order (line 19) | def find_order(a: int, n: int) -> int:

FILE: algorithms/math/find_primitive_root_simple.py
  function _find_order (line 20) | def _find_order(a: int, n: int) -> int:
  function _euler_totient (line 40) | def _euler_totient(n: int) -> int:
  function find_primitive_root (line 60) | def find_primitive_root(n: int) -> list[int]:

FILE: algorithms/math/gcd.py
  function gcd (line 17) | def gcd(a: int, b: int) -> int:
  function lcm (line 51) | def lcm(a: int, b: int) -> int:
  function trailing_zero (line 68) | def trailing_zero(x: int) -> int:
  function gcd_bit (line 90) | def gcd_bit(a: int, b: int) -> int:

FILE: algorithms/math/generate_strobogrammtic.py
  function gen_strobogrammatic (line 17) | def gen_strobogrammatic(n: int) -> list[str]:
  function _helper (line 33) | def _helper(n: int, length: int) -> list[str]:
  function strobogrammatic_in_range (line 59) | def strobogrammatic_in_range(low: str, high: str) -> int:
  function _helper2 (line 88) | def _helper2(n: int, length: int) -> list[str]:

FILE: algorithms/math/goldbach.py
  function _is_prime (line 18) | def _is_prime(n: int) -> bool:
  function goldbach (line 41) | def goldbach(n: int) -> tuple[int, int]:
  function verify_goldbach (line 76) | def verify_goldbach(limit: int) -> bool:

FILE: algorithms/math/hailstone.py
  function hailstone (line 17) | def hailstone(n: int) -> list[int]:

FILE: algorithms/math/is_strobogrammatic.py
  function is_strobogrammatic (line 17) | def is_strobogrammatic(num: str) -> bool:
  function is_strobogrammatic2 (line 43) | def is_strobogrammatic2(num: str) -> bool:

FILE: algorithms/math/krishnamurthy_number.py
  function _find_factorial (line 17) | def _find_factorial(n: int) -> int:
  function krishnamurthy_number (line 33) | def krishnamurthy_number(n: int) -> bool:

FILE: algorithms/math/linear_regression.py
  function linear_regression (line 14) | def linear_regression(x: list[float], y: list[float]) -> tuple[float, fl...
  function r_squared (line 40) | def r_squared(x: list[float], y: list[float]) -> float:
  function rmse (line 53) | def rmse(x: list[float], y: list[float]) -> float:

FILE: algorithms/math/magic_number.py
  function magic_number (line 17) | def magic_number(n: int) -> bool:

FILE: algorithms/math/manhattan_distance.py
  function manhattan_distance (line 12) | def manhattan_distance(a: tuple[float, ...], b: tuple[float, ...]) -> fl...

FILE: algorithms/math/modular_exponential.py
  function modular_exponential (line 17) | def modular_exponential(base: int, exponent: int, mod: int) -> int:

FILE: algorithms/math/modular_inverse.py
  function _extended_gcd (line 17) | def _extended_gcd(a: int, b: int) -> tuple[int, int, int]:
  function modular_inverse (line 41) | def modular_inverse(a: int, m: int) -> int:

FILE: algorithms/math/next_bigger.py
  function next_bigger (line 17) | def next_bigger(num: int) -> int:

FILE: algorithms/math/next_perfect_square.py
  function find_next_square (line 17) | def find_next_square(sq: float) -> float:
  function find_next_square2 (line 38) | def find_next_square2(sq: float) -> float:

FILE: algorithms/math/nth_digit.py
  function find_nth_digit (line 17) | def find_nth_digit(n: int) -> int:

FILE: algorithms/math/num_digits.py
  function num_digits (line 19) | def num_digits(n: int) -> int:

FILE: algorithms/math/num_perfect_squares.py
  function num_perfect_squares (line 19) | def num_perfect_squares(number: int) -> int:

FILE: algorithms/math/polynomial.py
  class Monomial (line 23) | class Monomial:
    method __init__ (line 26) | def __init__(
    method _rationalize_if_possible (line 57) | def _rationalize_if_possible(
    method equal_upto_scalar (line 74) | def equal_upto_scalar(self, other: object) -> bool:
    method __add__ (line 90) | def __add__(self, other: int | float | Fraction) -> Monomial:
    method __eq__ (line 119) | def __eq__(self, other: object) -> bool:
    method __mul__ (line 132) | def __mul__(self, other: int | float | Fraction) -> Monomial:
    method inverse (line 169) | def inverse(self) -> Monomial:
    method __truediv__ (line 185) | def __truediv__(self, other: int | float | Fraction) -> Monomial:
    method __floordiv__ (line 208) | def __floordiv__(self, other: int | float | Fraction) -> Monomial:
    method clone (line 219) | def clone(self) -> Monomial:
    method clean (line 230) | def clean(self) -> Monomial:
    method __sub__ (line 241) | def __sub__(self, other: int | float | Fraction) -> Monomial:
    method __hash__ (line 265) | def __hash__(self) -> int:
    method all_variables (line 278) | def all_variables(self) -> set:
    method substitute (line 286) | def substitute(
    method __str__ (line 319) | def __str__(self) -> str:
  class Polynomial (line 344) | class Polynomial:
    method __init__ (line 347) | def __init__(
    method _rationalize_if_possible (line 371) | def _rationalize_if_possible(
    method __add__ (line 388) | def __add__(self, other: int | float | Fraction | Monomial) -> Polynom...
    method __sub__ (line 435) | def __sub__(self, other: int | float | Fraction | Monomial) -> Polynom...
    method __mul__ (line 484) | def __mul__(self, other: int | float | Fraction | Monomial) -> Polynom...
    method __floordiv__ (line 519) | def __floordiv__(self, other: int | float | Fraction | Monomial) -> Po...
    method __truediv__ (line 530) | def __truediv__(self, other: int | float | Fraction | Monomial) -> Pol...
    method clone (line 560) | def clone(self) -> Polynomial:
    method variables (line 568) | def variables(self) -> set:
    method all_monomials (line 580) | def all_monomials(self) -> Iterable[Monomial]:
    method __eq__ (line 588) | def __eq__(self, other: object) -> bool:
    method subs (line 613) | def subs(
    method __str__ (line 645) | def __str__(self) -> str:
    method poly_long_division (line 658) | def poly_long_division(self, other: Polynomial) -> tuple[Polynomial, P...

FILE: algorithms/math/polynomial_division.py
  function polynomial_division (line 13) | def polynomial_division(

FILE: algorithms/math/power.py
  function power (line 17) | def power(a: int, n: int, mod: int | None = None) -> int:
  function power_recur (line 46) | def power_recur(a: int, n: int, mod: int | None = None) -> int:

FILE: algorithms/math/prime_check.py
  function prime_check (line 17) | def prime_check(n: int) -> bool:

FILE: algorithms/math/primes_sieve_of_eratosthenes.py
  function get_primes (line 17) | def get_primes(n: int) -> list[int]:

FILE: algorithms/math/pythagoras.py
  function pythagoras (line 17) | def pythagoras(

FILE: algorithms/math/rabin_miller.py
  function is_prime (line 20) | def is_prime(n: int, k: int) -> bool:

FILE: algorithms/math/recursive_binomial_coefficient.py
  function recursive_binomial_coefficient (line 17) | def recursive_binomial_coefficient(n: int, k: int) -> int:

FILE: algorithms/math/rsa.py
  function _extended_gcd (line 19) | def _extended_gcd(a: int, b: int) -> tuple[int, int, int]:
  function _modinv (line 31) | def _modinv(a: int, m: int) -> int:
  function generate_key (line 38) | def generate_key(k: int, seed: int | None = None) -> tuple[int, int, int]:
  function encrypt (line 100) | def encrypt(data: int, e: int, n: int) -> int:
  function decrypt (line 118) | def decrypt(data: int, d: int, n: int) -> int:

FILE: algorithms/math/sqrt_precision_factor.py
  function square_root (line 17) | def square_root(n: float, epsilon: float = 0.001) -> float:

FILE: algorithms/math/summing_digits.py
  function sum_dig_pow (line 17) | def sum_dig_pow(low: int, high: int) -> list[int]:

FILE: algorithms/math/surface_area_of_torus.py
  function surface_area_of_torus (line 19) | def surface_area_of_torus(major_radius: float, minor_radius: float) -> f...

FILE: algorithms/math/symmetry_group_cycle_index.py
  function cycle_product (line 23) | def cycle_product(m1: Monomial, m2: Monomial) -> Monomial:
  function cycle_product_for_two_polynomials (line 49) | def cycle_product_for_two_polynomials(
  function _cycle_index_sym_helper (line 70) | def _cycle_index_sym_helper(n: int, memo: dict[int, Polynomial]) -> Poly...
  function get_cycle_index_sym (line 93) | def get_cycle_index_sym(n: int) -> Polynomial:

FILE: algorithms/matrix/bomb_enemy.py
  function max_killed_enemies (line 20) | def max_killed_enemies(grid: list[list[str]]) -> int:
  function _row_kills (line 49) | def _row_kills(grid: list[list[str]], row: int, col: int) -> int:
  function _col_kills (line 69) | def _col_kills(grid: list[list[str]], row: int, col: int) -> int:

FILE: algorithms/matrix/cholesky_matrix_decomposition.py
  function cholesky_decomposition (line 20) | def cholesky_decomposition(matrix: list[list[float]]) -> list[list[float...

FILE: algorithms/matrix/copy_transform.py
  function rotate_clockwise (line 18) | def rotate_clockwise(matrix: list[list[int]]) -> list[list[int]]:
  function rotate_counterclockwise (line 42) | def rotate_counterclockwise(matrix: list[list[int]]) -> list[list[int]]:
  function top_left_invert (line 66) | def top_left_invert(matrix: list[list[int]]) -> list[list[int]]:
  function bottom_left_invert (line 90) | def bottom_left_invert(matrix: list[list[int]]) -> list[list[int]]:

FILE: algorithms/matrix/count_paths.py
  function count_paths (line 18) | def count_paths(rows: int, cols: int) -> int:

FILE: algorithms/matrix/crout_matrix_decomposition.py
  function crout_matrix_decomposition (line 19) | def crout_matrix_decomposition(

FILE: algorithms/matrix/matrix_exponentiation.py
  function multiply (line 18) | def multiply(mat_a: list[list[int]], mat_b: list[list[int]]) -> list[lis...
  function identity (line 41) | def identity(size: int) -> list[list[int]]:
  function matrix_exponentiation (line 60) | def matrix_exponentiation(mat: list[list[int]], power: int) -> list[list...

FILE: algorithms/matrix/matrix_inversion.py
  function invert_matrix (line 21) | def invert_matrix(
  function get_determinant (line 61) | def get_determinant(matrix: list[list[int | float]]) -> int | float:
  function _get_matrix_of_minors (line 84) | def _get_matrix_of_minors(
  function _get_minor (line 104) | def _get_minor(
  function _transpose_and_multiply (line 126) | def _transpose_and_multiply(
  function _array_is_matrix (line 147) | def _array_is_matrix(matrix: list[list]) -> bool:

FILE: algorithms/matrix/multiply.py
  function multiply (line 17) | def multiply(

FILE: algorithms/matrix/rotate_image.py
  function rotate (line 17) | def rotate(mat: list[list[int]]) -> list[list[int]]:

FILE: algorithms/matrix/search_in_sorted_matrix.py
  function search_in_a_sorted_matrix (line 18) | def search_in_a_sorted_matrix(

FILE: algorithms/matrix/sort_matrix_diagonally.py
  function sort_diagonally (line 20) | def sort_diagonally(mat: list[list[int]]) -> list[list[int]]:

FILE: algorithms/matrix/sparse_dot_vector.py
  function vector_to_index_value_list (line 17) | def vector_to_index_value_list(
  function dot_product (line 35) | def dot_product(

FILE: algorithms/matrix/sparse_mul.py
  function sparse_multiply (line 18) | def sparse_multiply(

FILE: algorithms/matrix/spiral_traversal.py
  function spiral_traversal (line 17) | def spiral_traversal(matrix: list[list[int]]) -> list[int]:

FILE: algorithms/matrix/sudoku_validator.py
  function valid_solution_hashtable (line 20) | def valid_solution_hashtable(board: list[list[int]]) -> bool:
  function valid_solution (line 66) | def valid_solution(board: list[list[int]]) -> bool:
  function valid_solution_set (line 105) | def valid_solution_set(board: list[list[int]]) -> bool:

FILE: algorithms/matrix/sum_sub_squares.py
  function sum_sub_squares (line 17) | def sum_sub_squares(matrix: list[list[int]], k: int) -> list[list[int]] ...

FILE: algorithms/queue/max_sliding_window.py
  function max_sliding_window (line 20) | def max_sliding_window(arr: list[int], k: int) -> list[int]:

FILE: algorithms/queue/moving_average.py
  class MovingAverage (line 19) | class MovingAverage:
    method __init__ (line 30) | def __init__(self, size: int) -> None:
    method next (line 38) | def next(self, val: int) -> float:

FILE: algorithms/queue/reconstruct_queue.py
  function reconstruct_queue (line 18) | def reconstruct_queue(people: list[list[int]]) -> list[list[int]]:

FILE: algorithms/queue/zigzagiterator.py
  class ZigZagIterator (line 19) | class ZigZagIterator:
    method __init__ (line 30) | def __init__(self, v1: list[int], v2: list[int]) -> None:
    method next (line 39) | def next(self) -> int:
    method has_next (line 51) | def has_next(self) -> bool:

FILE: algorithms/searching/binary_search.py
  function binary_search (line 17) | def binary_search(array: list[int], query: int) -> int:
  function binary_search_recur (line 46) | def binary_search_recur(array: list[int], low: int, high: int, val: int)...

FILE: algorithms/searching/exponential_search.py
  function exponential_search (line 15) | def exponential_search(arr: list[int], target: int) -> int:

FILE: algorithms/searching/find_min_rotate.py
  function find_min_rotate (line 17) | def find_min_rotate(array: list[int]) -> int:
  function find_min_rotate_recur (line 43) | def find_min_rotate_recur(array: list[int], low: int, high: int) -> int:

FILE: algorithms/searching/first_occurrence.py
  function first_occurrence (line 17) | def first_occurrence(array: list[int], query: int) -> int:

FILE: algorithms/searching/generalized_binary_search.py
  function binary_search_first_true (line 21) | def binary_search_first_true(

FILE: algorithms/searching/interpolation_search.py
  function interpolation_search (line 17) | def interpolation_search(array: list[int], search_key: int) -> int:

FILE: algorithms/searching/jump_search.py
  function jump_search (line 19) | def jump_search(array: list[int], target: int) -> int:

FILE: algorithms/searching/last_occurrence.py
  function last_occurrence (line 17) | def last_occurrence(array: list[int], query: int) -> int:

FILE: algorithms/searching/linear_search.py
  function linear_search (line 17) | def linear_search(array: list[int], query: int) -> int:

FILE: algorithms/searching/next_greatest_letter.py
  function next_greatest_letter (line 22) | def next_greatest_letter(letters: list[str], target: str) -> str:
  function next_greatest_letter_v1 (line 43) | def next_greatest_letter_v1(letters: list[str], target: str) -> str:
  function next_greatest_letter_v2 (line 72) | def next_greatest_letter_v2(letters: list[str], target: str) -> str:

FILE: algorithms/searching/search_insert.py
  function search_insert (line 18) | def search_insert(array: list[int], val: int) -> int:

FILE: algorithms/searching/search_range.py
  function search_range (line 18) | def search_range(nums: list[int], target: int) -> list[int]:

FILE: algorithms/searching/search_rotate.py
  function search_rotate (line 18) | def search_rotate(array: list[int], val: int) -> int:
  function search_rotate_recur (line 55) | def search_rotate_recur(

FILE: algorithms/searching/sentinel_search.py
  function sentinel_search (line 14) | def sentinel_search(arr: list[int], target: int) -> int:

FILE: algorithms/searching/ternary_search.py
  function ternary_search (line 18) | def ternary_search(left: int, right: int, key: int, array: list[int]) ->...

FILE: algorithms/searching/two_sum.py
  function two_sum (line 19) | def two_sum(numbers: list[int], target: int) -> list[int] | None:
  function two_sum1 (line 51) | def two_sum1(numbers: list[int], target: int) -> list[int] | None:
  function two_sum2 (line 75) | def two_sum2(numbers: list[int], target: int) -> list[int] | None:

FILE: algorithms/set/find_keyboard_row.py
  function find_keyboard_row (line 23) | def find_keyboard_row(words: list[str]) -> list[str]:

FILE: algorithms/set/randomized_set.py
  class RandomizedSet (line 19) | class RandomizedSet:
    method __init__ (line 22) | def __init__(self) -> None:
    method insert (line 26) | def insert(self, new_one: int) -> None:
    method remove (line 37) | def remove(self, old_one: int) -> None:
    method random_element (line 53) | def random_element(self) -> int:

FILE: algorithms/set/set_covering.py
  function _powerset (line 23) | def _powerset(iterable: list[str]) -> chain[tuple[str, ...]]:
  function optimal_set_cover (line 36) | def optimal_set_cover(
  function greedy_set_cover (line 76) | def greedy_set_cover(

FILE: algorithms/sorting/bead_sort.py
  function bead_sort (line 17) | def bead_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/bitonic_sort.py
  function bitonic_sort (line 18) | def bitonic_sort(array: list[int], reverse: bool = False) -> list[int]:
  function _compare (line 46) | def _compare(array: list[int], reverse: bool) -> list[int]:
  function _bitonic_merge (line 55) | def _bitonic_merge(array: list[int], reverse: bool) -> list[int]:

FILE: algorithms/sorting/bogo_sort.py
  function bogo_sort (line 19) | def bogo_sort(array: list[int]) -> list[int]:
  function _is_sorted (line 37) | def _is_sorted(array: list[int]) -> bool:

FILE: algorithms/sorting/bubble_sort.py
  function bubble_sort (line 17) | def bubble_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/bucket_sort.py
  function bucket_sort (line 18) | def bucket_sort(array: list[int]) -> list[int]:
  function _insertion_sort (line 45) | def _insertion_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/cocktail_shaker_sort.py
  function cocktail_shaker_sort (line 17) | def cocktail_shaker_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/comb_sort.py
  function comb_sort (line 18) | def comb_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/counting_sort.py
  function counting_sort (line 18) | def counting_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/cycle_sort.py
  function cycle_sort (line 18) | def cycle_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/exchange_sort.py
  function exchange_sort (line 17) | def exchange_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/gnome_sort.py
  function gnome_sort (line 18) | def gnome_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/heap_sort.py
  function max_heap_sort (line 18) | def max_heap_sort(array: list[int]) -> list[int]:
  function _max_heapify (line 36) | def _max_heapify(array: list[int], end: int) -> None:
  function min_heap_sort (line 55) | def min_heap_sort(array: list[int]) -> list[int]:
  function _min_heapify (line 73) | def _min_heapify(array: list[int], start: int) -> None:

FILE: algorithms/sorting/insertion_sort.py
  function insertion_sort (line 17) | def insertion_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/meeting_rooms.py
  function can_attend_meetings (line 18) | def can_attend_meetings(intervals: list) -> bool:

FILE: algorithms/sorting/merge_sort.py
  function merge_sort (line 17) | def merge_sort(array: list[int]) -> list[int]:
  function _merge (line 41) | def _merge(left: list[int], right: list[int], merged: list[int]) -> None:

FILE: algorithms/sorting/pancake_sort.py
  function pancake_sort (line 18) | def pancake_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/pigeonhole_sort.py
  function pigeonhole_sort (line 17) | def pigeonhole_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/quick_sort.py
  function quick_sort (line 17) | def quick_sort(array: list[int]) -> list[int]:
  function _quick_sort_recursive (line 34) | def _quick_sort_recursive(array: list[int], first: int, last: int) -> None:
  function _partition (line 42) | def _partition(array: list[int], first: int, last: int) -> int:

FILE: algorithms/sorting/radix_sort.py
  function radix_sort (line 18) | def radix_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/selection_sort.py
  function selection_sort (line 17) | def selection_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/shell_sort.py
  function shell_sort (line 19) | def shell_sort(array: list[int]) -> list[int]:

FILE: algorithms/sorting/sort_colors.py
  function sort_colors (line 18) | def sort_colors(array: list[int]) -> list[int]:

FILE: algorithms/sorting/stooge_sort.py
  function stooge_sort (line 18) | def stooge_sort(array: list[int]) -> list[int]:
  function _stooge_sort (line 35) | def _stooge_sort(array: list[int], low: int, high: int) -> None:

FILE: algorithms/sorting/wiggle_sort.py
  function wiggle_sort (line 17) | def wiggle_sort(array: list[int]) -> list[int]:

FILE: algorithms/stack/is_consecutive.py
  function first_is_consecutive (line 20) | def first_is_consecutive(stack: list[int]) -> bool:
  function second_is_consecutive (line 51) | def second_is_consecutive(stack: list[int]) -> bool:

FILE: algorithms/stack/is_sorted.py
  function is_sorted (line 17) | def is_sorted(stack: list[int]) -> bool:

FILE: algorithms/stack/longest_abs_path.py
  function length_longest_path (line 18) | def length_longest_path(input_str: str) -> int:

FILE: algorithms/stack/ordered_stack.py
  class OrderedStack (line 18) | class OrderedStack:
    method __init__ (line 30) | def __init__(self) -> None:
    method is_empty (line 34) | def is_empty(self) -> bool:
    method _push_direct (line 42) | def _push_direct(self, item: int) -> None:
    method push (line 50) | def push(self, item: int) -> None:
    method pop (line 66) | def pop(self) -> int:
    method peek (line 79) | def peek(self) -> int:
    method size (line 87) | def size(self) -> int:

FILE: algorithms/stack/remove_min.py
  function remove_min (line 17) | def remove_min(stack: list[int]) -> list[int]:

FILE: algorithms/stack/simplify_path.py
  function simplify_path (line 17) | def simplify_path(path: str) -> str:

FILE: algorithms/stack/stutter.py
  function first_stutter (line 19) | def first_stutter(stack: list[int]) -> list[int]:
  function second_stutter (line 43) | def second_stutter(stack: list[int]) -> list[int]:

FILE: algorithms/stack/switch_pairs.py
  function first_switch_pairs (line 20) | def first_switch_pairs(stack: list[int]) -> list[int]:
  function second_switch_pairs (line 49) | def second_switch_pairs(stack: list[int]) -> list[int]:

FILE: algorithms/stack/valid_parenthesis.py
  function is_valid (line 17) | def is_valid(s: str) -> bool:

FILE: algorithms/streaming/misra_gries.py
  function misras_gries (line 18) | def misras_gries(array: list[int], k: int = 2) -> dict[str, int] | None:
  function _count_frequency (line 60) | def _count_frequency(array: list[int], element: int) -> int:

FILE: algorithms/streaming/one_sparse_recovery.py
  function one_sparse (line 18) | def one_sparse(array: list[tuple[int, str]]) -> int | None:
  function _check_bit_sum_consistency (line 51) | def _check_bit_sum_consistency(bitsum: list[int], sum_signs: int) -> bool:
  function _update_bit_sum (line 64) | def _update_bit_sum(bitsum: list[int], val: int, sign: str) -> None:

FILE: algorithms/string/add_binary.py
  function add_binary (line 16) | def add_binary(first: str, second: str) -> str:

FILE: algorithms/string/alphabet_board_path.py
  function alphabet_board_path (line 20) | def alphabet_board_path(target: str) -> str:

FILE: algorithms/string/atbash_cipher.py
  function atbash (line 17) | def atbash(text: str) -> str:

FILE: algorithms/string/breaking_bad.py
  function match_symbol (line 21) | def match_symbol(words: list[str], symbols: list[str]) -> list[str]:
  function match_symbol_1 (line 44) | def match_symbol_1(words: list[str], symbols: list[str]) -> list[str]:
  class _TrieNode (line 72) | class _TrieNode:
    method __init__ (line 75) | def __init__(self) -> None:
  function bracket (line 80) | def bracket(words: list[str], symbols: list[str]) -> tuple[str, ...]:

FILE: algorithms/string/caesar_cipher.py
  function caesar_cipher (line 17) | def caesar_cipher(text: str, shift: int) -> str:

FILE: algorithms/string/check_pangram.py
  function check_pangram (line 17) | def check_pangram(input_string: str) -> bool:

FILE: algorithms/string/contain_string.py
  function contain_string (line 17) | def contain_string(haystack: str, needle: str) -> int:

FILE: algorithms/string/count_binary_substring.py
  function count_binary_substring (line 17) | def count_binary_substring(text: str) -> int:

FILE: algorithms/string/decode_string.py
  function decode_string (line 18) | def decode_string(text: str) -> str:

FILE: algorithms/string/delete_reoccurring.py
  function delete_reoccurring_characters (line 17) | def delete_reoccurring_characters(string: str) -> str:

FILE: algorithms/string/domain_extractor.py
  function domain_name_1 (line 17) | def domain_name_1(url: str) -> str:
  function domain_name_2 (line 37) | def domain_name_2(url: str) -> str:

FILE: algorithms/string/encode_decode.py
  function encode (line 17) | def encode(strs: str) -> str:
  function decode (line 36) | def decode(text: str) -> list[str]:

FILE: algorithms/string/first_unique_char.py
  function first_unique_char (line 17) | def first_unique_char(text: str) -> int:

FILE: algorithms/string/fizzbuzz.py
  function fizzbuzz (line 17) | def fizzbuzz(number: int) -> list[int | str]:
  function fizzbuzz_with_helper_func (line 53) | def fizzbuzz_with_helper_func(number: int) -> list[int | str]:
  function _fb (line 69) | def _fb(value: int) -> int | str:

FILE: algorithms/string/group_anagrams.py
  function group_anagrams (line 17) | def group_anagrams(strings: list[str]) -> list[list[str]]:

FILE: algorithms/string/int_to_roman.py
  function int_to_roman (line 17) | def int_to_roman(num: int) -> str:

FILE: algorithms/string/is_palindrome.py
  function is_palindrome (line 20) | def is_palindrome(text: str) -> bool:
  function _remove_punctuation (line 46) | def _remove_punctuation(text: str) -> str:
  function _string_reverse (line 58) | def _string_reverse(text: str) -> str:
  function is_palindrome_reverse (line 70) | def is_palindrome_reverse(text: str) -> bool:
  function is_palindrome_two_pointer (line 87) | def is_palindrome_two_pointer(text: str) -> bool:
  function is_palindrome_stack (line 107) | def is_palindrome_stack(text: str) -> bool:
  function is_palindrome_deque (line 127) | def is_palindrome_deque(text: str) -> bool:

FILE: algorithms/string/is_rotated.py
  function is_rotated (line 17) | def is_rotated(first: str, second: str) -> bool:
  function is_rotated_v1 (line 37) | def is_rotated_v1(first: str, second: str) -> bool:

FILE: algorithms/string/judge_circle.py
  function judge_circle (line 17) | def judge_circle(moves: str) -> bool:

FILE: algorithms/string/knuth_morris_pratt.py
  function knuth_morris_pratt (line 19) | def knuth_morris_pratt(text: Sequence, pattern: Sequence) -> list[int]:

FILE: algorithms/string/license_number.py
  function license_number (line 17) | def license_number(key: str, group_size: int) -> str:

FILE: algorithms/string/longest_common_prefix.py
  function _common_prefix (line 17) | def _common_prefix(first: str, second: str) -> str:
  function longest_common_prefix_v1 (line 37) | def longest_common_prefix_v1(strings: list[str]) -> str:
  function longest_common_prefix_v2 (line 58) | def longest_common_prefix_v2(strings: list[str]) -> str:
  function longest_common_prefix_v3 (line 80) | def longest_common_prefix_v3(strings: list[str]) -> str:
  function _longest_common_recursive (line 98) | def _longest_common_recursive(strings: list[str], left: int, right: int)...

FILE: algorithms/string/longest_palindromic_substring.py
  function longest_palindrome (line 17) | def longest_palindrome(text: str) -> str:

FILE: algorithms/string/make_sentence.py
  function make_sentence (line 19) | def make_sentence(text_piece: str, dictionaries: list[str]) -> bool:

FILE: algorithms/string/manacher.py
  function manacher (line 11) | def manacher(s: str) -> str:

FILE: algorithms/string/merge_string_checker.py
  function is_merge_recursive (line 17) | def is_merge_recursive(text: str, part1: str, part2: str) -> bool:
  function is_merge_iterative (line 44) | def is_merge_iterative(text: str, part1: str, part2: str) -> bool:

FILE: algorithms/string/min_distance.py
  function min_distance (line 17) | def min_distance(word1: str, word2: str) -> int:
  function _lcs (line 34) | def _lcs(word1: str, word2: str, length1: int, length2: int) -> int:
  function min_distance_dp (line 56) | def min_distance_dp(word1: str, word2: str) -> int:

FILE: algorithms/string/multiply_strings.py
  function multiply (line 17) | def multiply(num1: str, num2: str) -> str:

FILE: algorithms/string/one_edit_distance.py
  function is_one_edit (line 17) | def is_one_edit(source: str, target: str) -> bool:
  function is_one_edit2 (line 44) | def is_one_edit2(source: str, target: str) -> bool:

FILE: algorithms/string/panagram.py
  function panagram (line 19) | def panagram(string: str) -> bool:

FILE: algorithms/string/rabin_karp.py
  class RollingHash (line 17) | class RollingHash:
    method __init__ (line 25) | def __init__(self, text: str, window_size: int) -> None:
    method move_window (line 38) | def move_window(self) -> None:
    method window_text (line 49) | def window_text(self) -> str:
  function rabin_karp (line 58) | def rabin_karp(word: str, text: str) -> int | None:

FILE: algorithms/string/repeat_string.py
  function repeat_string (line 17) | def repeat_string(base: str, target: str) -> int:

FILE: algorithms/string/repeat_substring.py
  function repeat_substring (line 17) | def repeat_substring(text: str) -> bool:

FILE: algorithms/string/reverse_string.py
  function recursive (line 17) | def recursive(text: str) -> str:
  function iterative (line 36) | def iterative(text: str) -> str:
  function pythonic (line 61) | def pythonic(text: str) -> str:
  function ultra_pythonic (line 78) | def ultra_pythonic(text: str) -> str:

FILE: algorithms/string/reverse_vowel.py
  function reverse_vowel (line 17) | def reverse_vowel(text: str) -> str:

FILE: algorithms/string/reverse_words.py
  function _reverse_list (line 17) | def _reverse_list(array: list[str], left: int, right: int) -> None:
  function reverse_words (line 31) | def reverse_words(string: str) -> str:

FILE: algorithms/string/roman_to_int.py
  function roman_to_int (line 17) | def roman_to_int(text: str) -> int:

FILE: algorithms/string/rotate.py
  function rotate (line 17) | def rotate(text: str, positions: int) -> str:
  function rotate_alt (line 38) | def rotate_alt(string: str, positions: int) -> str:

FILE: algorithms/string/strip_url_params.py
  function strip_url_params1 (line 21) | def strip_url_params1(url: str, params_to_strip: list[str] | None = None...
  function strip_url_params2 (line 94) | def strip_url_params2(url: str, param_to_strip: list[str] | None = None)...
  function strip_url_params3 (line 125) | def strip_url_params3(url: str, strip: list[str] | None = None) -> str:

FILE: algorithms/string/strong_password.py
  function strong_password (line 18) | def strong_password(length: int, password: str) -> int:

FILE: algorithms/string/swap_characters.py
  function can_swap_to_equal (line 12) | def can_swap_to_equal(s: str, t: str) -> bool:

FILE: algorithms/string/text_justification.py
  function text_justification (line 18) | def text_justification(words: list[str], max_width: int) -> list[str]:

FILE: algorithms/string/unique_morse.py
  function convert_morse_word (line 46) | def convert_morse_word(word: str) -> str:
  function unique_morse (line 66) | def unique_morse(words: list[str]) -> int:

FILE: algorithms/string/validate_coordinates.py
  function is_valid_coordinates_0 (line 19) | def is_valid_coordinates_0(coordinates: str) -> bool:
  function is_valid_coordinates_1 (line 46) | def is_valid_coordinates_1(coordinates: str) -> bool:
  function is_valid_coordinates_regular_expression (line 68) | def is_valid_coordinates_regular_expression(coordinates: str) -> bool:

FILE: algorithms/string/word_squares.py
  function word_squares (line 19) | def word_squares(words: list[str]) -> list[list[str]]:

FILE: algorithms/string/z_algorithm.py
  function compute_z_array (line 14) | def compute_z_array(s: str) -> list[int]:
  function z_search (line 32) | def z_search(text: str, pattern: str) -> list[int]:

FILE: algorithms/tree/bin_tree_to_list.py
  function bin_tree_to_list (line 19) | def bin_tree_to_list(root: TreeNode | None) -> TreeNode | None:
  function _bin_tree_to_list_util (line 41) | def _bin_tree_to_list_util(root: TreeNode | None) -> TreeNode | None:

FILE: algorithms/tree/binary_tree_paths.py
  function binary_tree_paths (line 19) | def binary_tree_paths(root: TreeNode | None) -> list[str]:
  function _dfs (line 39) | def _dfs(result: list[str], root: TreeNode, current: str) -> None:

FILE: algorithms/tree/binary_tree_views.py
  function left_view (line 27) | def left_view(root: TreeNode | None) -> list[int]:
  function right_view (line 59) | def right_view(root: TreeNode | None) -> list[int]:
  function top_view (line 91) | def top_view(root: TreeNode | None) -> list[int]:
  function bottom_view (line 125) | def bottom_view(root: TreeNode | None) -> list[int]:

FILE: algorithms/tree/bst_array_to_bst.py
  function array_to_bst (line 9) | def array_to_bst(nums):

FILE: algorithms/tree/bst_closest_value.py
  function closest_value (line 18) | def closest_value(root, target):

FILE: algorithms/tree/bst_count_left_node.py
  function count_left_node (line 23) | def count_left_node(root):
  class TestSuite (line 48) | class TestSuite(unittest.TestCase):
    method setUp (line 49) | def setUp(self):
    method test_count_left_node (line 61) | def test_count_left_node(self):

FILE: algorithms/tree/bst_delete_node.py
  class Solution (line 43) | class Solution:
    method delete_node (line 44) | def delete_node(self, root, key):

FILE: algorithms/tree/bst_depth_sum.py
  function depth_sum (line 24) | def depth_sum(root, n):
  function recur_depth_sum (line 29) | def recur_depth_sum(root, n):
  class TestSuite (line 58) | class TestSuite(unittest.TestCase):
    method setUp (line 59) | def setUp(self):
    method test_depth_sum (line 71) | def test_depth_sum(self):

FILE: algorithms/tree/bst_height.py
  function height (line 24) | def height(root):
  class TestSuite (line 47) | class TestSuite(unittest.TestCase):
    method setUp (line 48) | def setUp(self):
    method test_height (line 60) | def test_height(self):

FILE: algorithms/tree/bst_is_bst.py
  function is_bst (line 24) | def is_bst(root):

FILE: algorithms/tree/bst_iterator.py
  class BSTIterator (line 1) | class BSTIterator:
    method __init__ (line 2) | def __init__(self, root):
    method has_next (line 8) | def has_next(self):
    method next (line 11) | def next(self):

FILE: algorithms/tree/bst_kth_smallest.py
  class Node (line 1) | class Node:
    method __init__ (line 2) | def __init__(self, val, left=None, right=None):
  function kth_smallest (line 8) | def kth_smallest(root, k):
  class Solution (line 22) | class Solution:
    method kth_smallest (line 23) | def kth_smallest(self, root, k):
    method helper (line 33) | def helper(self, node, count):

FILE: algorithms/tree/bst_lowest_common_ancestor.py
  function lowest_common_ancestor (line 24) | def lowest_common_ancestor(root, p, q):

FILE: algorithms/tree/bst_num_empty.py
  function num_empty (line 27) | def num_empty(root):
  class TestSuite (line 54) | class TestSuite(unittest.TestCase):
    method setUp (line 55) | def setUp(self):
    method test_num_empty (line 67) | def test_num_empty(self):

FILE: algorithms/tree/bst_predecessor.py
  function predecessor (line 1) | def predecessor(root, node):

FILE: algorithms/tree/bst_serialize_deserialize.py
  function serialize (line 4) | def serialize(root):
  function deserialize (line 18) | def deserialize(data):

FILE: algorithms/tree/bst_successor.py
  function successor (line 1) | def successor(root, node):

FILE: algorithms/tree/bst_unique_bst.py
  function num_trees (line 30) | def num_trees(n):

FILE: algorithms/tree/bst_validate_bst.py
  function validate_bst (line 19) | def validate_bst(node):

FILE: algorithms/tree/construct_tree_postorder_preorder.py
  function construct_tree_util (line 22) | def construct_tree_util(
  function construct_tree (line 71) | def construct_tree(pre: list[int], post: list[int], size: int) -> list[i...
  function _inorder (line 91) | def _inorder(root: TreeNode | None, result: list[int] | None = None) -> ...

FILE: algorithms/tree/deepest_left.py
  class DeepestLeft (line 19) | class DeepestLeft:
    method __init__ (line 28) | def __init__(self) -> None:
  function find_deepest_left (line 33) | def find_deepest_left(

FILE: algorithms/tree/invert_tree.py
  function reverse (line 18) | def reverse(root: TreeNode | None) -> None:

FILE: algorithms/tree/is_balanced.py
  function is_balanced (line 19) | def is_balanced(root: TreeNode | None) -> bool:
  function _get_depth (line 35) | def _get_depth(root: TreeNode | None) -> int:

FILE: algorithms/tree/is_subtree.py
  function is_subtree (line 21) | def is_subtree(big: TreeNode, small: TreeNode) -> bool:
  function _comp (line 50) | def _comp(p: TreeNode | None, q: TreeNode | None) -> bool:

FILE: algorithms/tree/is_symmetric.py
  function is_symmetric (line 19) | def is_symmetric(root: TreeNode | None) -> bool:
  function _helper (line 37) | def _helper(p: TreeNode | None, q: TreeNode | None) -> bool:
  function is_symmetric_iterative (line 54) | def is_symmetric_iterative(root: TreeNode | None) -> bool:

FILE: algorithms/tree/longest_consecutive.py
  function longest_consecutive (line 19) | def longest_consecutive(root: TreeNode | None) -> int:
  function _dfs (line 39) | def _dfs(root: TreeNode | None, current: int, target: int, max_len: int)...

FILE: algorithms/tree/lowest_common_ancestor.py
  function lca (line 20) | def lca(root: TreeNode | None, p: TreeNode, q: TreeNode) -> TreeNode | N...

FILE: algorithms/tree/max_height.py
  function max_height (line 21) | def max_height(root: TreeNode | None) -> int:

FILE: algorithms/tree/max_path_sum.py
  function max_path_sum (line 20) | def max_path_sum(root: TreeNode | None) -> float:
  function _helper (line 38) | def _helper(root: TreeNode | None, maximum: float) -> float:

FILE: algorithms/tree/min_height.py
  function min_depth (line 19) | def min_depth(self: object, root: TreeNode | None) -> int:
  function min_height (line 36) | def min_height(root: TreeNode | None) -> int:

FILE: algorithms/tree/path_sum.py
  function has_path_sum (line 22) | def has_path_sum(root: TreeNode | None, sum: int) -> bool:
  function has_path_sum2 (line 44) | def has_path_sum2(root: TreeNode | None, sum: int) -> bool:
  function has_path_sum3 (line 72) | def has_path_sum3(root: TreeNode | None, sum: int) -> bool:

FILE: algorithms/tree/path_sum2.py
  function path_sum (line 21) | def path_sum(root: TreeNode | None, sum: int) -> list[list[int]]:
  function _dfs (line 42) | def _dfs(root: TreeNode, sum: int, path: list[int], result: list[list[in...
  function path_sum2 (line 60) | def path_sum2(root: TreeNode | None, target: int) -> list[list[int]]:
  function path_sum3 (line 89) | def path_sum3(root: TreeNode | None, sum: int) -> list[list[int]]:

FILE: algorithms/tree/pretty_print.py
  function tree_print (line 17) | def tree_print(tree: dict) -> list[str]:

FILE: algorithms/tree/same_tree.py
  function is_same_tree (line 19) | def is_same_tree(tree_p: TreeNode | None, tree_q: TreeNode | None) -> bool:

FILE: algorithms/tree/traversal_inorder.py
  class Node (line 6) | class Node:
    method __init__ (line 7) | def __init__(self, val, left=None, right=None):
  function inorder (line 13) | def inorder(root):
  function inorder_rec (line 29) | def inorder_rec(root, res=None):

FILE: algorithms/tree/traversal_level_order.py
  function level_order (line 21) | def level_order(root):

FILE: algorithms/tree/traversal_postorder.py
  class Node (line 6) | class Node:
    method __init__ (line 7) | def __init__(self, val, left=None, right=None):
  function postorder (line 13) | def postorder(root):
  function postorder_rec (line 33) | def postorder_rec(root, res=None):

FILE: algorithms/tree/traversal_preorder.py
  class Node (line 6) | class Node:
    method __init__ (line 9) | def __init__(self, val, left=None, right=None):
  function preorder (line 15) | def preorder(root):
  function preorder_rec (line 32) | def preorder_rec(root, res=None):

FILE: algorithms/tree/traversal_zigzag.py
  function zigzag_level (line 23) | def zigzag_level(root):

FILE: algorithms/tree/trie_add_and_search.py
  class TrieNode (line 20) | class TrieNode:
    method __init__ (line 21) | def __init__(self, letter, is_terminal=False):
  class WordDictionary (line 27) | class WordDictionary:
    method __init__ (line 28) | def __init__(self):
    method add_word (line 31) | def add_word(self, word):
    method search (line 39) | def search(self, word, node=None):
  class WordDictionary2 (line 62) | class WordDictionary2:
    method __init__ (line 63) | def __init__(self):
    method add_word (line 66) | def add_word(self, word):
    method search (line 70) | def search(self, word):

FILE: tests/test_array.py
  class TestJosephus (line 36) | class TestJosephus(unittest.TestCase):
    method test_josephus (line 37) | def test_josephus(self):
  class TestDeleteNth (line 53) | class TestDeleteNth(unittest.TestCase):
    method test_delete_nth_naive (line 54) | def test_delete_nth_naive(self):
    method test_delete_nth (line 71) | def test_delete_nth(self):
  class TestFlatten (line 89) | class TestFlatten(unittest.TestCase):
    method test_flatten (line 90) | def test_flatten(self):
    method test_flatten_iter (line 104) | def test_flatten_iter(self):
  class TestGarage (line 134) | class TestGarage(unittest.TestCase):
    method test_garage (line 135) | def test_garage(self):
  class TestLongestNonRepeat (line 147) | class TestLongestNonRepeat(unittest.TestCase):
    method test_longest_non_repeat_v1 (line 148) | def test_longest_non_repeat_v1(self):
    method test_longest_non_repeat_v2 (line 165) | def test_longest_non_repeat_v2(self):
    method test_get_longest_non_repeat_v1 (line 182) | def test_get_longest_non_repeat_v1(self):
    method test_get_longest_non_repeat_v2 (line 198) | def test_get_longest_non_repeat_v2(self):
  class TestMaxOnesIndex (line 215) | class TestMaxOnesIndex(unittest.TestCase):
    method test_max_ones_index (line 216) | def test_max_ones_index(self):
  class TestMergeInterval (line 223) | class TestMergeInterval(unittest.TestCase):
    method test_merge (line 224) | def test_merge(self):
    method test_merge_intervals (line 232) | def test_merge_intervals(self):
  class TestMissingRanges (line 238) | class TestMissingRanges(unittest.TestCase):
    method test_missing_ranges (line 239) | def test_missing_ranges(self):
  class TestMoveZeros (line 253) | class TestMoveZeros(unittest.TestCase):
    method test_move_zeros (line 254) | def test_move_zeros(self):
  class TestPlusOne (line 267) | class TestPlusOne(unittest.TestCase):
    method test_plus_one_v1 (line 268) | def test_plus_one_v1(self):
    method test_plus_one_v2 (line 276) | def test_plus_one_v2(self):
    method test_plus_one_v3 (line 284) | def test_plus_one_v3(self):
  class TestRemoveDuplicate (line 293) | class TestRemoveDuplicate(unittest.TestCase):
    method test_remove_duplicates (line 294) | def test_remove_duplicates(self):
  class TestRotateArray (line 318) | class TestRotateArray(unittest.TestCase):
    method test_rotate_v1 (line 319) | def test_rotate_v1(self):
    method test_rotate_v2 (line 332) | def test_rotate_v2(self):
    method test_rotate_v3 (line 345) | def test_rotate_v3(self):
  class TestSummaryRanges (line 359) | class TestSummaryRanges(unittest.TestCase):
    method test_summarize_ranges (line 360) | def test_summarize_ranges(self):
  class TestThreeSum (line 371) | class TestThreeSum(unittest.TestCase):
    method test_three_sum (line 372) | def test_three_sum(self):
  class TestTwoSum (line 381) | class TestTwoSum(unittest.TestCase):
    method test_two_sum (line 382) | def test_two_sum(self):
  class TestTrimmean (line 390) | class TestTrimmean(unittest.TestCase):
    method test_trimmean (line 391) | def test_trimmean(self):
  class TestTop1 (line 397) | class TestTop1(unittest.TestCase):
    method test_top_1 (line 398) | def test_top_1(self):
  class TestLimit (line 403) | class TestLimit(unittest.TestCase):
    method test_limit (line 404) | def test_limit(self):
  class TestNSum (line 411) | class TestNSum(unittest.TestCase):
    method test_n_sum (line 412) | def test_n_sum(self):

FILE: tests/test_backtracking.py
  class TestAddOperator (line 28) | class TestAddOperator(unittest.TestCase):
    method test_add_operators (line 29) | def test_add_operators(self):
  class TestPermuteAndAnagram (line 58) | class TestPermuteAndAnagram(unittest.TestCase):
    method test_permute (line 59) | def test_permute(self):
    method test_permute_iter (line 63) | def test_permute_iter(self):
    method test_angram (line 69) | def test_angram(self):
  class TestArrayCombinationSum (line 74) | class TestArrayCombinationSum(unittest.TestCase):
    method test_array_sum_combinations (line 75) | def test_array_sum_combinations(self):
    method test_unique_array_sum_combinations (line 97) | def test_unique_array_sum_combinations(self):
  class TestCombinationSum (line 109) | class TestCombinationSum(unittest.TestCase):
    method check_sum (line 110) | def check_sum(self, nums, target):
    method test_combination_sum (line 116) | def test_combination_sum(self):
  class TestFactorCombinations (line 128) | class TestFactorCombinations(unittest.TestCase):
    method test_get_factors (line 129) | def test_get_factors(self):
    method test_recursive_get_factors (line 140) | def test_recursive_get_factors(self):
  class TestFindWords (line 152) | class TestFindWords(unittest.TestCase):
    method test_normal (line 153) | def test_normal(self):
    method test_none (line 166) | def test_none(self):
    method test_empty (line 177) | def test_empty(self):
    method test_uneven (line 182) | def test_uneven(self):
    method test_repeat (line 187) | def test_repeat(self):
  class TestGenerateAbbreviations (line 193) | class TestGenerateAbbreviations(unittest.TestCase):
    method test_generate_abbreviations (line 194) | def test_generate_abbreviations(self):
  class TestPatternMatch (line 254) | class TestPatternMatch(unittest.TestCase):
    method test_pattern_match (line 255) | def test_pattern_match(self):
  class TestGenerateParenthesis (line 268) | class TestGenerateParenthesis(unittest.TestCase):
    method test_generate_parenthesis (line 269) | def test_generate_parenthesis(self):
  class TestLetterCombinations (line 282) | class TestLetterCombinations(unittest.TestCase):
    method test_letter_combinations (line 283) | def test_letter_combinations(self):
  class TestPalindromicSubstrings (line 293) | class TestPalindromicSubstrings(unittest.TestCase):
    method test_palindromic_substrings (line 294) | def test_palindromic_substrings(self):
  class TestPermuteUnique (line 315) | class TestPermuteUnique(unittest.TestCase):
    method test_permute_unique (line 316) | def test_permute_unique(self):
  class TestPermute (line 343) | class TestPermute(unittest.TestCase):
    method test_permute (line 344) | def test_permute(self):
    method test_permute_recursive (line 378) | def test_permute_recursive(self):
  class TestSubsetsUnique (line 413) | class TestSubsetsUnique(unittest.TestCase):
    method test_subsets_unique (line 414) | def test_subsets_unique(self):
  class TestSubsets (line 441) | class TestSubsets(unittest.TestCase):
    method test_subsets (line 442) | def test_subsets(self):
    method test_subsets_v2 (line 468) | def test_subsets_v2(self):

FILE: tests/test_bit_manipulation.py
  class TestSuite (line 37) | class TestSuite(unittest.TestCase):
    method setUp (line 38) | def setUp(self):
    method test_add_bitwise_operator (line 42) | def test_add_bitwise_operator(self):
    method test_count_ones_recur (line 48) | def test_count_ones_recur(self):
    method test_count_ones_iter (line 62) | def test_count_ones_iter(self):
    method test_count_flips_to_convert (line 76) | def test_count_flips_to_convert(self):
    method test_find_missing_number (line 86) | def test_find_missing_number(self):
    method test_find_missing_number2 (line 96) | def test_find_missing_number2(self):
    method test_flip_bit_longest_seq (line 106) | def test_flip_bit_longest_seq(self):
    method test_is_power_of_two (line 116) | def test_is_power_of_two(self):
    method test_reverse_bits (line 124) | def test_reverse_bits(self):
    method test_single_number (line 136) | def test_single_number(self):
    method test_single_number2 (line 151) | def test_single_number2(self):
    method test_single_number3 (line 161) | def test_single_number3(self):
    method test_subsets (line 165) | def test_subsets(self):
    method test_get_bit (line 194) | def test_get_bit(self):
    method test_set_bit (line 199) | def test_set_bit(self):
    method test_clear_bit (line 203) | def test_clear_bit(self):
    method test_update_bit (line 207) | def test_update_bit(self):
    method test_int_to_bytes_big_endian (line 215) | def test_int_to_bytes_big_endian(self):
    method test_int_to_bytes_little_endian (line 218) | def test_int_to_bytes_little_endian(self):
    method test_bytes_big_endian_to_int (line 221) | def test_bytes_big_endian_to_int(self):
    method test_bytes_little_endian_to_int (line 224) | def test_bytes_little_endian_to_int(self):
    method test_swap_pair (line 227) | def test_swap_pair(self):
    method test_find_difference (line 233) | def test_find_difference(self):
    method test_has_alternative_bit (line 236) | def test_has_alternative_bit(self):
    method test_has_alternative_bit_fast (line 242) | def test_has_alternative_bit_fast(self):
    method test_insert_one_bit (line 248) | def test_insert_one_bit(self):
    method test_insert_mult_bits (line 261) | def test_insert_mult_bits(self):
    method test_remove_bit (line 272) | def test_remove_bit(self):
    method test_binary_gap (line 283) | def test_binary_gap(self):

FILE: tests/test_community_algorithms.py
  class TestManacher (line 32) | class TestManacher(unittest.TestCase):
    method test_odd_palindrome (line 33) | def test_odd_palindrome(self):
    method test_even_palindrome (line 37) | def test_even_palindrome(self):
    method test_single_char (line 40) | def test_single_char(self):
    method test_full_palindrome (line 43) | def test_full_palindrome(self):
    method test_empty (line 46) | def test_empty(self):
    method test_all_same (line 49) | def test_all_same(self):
  class TestZAlgorithm (line 53) | class TestZAlgorithm(unittest.TestCase):
    method test_z_array_basic (line 54) | def test_z_array_basic(self):
    method test_z_search_found (line 60) | def test_z_search_found(self):
    method test_z_search_multiple (line 63) | def test_z_search_multiple(self):
    method test_z_search_not_found (line 66) | def test_z_search_not_found(self):
    method test_z_search_empty (line 69) | def test_z_search_empty(self):
    method test_z_array_empty (line 73) | def test_z_array_empty(self):
  class TestGrayCode (line 77) | class TestGrayCode(unittest.TestCase):
    method test_2bit (line 78) | def test_2bit(self):
    method test_3bit (line 81) | def test_3bit(self):
    method test_1bit (line 84) | def test_1bit(self):
    method test_0bit (line 87) | def test_0bit(self):
    method test_successive_differ_by_one_bit (line 90) | def test_successive_differ_by_one_bit(self):
    method test_gray_to_binary_roundtrip (line 96) | def test_gray_to_binary_roundtrip(self):
  class TestKdTree (line 102) | class TestKdTree(unittest.TestCase):
    method test_nearest_basic (line 103) | def test_nearest_basic(self):
    method test_nearest_exact (line 108) | def test_nearest_exact(self):
    method test_nearest_3d (line 113) | def test_nearest_3d(self):
    method test_single_point (line 118) | def test_single_point(self):
  class TestExponentialSearch (line 123) | class TestExponentialSearch(unittest.TestCase):
    method test_found (line 124) | def test_found(self):
    method test_first_element (line 128) | def test_first_element(self):
    method test_last_element (line 131) | def test_last_element(self):
    method test_not_found (line 134) | def test_not_found(self):
    method test_empty (line 137) | def test_empty(self):
    method test_single_element_found (line 140) | def test_single_element_found(self):
    method test_single_element_not_found (line 143) | def test_single_element_not_found(self):
  class TestSentinelSearch (line 147) | class TestSentinelSearch(unittest.TestCase):
    method test_found (line 148) | def test_found(self):
    method test_last_element (line 152) | def test_last_element(self):
    method test_not_found (line 156) | def test_not_found(self):
    method test_empty (line 160) | def test_empty(self):
    method test_restores_array (line 163) | def test_restores_array(self):
  class TestManhattanDistance (line 169) | class TestManhattanDistance(unittest.TestCase):
    method test_2d (line 170) | def test_2d(self):
    method test_3d (line 173) | def test_3d(self):
    method test_same_point (line 176) | def test_same_point(self):
    method test_negative (line 179) | def test_negative(self):
  class TestLinearRegression (line 183) | class TestLinearRegression(unittest.TestCase):
    method test_basic_fit (line 184) | def test_basic_fit(self):
    method test_perfect_line (line 191) | def test_perfect_line(self):
    method test_r_squared_perfect (line 198) | def test_r_squared_perfect(self):
    method test_rmse_perfect (line 203) | def test_rmse_perfect(self):
    method test_rmse_nonperfect (line 208) | def test_rmse_nonperfect(self):
    method test_too_few_points (line 213) | def test_too_few_points(self):
  class TestPolynomialDivision (line 218) | class TestPolynomialDivision(unittest.TestCase):
    method test_basic (line 219) | def test_basic(self):
    method test_with_remainder (line 225) | def test_with_remainder(self):
    method test_divide_by_zero (line 232) | def test_divide_by_zero(self):
  class TestAlphabetBoardPath (line 237) | class TestAlphabetBoardPath(unittest.TestCase):
    method test_leet (line 238) | def test_leet(self):
    method test_code (line 244) | def test_code(self):
    method test_z (line 248) | def test_z(self):
    method test_za (line 253) | def test_za(self):
  class TestSwapCharacters (line 258) | class TestSwapCharacters(unittest.TestCase):
    method test_can_swap (line 259) | def test_can_swap(self):
    method test_identical (line 262) | def test_identical(self):
    method test_too_many_diffs (line 266) | def test_too_many_diffs(self):
    method test_different_lengths (line 269) | def test_different_lengths(self):
    method test_one_diff (line 272) | def test_one_diff(self):
  class TestMinimax (line 276) | class TestMinimax(unittest.TestCase):
    method test_depth_2 (line 277) | def test_depth_2(self):
    method test_depth_3 (line 281) | def test_depth_3(self):
    method test_single_leaf (line 284) | def test_single_leaf(self):
    method test_minimizing (line 287) | def test_minimizing(self):
  class TestTsp (line 291) | class TestTsp(unittest.TestCase):
    method test_4_cities (line 292) | def test_4_cities(self):
    method test_3_cities (line 301) | def test_3_cities(self):
  class TestCountPathsDp (line 310) | class TestCountPathsDp(unittest.TestCase):
    method test_3x7 (line 311) | def test_3x7(self):
    method test_3x3 (line 316) | def test_3x3(self):
    method test_1x1 (line 319) | def test_1x1(self):
    method test_2x2 (line 322) | def test_2x2(self):
  class TestBlossom (line 326) | class TestBlossom(unittest.TestCase):
    method test_path_graph (line 327) | def test_path_graph(self):
    method test_triangle (line 332) | def test_triangle(self):
    method test_empty_graph (line 337) | def test_empty_graph(self):
    method test_complete_4 (line 341) | def test_complete_4(self):

FILE: tests/test_compression.py
  class TestHuffmanCoding (line 8) | class TestHuffmanCoding(unittest.TestCase):
    method setUpClass (line 10) | def setUpClass(cls):
    method setUp (line 15) | def setUp(self):
    method test_huffman_coding (line 23) | def test_huffman_coding(self):
    method tearDown (line 36) | def tearDown(self):
  class TestRLECompression (line 44) | class TestRLECompression(unittest.TestCase):
    method test_encode_rle (line 45) | def test_encode_rle(self):
    method test_decode_rle (line 53) | def test_decode_rle(self):
  class TestEliasCoding (line 60) | class TestEliasCoding(unittest.TestCase):
    method test_elias_gamma (line 61) | def test_elias_gamma(self):
    method test_elias_delta (line 82) | def test_elias_delta(self):

FILE: tests/test_data_structures.py
  class TestRBTree (line 16) | class TestRBTree(unittest.TestCase):
    method _make_tree (line 17) | def _make_tree(self, values):
    method test_insert_single (line 23) | def test_insert_single(self):
    method test_insert_multiple_sorted (line 29) | def test_insert_multiple_sorted(self):
    method test_root_is_black (line 36) | def test_root_is_black(self):
    method test_empty_tree (line 40) | def test_empty_tree(self):
    method test_insert_duplicates_order (line 45) | def test_insert_duplicates_order(self):
  class TestAvlTree (line 52) | class TestAvlTree(unittest.TestCase):
    method test_insert_single (line 53) | def test_insert_single(self):
    method test_insert_multiple_root_exists (line 59) | def test_insert_multiple_root_exists(self):
    method test_balanced_after_insert (line 65) | def test_balanced_after_insert(self):
    method test_empty_tree (line 72) | def test_empty_tree(self):
    method test_in_order_traverse_populated (line 77) | def test_in_order_traverse_populated(self):
    method test_insert_balance_factor (line 83) | def test_insert_balance_factor(self):
  class TestTrie (line 91) | class TestTrie(unittest.TestCase):
    method test_insert_and_search (line 92) | def test_insert_and_search(self):
    method test_search_missing (line 97) | def test_search_missing(self):
    method test_starts_with (line 102) | def test_starts_with(self):
    method test_empty_trie (line 108) | def test_empty_trie(self):
    method test_multiple_words (line 113) | def test_multiple_words(self):
    method test_insert_single_char (line 121) | def test_insert_single_char(self):
  class TestUnionFind (line 128) | class TestUnionFind(unittest.TestCase):
    method test_add_and_root (line 129) | def test_add_and_root(self):
    method test_unite_connects (line 134) | def test_unite_connects(self):
    method test_not_connected (line 141) | def test_not_connected(self):
    method test_count_decrements_on_unite (line 147) | def test_count_decrements_on_unite(self):
    method test_unite_same_element (line 156) | def test_unite_same_element(self):
    method test_transitive_connectivity (line 162) | def test_transitive_connectivity(self):
  class TestSegmentTree (line 171) | class TestSegmentTree(unittest.TestCase):
    method test_max_query (line 172) | def test_max_query(self):
    method test_sum_query (line 176) | def test_sum_query(self):
    method test_single_element_query (line 180) | def test_single_element_query(self):
    method test_full_range_max (line 185) | def test_full_range_max(self):
  class TestHashTable (line 191) | class TestHashTable(unittest.TestCase):
    method test_put_and_get (line 192) | def test_put_and_get(self):
    method test_get_missing (line 197) | def test_get_missing(self):
    method test_delete (line 201) | def test_delete(self):
    method test_update_existing (line 207) | def test_update_existing(self):
    method test_len (line 213) | def test_len(self):
    method test_bracket_operators (line 219) | def test_bracket_operators(self):
  class TestResizableHashTable (line 227) | class TestResizableHashTable(unittest.TestCase):
    method test_put_and_get (line 228) | def test_put_and_get(self):
    method test_resizes_automatically (line 233) | def test_resizes_automatically(self):
  class TestSeparateChainingHashTable (line 241) | class TestSeparateChainingHashTable(unittest.TestCase):
    method test_put_and_get (line 242) | def test_put_and_get(self):
    method test_get_missing (line 247) | def test_get_missing(self):
    method test_delete (line 251) | def test_delete(self):
    method test_len (line 257) | def test_len(self):
    method test_collision_handling (line 263) | def test_collision_handling(self):
    method test_bracket_operators (line 271) | def test_bracket_operators(self):

FILE: tests/test_dynamic_programming.py
  class TestBuySellStock (line 30) | class TestBuySellStock(unittest.TestCase):
    method test_max_profit_naive (line 31) | def test_max_profit_naive(self):
    method test_max_profit_optimized (line 35) | def test_max_profit_optimized(self):
  class TestClimbingStairs (line 40) | class TestClimbingStairs(unittest.TestCase):
    method test_climb_stairs (line 41) | def test_climb_stairs(self):
    method test_climb_stairs_optimized (line 45) | def test_climb_stairs_optimized(self):
  class TestCoinChange (line 50) | class TestCoinChange(unittest.TestCase):
    method test_count (line 51) | def test_count(self):
  class TestCombinationSum (line 56) | class TestCombinationSum(unittest.TestCase):
    method test_combination_sum_topdown (line 57) | def test_combination_sum_topdown(self):
    method test_combination_sum_bottom_up (line 60) | def test_combination_sum_bottom_up(self):
  class TestEditDistance (line 64) | class TestEditDistance(unittest.TestCase):
    method test_edit_distance (line 65) | def test_edit_distance(self):
  class TestEggDrop (line 70) | class TestEggDrop(unittest.TestCase):
    method test_egg_drop (line 71) | def test_egg_drop(self):
  class TestFib (line 77) | class TestFib(unittest.TestCase):
    method test_fib_recursive (line 78) | def test_fib_recursive(self):
    method test_fib_list (line 82) | def test_fib_list(self):
    method test_fib_iter (line 86) | def test_fib_iter(self):
  class TestHosoyaTriangle (line 91) | class TestHosoyaTriangle(unittest.TestCase):
    method test_hosoya (line 99) | def test_hosoya(self):
  class TestHouseRobber (line 167) | class TestHouseRobber(unittest.TestCase):
    method test_house_robber (line 168) | def test_house_robber(self):
  class TestJobScheduling (line 172) | class TestJobScheduling(unittest.TestCase):
    method test_job_scheduling (line 173) | def test_job_scheduling(self):
  class TestKnapsack (line 178) | class TestKnapsack(unittest.TestCase):
    method test_get_maximum_value (line 179) | def test_get_maximum_value(self):
  class TestLongestIncreasingSubsequence (line 187) | class TestLongestIncreasingSubsequence(unittest.TestCase):
    method test_longest_increasing_subsequence (line 188) | def test_longest_increasing_subsequence(self):
  class TestLongestIncreasingSubsequenceOptimized (line 193) | class TestLongestIncreasingSubsequenceOptimized(unittest.TestCase):
    method test_longest_increasing_subsequence_optimized (line 194) | def test_longest_increasing_subsequence_optimized(self):
  class TestLongestIncreasingSubsequenceOptimized2 (line 199) | class TestLongestIncreasingSubsequenceOptimized2(unittest.TestCase):
    method test_longest_increasing_subsequence_optimized2 (line 200) | def test_longest_increasing_subsequence_optimized2(self):
  class TestIntDivide (line 205) | class TestIntDivide(unittest.TestCase):
    method test_int_divide (line 206) | def test_int_divide(self):
  class TestDpKFactor (line 212) | class TestDpKFactor(unittest.TestCase):
    method test_kfactor (line 213) | def test_kfactor(self):
  class TestPlantingTrees (line 240) | class TestPlantingTrees(unittest.TestCase):
    method test_simple (line 241) | def test_simple(self):
    method test_simple2 (line 253) | def test_simple2(self):
  class TestRegexMatching (line 266) | class TestRegexMatching(unittest.TestCase):
    method test_none_0 (line 267) | def test_none_0(self):
    method test_none_1 (line 272) | def test_none_1(self):
    method test_no_symbol_equal (line 277) | def test_no_symbol_equal(self):
    method test_no_symbol_not_equal_0 (line 282) | def test_no_symbol_not_equal_0(self):
    method test_no_symbol_not_equal_1 (line 287) | def test_no_symbol_not_equal_1(self):
    method test_symbol_0 (line 292) | def test_symbol_0(self):
    method test_symbol_1 (line 297) | def test_symbol_1(self):
    method test_symbol_2 (line 302) | def test_symbol_2(self):

FILE: tests/test_graph.py
  class TestTarjan (line 38) | class TestTarjan(unittest.TestCase):
    method test_tarjan_example_1 (line 46) | def test_tarjan_example_1(self):
    method test_tarjan_example_2 (line 62) | def test_tarjan_example_2(self):
  class TestCheckBipartite (line 79) | class TestCheckBipartite(unittest.TestCase):
    method test_check_bipartite (line 80) | def test_check_bipartite(self):
  class TestDijkstra (line 89) | class TestDijkstra(unittest.TestCase):
    method test_dijkstra (line 90) | def test_dijkstra(self):
  class TestMaximumFlow (line 107) | class TestMaximumFlow(unittest.TestCase):
    method test_ford_fulkerson (line 115) | def test_ford_fulkerson(self):
    method test_edmonds_karp (line 127) | def test_edmonds_karp(self):
    method dinic (line 139) | def dinic(self):
  class TestMaximumFlowBfs (line 152) | class TestMaximumFlowBfs(unittest.TestCase):
    method test_maximum_flow_bfs (line 159) | def test_maximum_flow_bfs(self):
  class TestMaximumFlowDfs (line 173) | class TestMaximumFlowDfs(unittest.TestCase):
    method test_maximum_flow_dfs (line 180) | def test_maximum_flow_dfs(self):
  class TestAllPairsShortestPath (line 194) | class TestAllPairsShortestPath(unittest.TestCase):
    method test_all_pairs_shortest_path (line 195) | def test_all_pairs_shortest_path(self):
  class TestBellmanFord (line 217) | class TestBellmanFord(unittest.TestCase):
    method test_bellman_ford (line 218) | def test_bellman_ford(self):
  class TestConnectedComponentInGraph (line 237) | class TestConnectedComponentInGraph(unittest.TestCase):
    method test_count_connected_components (line 242) | def test_count_connected_components(self):
    method test_connected_components_with_empty_graph (line 260) | def test_connected_components_with_empty_graph(self):
    method test_connected_components_without_edges_graph (line 271) | def test_connected_components_without_edges_graph(self):
  class PrimsMinimumSpanning (line 283) | class PrimsMinimumSpanning(unittest.TestCase):
    method test_prim_spanning (line 284) | def test_prim_spanning(self):
  class TestDigraphStronglyConnected (line 302) | class TestDigraphStronglyConnected(unittest.TestCase):
    method test_digraph_strongly_connected (line 303) | def test_digraph_strongly_connected(self):
  class TestCycleDetection (line 320) | class TestCycleDetection(unittest.TestCase):
    method test_cycle_detection_with_cycle (line 321) | def test_cycle_detection_with_cycle(self):
    method test_cycle_detection_with_no_cycle (line 332) | def test_cycle_detection_with_no_cycle(self):
  class TestFindPath (line 344) | class TestFindPath(unittest.TestCase):
    method test_find_all_paths (line 345) | def test_find_all_paths(self):
  class TestPathBetweenTwoVertices (line 369) | class TestPathBetweenTwoVertices(unittest.TestCase):
    method test_node_is_reachable (line 370) | def test_node_is_reachable(self):
  class TestStronglyConnectedComponentsKosaraju (line 383) | class TestStronglyConnectedComponentsKosaraju(unittest.TestCase):
    method test_kosaraju_algorithm (line 384) | def test_kosaraju_algorithm(self):
  class TestCountIslandsBfs (line 400) | class TestCountIslandsBfs(unittest.TestCase):
    method test_count_islands (line 401) | def test_count_islands(self):
  class TestMazeSearchBfs (line 423) | class TestMazeSearchBfs(unittest.TestCase):
    method test_maze_search (line 424) | def test_maze_search(self):
  class TestWordLadder (line 436) | class TestWordLadder(unittest.TestCase):
    method test_ladder_length (line 437) | def test_ladder_length(self):
  class TestAllFactors (line 462) | class TestAllFactors(unittest.TestCase):
    method test_get_factors (line 463) | def test_get_factors(self):
    method test_get_factors_iterative1 (line 469) | def test_get_factors_iterative1(self):
    method test_get_factors_iterative2 (line 475) | def test_get_factors_iterative2(self):
  class TestCountIslandsDfs (line 482) | class TestCountIslandsDfs(unittest.TestCase):
    method test_num_islands (line 483) | def test_num_islands(self):
  class TestPacificAtlantic (line 498) | class TestPacificAtlantic(unittest.TestCase):
    method test_pacific_atlantic (line 499) | def test_pacific_atlantic(self):
  class TestSudoku (line 514) | class TestSudoku(unittest.TestCase):
    method test_sudoku_solver (line 515) | def test_sudoku_solver(self):
  class TestWallsAndGates (line 524) | class TestWallsAndGates(unittest.TestCase):
    method test_walls_and_gates (line 525) | def test_walls_and_gates(self):
  class TestMazeSearchDfs (line 538) | class TestMazeSearchDfs(unittest.TestCase):
    method test_maze_search (line 539) | def test_maze_search(self):
  class TestTopSort (line 559) | class TestTopSort(unittest.TestCase):
    method setUp (line 560) | def setUp(self):
    method test_topsort (line 571) | def test_topsort(self):
  class TestTopologicalSort (line 578) | class TestTopologicalSort(unittest.TestCase):
    method test_simple_dag (line 579) | def test_simple_dag(self):
    method test_single_vertex (line 593) | def test_single_vertex(self):
    method test_disconnected_graph (line 600) | def test_disconnected_graph(self):
    method test_no_edges (line 612) | def test_no_edges(self):
    method test_cycle_detection (line 621) | def test_cycle_detection(self):
    method test_self_loop_cycle (line 628) | def test_self_loop_cycle(self):

FILE: tests/test_greedy.py
  class TestMaxContiguousSubsequenceSum (line 8) | class TestMaxContiguousSubsequenceSum(unittest.TestCase):
    method test_max_contiguous_subsequence_sum (line 9) | def test_max_contiguous_subsequence_sum(self):

FILE: tests/test_heap.py
  class TestBinaryHeap (line 6) | class TestBinaryHeap(unittest.TestCase):
    method setUp (line 11) | def setUp(self):
    method test_insert (line 20) | def test_insert(self):
    method test_remove_min (line 27) | def test_remove_min(self):
  class TestSuite (line 37) | class TestSuite(unittest.TestCase):
    method test_get_skyline (line 38) | def test_get_skyline(self):
    method test_max_sliding_window (line 44) | def test_max_sliding_window(self):
    method test_k_closest_points (line 48) | def test_k_closest_points(self):

FILE: tests/test_issue_fixes.py
  class TestDijkstraHeapq (line 21) | class TestDijkstraHeapq(unittest.TestCase):
    method setUp (line 24) | def setUp(self):
    method test_shortest_path (line 34) | def test_shortest_path(self):
    method test_same_source_and_target (line 39) | def test_same_source_and_target(self):
    method test_direct_neighbor (line 44) | def test_direct_neighbor(self):
    method test_unreachable_target (line 49) | def test_unreachable_target(self):
    method test_single_node (line 55) | def test_single_node(self):
    method test_triangle (line 61) | def test_triangle(self):
  class TestGoldbach (line 71) | class TestGoldbach(unittest.TestCase):
    method test_small_even (line 74) | def test_small_even(self):
    method test_goldbach_28 (line 77) | def test_goldbach_28(self):
    method test_goldbach_100 (line 82) | def test_goldbach_100(self):
    method test_goldbach_large (line 86) | def test_goldbach_large(self):
    method test_odd_raises (line 90) | def test_odd_raises(self):
    method test_two_raises (line 94) | def test_two_raises(self):
    method test_negative_raises (line 98) | def test_negative_raises(self):
    method test_verify_range (line 102) | def test_verify_range(self):
  class TestBinaryTreeViews (line 109) | class TestBinaryTreeViews(unittest.TestCase):
    method setUp (line 112) | def setUp(self):
    method test_left_view (line 126) | def test_left_view(self):
    method test_right_view (line 129) | def test_right_view(self):
    method test_top_view (line 132) | def test_top_view(self):
    method test_bottom_view (line 135) | def test_bottom_view(self):
    method test_empty_tree (line 138) | def test_empty_tree(self):
    method test_single_node (line 144) | def test_single_node(self):
    method test_left_skewed (line 151) | def test_left_skewed(self):
    method test_right_skewed (line 163) | def test_right_skewed(self):
  class TestSqrtDecomposition (line 179) | class TestSqrtDecomposition(unittest.TestCase):
    method test_full_range_sum (line 182) | def test_full_range_sum(self):
    method test_partial_range (line 186) | def test_partial_range(self):
    method test_single_element (line 190) | def test_single_element(self):
    method test_update (line 194) | def test_update(self):
    method test_update_full_range (line 199) | def test_update_full_range(self):
    method test_multiple_updates (line 204) | def test_multiple_updates(self):
    method test_out_of_range_update (line 210) | def test_out_of_range_update(self):
    method test_invalid_query (line 215) | def test_invalid_query(self):
    method test_small_array (line 220) | def test_small_array(self):
    method test_larger_array (line 226) | def test_larger_array(self):

FILE: tests/test_iterative_segment_tree.py
  function gcd (line 7) | def gcd(a, b):
  class TestSegmentTree (line 13) | class TestSegmentTree(unittest.TestCase):
    method test_segment_tree_creation (line 18) | def test_segment_tree_creation(self):
    method test_max_segment_tree (line 37) | def test_max_segment_tree(self):
    method test_min_segment_tree (line 41) | def test_min_segment_tree(self):
    method test_sum_segment_tree (line 45) | def test_sum_segment_tree(self):
    method test_gcd_segment_tree (line 49) | def test_gcd_segment_tree(self):
    method test_max_segment_tree_with_updates (line 53) | def test_max_segment_tree_with_updates(self):
    method test_min_segment_tree_with_updates (line 71) | def test_min_segment_tree_with_updates(self):
    method test_sum_segment_tree_with_updates (line 89) | def test_sum_segment_tree_with_updates(self):
    method test_gcd_segment_tree_with_updates (line 107) | def test_gcd_segment_tree_with_updates(self):
    method __test_all_segments (line 126) | def __test_all_segments(self, arr, fnc):
    method __test_all_segments_with_updates (line 135) | def __test_all_segments_with_updates(self, arr, fnc, upd):
    method __test_segments_helper (line 148) | def __test_segments_helper(self, seg_tree, fnc, arr):

FILE: tests/test_linked_list.py
  class Node (line 22) | class Node:
    method __init__ (line 23) | def __init__(self, x):
  function convert (line 29) | def convert(head):
  class TestSuite (line 39) | class TestSuite(unittest.TestCase):
    method setUp (line 40) | def setUp(self):
    method test_reverse_list (line 53) | def test_reverse_list(self):
    method test_is_sorted (line 65) | def test_is_sorted(self):
    method test_remove_range (line 81) | def test_remove_range(self):
    method test_swap_in_pairs (line 108) | def test_swap_in_pairs(self):
    method test_rotate_right (line 116) | def test_rotate_right(self):
    method test_is_cyclic (line 126) | def test_is_cyclic(self):
    method test_merge_two_list (line 149) | def test_merge_two_list(self):
    method test_is_palindrome (line 172) | def test_is_palindrome(self):
    method test_is_palindrome_stack (line 176) | def test_is_palindrome_stack(self):
    method test_is_palindrome_dict (line 180) | def test_is_palindrome_dict(self):
    method test_solution_0 (line 184) | def test_solution_0(self):
    method test_solution_1 (line 189) | def test_solution_1(self):
    method _assert_is_a_copy (line 194) | def _assert_is_a_copy(self, result):
    method _init_random_list_nodes (line 206) | def _init_random_list_nodes(self):

FILE: tests/test_map.py
  class TestHashTable (line 14) | class TestHashTable(unittest.TestCase):
    method test_one_entry (line 15) | def test_one_entry(self):
    method test_add_entry_bigger_than_table_size (line 20) | def test_add_entry_bigger_than_table_size(self):
    method test_get_none_if_key_missing_and_hash_collision (line 25) | def test_get_none_if_key_missing_and_hash_collision(self):
    method test_two_entries_with_same_hash (line 30) | def test_two_entries_with_same_hash(self):
    method test_get_on_full_table_does_halts (line 37) | def test_get_on_full_table_does_halts(self):
    method test_delete_key (line 44) | def test_delete_key(self):
    method test_delete_key_and_reassign (line 52) | def test_delete_key_and_reassign(self):
    method test_assigning_to_full_table_throws_error (line 59) | def test_assigning_to_full_table_throws_error(self):
    method test_len_trivial (line 67) | def test_len_trivial(self):
    method test_len_after_deletions (line 74) | def test_len_after_deletions(self):
    method test_resizable_hash_table (line 83) | def test_resizable_hash_table(self):
    method test_fill_up_the_limit (line 93) | def test_fill_up_the_limit(self):
  class TestSeparateChainingHashTable (line 101) | class TestSeparateChainingHashTable(unittest.TestCase):
    method test_one_entry (line 102) | def test_one_entry(self):
    method test_two_entries_with_same_hash (line 107) | def test_two_entries_with_same_hash(self):
    method test_len_trivial (line 114) | def test_len_trivial(self):
    method test_len_after_deletions (line 121) | def test_len_after_deletions(self):
    method test_delete_key (line 130) | def test_delete_key(self):
    method test_delete_key_and_reassign (line 138) | def test_delete_key_and_reassign(self):
    method test_add_entry_bigger_than_table_size (line 145) | def test_add_entry_bigger_than_table_size(self):
    method test_get_none_if_key_missing_and_hash_collision (line 150) | def test_get_none_if_key_missing_and_hash_collision(self):
  class TestWordPattern (line 156) | class TestWordPattern(unittest.TestCase):
    method test_word_pattern (line 157) | def test_word_pattern(self):
  class TestIsSomorphic (line 164) | class TestIsSomorphic(unittest.TestCase):
    method test_is_isomorphic (line 165) | def test_is_isomorphic(self):
  class TestLongestPalindromicSubsequence (line 171) | class TestLongestPalindromicSubsequence(unittest.TestCase):
    method test_longest_palindromic_subsequence_is_correct (line 172) | def test_longest_palindromic_subsequence_is_correct(self):
    method test_longest_palindromic_subsequence_is_incorrect (line 178) | def test_longest_palindromic_subsequence_is_incorrect(self):
  class TestIsAnagram (line 185) | class TestIsAnagram(unittest.TestCase):
    method test_is_anagram (line 186) | def test_is_anagram(self):

FILE: tests/test_math.py
  class TestPower (line 49) | class TestPower(unittest.TestCase):
    method test_power (line 57) | def test_power(self):
    method test_power_recur (line 63) | def test_power_recur(self):
  class TestBaseConversion (line 70) | class TestBaseConversion(unittest.TestCase):
    method test_int_to_base (line 78) | def test_int_to_base(self):
    method test_base_to_int (line 83) | def test_base_to_int(self):
  class TestDecimalToBinaryIP (line 89) | class TestDecimalToBinaryIP(unittest.TestCase):
    method test_decimal_to_binary_ip (line 97) | def test_decimal_to_binary_ip(self):
  class TestEulerTotient (line 110) | class TestEulerTotient(unittest.TestCase):
    method test_euler_totient (line 118) | def test_euler_totient(self):
  class TestExtendedGcd (line 125) | class TestExtendedGcd(unittest.TestCase):
    method test_extended_gcd (line 133) | def test_extended_gcd(self):
  class TestGcd (line 138) | class TestGcd(unittest.TestCase):
    method test_gcd (line 146) | def test_gcd(self):
    method test_gcd_non_integer_input (line 150) | def test_gcd_non_integer_input(self):
    method test_gcd_zero_input (line 156) | def test_gcd_zero_input(self):
    method test_gcd_negative_input (line 164) | def test_gcd_negative_input(self):
    method test_lcm (line 169) | def test_lcm(self):
    method test_lcm_negative_numbers (line 173) | def test_lcm_negative_numbers(self):
    method test_lcm_zero_input (line 178) | def test_lcm_zero_input(self):
    method test_trailing_zero (line 186) | def test_trailing_zero(self):
    method test_gcd_bit (line 190) | def test_gcd_bit(self):
  class TestGenerateStroboGrammatic (line 195) | class TestGenerateStroboGrammatic(unittest.TestCase):
    method test_gen_strobomatic (line 203) | def test_gen_strobomatic(self):
    method test_strobogrammatic_in_range (line 206) | def test_strobogrammatic_in_range(self):
  class TestIsStrobogrammatic (line 210) | class TestIsStrobogrammatic(unittest.TestCase):
    method test_is_strobogrammatic (line 218) | def test_is_strobogrammatic(self):
    method test_is_strobogrammatic2 (line 222) | def test_is_strobogrammatic2(self):
  class TestModularInverse (line 227) | class TestModularInverse(unittest.TestCase):
    method test_modular_inverse (line 235) | def test_modular_inverse(self):
  class TestModularExponential (line 245) | class TestModularExponential(unittest.TestCase):
    method test_modular_exponential (line 253) | def test_modular_exponential(self):
  class TestNextPerfectSquare (line 262) | class TestNextPerfectSquare(unittest.TestCase):
    method test_find_next_square (line 270) | def test_find_next_square(self):
    method test_find_next_square2 (line 274) | def test_find_next_square2(self):
  class TestPrimesSieveOfEratosthenes (line 279) | class TestPrimesSieveOfEratosthenes(unittest.TestCase):
    method test_primes (line 287) | def test_primes(self):
  class TestPrimeTest (line 292) | class TestPrimeTest(unittest.TestCase):
    method test_prime_test (line 300) | def test_prime_test(self):
  class TestPythagoras (line 312) | class TestPythagoras(unittest.TestCase):
    method test_pythagoras (line 320) | def test_pythagoras(self):
  class TestRabinMiller (line 324) | class TestRabinMiller(unittest.TestCase):
    method test_is_prime (line 332) | def test_is_prime(self):
  class TestRSA (line 338) | class TestRSA(unittest.TestCase):
    method test_encrypt_decrypt (line 346) | def test_encrypt_decrypt(self):
  class TestCombination (line 359) | class TestCombination(unittest.TestCase):
    method test_combination (line 367) | def test_combination(self):
    method test_combination_memo (line 371) | def test_combination_memo(self):
  class TestFactorial (line 376) | class TestFactorial(unittest.TestCase):
    method test_factorial (line 384) | def test_factorial(self):
    method test_factorial_recur (line 392) | def test_factorial_recur(self):
  class TestHailstone (line 401) | class TestHailstone(unittest.TestCase):
    method test_hailstone (line 409) | def test_hailstone(self):
  class TestCosineSimilarity (line 414) | class TestCosineSimilarity(unittest.TestCase):
    method test_cosine_similarity (line 422) | def test_cosine_similarity(self):
  class TestFindPrimitiveRoot (line 431) | class TestFindPrimitiveRoot(unittest.TestCase):
    method test_find_primitive_root_simple (line 439) | def test_find_primitive_root_simple(self):
  class TestFindOrder (line 448) | class TestFindOrder(unittest.TestCase):
    method test_find_order_simple (line 456) | def test_find_order_simple(self):
  class TestKrishnamurthyNumber (line 463) | class TestKrishnamurthyNumber(unittest.TestCase):
    method test_krishnamurthy_number (line 471) | def test_krishnamurthy_number(self):
  class TestMagicNumber (line 479) | class TestMagicNumber(unittest.TestCase):
    method test_magic_number (line 487) | def test_magic_number(self):
  class TestDiffieHellmanKeyExchange (line 496) | class TestDiffieHellmanKeyExchange(unittest.TestCase):
    method test_find_order_simple (line 504) | def test_find_order_simple(self):
  class TestNumberOfDigits (line 511) | class TestNumberOfDigits(unittest.TestCase):
    method test_num_digits (line 519) | def test_num_digits(self):
  class TestNumberOfPerfectSquares (line 528) | class TestNumberOfPerfectSquares(unittest.TestCase):
    method test_num_perfect_squares (line 536) | def test_num_perfect_squares(self):
  class TestChineseRemainderSolver (line 547) | class TestChineseRemainderSolver(unittest.TestCase):
    method test_k_three (line 548) | def test_k_three(self):
    method test_k_five (line 558) | def test_k_five(self):
    method test_exception_non_coprime (line 568) | def test_exception_non_coprime(self):
    method test_empty_lists (line 576) | def test_empty_lists(self):
  class TestFFT (line 583) | class TestFFT(unittest.TestCase):
    method test_real_numbers (line 591) | def test_real_numbers(self):
    method test_all_zero (line 598) | def test_all_zero(self):
    method test_all_ones (line 604) | def test_all_ones(self):
    method test_complex_numbers (line 610) | def test_complex_numbers(self):

FILE: tests/test_matrix.py
  class TestBombEnemy (line 20) | class TestBombEnemy(unittest.TestCase):
    method test_3x4 (line 21) | def test_3x4(self):
  class TestCopyTransform (line 41) | class TestCopyTransform(unittest.TestCase):
    method test_copy_transform (line 49) | def test_copy_transform(self):
  class TestCroutMatrixDecomposition (line 71) | class TestCroutMatrixDecomposition(unittest.TestCase):
    method test_crout_matrix_decomposition (line 79) | def test_crout_matrix_decomposition(self):
  class TestCholeskyMatrixDecomposition (line 116) | class TestCholeskyMatrixDecomposition(unittest.TestCase):
    method test_cholesky_matrix_decomposition (line 124) | def test_cholesky_matrix_decomposition(self):
  class TestInversion (line 170) | class TestInversion(unittest.TestCase):
    method test_inversion (line 178) | def test_inversion(self):
  class TestMatrixExponentiation (line 207) | class TestMatrixExponentiation(unittest.TestCase):
    method test_matrix_exponentiation (line 215) | def test_matrix_exponentiation(self):
  class TestMultiply (line 239) | class TestMultiply(unittest.TestCase):
    method test_multiply (line 247) | def test_multiply(self):
  class TestRotateImage (line 253) | class TestRotateImage(unittest.TestCase):
    method test_rotate_image (line 261) | def test_rotate_image(self):
  class TestSparseDotVector (line 268) | class TestSparseDotVector(unittest.TestCase):
    method test_sparse_dot_vector (line 276) | def test_sparse_dot_vector(self):
  class TestSpiralTraversal (line 286) | class TestSpiralTraversal(unittest.TestCase):
    method test_spiral_traversal (line 294) | def test_spiral_traversal(self):
  class TestSudokuValidator (line 301) | class TestSudokuValidator(unittest.TestCase):
    method test_sudoku_validator (line 309) | def test_sudoku_validator(self):
  class TestSumSubSquares (line 407) | class TestSumSubSquares(unittest.TestCase):
    method test_sum_sub_squares (line 415) | def test_sum_sub_squares(self):
  class TestSortMatrixDiagonally (line 429) | class TestSortMatrixDiagonally(unittest.TestCase):
    method test_sort_diagonally (line 430) | def test_sort_diagonally(self):

FILE: tests/test_monomial.py
  class TestSuite (line 8) | class TestSuite(unittest.TestCase):
    method setUp (line 9) | def setUp(self):
    method test_monomial_addition (line 28) | def test_monomial_addition(self):
    method test_monomial_subtraction (line 65) | def test_monomial_subtraction(self):
    method test_monomial_multiplication (line 103) | def test_monomial_multiplication(self):
    method test_monomial_inverse (line 123) | def test_monomial_inverse(self):
    method test_monomial_division (line 143) | def test_monomial_division(self):
    method test_monomial_substitution (line 155) | def test_monomial_substitution(self):
    method test_monomial_all_variables (line 189) | def test_monomial_all_variables(self):
    method test_monomial_clone (line 201) | def test_monomial_clone(self):

FILE: tests/test_polynomial.py
  class TestSuite (line 8) | class TestSuite(unittest.TestCase):
    method setUp (line 9) | def setUp(self):
    method test_polynomial_addition (line 36) | def test_polynomial_addition(self):
    method test_polynomial_subtraction (line 78) | def test_polynomial_subtraction(self):
    method test_polynomial_multiplication (line 88) | def test_polynomial_multiplication(self):
    method test_polynomial_variables (line 98) | def test_polynomial_variables(self):
    method test_polynomial_subs (line 112) | def test_polynomial_subs(self):
    method test_polynomial_clone (line 134) | def test_polynomial_clone(self):
    method test_polynomial_long_division (line 150) | def test_polynomial_long_division(self):

FILE: tests/test_queue.py
  class TestQueue (line 12) | class TestQueue(unittest.TestCase):
    method test_array_queue (line 17) | def test_array_queue(self):
    method test_linked_list_queue (line 46) | def test_linked_list_queue(self):
  class TestSuite (line 76) | class TestSuite(unittest.TestCase):
    method test_max_sliding_window (line 77) | def test_max_sliding_window(self):
    method test_reconstruct_queue (line 90) | def test_reconstruct_queue(self):
  class TestPriorityQueue (line 97) | class TestPriorityQueue(unittest.TestCase):
    method test_priority_queue (line 100) | def test_priority_queue(self):

FILE: tests/test_searching.py
  class TestSuite (line 27) | class TestSuite(unittest.TestCase):
    method test_first_occurrence (line 28) | def test_first_occurrence(self):
    method test_binary_search (line 41) | def test_binary_search(self):
    method test_ternary_search (line 53) | def test_ternary_search(self):
    method test_last_occurrence (line 61) | def test_last_occurrence(self):
    method test_linear_search (line 69) | def test_linear_search(self):
    method test_search_insert (line 76) | def test_search_insert(self):
    method test_two_sum (line 83) | def test_two_sum(self):
    method test_search_range (line 95) | def test_search_range(self):
    method test_find_min_rotate (line 106) | def test_find_min_rotate(self):
    method test_search_rotate (line 117) | def test_search_rotate(self):
    method test_jump_search (line 124) | def test_jump_search(self):
    method test_next_greatest_letter (line 131) | def test_next_greatest_letter(self):
    method test_interpolation_search (line 148) | def test_interpolation_search(self):

FILE: tests/test_set.py
  class TestFindKeyboardRow (line 6) | class TestFindKeyboardRow(unittest.TestCase):
    method test_find_keyboard_row (line 7) | def test_find_keyboard_row(self):

FILE: tests/test_sorting.py
  function is_sorted (line 27) | def is_sorted(array):
  class TestSuite (line 36) | class TestSuite(unittest.TestCase):
    method test_bogo_sort (line 37) | def test_bogo_sort(self):
    method test_bitonic_sort (line 40) | def test_bitonic_sort(self):
    method test_bubble_sort (line 43) | def test_bubble_sort(self):
    method test_comb_sort (line 46) | def test_comb_sort(self):
    method test_counting_sort (line 49) | def test_counting_sort(self):
    method test_cycle_sort (line 52) | def test_cycle_sort(self):
    method test_exchange_sort (line 55) | def test_exchange_sort(self):
    method test_heap_sort (line 58) | def test_heap_sort(self):
    method test_insertion_sort (line 63) | def test_insertion_sort(self):
    method test_merge_sort (line 66) | def test_merge_sort(self):
    method test_pancake_sort (line 69) | def test_pancake_sort(self):
    method test_pigeonhole_sort (line 72) | def test_pigeonhole_sort(self):
    method test_quick_sort (line 75) | def test_quick_sort(self):
    method test_selection_sort (line 78) | def test_selection_sort(self):
    method test_bucket_sort (line 81) | def test_bucket_sort(self):
    method test_shell_sort (line 84) | def test_shell_sort(self):
    method test_radix_sort (line 87) | def test_radix_sort(self):
    method test_gnome_sort (line 90) | def test_gnome_sort(self):
    method test_cocktail_shaker_sort (line 93) | def test_cocktail_shaker_sort(self):

FILE: tests/test_stack.py
  class TestSuite (line 20) | class TestSuite(unittest.TestCase):
    method test_is_consecutive (line 21) | def test_is_consecutive(self):
    method test_is_sorted (line 30) | def test_is_sorted(self):
    method test_remove_min (line 36) | def test_remove_min(self):
    method test_stutter (line 42) | def test_stutter(self):
    method test_switch_pairs (line 51) | def test_switch_pairs(self):
    method test_is_valid_parenthesis (line 63) | def test_is_valid_parenthesis(self):
    method test_simplify_path (line 71) | def test_simplify_path(self):
  class TestStack (line 76) | class TestStack(unittest.TestCase):
    method test_array_stack (line 77) | def test_array_stack(self):
    method test_linked_list_stack (line 109) | def test_linked_list_stack(self):
  class TestOrderedStack (line 143) | class TestOrderedStack(unittest.TestCase):
    method test_ordered_stack (line 144) | def test_ordered_stack(self):

FILE: tests/test_streaming.py
  class TestMisraGreis (line 9) | class TestMisraGreis(unittest.TestCase):
    method test_misra_correct (line 10) | def test_misra_correct(self):
    method test_misra_incorrect (line 15) | def test_misra_incorrect(self):
  class TestOneSparse (line 21) | class TestOneSparse(unittest.TestCase):
    method test_one_sparse_correct (line 22) | def test_one_sparse_correct(self):
    method test_one_sparse_incorrect (line 33) | def test_one_sparse_incorrect(self):

FILE: tests/test_string.py
  class TestAddBinary (line 70) | class TestAddBinary(unittest.TestCase):
    method test_add_binary (line 78) | def test_add_binary(self):
  class TestBreakingBad (line 84) | class TestBreakingBad(unittest.TestCase):
    method setUp (line 92) | def setUp(self):
    method test_match_symbol (line 97) | def test_match_symbol(self):
    method test_match_symbol_1 (line 100) | def test_match_symbol_1(self):
    method test_bracket (line 106) | def test_bracket(self):
  class TestDecodeString (line 119) | class TestDecodeString(unittest.TestCase):
    method test_decode_string (line 127) | def test_decode_string(self):
  class TestDeleteReoccurring (line 132) | class TestDeleteReoccurring(unittest.TestCase):
    method test_delete_reoccurring_characters (line 140) | def test_delete_reoccurring_characters(self):
  class TestDomainExtractor (line 144) | class TestDomainExtractor(unittest.TestCase):
    method test_valid (line 152) | def test_valid(self):
    method test_invalid (line 155) | def test_invalid(self):
  class TestEncodeDecode (line 159) | class TestEncodeDecode(unittest.TestCase):
    method test_encode (line 167) | def test_encode(self):
    method test_decode (line 170) | def test_decode(self):
  class TestGroupAnagrams (line 174) | class TestGroupAnagrams(unittest.TestCase):
    method test_group_anagrams (line 182) | def test_group_anagrams(self):
  class TestIntToRoman (line 189) | class TestIntToRoman(unittest.TestCase):
    method test_int_to_roman (line 197) | def test_int_to_roman(self):
  class TestIsPalindrome (line 203) | class TestIsPalindrome(unittest.TestCase):
    method test_is_palindrome (line 211) | def test_is_palindrome(self):
    method test_is_palindrome_reverse (line 216) | def test_is_palindrome_reverse(self):
    method test_is_palindrome_two_pointer (line 221) | def test_is_palindrome_two_pointer(self):
    method test_is_palindrome_stack (line 226) | def test_is_palindrome_stack(self):
    method test_is_palindrome_deque (line 231) | def test_is_palindrome_deque(self):
  class TestIsRotated (line 237) | class TestIsRotated(unittest.TestCase):
    method test_is_rotated (line 245) | def test_is_rotated(self):
    method test_is_rotated_v1 (line 252) | def test_is_rotated_v1(self):
  class TestRotated (line 260) | class TestRotated(unittest.TestCase):
    method test_rotate (line 261) | def test_rotate(self):
    method test_rotate_alt (line 267) | def test_rotate_alt(self):
  class TestLicenseNumber (line 274) | class TestLicenseNumber(unittest.TestCase):
    method test_license_number (line 282) | def test_license_number(self):
  class TestMakeSentence (line 290) | class TestMakeSentence(unittest.TestCase):
    method test_make_sentence (line 298) | def test_make_sentence(self):
  class TestMergeStringChecker (line 304) | class TestMergeStringChecker(unittest.TestCase):
    method test_is_merge_recursive (line 312) | def test_is_merge_recursive(self):
    method test_is_merge_iterative (line 315) | def test_is_merge_iterative(self):
  class TestMultiplyStrings (line 319) | class TestMultiplyStrings(unittest.TestCase):
    method test_multiply (line 327) | def test_multiply(self):
  class TestOneEditDistance (line 334) | class TestOneEditDistance(unittest.TestCase):
    method test_is_one_edit (line 342) | def test_is_one_edit(self):
    method test_is_one_edit2 (line 347) | def test_is_one_edit2(self):
  class TestRabinKarp (line 353) | class TestRabinKarp(unittest.TestCase):
    method test_rabin_karp (line 361) | def test_rabin_karp(self):
  class TestReverseString (line 366) | class TestReverseString(unittest.TestCase):
    method test_recursive (line 374) | def test_recursive(self):
    method test_iterative (line 377) | def test_iterative(self):
    method test_pythonic (line 380) | def test_pythonic(self):
    method test_ultra_pythonic (line 383) | def test_ultra_pythonic(self):
  class TestReverseVowel (line 387) | class TestReverseVowel(unittest.TestCase):
    method test_reverse_vowel (line 395) | def test_reverse_vowel(self):
  class TestReverseWords (line 399) | class TestReverseWords(unittest.TestCase):
    method test_reverse_words (line 407) | def test_reverse_words(self):
  class TestRomanToInt (line 414) | class TestRomanToInt(unittest.TestCase):
    method test_roman_to_int (line 422) | def test_roman_to_int(self):
  class TestStripUrlParams (line 428) | class TestStripUrlParams(unittest.TestCase):
    method test_strip_url_params1 (line 431) | def test_strip_url_params1(self):
    method test_strip_url_params2 (line 441) | def test_strip_url_params2(self):
    method test_strip_url_params3 (line 451) | def test_strip_url_params3(self):
  class TestValidateCoordinates (line 462) | class TestValidateCoordinates(unittest.TestCase):
    method test_valid (line 470) | def test_valid(self):
    method test_invalid (line 475) | def test_invalid(self):
  class TestWordSquares (line 487) | class TestWordSquares(unittest.TestCase):
    method test_word_squares (line 495) | def test_word_squares(self):
  class TestUniqueMorse (line 502) | class TestUniqueMorse(unittest.TestCase):
    method test_convert_morse_word (line 503) | def test_convert_morse_word(self):
    method test_unique_morse (line 507) | def test_unique_morse(self):
  class TestJudgeCircle (line 511) | class TestJudgeCircle(unittest.TestCase):
    method test_judge_circle (line 512) | def test_judge_circle(self):
  class TestStrongPassword (line 517) | class TestStrongPassword(unittest.TestCase):
    method test_strong_password (line 518) | def test_strong_password(self):
  class TestCaesarCipher (line 523) | class TestCaesarCipher(unittest.TestCase):
    method test_caesar_cipher (line 524) | def test_caesar_cipher(self):
  class TestCheckPangram (line 529) | class TestCheckPangram(unittest.TestCase):
    method test_check_pangram (line 530) | def test_check_pangram(self):
  class TestContainString (line 535) | class TestContainString(unittest.TestCase):
    method test_contain_string (line 536) | def test_contain_string(self):
  class TestCountBinarySubstring (line 542) | class TestCountBinarySubstring(unittest.TestCase):
    method test_count_binary_substring (line 543) | def test_count_binary_substring(self):
  class TestRepeatString (line 549) | class TestRepeatString(unittest.TestCase):
    method test_repeat_string (line 550) | def test_repeat_string(self):
  class TestTextJustification (line 555) | class TestTextJustification(unittest.TestCase):
    method test_text_justification (line 556) | def test_text_justification(self):
  class TestMinDistance (line 572) | class TestMinDistance(unittest.TestCase):
    method test_min_distance (line 573) | def test_min_distance(self):
  class TestMinDistanceDP (line 579) | class TestMinDistanceDP(unittest.TestCase):
    method test_min_distance (line 580) | def test_min_distance(self):
  class TestLongestCommonPrefix (line 586) | class TestLongestCommonPrefix(unittest.TestCase):
    method test_longest_common_prefix (line 587) | def test_longest_common_prefix(self):
  class TestFirstUniqueChar (line 599) | class TestFirstUniqueChar(unittest.TestCase):
    method test_first_unique_char (line 600) | def test_first_unique_char(self):
  class TestRepeatSubstring (line 605) | class TestRepeatSubstring(unittest.TestCase):
    method test_repeat_substring (line 606) | def test_repeat_substring(self):
  class TestAtbashCipher (line 612) | class TestAtbashCipher(unittest.TestCase):
    method test_atbash_cipher (line 620) | def test_atbash_cipher(self):
  class TestLongestPalindromicSubstring (line 627) | class TestLongestPalindromicSubstring(unittest.TestCase):
    method test_longest_palindromic_substring (line 634) | def test_longest_palindromic_substring(self):
  class TestKnuthMorrisPratt (line 641) | class TestKnuthMorrisPratt(unittest.TestCase):
    method test_knuth_morris_pratt (line 650) | def test_knuth_morris_pratt(self):
  class TestPanagram (line 657) | class TestPanagram(unittest.TestCase):
    method test_empty_string (line 665) | def test_empty_string(self):
    method test_single_word_non_panagram (line 675) | def test_single_word_non_panagram(self):
    method test_fox_panagram_no_spaces (line 685) | def test_fox_panagram_no_spaces(self):
    method test_fox_panagram_mixed_case (line 695) | def test_fox_panagram_mixed_case(self):
    method test_whitespace_punctuation (line 705) | def test_whitespace_punctuation(self):
    method test_fox_panagram (line 715) | def test_fox_panagram(self):
    method test_swedish_panagram (line 725) | def test_swedish_panagram(self):
  class TestFizzbuzz (line 736) | class TestFizzbuzz(unittest.TestCase):
    method test_fizzbuzz (line 741) | def test_fizzbuzz(self):

FILE: tests/test_tree.py
  class Node (line 11) | class Node:
    method __init__ (line 12) | def __init__(self, val, left=None, right=None):
  class TestTraversal (line 18) | class TestTraversal(unittest.TestCase):
    method test_preorder (line 19) | def test_preorder(self):
    method test_postorder (line 24) | def test_postorder(self):
    method test_inorder (line 29) | def test_inorder(self):
  function create_tree (line 35) | def create_tree():
  class TestBTree (line 49) | class TestBTree(unittest.TestCase):
    method setUpClass (line 51) | def setUpClass(cls):
    method setUp (line 58) | def setUp(self):
    method test_insertion_and_find_even_degree (line 63) | def test_insertion_and_find_even_degree(self):
    method test_insertion_and_find_odd_degree (line 72) | def test_insertion_and_find_odd_degree(self):
    method test_deletion_even_degree (line 81) | def test_deletion_even_degree(self):
    method test_deletion_odd_degree (line 94) | def test_deletion_odd_degree(self):
  class TestConstructTreePreorderPostorder (line 108) | class TestConstructTreePreorderPostorder(unittest.TestCase):
    method test_construct_tree (line 109) | def test_construct_tree(self):
  class TestFenwickTree (line 140) | class TestFenwickTree(unittest.TestCase):
    method test_construct_tree_with_update_1 (line 141) | def test_construct_tree_with_update_1(self):
    method test_construct_tree_with_update_2 (line 151) | def test_construct_tree_with_update_2(self):
    method test_construct_tree_with_update_3 (line 161) | def test_construct_tree_with_update_3(self):

FILE: tests/test_veb_tree.py
  class TestVEBTree (line 6) | class TestVEBTree(unittest.TestCase):
    method setUp (line 7) | def setUp(self):
    method test_insert_and_member (line 10) | def test_insert_and_member(self):
    method test_min_max (line 20) | def test_min_max(self):
    method test_successor (line 28) | def test_successor(self):
    method test_delete (line 36) | def test_delete(self):
    method test_invalid_universe (line 44) | def test_invalid_universe(self):