* Function to compute the number of positive divisors. * @param n number to compute divisors for * @returns number of positive divisors of n (or 1 i

* @brief The main function implements count of subsets * @param sum is the required sum of any subset * @param in_arr is the input array * @returns

* @brief This function calculates a raised to exponent b under modulo c using * modular exponentiation. * @param a integer base * @param b unsigned

* @brief Prints the values of the Circular Linked List, beginning from the * root Node * @details Goes through each Node from the root and p

* @brief Quadratic equation calculator. * @param a quadratic coefficient. * @param b linear coefficient. * @param c constant * @return Array conta

* @brief Querying the range from index l to index r, checking at every node * if it has some value to be propagated. Current node's value is retu

* @brief Recursive function to remove a value from the BST. * * @param parent The parent node of node. * @param node The node to search

* This function implements [Saddleback * Algorithm](https://www.geeksforgeeks.org/saddleback-search-algorithm-in-a-2d-array), * on a sorted 2D array

* @brief A function that implements Boyer-Moore's algorithm. * * @param str Text we are seatching in. * @param arg pattern structure containing the

* @brief Shifts the given vector to the left by the shift amount and returns a * new vector with the result. The original vector is not mutated. * @

* @brief Shifts the given vector to the right by the shift amount and returns a * new vector with the result. The original vector is not mutated. *

* Function to get prediction of model on single sample. * @param X array of feature vectors * @return returns predictions as vector */

* @brief The main function that implements the count of the subarrays * @param sum is the required sum of any subarrays * @param in_arr is the input

* @brief Returns the prefix sum in range from L to R. * @param l Left index of range. * @param r Right index of range. * @return Sum of

* @brief Wrapper to evaluate if the approximated * value is within `.XX%` threshold of the exact value. * @param approx aprroximate value * @par

* Returns the top most element of the stack * @returns top element of the queue */

* @brief Returns a std::vector of the values of the Circular Linked List * @details Starting from the root Node, appends each value of the list t

* @brief Function runs the dijkstra algorithm for some source vertex and * target vertex in the graph and returns the shortest distance of target *

* @brief Check if item is in the node * @param item item to check * @return true if item in the node, otherwise false */

* * Find operation takes a number x and returns the set to which this number * belongs to. * @param x element of some set * @return set to which x

* @brief Get the index of the item in the node, 0-based * @param item item to check * @return 0-based index of the item in the node, if not

* @brief Insert a value to the index position * @param index index of the item to remove * @param keep_left which child of the item to keep,

* @brief Lists out all the words in trie with the longest prefix * of the search key that is present in the trie. For example - if trie contains *

* @brief Function calculates the minimum path distance that will cover all the * cities starting from the source. * * @param cities matrix represen

* @brief to return the aliquot sum of a number * @param num The input number */

* this function performs the breadth first search on graph and return a * mapping which maps the nodes to a boolean value representing whether

* @brief The change() function is used * to return the updated iterative value corresponding * to the given function * @param x is the value corres

* create a textual form of complex number * \param[in] x point at which to evaluate the polynomial * \returns pointer to converted string */

* @brief removes the first element from the queue * @exception std::invalid_argument if queue is empty */

* @brief This function clears the memory allocated to entire tree recursively. * Its just for clean up the memory and not relevant to the actual topi

* * @brief * Explores the given vertex, exploring a vertex means traversing * over all the vertices which are connected to the vertex that is * cu

* returns i^th digit as an ASCII character **/

* @brief Function runs the dijkstra algorithm for some source vertex and * target vertex in the graph and returns the shortest distance of target *

* @fn double evaluate_by_simpson(int N, double h, double a, * std::function<double (double)> func) * @brief Calculate integral or assert if integral

* @brief The expected value of a geometrically distributed random variable * X * @returns E[X] = 1/p */

* @fn double f(double x) * @brief A function f(x) that will be used to test the method * @param x The independent variable xi * @returns the value

Get the entry instance corresponding to a key * @param key key value to search/probe * @returns if present, the entry instance * @returns if not pr

* @brief Using Z_function to find a pattern in a text * \param[in] pattern string pattern to search * \param[in] text text in which to search * \re

* @brief The main function that finds the stable matching between two sets of * elements using the Gale-Shapley Algorithm. * @note This doesn't work

* algorithm */

* algorithm */

* @brief A function to get page hits * @returns int * */

* @brief Inorder successor of a node is the next node in inorder traversal of * the Binary Tree. This function takes the root node and the data of th

* @brief A function to get page fault * @returns int * */

* \brief Function to get random numbers to generate our complex numbers for * test */

* This function finds value for given character (i.e.0-25) * @param c character for which we want value * @return returns co

* Function for the process of Gram Schimdt Process * @param r number of vectors * @param c dimension of vectors * @param A stores input of given LI

* @brief This function counts the number of augmenting paths between left and right sides of the Bipartite graph * @returns size of maximum matching

* @brief The main function that implements the House Robber algorithm using * dynamic programming * @param money array containing money in the ith h

* @brief inserts a new element into AVL tree * @param root of the tree * @param[in] item the element to be insterted into the tree * @return root o

List insert a new value at head in list */

Determine whether the stack is empty */

* @brief returns lower 128-bit integer part * @returns returns lower 128-bit integer part */

* \brief Query the structure to find the lowest common ancestor. * Assumes that the provided numbers are valid indices of vertices. * Iterat

* @brief Function that returns the longest palindromic * subsequence of a string * @param a string whose longest palindromic subsequence is to be

* @brief This function is used in test cases to quickly create BST containing * large data instead of hard coding it in code. For a given root, this

* @fn double midpoint(const std::int32_t N, const double h, const double a, * const std::function<double (double)>& func) * @brief Main function for

* @brief multiply Point and integer * @details Multiply Point by a scalar factor (here it is a private key p). The * multiplication is called as [do

* Function to get the number of vertices in the graph * @return the number of vertices in the graph. */

* @brief To find orientation of ordered triplet (p, q, r). * @param p Co-ordinates of Point p <int, int>. * @param q Co-ordinates of Point q <int, i

* @brief Removes the topmost element from the stack * @returns void */

* @brief This function finds whether a number is power of 2 or not * @param n value for which we want to check * prints the result, as "Yes, the num

* predict the output of the model for given set of features * \param[in] x input vector * \param[out] out optional argument to return neuron

* @brief Prints the BST in inorder traversal using recursion. * @param root A pointer to the root node of the BST. * @returns void * */

* @brief Inserts an element to the top of the stack. * @param val the element that will be inserted into the stack * @returns void */

Performs quadratic probing to resolve collisions * @param key key value to search/probe * @param searching `true` if only searching, `false1 if assi

* @brief Returns the sum of all elements in a range * * @param segtree the segment tree * @param lazy for lazy propagation * @param qlow l

* @brief Wrapper function for substr that considers leading zeros. * @param str, the binary input string. * @param x1, the substr parameter integer

* @brief The main function implements set kth bit * @param N is the number whose kth bit will be set * @returns returns an integer after setting the

* @brief Returns the number of items present in the cache. * @return number of items in the cache */

return sample standard deviation computed till last sample */

* @brief Main searching function * @param sublist A linked list which is supposed to be searched in mainList. * @param mainList A linked list in whi

* @brief Displays the topmost element of the stack * * @return The topmost element of the stack * @throws std::out_of_range if the stac

* @brief The variance of a geometrically distributed random variable X * @returns V[X] = (1 - p) / p^2 */

Function to sort array * * @param arr array to be sorted * @param l start index of array * @param r end index of array * */

* @brief Get the child's index of the children array * @param child child pointer of which to get the index * @return the index of child

* @brief Get next node which is possibly contains item * @param item item to search * @return the next node that possibly contains item

* @brief Check if node is a full (4-node) * @return true if node is full (4-node), false otherwise */