set up empty queue

* @brief creates a new game - generates a random word and stores in global variable current_word * @returns current_game - a new game instance contai

* @brief checks if letter has been guessed before * @param new_guess letter that has been guessed by player * @param guesses array of player's previ

* create a new large number * \returns pointer to a large number */

* This function gets the next item from the Vector each time it's called. * @params Vector* (a pointer to the Vector struct) * @returns: int */

* At every node, there are 2 possible ways to move -> down or right. * Since it is a square grid, there are in all, 2N steps with N down * and N rig

* @brief Converet octal number to binary * @param octalnum octal value that need to convert * @returns A binary number after conversion */

* @brief Convert octal number to decimal number * @param octalValue is the octal number that needs to be converted * @returns a decimal number after

Function to calculate order of the number

Sorts the array using flip operations

Partition method which selects a pivot and places each element which is less than the pivot value to its left and the elements greater than the pi

* @brief Sorts the target array by dividing it into a variable number of internally sorted piles then merge the piles * @param array pointer to the a

* Returns the next value to be popped. */

function for peeping the element from top of the stack

* @brief gradually draws duck as player gets letters incorrect * @param score how many incorrect guesses player has made * @returns void */

* @brief Update table by placing an `O` * * @returns None */

* @brief Update table by placing an `O` * * @param e1 location to place `O` * * @returns None */

Returns element at front of queue

* Evaluate the value of a polynomial with given coefficients * \param[in] coeffs coefficients of the polynomial * \param[in] degree degree of polyno

Removes element from stack, or returns INT_MIN if stack empty

Removes element from stack, or returns INT_MIN if stack empty

function for poping the element out

* @brief performs postprocessing on a compiled NFA, * add circular empty character transition rules where * it's needed for the NFA to

* performs postorder traversal * param[in] curr node pointer to the topmost node of the tree */

Function to calculate x raised to the power y

* @details * This function return ten to the power a(The parameter specified to it) like: * if the parameter specified is 4 i.e. -> power_of_ten(

* @brief performs preprocessing on a regex string, * making all implicit concatenations explicit * @param input target regex string * @retur

* performs preorder traversal * param[in] curr node pointer to the topmost node of the tree */

variable upto which prime numbers are to be found out * @addtogroup misc * @{ */ * @brief Prime Sieve works in O(nlogn) time * @param p array to be

* Print the matrix to stdout * @param [in] a array to print */

Utility function to print distances

Utility function to print distances

Utility function to print distances

A utility function to print a given linked list

Function to get the middle of the linked list*/

* @brief Recursively prints the solution * @param l dimension of the solutions array * @param s solutions * @param i starting index * @param j end

* @brief Function printTable * Responsible for printing the board * @param logic return of the logical matrix * @param stage game step * @returns

Print tasks into the stdout

* @brief The algorithm here is also the same as the `print_int_value` function * * @details * First, the digits before decimal is printed by conver

Print a large number */

* @details * First size of the string is calculated to check whether * width and precision are to be taken into account or not. * Then, the string is

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

Iterative constructor of all sets in the current level. This function * dynamically allocates memory when creating new sets. These are freed by the

Utilitary procedure to free all nodes in a tree * @param root pointer to parent node */

Pushes element into stack

Pushes element into stack

* @brief The push function pushes the element onto the stack. * * @param ptr Stack pointer * @param data Value to be pushed onto stack * @return i

function for pushing the element

* Function to convert given Euler angles to a quaternion. * \f{eqnarray*}{ * q_{0} & = * &\cos\left(\frac{\phi}{2}\right)\cos\left(\frac{\theta}{2}

This is where the sorting of the array takes place arr[] --- Array to be sorted lower --- Starting index upper --- Ending index */

This is where the sorting of the array takes place arr[] --- Array to be sorted n --- Array Size max --- Maximum element in Array */

* @brief Reads words from file to tree * @param file file to be read from * @param root root node of tree * @returns a pointer to the root node */

* @brief helper function to recursively redirect transition rule targets * @param nfa target NFA * @param src the state to redirect away from * @pa

* Function to remove digits preceeding the * current digit. */

* @brief Reverses a string using [two pointer algorithm](https://www.geeksforgeeks.org/program-reverse-array-using-pointers/?ref=rp) * @param p point

this function is used to put a string

Strongly connected components

* searches for the element * \param[in] root node pointer to the topmost node of the tree * \param[in] ele value searched for */

* Builds a Segment tree * It is assumed that leaves of tree already contains data. * @param tree pointer to segment tree to be build */

* Dispose Segment Tree * Frees all heap memory accquired by segment tree * @param tree pointer to segment tree */

* Initializes Segment Tree * Accquires memory for segment tree * and fill the leaves of segment tree with data from array * @param arr the array da

* Selection sort algorithm implements * @param arr array to be sorted * @param size size of array */

* @brief Selection Sort algorithm implemented using recursion * @param arr array to be sorted * @param size size of the array * @returns void */

* @brief Compute approximation using the semi-implicit-Euler * method in the given limits. * @param[in] dx step size * @param[in] x0 initi

* @brief Compute next step approximation using the semi-implicit-Euler * method. * @param[in] dx step size * @param[in,out] x take @f$x_n@f$ and

* Shell sort algorithm.\n * Optimized algorithm - takes half the time as other * @param [in,out] array array to sort * @param [in] LEN length of th

* Alphabetical sorting using 'shell sort' algorithm */

function to show each pass