Delete the tail end node and return the node's data. >>> linked_list = LinkedList() >>> linked_list.insert_tail("firs

Return the cross product of vectors (pivot->query) and (pivot->target). The sign of the result encodes the orientation of the ordered triple

Empties the tree >>> t = BinarySearchTree() >>> assert t.root is None >>> t.put(8) >>> assert t.root is not

Calculate Euclidean distance between two points. >>> Point(0, 0).euclidean_distance(Point(3, 4)) 5.0 >>> Point(1, 1)

Calculate the Lorentz factor y = 1 / √(1 - v²/c²) for a given velocity >>> gamma(4) 1.0000000000000002 >>> gamma(1e5) 1.000000055

Returns a list of all the entities within the planet. >>> wt = WaTor(WIDTH, HEIGHT) >>> len(wt.get_entities()) == PREDATOR_I

Gets the max label inserted in the tree >>> t = BinarySearchTree() >>> t.get_max_label() Traceback (most recent call

Gets the min label inserted in the tree >>> t = BinarySearchTree() >>> t.get_min_label() Traceback (most recent call

getter for the height

Insert new element

Insert data to the beginning of linked list. >>> linked_list = LinkedList() >>> linked_list.insert_head("head") >>> l

Insert the data of the node at the nth pos in the Circular Linked List. Args: index: The index at which the data should b

Convert a given positive decimal integer to base 'base'. Where 'base' ranges from 2 to 36. Examples: >>> int_to_base(0, 21) '0'

Checks to see if a number is a prime in O(sqrt(n)). A number is prime if it has exactly two factors: 1 and itself. Returns boolean representin

Returns true iff this node is the right child of its parent.

Check if number is a perfect square. >>> is_sq(1) True >>> is_sq(1000001) False >>> is_sq(1000000) True

Iterate the function "eval_function" exactly nb_iterations times. The first argument of the function is a parameter which is contained in

a mirror symmetry rotation of the left_rotation

Finds the maclaurin approximation of cos :param theta: the angle to which cos is found :param accuracy: the degree of accuracy wante

Finds the maclaurin approximation of sin :param theta: the angle to which sin is found :param accuracy: the degree of accuracy wante

correct a single violation of the heap property in a subtree's root. It is the function that is responsible for restoring the proper

Return the median of the input list :param arr: Array to find median of :return: median of arr >>> median_of_five([2, 4, 5, 7, 899])

Check whether *point*, known to be collinear with the segment, lies on it. >>> on_segment(Point(0, 0), Point(4, 4), Point(2, 2)) True >>>

Removes the last element of the deque and returns it. Time complexity: O(1) @returns topop.val: the value of the node to pop.

Pop the smallest value from the heap and return it. >>> sh = SkewHeap([3, 1, 3, 7]) >>> sh.pop() 1 >>> sh.po

input: positive integer 'number' returns a list of the prime number factors of 'number' >>> prime_factorization(0) [0] >>> prime

This method prints every node data. >>> linked_list = LinkedList() >>> linked_list.insert_tail("first") >>> linked_li

add a Node to the stack

Converts the given non-negative integer to hex string. Example: Suppose the input is the following: i = 1234 The input is 0

r""" A B / \ / \ B C Bl A / \ -->

Static method to be used inside other methods. Left rotates n by b. >>> SHA1Hash('').rotate(12,2) 48

Plots of whether the absolute value of z_final is greater than the value of escape_radius. Adds the function_label and function_params to

Implementation of the simulated annealing algorithm. We start with a given state, find all its neighbors. Pick a random neighbor, if that nei

Return the size of the stack. >>> S = Stack(3) >>> S.size() 0 >>> S = Stack(3) >>> S.push(10)

Simple image transformation using one of two available filter functions: Erosion and Dilation. Args: image: binarized input imag

Union of two sets. set with bigger rank should be parent, so that the disjoint set tree will be more flat.

Ask for user value and validate that it fulfill a condition. :input_type: user input expected type of value :input_msg: message to show

>>> from math import isclose >>> isclose(variance([1,2],[0.7,0.3]), 0.21) True

Return the 2-d vector product of two vectors. >>> vector_product((1, 2), (-5, 0)) 10 >>> vector_product((3, 1), (6, 10)) 24

getter for the width

Implement safety checker that calculates the needs by ensuring that ``max_claim[i][j] - alloc_table[i][j] <= avail[j]``

Compares the two items using default comparison

Basic checks on the arguments to the rod-cutting algorithms * `n`: int, the length of the rod * `prices`: list, the price list for each

Fixes the heap in upward direction of given index

:param key: Searched key, :return: Tuple with searched node (or None if given key is not present) and list of nodes

>>> _validate_dict({"b": 0.5}, "mock_name", float) >>> _validate_dict("invalid", "mock_name", float) Traceback (most recent call last):

validates an input instance before a convex-hull algorithms uses it Parameters --------- points: array-like, the 2d points to valida

Adds the given node at the tail of the list and shifting it to proper position

Adds a vertex to the graph

returns the list containing all the possible combinations a string(`target`) can be constructed from the given list of substrings(`word_b

Calculate the area of a regular polygon. Wikipedia reference: https://en.wikipedia.org/wiki/Polygon#Regular_polygons Formula: (n*s^2*c

Calculates β = v/c, the given velocity as a fraction of c >>> beta(c) 1.0 >>> beta(199792458) 0.666435904801848 >>> beta(1e5)

Perform bidirectional search on a graph to find the shortest path. Args: graph: A dictionary where keys are nodes and values are lis

>>> binary_search_insertion([1, 2, 7, 9, 10], 4) [1, 2, 4, 7, 9, 10]

Calculates Spearman's rank correlation coefficient. :param variable_1: List of floats representing the first variable. :param variable_2

input: an index (pos) and a value changes the specified component (pos) with the 'value'

Check that the arguments are valid

Counts the number of inversions using a naive brute-force algorithm Parameters ---------- arr: arr: array-like, the list containing t

Counts the number of inversions using a divide-and-conquer algorithm Parameters ----------- arr: array-like, the list containing the

Convert a positive integer to another base as str. >>> decimal_to_any(0, 2) '0' >>> decimal_to_any(5, 4) '11' >>> decimal_to_

>>> linked_list = DoublyLinkedList() >>> linked_list.delete_at_nth(0) Traceback (most recent call last): ....

>>> determinant([[1, 2], [3, 4]]) -2 >>> determinant([[1.5, 2.5], [3, 4]]) -1.5

>>> root = Node(1) >>> root.diameter() 1 >>> root.left = Node(2) >>> root.diameter() 2 >>> ro

Return the cost of the shortest path between vertices start and end. >>> dijkstra(G, "E", "C") 6 >>> dijkstra(G2, "E", "F") 3 >>>

Display these values as a 2-D grid.

This is the function to integrate, f(x) = (x - 0)^2 = x^2. :param x: The input value :return: The value of f(x) >>> f(0) 0

>>> f(5) 39.98652410600183

Finds fibonacci number in index k. Parameters ---------- k : Index of fibonacci. Returns ------- int Fibonac

Get the Fibonacci number of `index`. If the number does not exist, calculate all missing numbers leading up to the number of `index`.

Get image rotation :param img: np.ndarray :param pt1: 3x2 list :param pt2: 3x2 list :param rows: columns image shape :param c

Returns a list of successors (both in the grid and free spaces)

Returns a list of successors (both in the grid and free spaces)