Move one disc from one tower to another * \param [in,out] From tower to move disk *from* * \param [in,out] To tower to move disk *to* */

To multiply 2 matrices * \param [in] A matrix 1 of size (m\f$\times\f$n) * \param [in] B \p matrix 2 of size (p\f$\times\f$q)\n\note \f$p=n\f$ * \r

* Function to multiply two matrices * @param T matrix 1 * @param A martix 2 * @returns resultant matrix */

Computes n choose r * \param [in] n * \param [in] r * \returns \f$\displaystyle {n\choose r} = * \frac{n!}{r!(n-r)!} = \frac{n\times(n-1)\times(n-

* @brief computes nCr % p * @param[in] n the number of objects to be chosen * @param[in] r the number of objects to choose from * @retu

* @brief Used for second hash function * * @param key key value to hash * @return hash value of the key */

* Find the probability of x successes in a Poisson dist. * \f[p(\mu,x) = \frac{\mu^x e^{-\mu}}{x!}\f] */

pop a byte out of stack variable

* @brief postOrderIterative() function that will perform the postorder * traversal iteratively, and return the result array that contain the postord

* @brief preOrderIterative() function that will perform the preorder traversal * iteratively, and return the result array that contain the preorder

printing the linked list

utility function to print the Array

* @brief A simple function to print the linked list * @param start The head of the linked list * @returns void */

* @brief This function prints roots of the equation. * @param root which we have to print. * @param count which is count of the root in an interval

* @brief Problem statement for a system with first-order differential * equations. Updates the system differential variables. * \note This function

* @brief Problem statement for a system with first-order differential * equations. Updates the system differential variables. * \note This function

* @brief Function to sort vector digit by digit. * @param ar - vector to be sorted * @returns sorted vector */

* @brief Helper method for range_comb method below * @param i The current node * @param l The leftmost node of the current node * @p

* Function to compute sum of fibonacci sequence from 0 to n. * @param n number * @returns uint64_t ans, the sum of sequence */

* @brief reverses a given string * @param in_str input string * @return the string in which the characters appear in the reversed order as in * in_

* @param root of the tree to be rotated * @return node after right rotation */

* Function implementing Shortest Common Super-Sequence algorithm using look-up table method. * @param str1 first string 'X' * @param

* @brief Utility function to print array * @returns void */

* @brief Performs the sieve * @param vec Array of bools, all initialised to true, where the number of * elements is the highest number we wish to ch

* @brief Utility function to return the current size of the stack * @returns current size of stack */

* @brief A utility function that returns the size of the set to which i * belongs to * @param i element of some set * @returns size of

* @brief Sort the list * @returns void */

* Function to find the sum of the digits of an integer. * @param num The integer. * @return Sum of the digits of the integer. * * \detail * First

* @brief Function to calculate the sum of all the proper divisor * of an integer. * @param num selected number. * @return Sum of the proper divisor

* @brief counts the sum of edges in the given tree * @param adj 2D vector adjacency matrix * @returns the int size of the tree */

iterative Timsort function to sort the array[0...n-1] (similar to merge sort)

* @brief Doing range update, checking at every node if it has some value to * be propagated. All nodes affected by the update are copied and

The main function that finds the shortest path from given source to all other vertices using Bellman-Ford.It also detects negative weight cycle

* * Function to create a set * @param n number of element * */

* @brief Function to verify presence and hence delete an entry from the trie * @param entry string entry to be deleted from the trie */

* * Find the next gap by shrinking the current gap by shrink factor of 1.3 * @param gap current gap * @return new gap * */

The main function that finds the shortest path from a vertex to all other vertices using Floyd-Warshall Algorithm.

The main function that builds a Huffman Tree and print codes by traversing the built Huffman Tree

* @brief Inserts the given data in BST while maintaining the properties of BST. * @param root Pointer to the root node of the BST * @param data Data

* @brief Function to insert a word in the trie * @param entry string entry to be inserted in the trie */

* @brief Insert item to the proper position of the node and return the * position index. * * This is a helper function we use during in

function to search the value in an array using interpolation search * \param [in] arr array to search in * \param [in] value value to search for

Check if a number is prime * \param[in] number number to check * \returns true if prime else false */

* @brief Recursive function to calculate the maximum value obtainable using * an unbounded knapsack approach. * * @param i Current index in

Function to find the most efficient way to multiply the given sequence of matrices

* @brief Finds the N-Bonacci series for the `n` parameter value and `m` * parameter terms * @param n is in the N-Bonacci series * @param m is the n

* @brief Remove item from tree * @param item item to remove * @return true if item found and removed, false otherwise */

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

Perform Sieve algorithm */

Calculating prime number upto a given range */

Bisection method implemented for the function \f$x^2-a=0\f$ * whose roots are \f$\pm\sqrt{a}\f$ and only the positive root is returned. */

* Recursive algorithm to solve the puzzle * \param [in] n starting number of disks * \param [in,out] From tower to move disks from * \param [in,ou

* @brief In-order traverse the tree, print items * @param tree tree to traverse */

* Compute the area of triangle formed by three points using [Heron's * formula](https://en.wikipedia.org/wiki/Heron%27s_formula). * If the lengths o