* * Union operation combines two disjoint sets to make a single set * in this union function we pass two elements and check if they are * from diff

* @brief Generate the Z-function for the inputted string. * \param[in] pattern text on which to apply the Z-function * \returns the Z-function outpu

* @brief Get integer from given string. * @details Create an integer from a given string * @param str integer string, can be hexadecimal (st

* \brief Member function to give the modulus of our complex number. * Member function to which gives the absolute value (modulus) of our * c

* function to add two string numbers * \param [in] a first number in string to add * \param [in] b second number in string to add * \returns sum as

* @brief create and add a new node with a give value and at a given height * * @param x value at the new node * @param h height of the

* \brief * Adds and edge between two vertices of graph say u and v in this * case. * * @param adj Adjacency list representation of graph * @param

Adds the given edge to the graph

Adds the given edge to the graph

Information about the adding process * @param key key value to hash and add to table */

Information about the adding process * @param key key value to add to table */

Information about the adding process * @param key key value to hash and add */

* @brief Adds the process to the ready queue if it isn't already there * @param id Process ID * @param arrival Arrival time of the process

* @brief Adds the process to the ready queue if it isn't already there * @param id Process ID * @param arrival Arrival time of the process

Calculates the probability of the events A or B for dependent events * note that if value of B_given_A is unknown, use chainrule to find it * \param

* calculates the probability of the independent events A or B for independent * events * \parama [in] A probability of event A * \parama [in] B pro

namespace strings * @brief A test case in which we search for every appearance of the word 'and' * @param text The text in which we search for appear

! Wrapper for Fibonacci * \param[in] n \f$n^\text{th}\f$ Fibonacci number * \return \f$n^\text{th}\f$ Fibonacci number */

* \brief Member function to give the argument of our complex number. * @return Argument of our Complex number in radians. */

returns P(A|B) */

returns P(B|A) */

function to perform the above algorithm

Recursive function to calculate exponent in \f$O(\log(n))\f$ using binary exponent.

* @brief Calculate exponent with modulo using binary exponentiation in \f$O(\log b)\f$ time. * @param a The base * @param b The exponent * @param m

finds the expected value of a binomial distribution * \param [in] n * \param [in] p * \returns \f$\mu=np\f$ */

calculates the probability of a result within a range (inclusive, inclusive) * \returns \f$\displaystyle \left.P(n,p)\right|_{x_0}^{x_1} = * \sum_{i

finds the standard deviation of the binomial distribution * \param [in] n * \param [in] p * \returns \f$\sigma = \sqrt{\sigma^2} = \sqrt{n\cdot p\c

calculates the probability of exactly x successes * \returns \f$\displaystyle P(n,p,x) = {n\choose x} p^x (1-p)^{n-x}\f$ */

* This function returns the number of set bits in the given number. * @param value the number of which we want to count the number of set bits. * @r

It recursively sorts a bitonic sequence in ascending order, if dir = 1, and in descending order otherwise (means dir=0). The sequence to be sorted

This function first produces a bitonic sequence by recursively sorting its two halves in opposite sorting orders, and then calls bitonicMerge

* Find a pattern in a string by comparing the pattern to every substring. * @param text Any string that might contain the pattern. * @param patt

Function to sort arr[] of size n using bucket sort

* @brief function that builds the PSA * @param original_array original array of values * @returns void */

* @brief Builds the sparse table for computing min/max/gcd/lcm/...etc * for any contiguous sub-segment of the array.This is an example of *

* Get the morse representation for given character. * @param c Character * @returns morse representation string of character */

* @brief Function that checks if the string passed in param can be * segmented from position 'pos', and then correctly go on to segment the * rest o

* @brief function to check whether the passed graph is bipartite or not * @param graph is a 2D matrix whose rows or the first index signify the node

* compare if two sub-strings are equal * \param[in] str1 string pattern to search * \param[in] str2 text in which to search * \param[in] start1,end

* check for termination condition * \param[in] delta point at which to evaluate the polynomial * \returns `false` if termination not reached * \ret

The parameter dir indicates the sorting direction, ASCENDING or DESCENDING; if (a[i] > a[j]) agrees with the direction, then a[i] and a[j] are i

* @brief Constructing the segment tree with the early passed vector. Every * call creates a node to hold the sum of the given range, set its poin

* @brief Prints convex hull of a set of n points. * @param points vector of Point<int, int> with co-ordinates. * @param size Size of the vector. *

* @brief creates a deep copy of a list starting at the input node * @param[in] node pointer to the first node/head of the list to be copied * @re

* @brief Helper function to perform DFS and count the number of paths from node `u` to node `v` * @param A adjacency matrix representing the grap

* The same after the remainder will be added after the same hash header * To avoid conflict, zipper method is used * Insert elements into the linked

* create a symmetric square matrix of given size with random elements. A * symmetric square matrix will *always* have real eigen values. * * \param

* @brief Creates the message schedule array * @param input Input string * @param byte_num Position of the first byte of the chunk * @return std::ar

creating the linked list with 'n' nodes

Decreases value of key at index 'i' to new_val. It is assumed that new_val * is smaller than harr[i]. */

* @brief calls delete on every node * @param root of the tree */

This function deletes key at index i. It first reduced value to minus * infinite, then calls extractMin() */

* @brief delete a word/string from a trie * @param word string to delete from trie */

* \brief * initiates depth first search algorithm. * * @param adj adjacency list of graph * @param start vertex from where DFS starts traversing.

* @brief Remove element that is located at the first of the queue * @returns data that is deleted if queue is not empty */

* @brief Function to perform Depth First Search on the graph * @param v Starting vertex for depth-first search * @param visited Array representing w

* Function to print the orthogonalised vector * * @param r number of vectors * @param c dimenaion of vectors * @param B stores orthogonalised vect

* @brief A function to display the current cache * @returns Void * */

* function displays all the elements in the list * @returns 'void' */

* @brief Utility function to show all elements in the queue */

* @brief Display the chain */

* Display skip list level */

Compute double factorial using iterative method */

Compute double factorial using resursive method. * <br/>Recursion can be costly for large numbers. */

* @brief Generates a (discrete) sample according to the geometrical * distribution * @returns A geometrically distributed number in [1,\inft

A Naive recursive C++ program to find * minimum number of operations to convert * str1 to str2. * O(3^m) */

A DP based program * O(m x n) */

* @brief a1z26 encryption implementation * @param text is the plaintext input * @returns encoded string with dashes to seperate letters */

* @brief Adds new element to the end of the queue * @param ele to be added to the end of the queue */

define \f$f(x)\f$ to find root for. * Currently defined as: * \f[ * f(x) = x^3 - 4x - 9 * \f] */