* @brief Get the input from the user * @return valid argument to the fibonacci function */

Utilitary procedure to find the greatest key in the left subtree * @param root pointer to parent node * @returns pointer to parent node */

* @brief Stores word in memory * @param word word to be stored in memory * @returns a pointer to the newly allocated word if the word IS stored succ

* @brief getPrecedence function returns the precedence after comparing two operators passed as parameter. * @param op1 : first operator * @param op2

* @brief Returns specific required next character * @param p pointer to a format string of `min_printf()` * @param buffer struct for checking if buf

* Get all integer divisors of a number * \param[in] N number to find divisors for * \param[out] D array to store divisors in * \returns number of d

* Get minimum value and index of the value in a matrix * \param[in] X matrix to search * \param[in] N number of points in the vector * \param[out]

* Function to get the number of days in a month. * \param month month identified by an integer -\n * > 0 = Jan and 11 = December * \returns numb

* @brief Find and get the location for next empty cell. * * @param [in] a pointer to sudoku instance * @param [out] x pointer to row index of next

* @brief Calculates the number of digits in a number * @param n number whose digits are to be counted * @return number of digits in n */

* \returns -1 if N is deficient * \returns 1 if N is abundant * \returns 0 if N is perfect */

* Returns: * -1 if N is deficient * 1 if N is abundant * 0 if N is perfect */

Compute the product of two numbers in a file * * \param[in] fp pointer to file that is already open * \param[in] start_pos line number of the first

* @brief Takes width and precision specified from the format of the string * @param p pointer of the format string * @param width variable in which wi

grow: increases the stack by 10 elements. This utility function isn't part of the public interface */

Function for Tower of Hanoi algorithm

If start from vertex v, decide if the graph has euler path

--------------------------------------------------------------------------*/

* @brief Heap Sort algorithm * @param arr array to be sorted * @param size size of the array * @returns void */

* @brief heapifyDown Adjusts new root to the correct position in the heap * This heapify procedure can be thought of as building a heap from * the t

* @brief heapifyUp Adjusts arr[i] to the correct position in the heap * This heapify procedure can be thought of as building a heap from * the botto

Utilitary procedure to measure the height of the binary tree * @param root pointer to parent node * @param data value to store int he new node * @r

* @brief Convert a hexadecimal number to octal number. * @param hex Hexadecimal number to convert. * @returns A pointer to the converted octal strin

* @brief inList function is used to know if an element is already in the memoryInfo list. * @details This function is used to know if an allocation

Traversal procedure to list the current keys in the tree in order of value * (from the left to the right) * @param root pointer to parent node */

* @brief checks if letter is in current word * @param letter letter guessed by player * @param word current word * @param size length of word * @r

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

Insertion procedure, which inserts the input key in a new node in the tree * @param root pointer to parent node * @param data value to store int he

To insert a node in the existing tree

* @brief Insert a node at start of list * @param head start pointer of list * @param data the data that the node i

* @brief Insert a node at end of list * * @param head start pointer of list * @param data the data that the node

* inserts a node into the tree * param[in,out] root pointer to node pointer to the topmost node of the tree * param[in] data value to be inserted in

This is where the sorting of the array takes place arr[] --- Array to be sorted size --- Array Size */

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

* @brief Given a valid affine cipher key, this function will produce the * inverse key. * * @param key They key to be inverted * * @returns inver

* @brief determines whether the NFA is currently in its accepting state * @param nfa target NFA * @returns `1` if the NFA is in its accepting state

Another way */

isEmpty(): returns 1 if stack is empty otherwise 0. */

* @brief isOprnd function * @param ch : this is the element from the infix array * @returns 1 or 0 on exit */

* @brief Check if input year is a leap year. * \param year year to check * \return 1 if input year is a leap year * \return 0 if input year is n

Check if number is palindromic * \param[in] n number to check * \returns 1 if palindromic * \returns 0 if not palindromic */

Function to check if a number is prime */

* check if a given number can be represented as a sum * of two abundant numbers. * \returns 1 - if yes * \returns 0 - if not */

* check if a given number can be represented as a sum * of two abundant numbers. * \returns 1 - if yes * \returns 0 - if not */

* @brief Checking if alphabet is valid * @param base alphabet inputed by user * @return int64_t as success or not */

* Get minimum value and index of the value in a vector * \param[in] X vector to search * \param[in] N number of points in the vector * \param[out]

* Update weights of the SOM using Kohonen algorithm * * \param[in] x data point * \param[in,out] W weights matrix * \param[in,out] D temporary vec

* Update weights of the SOM using Kohonen algorithm * * \param[in] X data point * \param[in,out] W weights matrix * \param[in,out] D temporary vec

* Alphabetical sorting using 'lazy sort' algorithm */

Function to return LCM of two numbers

Compute [Least Common Multiple * (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple) of two numbers * @param a first number * @param b seco

* @brief Builds the LCS according to B using a traceback approach * @param s1 first null-terminated string * @param l1 length of s1 * @param l2 len

* @brief Computes LCS between s1 and s2 using a dynamic-programming approach * @param s1 first null-terminated string * @param s2 second null-termin

Perform LU decomposition on matrix * \param[in] A matrix to decompose * \param[out] L output L matrix * \param[out] U output U matrix * \param[in]

* Perform multiplication of two matrices. * * R2 must be equal to C1 * * Resultant matrix size should be R1xC2 * \param[in] A first matrix to multi

* @brief Finds the optimal sequence using the classic O(n^3) algorithm. * @param l length of cost array * @param p costs of each matrix * @param s

* @brief Perform merge of segments. * * @param a array to sort * @param l left index for merge * @param r right index for merge * @param n total

Merge sort algorithm implementation * @param a array to sort * @param n number of elements in the array * @param l index to sort from * @param r i

* @brief Compute approximation using the midpoint-Euler * method in the given limits. * @param[in] dx step size * @param[in] x0 initial va

* @brief Compute next step approximation using the midpoint-Euler * method. * @f[y_{n+1} = y_n + dx\, f\left(x_n+\frac{1}{2}dx, * y_n + \frac{1}{2}

Utility function to find minimum distance vertex in mdist

Returns the node with min key in the left subtree*/

the function miroir (in french ) it means "mirror" , the major idea is to permute the first caractere with the last using an auxilary variable (aux) t

Function to perform binary search on the mid values of row to get the * desired pair of rows where the element can be found * @param [in] mat matrix

* @brief finds the value x such that (a * x) % m = 1 * * @param a number we are finding the inverse for * @param m the modulus the inversion is bas

* multiply large number with another integer and * store the result in the same large number */

The node constructor, which receives the key value input and returns a node * pointer * @param data data to store in a new node * @returns new node