Algorithms For Each Major CS Language:

Folders:

Deploy: https://bgoonz-branch-the-algos.vercel.app/

- Link To Filelist

NETLIFY

FOLDERS

Navigation:

Arithmetic Progression

A sequence of numbers is said to be in an Arithmetic progression if the difference between any two consecutive terms is always the same. In simple terms, it means that the next number in the series is calculated by adding a fixed number to the previous number in the series. For example, 2, 4, 6, 8, 10 is an AP because the difference between any two consecutive terms in the series (common difference) is same (4 - 2 = 6 - 4 = 8 - 6 = 10 - 8 = 2).

Facts about Arithmetic Progression:

Initial term: In an arithmetic progression, the first number in the series is called the initial term.
Common difference: The value by which consecutive terms increase or decrease is called the common difference.
The behavior of the arithmetic progression depends on the common difference d. If the common difference is positive, then the members (terms) will grow towards positive infinity. But if the common difference is negative, then the members (terms) will grow towards negative infinity.

Formula of the nth term of an A.P:

a is the initial term, and d is a common difference. Thus, the explicit formula is:

Formula of the sum of first nth term of A.P:

General Formulas to solve problems related to Arithmetic Progressions:

If a is the first term and d too, that would be a common difference:

nth term of an AP = a + (n-1)*d.
Arithmetic Mean = Sum of all terms in the AP / Number of terms in the AP.
Sum of ‘n’ terms of an AP = 0.5 n (first term + last term) = 0.5 n [ 2a + (n-1) d ].

Source

Arithmetic Progression

YouTube

Average (Mean)

Calculate the average of a list of numbers using mean.

Applications

Calculating the mean of a list of numbers is one of the most common ways to determine the average of those numbers.

Calculating a mean would be useful in these situations:

Determining the average score for all players of a video game level.
Finding the average grade for tests that a student took this semester.
Determining the average size of all files in a directory/folder.

Steps

Input a list of numbers.
Calculate the sum of all numbers in the list.
Count the numbers in the list.
Divide the sum by the total count of numbers in the list.
Return mean.

Example

Given the list [2, 4, 6, 8, 20, 50, 70], let's calculate the average.

Step 1

Send [2, 4, 6, 8, 20, 50, 70] as input for a method/function.

Step 2

Add all the numbers together.

2 + 4 + 6 + 8 + 20 + 50 + 70 = 160, so sum = 160.

Step 3

Count the numbers in the list.

The list has seven numbers, so count = 7.

Step 4

Divide the sum of all the numbers by the count of the numbers.

sum = 160
count = 7

If we ignore significant digits: sum / count = 22.857142

If we properly consider significant digits: sum / count = 23

Step 5

Return the value of 22.857142 or 23.

Implementation

Python
Ruby

Video URL

Mean on Khan Academy

Others

Mean on Wikipedia

Fibonacci

Calculating Fibonacci numbers

In mathematics, the Fibonacci numbers commonly denoted F(n), form a sequence, called the Fibonacci sequence, such that each number is the sum of the two preceding ones, starting from 0 and 1. The Sequence looks like this:

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...]

Applications

Finding N-th member of this sequence would be useful in many Applications:

Recently Fibonacci sequence and the golden ratio are of great interest to researchers in many fields of science including high energy physics, quantum mechanics, Cryptography and Coding.

Steps

Prepare Base Matrice
Calculate the power of this Matrice
Take Corresponding value from Matrix

Example

Find 8-th member of Fibonacci

Step 0

| F(n+1)  F(n)  |
| F(n)    F(n-1)|

Step 1

Calculate matrix^1
| 1 1 |
| 1 0 |

Step 2

Calculate matrix^2
| 2 1 |
| 1 1 |

Step 3

Calculate matrix^4
| 5 3 |
| 3 2 |

Step 4

Calculate matrix^8
| 34 21 |
| 21 13 |

Step 5

F(8)=21

Implementation

Video URL

Youtube

Others

Proof

Finding the number of digits in a number

Let's say N = 2019. The number of digits in N here is 4 and the digits are: 2, 0, 1, and 9.

Some more Examples:

N = 00  [zero]
Number of digits = 0

N = -123 [negative]
Number of digits = 3

N = 10000 [positive]
Number of digits = 5

1st Solution

Simple Solution

The first solution that comes to mind is quite simple:

1. Check whether the number N is equal to zero.
2. Increase the count of digits by 1 if N is not zero.
3. Reduce the number by dividing it by 10.
4. Repeat the above steps until the number is reduced to zero.

Analysis of the above algorithm: You can clearly see that the number of operations performed in the above solution is equal to the count of digits present in the number. So, the time complexity of the solution is O(digitsCount).

Dry-run of the above algorithm: Consider an example, N = 58964. Initialize a variable digitsCount to zero which will store the count of digits. Keep incrementing digitsCount until N is not zero, and reduce it by dividing by 10 at each step.

Iteration 1: N not equals to 0
Increment digitsCount, digitsCount = digitsCount + 1.
digitsCount = 0 + 1 = 1.
N = N/10 = 58964/10 = 5896.

Iteration 2: N not equals to 0
Increment digitsCount, digitsCount = digitsCount + 1.
digitsCount = 1 + 1 = 2.
N = N/10 = 5896/10 = 589.

Iteration 3: N not equals to 0
Increment digitsCount, digitsCount = digitsCount + 1.
digitsCount = 2 + 1 = 3.
N = N/10 = 589/10 = 58.

Iteration 4: N not equals to 0
Increment digitsCount, digitsCount = digitsCount + 1.
digitsCount = 3 + 1 = 4.
N = N/10 = 58/10 = 5.

Iteration 5: N not equals to 0
Increment digitsCount, digitsCount = digitsCount + 1.
digitsCount = 4 + 1 = 5.
N = N/10 = 5/10 = 0.

Iteration 6: N becomes equal to 0.
Terminate any further operation.
Return value of digitsCount.

Therefore, number of digits = 5.

2nd Solution

Better Solution

A better solution is to use mathematics to solve this problem. The number of digits in a number say N can be easily obtained by using the following formula:

number of digits in N = log10(N) + 1.

Derivation: Suppose the number of digits in the number N is K.

Therefore, we can say that:

10^(K-1) <= N < 10K

Applying base-10 logarithm to both sides in the above equation, we get:

K-1 <= log10(N) < K.

or, K - 1 + 1 <= log10(N) + 1 < K + 1
or, K <= log10(N) + 1 < K + 1

Therefore,

K = floor(log10(N) + 1)

Analysis of the above algorithm: The above algorithm uses two mathematical functions: the logarithm of a number and the floor function. Therefore, its time complexity depends on the complexity of those two functions. Practically, the floor function is always, or can at least easily be made, constant time - all it has to do is: drop the digits behind the decimal point. For practical purposes, one can assume that the logarithm is constant time as well, as one will usually be working with fixed-width floating-point values. If one uses arbitrary-precision "big number" libraries however, logarithm will not be constant anymore: performance will depend on the logarithm algorithms used.

Source

Proof in GeeksForGeeks

YouTube

Video URL

Geometric Progression

# Geometric Progression

A sequence of numbers is said to be in a Geometric progression if the ratio of any two consecutive terms is always the same. In simple terms, it means that the next number in the series is calculated by multiplying a fixed number to the previous number in the series.

For example, 2, 4, 8, 16 is a GP because ratio of any two consecutive terms in the series (common ratio) is the same (4 / 2 = 8 / 4 = 16 / 8 = 2).

Facts about Geometric Progression:

Initial term: In a geometric progression, the first number is called the initial term.
Common ratio: The ratio of any two consecutive terms by taking the previous term in the denominator.
The behaviour of a geometric sequence depends on the value of the common ratio. If the common ratio is:

Positive, the terms will all be of the same sign as the initial term.
Negative, the terms will alternate between positive and negative.
Greater than 1, there will be exponential growth towards positive or negative infinity (depending on the sign of the initial term).
1, the progression is a constant sequence.
Between -1 and 1 but not zero, there will be exponential decay towards zero.
-1, the progression is an alternating sequence.
Less than -1, for the absolute values there is exponential growth towards (unsigned) infinity, due to the alternating sign.

Formula of the nth term of a G.P:

a is the initial term, and d is a common difference. Thus, the explicit formula is:

Formula of the sum of the first nth term of G.P:

General Formulas to solve problems related to Geometric Progressions:

If a is the first term and r is the common ratio: nth term of a GP = a*rn-1.

Geometric Mean = nth root of the product of n terms in the GP.
Sum of n terms of a GP (r < 1) = [a (1 – rn)] / [1 – r].
Sum of n terms of a GP (r > 1) = [a (rn – 1)] / [r – 1].
Sum of infinite terms of a GP (r < 1) = (a) / (1 – r).

Source

Geometric Progression

YouTube

Caesar Cipher

The Caesar cipher is a simple cipher and one of the best known encryption algorithms. It is very simple to encrypt, decrypt and intercept. The Caesar cipher is a substitution cipher where each letter in the plain-text (decoded text) is replaced by a letter a certain number of spaces to the right of the letter in the alphabet. (The amount of spaces is called the key or shift and is only known by the sender and intended receiver).

Disclaimer: Do not attempt to encrypt personal data or serious messages with this cipher!!! It takes only half a second to crack by a computer!

It takes a very small amount of time to encode and decode messages. (Less than a second, usually)
No real applications exist for the cipher as it is the most insecure out there.
This cipher was invented by Julius Caesar as a way to send messages of high military significance.

Steps

Encryption

Choose the alphabet you are going to use.
Choose a secret key (shift) that you are going to use in this case n.
For every letter in the plain-text, replace it by a letter of the alphabet that is n letters away from the letter. (Ex: for a key of 1, a would become b, z would become a, etc.)
The message should now be encoded.

Decryption

Choose the alphabet that the message was encrypted with.
Let n be the secret key the message is encoded in.
For every letter in the cipher-text, replace it by a letter of the alphabet that is n letters behind in the alphabet from the letter. c would be b, a would be z with a key of 1.
The message should now be decoded

Example

An example of encryption

Let us say we are sending a secret message to a friend.

We first write out our message. In this case: The Caesar cipher is a fun substitution cipher
Our alphabet will be: abcdefghijklmnopqrstuvwxyz. For the uses of this tutorial, case doesn't matter. (On a shift of 1: A will become B, a will become b)
Let our key be 6.
Starting with the first letter: T. The letter 6 letters away is Z. We add Z to the message.
The second letter is h. The letter 6 letters away is n. Our message is now Zn
We continue like that until the end. Our final message is: Znk Igkygx iovnkx oy g lat yahyzozazout iovnkx.
Decryption is the same way, except instead of going to the right in the alphabet, we go backwards.

Implementation

Python

Hill Cipher

The Hill cipher was invented by Lester S. Hill.

Hill cipher is a polygraphic substitution cipher based on linear algebra. Each letter is represented by a number modulo 26. Often the simple scheme A = 0, B = 1, …, Z = 25 is used, but this is not an essential feature of the cipher. To encrypt a message, each block of n letters (considered as an n-component vector) is multiplied by an invertible n × n matrix, against modulus 26. To decrypt the message, each block is multiplied by the inverse of the matrix used for encryption.

Example

Suppose we take an example as: Plain Text (PT):ACT key:GYBNQKURP

Steps

Encryption

We have to write key as an n × n matrix as

   [6 24 1]
   [13 16 10]
   [20 17 15]

Same way convert PT into a vector as

    [0]
    [2]
    [19]

Now, we need to encipher the vector by just multiplying these two matrices

    [6 24 1]        [0]         [67]        [15]
    [13 16 10]  *   [2]     =   [222]   ≈   [4]   (mod 26)
    [20 17 15]      [19]        [319]       [7]

So we will get the encrypted text as POH.

Decryption

We need to first inverse our key matrix

           -1
   [6 24 1]        [8 5 10]
   [13 16 10]   ≈  [21 8 21]  (mod 26)
   [20 17 15]      [21 12 8]

For the previous Cipher Text POH

    [8 5 10]      [15]      [260]     [0]
    [21 8 21]  *  [14]  ≈   [574]  ≈  [2]    (mod 26)  ≈ ACT
    [21 12 8]     [7]       [539]     [19]

Implementations

Python

Video Explanation

Video explanation of the Hill Cipher

Bellman-Ford

Problem Statement

Given a weighted directed graph G(V,E) and a source vertex s ∈ V, determine for each vertex v ∈ V the shortest path between s and v.

Approach

Initialize the distance from the source to all vertices as infinite.
Initialize the distance to itself as 0.
Create an array dist[] of size |V| with all values as infinite except dist[s].
Repeat the following |V| - 1 times. Where |V| is number of vertices.
Create another loop to go through each edge (u, v) in E and do the following:
1. dist[v] = minimum(dist[v], dist[u] + weight of edge).
Lastly iterate through all edges on last time to make sure there are no negatively weighted cycles.

Time Complexity

O(VE)

Space Complexity

O(V^2)

Founder's Name

Richard Bellman & Lester Ford, Jr.

Example

    # of vertices in graph = 5 [A, B, C, D, E]
    # of edges in graph = 8

    edges  [A->B, A->C, B->C, B->D, B->E, D->C, D->B, E->D]
    weight [ -1,    4,    3,    2,    2,    5,    1,   -4 ]
    source [  A,    A,    B,    B,    B,    D,    D,    E ]



    // edge A->B
    graph->edge[0].src = A
    graph->edge[0].dest = B
    graph->edge[0].weight = -1

    // edge A->C
    graph->edge[1].src = A
    graph->edge[1].dest = C
    graph->edge[1].weight = 4

    // edge B->C
    graph->edge[2].src = B
    graph->edge[2].dest = C
    graph->edge[2].weight = 3

    // edge B->D
    graph->edge[3].src = B
    graph->edge[3].dest = D
    graph->edge[3].weight = 2

    // edge B->E
    graph->edge[4].src = B
    graph->edge[4].dest = E
    graph->edge[4].weight = 2

    // edge D->C
    graph->edge[5].src = D
    graph->edge[5].dest = C
    graph->edge[5].weight = 5

    // edge D->B
    graph->edge[6].src = D
    graph->edge[6].dest = B
    graph->edge[6].weight = 1

    // edge E->D
    graph->edge[7].src = E
    graph->edge[7].dest = D
    graph->edge[7].weight = -3

    for source = A

    Vertex   Distance from Source
	A                0				A->A
	B                -1				A->B
	C                2 				A->B->C = -1 + 3
	D                -2				A->B->E->D = -1 + 2 + -3
	E                1				A->B->E = -1 + 2

Code Implementation Links

Video Explanation

A video explaining the Bellman-Ford Algorithm

Others

Sources Used:

Singly Linked List

# Singly Linked List

Singly Linked List is a linear and connected data structure made of Nodes. Each node is composed of a variable data where its content is stored and a pointer to the next Node on the list. The Linked List has a pointer to the first element of this Node sequence and may also have another pointer to the last Node to make operations at the far end less time-consuming. You can also store a length variable to store the total length.

Advantages over Arrays

Size of a linked list is not fixed (dynamic size)
Deleting and adding an element is not expensive compared to an array

Drawbacks

Elements can be accessed sequentially not randomly compared to an array
Extra memory allocation needs to be done for pointers which connects elements in a linked list

Time Complexity

Operation	Average	Worst
Access	O(n)	O(n)
Search	O(n)	O(n)
Insertion	O(1)	O(1)
Deletion	O(1)	O(1)

Example

class LinkedList {
    Node head;      // Pointer to the first element
    Node tail;      // Optional. Points to the last element

    int length;     // Optional

    class Node {
        int data;   // Node data. Can be int, string, float, templates, etc
        Node next;  // Pointer to the next node on the list
    }
}

Code Implementation Links

Video Explanation

A CS50 video explaining the Linked List Data Structure

Doubly Linked List

Singly Linked List is a linear and connected data structure made of Nodes. Each node is composed of a variable data where its content is stored and a pointer to the next Node on the list. The Linked List has a pointer to the first element of this Node sequence and may also have another pointer to the last Node to make operations at the far end less time-consuming. You can also store a length variable to store the total length.

A Doubly Linked List (DLL) contains an extra pointer, typically called previous pointer, together with next pointer and data which are there in singly linked list.

Advantages over singly linked list

A DLL can be traversed in both forward and backward direction.
The delete operation in DLL is more efficient if pointer to the node to be deleted is given.
We can quickly insert a new node before a given node. In singly linked list, to delete a node, pointer to the previous node is needed. To get this previous node, sometimes the list is traversed. In DLL, we can get the previous node using previous pointer.

Disadvantages over singly linked list

Every node of DLL Require extra space for an previous pointer. It is possible to implement DLL with single pointer though (See this and this).
All operations require an extra pointer previous to be maintained. For example, in insertion, we need to modify previous pointers together with next pointers. For example in following functions for insertions at different positions, we need 1 or 2 extra steps to set previous pointer.

Time Complexity

Operation	Average	Worst
Access	Θ(n)	O(n)
Search	Θ(n)	O(n)
Insertion	Θ(1)	O(1)
Deletion	Θ(1)	O(1)

Example

class LinkedList {

    Node head;      // Pointer to the first element
	Node tail;      // Optional. Points to the last element

	int length;     // Optional

    class Node {
        int data;   // Node data. Can be int, string, float, templates, etc
        Node next;  // Pointer to the next node on the list
        Node prev;

        Node(int data) {
            this.data = data;
        }
    }


    // Adding a node at the front of the list
    public void push(int new_data) {

        /* 1. allocate node
         * 2. put in the data */
        Node new_Node = new Node(new_data);

        /* 3. Make next of new node as head and previous as NULL */
        new_Node.next = head;
        new_Node.prev = null;

        /* 4. change prev of head node to new node */
        if (head != null)
            head.prev = new_Node;

        /* 5. move the head to point to the new node */
        head = new_Node;
    }

    /* Given a node as prev_node, insert a new node after the given node */
    public void InsertAfter(Node prev_Node, int new_data) {

        /*1. check if the given prev_node is NULL */
        if (prev_Node == null) {
            System.out.println("The given previous node cannot be NULL ");
            return;
        }

        /* 2. allocate node
         * 3. put in the data */
        Node new_node = new Node(new_data);

        /* 4. Make next of new node as next of prev_node */
        new_node.next = prev_Node.next;

        /* 5. Make the next of prev_node as new_node */
        prev_Node.next = new_node;

        /* 6. Make prev_node as previous of new_node */
        new_node.prev = prev_Node;

        /* 7. Change previous of new_node's next node */
        if (new_node.next != null)
            new_node.next.prev = new_node;
    }
}

Adding node at front

Add a node after a given node

Code Implementation Links

Video Explanation

A CS50 video explaining the Doubly Linked List Data Structure

Coin Change

Problem Statement

Given a value N, if we want to make change for N cents, and we have infinite supply of each of S = {S1, S2, .. , Sm} valued coins, how many ways can we make the change? The order of coins doesn’t matter.

Approach

Let the dp[i] be the length of the coin change of prefix N[1..i]. Our answer is dp[N]. We fill dp[0] as 1 because there is only one way to get 0 coins (We pick no coins).

Now let's try calculate dp[i] for any i. dp[0..i] will store each sub problems from 0 to N. That's why the answer will be dp[N]. First, we need to iterate each coin types to pick them one-by-one. Then we iterate the sub problems from current coin that we pick before to N cents. That's why we must make dp table with N columns.

This is the codes for the Coin Change algorithm:

    for coin_val in S:
        for i in range(coin_val, n + 1):
            dp[i] += dp[i - coin_val]

In the second iteration, for every cent that can be exchanged, we take it by subtracting the i-th column by the value of the coin we take and adding it into the current column. So dp[i] will store the current sub problem.

Time Complexity

O(N * S) in any case

Space Complexity

O(N) - simple implementation. We only need 1D array to store the answer.

Example

Let's say we have 3 coin types [1,2,3] and we want to change for 7 cents. So we will define our table like this.

[1, 0, 0, 0, 0, 0, 0, 0]

0th column will store 1 since there is only one way to get 0 cents.

For the first iteration we take a coin that has a value of 1. Then for all sub problems, there is only one way to make change. For 7 cents, the only way is {1,1,1,1,1,1,1}. On the final iteration, our table be like:

[1, 1, 1, 1, 1, 1, 1, 1]

For the second iteration, we take a coin that has a value of 2. From here, all sub problems that can be divided by 2 will store another new way to make change. So, when the iteration stopped at 2nd column it will be like dp[2] += dp[0]. We know that dp[0] stored a value of 1. Thus, dp[2] will store the value of 1 + 1 = 2. From here we know that for 2 cents, there are 2 ways {1,1} and {2}. And this operation will continue. Now our table be like:

[1, 1, 2, 2, 3, 3, 4, 4]

4 ways to make 7 cents using value of 1 and 2. {{1,1,1,1,1,1,1}, {1,1,1,1,1,2}, {1,1,1,2,2}, {1,2,2,2}}

For the final iteration (3rd iteration), we take a coin that has a value of 3. Like before, now all the columns that can be devided by 3 will store another new way. And the final result will be like:

[1, 1, 2, 3, 4, 5, 7, 8]

So the final answer is 8. 8 ways to make change of 7 cents using all coin types. {{1,1,1,1,1,1,1}, {1,1,1,1,1,2}, {1,1,1,2,2}, {1,2,2,2}, {1,1,1,1,3}, {1,3,3}, {2,2,3}, {1,1,2,3}}

Code Implementation Link

Python

Video Explanation

Total Unique Ways To Make Change by Back To Back SWE

Longest Common Subsequence

Problem Statement

Given two strings S and T, find the length of the longest common subsequence (LCS).

Approach

Let the dp[i][j] be the length of the longest common subsequence of prefixes S[1..i] and T[1..j]. Our answer (the length of LCS) is dp[|S|][|T|] since the prefix of the length of string is the string itself.

Both dp[0][i] and dp[i][0] are 0 for any i since the LCS of empty prefix and anything else is an empty string.

Now let's try to calculate dp[i][j] for any i, j. Let's say S[1..i] = *A and T[1..j] = *B where * stands for any sequence of letters (could be different for S and T), A stands for any letter and B stands for any letter different from A. Since A != B, our LCS doesn't include A or B as a last character. So we could try to throw away A or B character. If we throw A, our LCS length will be dp[i - 1][j] (since we have prefixes S[1..i - 1] and T[1..j]). If we try to throw B character, we will have prefixes S[1..i] and T[1..j - 1] so the length of LCS will be dp[i][j - 1]. As we are looking for the Longest common subsequence, we will pick the maximum value from dp[i][j - 1] and dp[i - 1][j].

But what if S[1..i] = *A and T[1..j] = *A? We could say that the LCS of our prefixes is LCS of prefixes S[1..i - 1] and T[1..j - 1] plus the letter A. So dp[i][j] = dp[i - 1][j - 1] + 1 if S[i] = T[j].

We could see that we can fill our dp table row by row, column by column. So our algorithm will be like:

Let's say that we have strings S of the length N and T of the length M (numbered from 1). Let's create the table dp of size (N + 1) x (M + 1) numbered from 0.
Let's fill the 0th row and the 0th column of dp with 0.
Then, we follow the algorithm:

for i in range(1..N):
    for j in range(1..M):
        if(S[i] == T[j])
            dp[i][j] = dp[i - 1][j - 1] + 1
        else
            dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])

Time Complexity

O(N * M) In any case

Space Complexity

O(N * M) - simple implementation O(min {N, M}) - two-layers implementation (as dp[i][j] depends on only i-th and i-th layers, we coudld store only two layers).

Example

Let's say we have strings ABCB and BBCB. We will build such a table:

# # A B C B
# 0 0 0 0 0
B 0 ? ? ? ?
B 0 ? ? ? ?
C 0 ? ? ? ?
B 0 ? ? ? ?

Now we will start to fill our table from 1st row. Since S[1] = A and T[1] = B, the dp[1][1] will be tha maximal value of dp[0][1] = 0 and dp[1][0] = 0. So dp[1][1] = 0. But now S[2] = B = T[1], so dp[1][2] = dp[0][1] + 1 = 1. dp[1][3] is 1 since A != C and we pick max{dp[1][2], dp[0][3]}. And dp[1][4] = dp[0][3] + 1 = 1.

# # A B C B
# 0 0 0 0 0
B 0 0 1 1 1
B 0 ? ? ? ?
C 0 ? ? ? ?
B 0 ? ? ? ?

Now let's fill the other part of the table:

# # A B C B
# 0 0 0 0 0
B 0 0 1 1 1
B 0 0 1 1 2
C 0 0 1 2 2
B 0 0 1 2 3

So the length of LCS is dp[4][4] = 3.

Code Implementation Links

Video Explanation

Video explanation by Tushar Roy

Binary Search (A divide and conquer algorithm)

# Binary Search (A divide and conquer algorithm)

Problem Statement

Given a sorted array of n elements, write a function to search for the index of a given element (target)

Approach

Search for the array by dividing the array in half repeatedly.
Initially consider the actual array and pick the element at the middle index
Keep a lower index i.e. 0 and higher index i.e. length of array
If it is equal to the target element then return the index
Else if it is greater than the target element then consider only the left half of array. (lower index = 0, higher = middle - 1)
Else if it is less than the target element then consider only the right half of array. (lower index = middle + 1, higher = length of array)
Return -1 if target element is not found in the array (Base Case: If lower index is greater than or equal to higher index)

Time Complexity

O(log n) Worse Case
O(1) Best Case (If middle element of initial array is the target element)

Space Complexity

O(1) For iterative approach
O(log n) For recursive approach due to recursion call stack

Example

arr = [1,2,3,4,5,6,7]

target = 2
Initially the element at middle index is 4 which is greater than 2. Therefore we search the left half of the
array i.e. [1,2,3].
Here we find the middle element equal to target element so we return its index i.e. 1

target = 9
Binary Search should return -1 as 9 is not present in the array

Code Implementation Links

Video Explanation

A CS50 video explaining the Binary Search Algorithm

Animation Explanation

Tute Board

Exponential Search

Prerequisites

Binary Search algorithm

Problem Statement

Given a sorted array of n elements, write a function to search for the index of a given element (target)

Approach

Search for the range within which the target is included increasing index by powers of 2
If this range exists in array apply the Binary Search algorithm over it
Else return -1

Example

arr = [1, 2, 3, 4, 5, 6, 7, ... 998, 999, 1_000]

target = 998
index = 0

1. SEARCHING FOR THE RANGE
   index = 1, 2, 4, 8, 16, 32, 64, ..., 512, ..., 1_024
   after 10 iteration we have the index at 1_024 and outside of the array
2. BINARY SEARCH
   Now we can apply the binary search on the subarray from 512 and 1_000.

Note: we apply the Binary Search from 512 to 1_000 because at i = 2^10 = 1_024 the array is finisced and the target number is less than the latest index of the array ( 1_000 ).

Time Complexity

worst case: O(log *i*) where *i* = index (position) of the target

best case: O(*1*)

Complexity Explanation

The complexity of the first part of the algorithm is O( log i ) because if i is the position of the target in the array, after doubling the search index ⌈log(i)⌉ times, the algorithm will be at a search index that is greater than or equal to i. We can write 2^⌈log(i)⌉ >= i
The complexity of the second part of the algorithm also is O ( log i ) because that is a simple Binary Search. The Binary Search complexity ( as explained here ) is O( n ) where n is the length of the array. In the Exponential Search, the length of the array on which the algorithm is applied is 2^i - 2^(i-1), put into words it means '( the length of the array from start to i ) - ( the part of array skipped until the previous iteration )'. Is simple verify that 2^i - 2^(i-1) = 2^(i-1)

After this detailed explanation we can say that the the complexity of the Exponential Search is:

O(log i) + O(log i) = 2O(log i) = O(log i)

Binary Search vs Exponential Search

Let's take a look at this comparison with a less theoretical example. Imagine we have an array with1_000_000 elements and we want to search an element that is in the 4th position. It's easy to see that:

The Binary Search start from the middle of the array and arrive to the 4th position after many iterations
The Exponential Search arrive at the 4th index after only 2 iterations

Code Implementation Links

Linear Search

# Linear Search

Problem Statement

Given an array of n elements, write a function to search for the index of a given element (target)

Approach

Start iterating with the first element in the array.
Compare it with the target element
If it is equal to the target element then return the index
Else continue iterating
Return -1 if target element is not found in the array

Time Complexity

O(n) Worse Case
O(1) Best Case (If first element of array is the target element)

Space Complexity

O(1)

Example

arr = [1, 3, 9, 5, 0, 2]

target = 5
Linear Search should return index 3 as 5 is on index 3

target = 6
Linear Search should return -1 as 6 is not present in the array

Code Implementation Links

Video Explanation

A CS50 video explaining the Linear Search Algorithm

Animation Explanation

Tute Board

Quick Sort

Problem Statement

Given an unsorted array of n elements, write a function to sort the array

Approach

Make the right-most index value pivot
partition the array using pivot value
quicksort left partition recursively
quicksort right partition recursively

Time Complexity

O(n^2) Worst case performance
O(n log n) Best-case performance
O(n log n) Average performance

Space Complexity

O(log n) Worst case

Founder's Name

Tony Hoare in 1959

Example

arr[] = {10, 80, 30, 90, 40, 50, 70}
Indexes:  0   1   2   3   4   5   6

low = 0, high =  6, pivot = arr[h] = 70
Initialize index of smaller element, i = -1

Traverse elements from j = low to high-1
j = 0 : Since arr[j] <= pivot, do i++ and swap(arr[i], arr[j])
i = 0
arr[] = {10, 80, 30, 90, 40, 50, 70} // No change as i and j
                                     // are same

j = 1 : Since arr[j] > pivot, do nothing
// No change in i and arr[]

j = 2 : Since arr[j] <= pivot, do i++ and swap(arr[i], arr[j])
i = 1
arr[] = {10, 30, 80, 90, 40, 50, 70} // We swap 80 and 30

j = 3 : Since arr[j] > pivot, do nothing
// No change in i and arr[]

j = 4 : Since arr[j] <= pivot, do i++ and swap(arr[i], arr[j])
i = 2
arr[] = {10, 30, 40, 90, 80, 50, 70} // 80 and 40 Swapped
j = 5 : Since arr[j] <= pivot, do i++ and swap arr[i] with arr[j]
i = 3
arr[] = {10, 30, 40, 50, 80, 90, 70} // 90 and 50 Swapped

We come out of loop because j is now equal to high-1.
Finally we place pivot at correct position by swapping
arr[i+1] and arr[high] (or pivot)
arr[] = {10, 30, 40, 50, 70, 90, 80} // 80 and 70 Swapped

Now 70 is at its correct place. All elements smaller than
70 are before it and all elements greater than 70 are after
it.

Code Implementation Links

Video Explanation

A video explaining the Quick Sort Algorithm

Recursive Bubble Sort

Bubble Sort is one of the simplest sorting algorithms that compares two elements at a time and swaps them if they are in the wrong order. This process is repeated until the entire sequence is in order.

Time Complexity: O(n ^ 2) for average case; O(n) for best case.
Space Complexity: O(n); note that iterative bubble sort has space complexity as O(1).

Steps

Base case: If the size of the array is 1, return.

We need to fix the last element of the current sub-array. For this, iterate over the entire array using normal Bubble Sort, and perform swapping.
Next, call the function on the entire array excluding the last element(which was fixed by the iteration in the above step)
Repeat until Base Case is reached.

Example

Let the given array be: {5, 3, 2, 1, 4}

First Iteration:

{5, 3, 2, 1, 4} -> {3, 5, 2, 1, 4} Swap since 5 > 3
{3, 5, 2, 1, 4} -> {3, 2, 5, 1, 4} Swap since 5 > 2
{3, 2, 5, 1, 4} -> {3, 2, 1, 5, 4} Swap since 5 > 1
{3, 2, 1, 5, 4} -> {3, 2, 1, 4, 5} Swap since 5 > 4

This iteration has fixed the position of 5. Now, we will consider the array up to index 3.

Second Iteration:

{3, 2, 1, 4, 5} -> {2, 3, 1, 4, 5} Swap since 3 > 2
{2, 3, 1, 4, 5} -> {2, 1, 3, 4, 5} Swap since 3 > 1
{2, 1, 3, 4, 5}; As 3 < 4, do not swap

Note: As we check one less element with every iteration, we do not need elements at index 3 and 4 i.e., 4 and 5, as 5 is already in order. Formally, for an array with n integers, we consider elements only up to index n - i, where i is the iteration number.

Third Iteration:

{2, 1, 3, 4, 5} -> {1, 2, 3, 4, 5} Swap since 1 > 2
{1, 2, 3, 4, 5}; As 2 < 3, do not swap

Fourth Iteration:

{1, 2, 3, 4, 5}; As 1 < 2, do not swap

Fifth Iteration:

{1, 2, 3, 4, 5}; As the size of the array is 1, return.

Note: This is the base case.

Pseudo Code

void bubbleSort(arr[], n)
    if(n==1)
        return;

    for(i = 0; i<n-1; i++)
        if(arr[i] > arr[i+1])
            swap(arr[i], arr[i+1])

    bubbleSort(arr, n-1)

Implementations

Java
C

Video Explanation

A video explaining iterative as well as recursive bubble sort

Bubble Sort

Problem Statement

Given an unsorted array of n elements, write a function to sort the array

Approach

select the first element of the array
compare it with its next element
if it is larger than the next element then swap them
else do nothing
keep doing this for every index of the array
repeat the above process n times.

Time Complexity

O(n^2) Worst case performance

O(n) Best-case performance

O(n^2) Average performance

Space Complexity

O(1) Worst case

Founder's Name

The term “Bubble Sort” was first used by Iverson, K in 1962.

Example

arr[] = {10, 80, 40, 30}
Indexes: 0   1   2   3

1. Index = 0, Number = 10
2. 10 < 80, do nothing and continue

3. Index = 1, Number = 80
4. 80 > 40, swap 80 and 40
5. The array now is {10, 40, 80, 30}

6. Index = 2, Number = 80
7. 80 > 30, swap 80 and 30
8. The array now is {10, 40, 30, 80}

Repeat the Above Steps again

arr[] = {10, 40, 30, 80}
Indexes: 0   1   2   3

1. Index = 0, Number = 10
2. 10 < 40, do nothing and continue

3. Index = 1, Number = 40
4. 40 > 30, swap 40 and 30
5. The array now is {10, 30, 40, 80}

6. Index = 2, Number = 40
7. 40 < 80, do nothing
8. The array now is {10, 30, 40, 80}

Repeat the Above Steps again

arr[] = {10, 30, 40, 80}
Indexes: 0   1   2   3

1. Index = 0, Number = 10
2. 10 < 30, do nothing and continue

3. Index = 1, Number = 30
4. 30 < 40, do nothing and continue

5. Index = 2, Number = 40
6. 40 < 80, do nothing

Since there are no swaps in above steps, it means the array is sorted and we can stop here.

Code Implementation Links

Video Explanation

A video explaining the Bubble Sort Algorithm

Others

Bubble sort is also known as Sinking sort.

Animation Explanation

Tute Board

Directory Structure

.
├── ./AArch64_Assembly
│   ├── ./AArch64_Assembly/DIRECTORY.html
│   ├── ./AArch64_Assembly/DIRECTORY.md
│   ├── ./AArch64_Assembly/misc
│   │   ├── ./AArch64_Assembly/misc/2048.s
│   │   ├── ./AArch64_Assembly/misc/hello_world.s
│   │   ├── ./AArch64_Assembly/misc/josephus_problem.s
│   │   ├── ./AArch64_Assembly/misc/perfect_numbers.s
│   │   ├── ./AArch64_Assembly/misc/sha1.s
│   │   ├── ./AArch64_Assembly/misc/sha256.s
│   │   └── ./AArch64_Assembly/misc/y_combinator.s
│   ├── ./AArch64_Assembly/README.html
│   ├── ./AArch64_Assembly/README.md
│   ├── ./AArch64_Assembly/sorters
│   │   ├── ./AArch64_Assembly/sorters/bead_sort.s
│   │   ├── ./AArch64_Assembly/sorters/bogo_sort.s
│   │   ├── ./AArch64_Assembly/sorters/bubble_sort.s
│   │   ├── ./AArch64_Assembly/sorters/circle_sort.s
│   │   ├── ./AArch64_Assembly/sorters/cocktail_sort.s
│   │   ├── ./AArch64_Assembly/sorters/comb_sort.s
│   │   ├── ./AArch64_Assembly/sorters/counting_sort.s
│   │   ├── ./AArch64_Assembly/sorters/gnome_sort.s
│   │   ├── ./AArch64_Assembly/sorters/heap_sort.s
│   │   ├── ./AArch64_Assembly/sorters/insertion_sort.s
│   │   ├── ./AArch64_Assembly/sorters/jort_sort.s
│   │   ├── ./AArch64_Assembly/sorters/merge_sort.s
│   │   ├── ./AArch64_Assembly/sorters/pancake_sort.s
│   │   ├── ./AArch64_Assembly/sorters/patience_sort.s
│   │   ├── ./AArch64_Assembly/sorters/permutation_sort.s
│   │   ├── ./AArch64_Assembly/sorters/quick_sort.s
│   │   ├── ./AArch64_Assembly/sorters/radix_sort.s
│   │   ├── ./AArch64_Assembly/sorters/selection_sort.s
│   │   └── ./AArch64_Assembly/sorters/shell_sort.s
│   └── ./AArch64_Assembly/string
│       ├── ./AArch64_Assembly/string/append.s
│       ├── ./AArch64_Assembly/string/comparison.s
│       ├── ./AArch64_Assembly/string/concatenation.s
│       ├── ./AArch64_Assembly/string/interpolation.s
│       ├── ./AArch64_Assembly/string/length.s
│       ├── ./AArch64_Assembly/string/matching.s
│       ├── ./AArch64_Assembly/string/prepend.s
│       ├── ./AArch64_Assembly/string/substring.s
│       └── ./AArch64_Assembly/string/tokenize_string.s
├── ./Algorithms-Explanation
│   ├── ./Algorithms-Explanation/en
│   │   ├── ./Algorithms-Explanation/en/Basic Math
│   │   │   ├── ./Algorithms-Explanation/en/Basic Math/Arithmetic Progressions.html
│   │   │   ├── ./Algorithms-Explanation/en/Basic Math/Arithmetic Progressions.md
│   │   │   ├── ./Algorithms-Explanation/en/Basic Math/Average_Mean.html
│   │   │   ├── ./Algorithms-Explanation/en/Basic Math/Average_Mean.md
│   │   │   ├── ./Algorithms-Explanation/en/Basic Math/Fibonacci_Numbers.html
│   │   │   ├── ./Algorithms-Explanation/en/Basic Math/Fibonacci_Numbers.md
│   │   │   ├── ./Algorithms-Explanation/en/Basic Math/Finding the number of digits in a number.html
│   │   │   ├── ./Algorithms-Explanation/en/Basic Math/Finding the number of digits in a number.md
│   │   │   ├── ./Algorithms-Explanation/en/Basic Math/Geometric Pogression.html
│   │   │   └── ./Algorithms-Explanation/en/Basic Math/Geometric Pogression.md
│   │   ├── ./Algorithms-Explanation/en/Ciphers
│   │   │   ├── ./Algorithms-Explanation/en/Ciphers/caesar_cipher.html
│   │   │   ├── ./Algorithms-Explanation/en/Ciphers/caesar_cipher.md
│   │   │   ├── ./Algorithms-Explanation/en/Ciphers/hill_cipher.html
│   │   │   └── ./Algorithms-Explanation/en/Ciphers/hill_cipher.md
│   │   ├── ./Algorithms-Explanation/en/Data Structures
│   │   │   ├── ./Algorithms-Explanation/en/Data Structures/Graph
│   │   │   └── ./Algorithms-Explanation/en/Data Structures/Linked Lists
│   │   ├── ./Algorithms-Explanation/en/Dynamic Programming
│   │   │   ├── ./Algorithms-Explanation/en/Dynamic Programming/Coin Change.html
│   │   │   ├── ./Algorithms-Explanation/en/Dynamic Programming/Coin Change.md
│   │   │   ├── ./Algorithms-Explanation/en/Dynamic Programming/Longest Common Subsequence.html
│   │   │   └── ./Algorithms-Explanation/en/Dynamic Programming/Longest Common Subsequence.md
│   │   ├── ./Algorithms-Explanation/en/Image Processing
│   │   │   ├── ./Algorithms-Explanation/en/Image Processing/Harris Detector.html
│   │   │   └── ./Algorithms-Explanation/en/Image Processing/Harris Detector.md
│   │   ├── ./Algorithms-Explanation/en/README.html
│   │   ├── ./Algorithms-Explanation/en/README.md
│   │   ├── ./Algorithms-Explanation/en/Search Algorithms
│   │   │   ├── ./Algorithms-Explanation/en/Search Algorithms/Binary Search.html
│   │   │   ├── ./Algorithms-Explanation/en/Search Algorithms/Binary Search.md
│   │   │   ├── ./Algorithms-Explanation/en/Search Algorithms/Exponential Search.html
│   │   │   ├── ./Algorithms-Explanation/en/Search Algorithms/Exponential Search.md
│   │   │   ├── ./Algorithms-Explanation/en/Search Algorithms/Linear Search.html
│   │   │   └── ./Algorithms-Explanation/en/Search Algorithms/Linear Search.md
│   │   ├── ./Algorithms-Explanation/en/Selection Algorithms
│   │   │   ├── ./Algorithms-Explanation/en/Selection Algorithms/Quick Select.html
│   │   │   └── ./Algorithms-Explanation/en/Selection Algorithms/Quick Select.md
│   │   └── ./Algorithms-Explanation/en/Sorting Algorithms
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Bubble Sort.html
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Bubble Sort.md
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Counting Sort.html
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Counting Sort.md
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Heap Sort.html
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Heap Sort.md
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Insertion Sort.html
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Insertion Sort.md
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Merge Sort.html
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Merge Sort.md
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Quick Sort.html
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Quick Sort.md
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Radix Sort.html
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Radix Sort.md
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Recursive Versions
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Selection Sort.html
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Selection Sort.md
│   │       ├── ./Algorithms-Explanation/en/Sorting Algorithms/Shell Sort.html
│   │       └── ./Algorithms-Explanation/en/Sorting Algorithms/Shell Sort.md
│   ├── ./Algorithms-Explanation/README.html
│   └── ./Algorithms-Explanation/README.md
├── ./algorithms-keeper
│   ├── ./algorithms-keeper/algorithms_keeper
│   │   ├── ./algorithms-keeper/algorithms_keeper/api.py
│   │   ├── ./algorithms-keeper/algorithms_keeper/constants.py
│   │   ├── ./algorithms-keeper/algorithms_keeper/event
│   │   │   ├── ./algorithms-keeper/algorithms_keeper/event/check_run.py
│   │   │   ├── ./algorithms-keeper/algorithms_keeper/event/commands.py
│   │   │   ├── ./algorithms-keeper/algorithms_keeper/event/__init__.py
│   │   │   ├── ./algorithms-keeper/algorithms_keeper/event/installation.py
│   │   │   ├── ./algorithms-keeper/algorithms_keeper/event/issues.py
│   │   │   └── ./algorithms-keeper/algorithms_keeper/event/pull_request.py
│   │   ├── ./algorithms-keeper/algorithms_keeper/__init__.py
│   │   ├── ./algorithms-keeper/algorithms_keeper/__main__.py
│   │   ├── ./algorithms-keeper/algorithms_keeper/parser
│   │   │   ├── ./algorithms-keeper/algorithms_keeper/parser/files_parser.py
│   │   │   ├── ./algorithms-keeper/algorithms_keeper/parser/__init__.py
│   │   │   ├── ./algorithms-keeper/algorithms_keeper/parser/python_parser.py
│   │   │   ├── ./algorithms-keeper/algorithms_keeper/parser/record.py
│   │   │   └── ./algorithms-keeper/algorithms_keeper/parser/rules
│   │   └── ./algorithms-keeper/algorithms_keeper/utils.py
│   ├── ./algorithms-keeper/mypy.ini
│   ├── ./algorithms-keeper/Procfile
│   ├── ./algorithms-keeper/pytest.ini
│   ├── ./algorithms-keeper/README.html
│   ├── ./algorithms-keeper/README.md
│   ├── ./algorithms-keeper/requirements-dev.txt
│   ├── ./algorithms-keeper/requirements.txt
│   ├── ./algorithms-keeper/runtime.txt
│   └── ./algorithms-keeper/tests
│       ├── ./algorithms-keeper/tests/data
│       │   ├── ./algorithms-keeper/tests/data/annotation.py
│       │   ├── ./algorithms-keeper/tests/data/descriptive_name.py
│       │   ├── ./algorithms-keeper/tests/data/doctest.py
│       │   ├── ./algorithms-keeper/tests/data/__init__.py
│       │   ├── ./algorithms-keeper/tests/data/no_errors.py
│       │   └── ./algorithms-keeper/tests/data/return_annotation.py
│       ├── ./algorithms-keeper/tests/__init__.py
│       ├── ./algorithms-keeper/tests/test_api.py
│       ├── ./algorithms-keeper/tests/test_check_runs.py
│       ├── ./algorithms-keeper/tests/test_commands.py
│       ├── ./algorithms-keeper/tests/test_installations.py
│       ├── ./algorithms-keeper/tests/test_issues.py
│       ├── ./algorithms-keeper/tests/test_main.py
│       ├── ./algorithms-keeper/tests/test_parser.py
│       ├── ./algorithms-keeper/tests/test_pull_requests.py
│       ├── ./algorithms-keeper/tests/test_rules.py
│       ├── ./algorithms-keeper/tests/test_utils.py
│       └── ./algorithms-keeper/tests/utils.py
├── ./C
│   ├── ./C/client_server
│   │   ├── ./C/client_server/client.c
│   │   ├── ./C/client_server/CMakeLists.txt
│   │   ├── ./C/client_server/server.c
│   │   ├── ./C/client_server/udp_client.c
│   │   └── ./C/client_server/udp_server.c
│   ├── ./C/CMakeLists.txt
│   ├── ./C/CodingGuidelines.html
│   ├── ./C/CodingGuidelines.md
│   ├── ./C/conversions
│   │   ├── ./C/conversions/binary_to_decimal.c
│   │   ├── ./C/conversions/binary_to_hexadecimal.c
│   │   ├── ./C/conversions/binary_to_octal.c
│   │   ├── ./C/conversions/c_atoi_str_to_integer.c
│   │   ├── ./C/conversions/CMakeLists.txt
│   │   ├── ./C/conversions/decimal_to_binary.c
│   │   ├── ./C/conversions/decimal_to_binary_recursion.c
│   │   ├── ./C/conversions/decimal_to_hexa.c
│   │   ├── ./C/conversions/decimal_to_octal.c
│   │   ├── ./C/conversions/decimal_to_octal_recursion.c
│   │   ├── ./C/conversions/hexadecimal_to_octal2.c
│   │   ├── ./C/conversions/hexadecimal_to_octal.c
│   │   ├── ./C/conversions/infix_to_postfix.c
│   │   ├── ./C/conversions/int_to_string.c
│   │   ├── ./C/conversions/octal_to_binary.c
│   │   ├── ./C/conversions/octal_to_decimal.c
│   │   ├── ./C/conversions/octal_to_hexadecimal.c
│   │   └── ./C/conversions/to_decimal.c
│   ├── ./C/data_structures
│   │   ├── ./C/data_structures/array
│   │   │   ├── ./C/data_structures/array/carray.c
│   │   │   ├── ./C/data_structures/array/carray.h
│   │   │   ├── ./C/data_structures/array/carray_tests.c
│   │   │   ├── ./C/data_structures/array/README.html
│   │   │   └── ./C/data_structures/array/README.md
│   │   ├── ./C/data_structures/binary_trees
│   │   │   ├── ./C/data_structures/binary_trees/avl_tree.c
│   │   │   ├── ./C/data_structures/binary_trees/binary_search_tree.c
│   │   │   ├── ./C/data_structures/binary_trees/create_node.c
│   │   │   ├── ./C/data_structures/binary_trees/recursive_traversals.c
│   │   │   ├── ./C/data_structures/binary_trees/red_black_tree.c
│   │   │   ├── ./C/data_structures/binary_trees/segment_tree.c
│   │   │   ├── ./C/data_structures/binary_trees/threaded_binary_trees.c
│   │   │   └── ./C/data_structures/binary_trees/words_alphabetical.c
│   │   ├── ./C/data_structures/dictionary
│   │   │   ├── ./C/data_structures/dictionary/dict.c
│   │   │   ├── ./C/data_structures/dictionary/dict.h
│   │   │   ├── ./C/data_structures/dictionary/README.html
│   │   │   ├── ./C/data_structures/dictionary/README.md
│   │   │   └── ./C/data_structures/dictionary/test_program.c
│   │   ├── ./C/data_structures/dynamic_array
│   │   │   ├── ./C/data_structures/dynamic_array/dynamic_array.c
│   │   │   ├── ./C/data_structures/dynamic_array/dynamic_array.h
│   │   │   ├── ./C/data_structures/dynamic_array/main.c
│   │   │   └── ./C/data_structures/dynamic_array/Makefile
│   │   ├── ./C/data_structures/graphs
│   │   │   ├── ./C/data_structures/graphs/bellman_ford.c
│   │   │   ├── ./C/data_structures/graphs/bfs.c
│   │   │   ├── ./C/data_structures/graphs/bfs_queue.c
│   │   │   ├── ./C/data_structures/graphs/dfs.c
│   │   │   ├── ./C/data_structures/graphs/dfs_recursive.c
│   │   │   ├── ./C/data_structures/graphs/dijkstra.c
│   │   │   ├── ./C/data_structures/graphs/euler.c
│   │   │   ├── ./C/data_structures/graphs/floyd_warshall.c
│   │   │   ├── ./C/data_structures/graphs/graph.c
│   │   │   ├── ./C/data_structures/graphs/graph.h
│   │   │   ├── ./C/data_structures/graphs/hamiltonian.c
│   │   │   ├── ./C/data_structures/graphs/kruskal.c
│   │   │   ├── ./C/data_structures/graphs/Makefile
│   │   │   ├── ./C/data_structures/graphs/queue.c
│   │   │   ├── ./C/data_structures/graphs/queue.h
│   │   │   ├── ./C/data_structures/graphs/strongly_connected_components.c
│   │   │   ├── ./C/data_structures/graphs/topological_sort.c
│   │   │   └── ./C/data_structures/graphs/transitive_closure.c
│   │   ├── ./C/data_structures/hash_set
│   │   │   ├── ./C/data_structures/hash_set/hash_set.c
│   │   │   ├── ./C/data_structures/hash_set/hash_set.h
│   │   │   ├── ./C/data_structures/hash_set/main.c
│   │   │   └── ./C/data_structures/hash_set/Makefile
│   │   ├── ./C/data_structures/heap
│   │   │   ├── ./C/data_structures/heap/max_heap.c
│   │   │   └── ./C/data_structures/heap/min_heap.c
│   │   ├── ./C/data_structures/linked_list
│   │   │   ├── ./C/data_structures/linked_list/ascending_priority_queue.c
│   │   │   ├── ./C/data_structures/linked_list/circular_linked_list.c
│   │   │   ├── ./C/data_structures/linked_list/doubly_linked_list.c
│   │   │   ├── ./C/data_structures/linked_list/merge_linked_lists.c
│   │   │   ├── ./C/data_structures/linked_list/middle_element_in_list.c
│   │   │   ├── ./C/data_structures/linked_list/queue_linked_list.c
│   │   │   ├── ./C/data_structures/linked_list/singly_link_list_deletion.c
│   │   │   └── ./C/data_structures/linked_list/stack_using_linked_lists.c
│   │   ├── ./C/data_structures/list
│   │   │   ├── ./C/data_structures/list/list.c
│   │   │   ├── ./C/data_structures/list/list.h
│   │   │   ├── ./C/data_structures/list/main.c
│   │   │   └── ./C/data_structures/list/Makefile
│   │   ├── ./C/data_structures/queue.c
│   │   ├── ./C/data_structures/stack
│   │   │   ├── ./C/data_structures/stack/main.c
│   │   │   ├── ./C/data_structures/stack/parenthesis.c
│   │   │   ├── ./C/data_structures/stack/README.html
│   │   │   ├── ./C/data_structures/stack/README.md
│   │   │   ├── ./C/data_structures/stack/stack.c
│   │   │   ├── ./C/data_structures/stack/stack.h
│   │   │   └── ./C/data_structures/stack/stack_linked_list
│   │   ├── ./C/data_structures/stack.c
│   │   └── ./C/data_structures/trie
│   │       └── ./C/data_structures/trie/trie.c
│   ├── ./C/developer_tools
│   │   ├── ./C/developer_tools/CMakeLists.txt
│   │   ├── ./C/developer_tools/malloc_dbg.c
│   │   ├── ./C/developer_tools/malloc_dbg.h
│   │   ├── ./C/developer_tools/min_printf.h
│   │   ├── ./C/developer_tools/test_malloc_dbg.c
│   │   └── ./C/developer_tools/test_min_printf.c
│   ├── ./C/DIRECTORY.html
│   ├── ./C/DIRECTORY.md
│   ├── ./C/Doxyfile
│   ├── ./C/exercism
│   │   ├── ./C/exercism/acronym
│   │   │   ├── ./C/exercism/acronym/acronym.c
│   │   │   └── ./C/exercism/acronym/acronym.h
│   │   ├── ./C/exercism/hello_world
│   │   │   ├── ./C/exercism/hello_world/hello_world.c
│   │   │   └── ./C/exercism/hello_world/hello_world.h
│   │   ├── ./C/exercism/isogram
│   │   │   ├── ./C/exercism/isogram/isogram.c
│   │   │   └── ./C/exercism/isogram/isogram.h
│   │   ├── ./C/exercism/README.html
│   │   ├── ./C/exercism/README.md
│   │   ├── ./C/exercism/rna_transcription
│   │   │   ├── ./C/exercism/rna_transcription/rna_transcription.c
│   │   │   └── ./C/exercism/rna_transcription/rna_transcription.h
│   │   └── ./C/exercism/word_count
│   │       ├── ./C/exercism/word_count/word_count.c
│   │       └── ./C/exercism/word_count/word_count.h
│   ├── ./C/games
│   │   ├── ./C/games/CMakeLists.txt
│   │   ├── ./C/games/naval_battle.c
│   │   └── ./C/games/tic_tac_toe.c
│   ├── ./C/geometry
│   │   ├── ./C/geometry/CMakeLists.txt
│   │   ├── ./C/geometry/geometry_datatypes.h
│   │   ├── ./C/geometry/quaternions.c
│   │   └── ./C/geometry/vectors_3d.c
│   ├── ./C/graphics
│   │   ├── ./C/graphics/CMakeLists.txt
│   │   └── ./C/graphics/spirograph.c
│   ├── ./C/greedy_approach
│   │   ├── ./C/greedy_approach/djikstra.c
│   │   └── ./C/greedy_approach/prim.c
│   ├── ./C/hash
│   │   ├── ./C/hash/CMakeLists.txt
│   │   ├── ./C/hash/hash_adler32.c
│   │   ├── ./C/hash/hash_crc32.c
│   │   ├── ./C/hash/hash_djb2.c
│   │   ├── ./C/hash/hash_sdbm.c
│   │   ├── ./C/hash/hash_xor8.c
│   │   ├── ./C/hash/README.html
│   │   └── ./C/hash/README.md
│   ├── ./C/leetcode
│   │   ├── ./C/leetcode/README.html
│   │   ├── ./C/leetcode/README.md
│   │   └── ./C/leetcode/src
│   │       ├── ./C/leetcode/src/101.c
│   │       ├── ./C/leetcode/src/104.c
│   │       ├── ./C/leetcode/src/1089.c
│   │       ├── ./C/leetcode/src/108.c
│   │       ├── ./C/leetcode/src/109.c
│   │       ├── ./C/leetcode/src/110.c
│   │       ├── ./C/leetcode/src/112.c
│   │       ├── ./C/leetcode/src/1184.c
│   │       ├── ./C/leetcode/src/1189.c
│   │       ├── ./C/leetcode/src/11.c
│   │       ├── ./C/leetcode/src/1207.c
│   │       ├── ./C/leetcode/src/121.c
│   │       ├── ./C/leetcode/src/125.c
│   │       ├── ./C/leetcode/src/12.c
│   │       ├── ./C/leetcode/src/136.c
│   │       ├── ./C/leetcode/src/13.c
│   │       ├── ./C/leetcode/src/141.c
│   │       ├── ./C/leetcode/src/142.c
│   │       ├── ./C/leetcode/src/153.c
│   │       ├── ./C/leetcode/src/160.c
│   │       ├── ./C/leetcode/src/169.c
│   │       ├── ./C/leetcode/src/173.c
│   │       ├── ./C/leetcode/src/189.c
│   │       ├── ./C/leetcode/src/190.c
│   │       ├── ./C/leetcode/src/191.c
│   │       ├── ./C/leetcode/src/1.c
│   │       ├── ./C/leetcode/src/201.c
│   │       ├── ./C/leetcode/src/203.c
│   │       ├── ./C/leetcode/src/206.c
│   │       ├── ./C/leetcode/src/20.c
│   │       ├── ./C/leetcode/src/215.c
│   │       ├── ./C/leetcode/src/217.c
│   │       ├── ./C/leetcode/src/21.c
│   │       ├── ./C/leetcode/src/226.c
│   │       ├── ./C/leetcode/src/231.c
│   │       ├── ./C/leetcode/src/234.c
│   │       ├── ./C/leetcode/src/242.c
│   │       ├── ./C/leetcode/src/24.c
│   │       ├── ./C/leetcode/src/268.c
│   │       ├── ./C/leetcode/src/26.c
│   │       ├── ./C/leetcode/src/278.c
│   │       ├── ./C/leetcode/src/27.c
│   │       ├── ./C/leetcode/src/283.c
│   │       ├── ./C/leetcode/src/287.c
│   │       ├── ./C/leetcode/src/28.c
│   │       ├── ./C/leetcode/src/29.c
│   │       ├── ./C/leetcode/src/2.c
│   │       ├── ./C/leetcode/src/344.c
│   │       ├── ./C/leetcode/src/35.c
│   │       ├── ./C/leetcode/src/367.c
│   │       ├── ./C/leetcode/src/387.c
│   │       ├── ./C/leetcode/src/389.c
│   │       ├── ./C/leetcode/src/38.c
│   │       ├── ./C/leetcode/src/3.c
│   │       ├── ./C/leetcode/src/404.c
│   │       ├── ./C/leetcode/src/442.c
│   │       ├── ./C/leetcode/src/461.c
│   │       ├── ./C/leetcode/src/476.c
│   │       ├── ./C/leetcode/src/4.c
│   │       ├── ./C/leetcode/src/509.c
│   │       ├── ./C/leetcode/src/520.c
│   │       ├── ./C/leetcode/src/53.c
│   │       ├── ./C/leetcode/src/561.c
│   │       ├── ./C/leetcode/src/617.c
│   │       ├── ./C/leetcode/src/647.c
│   │       ├── ./C/leetcode/src/66.c
│   │       ├── ./C/leetcode/src/674.c
│   │       ├── ./C/leetcode/src/700.c
│   │       ├── ./C/leetcode/src/701.c
│   │       ├── ./C/leetcode/src/704.c
│   │       ├── ./C/leetcode/src/709.c
│   │       ├── ./C/leetcode/src/771.c
│   │       ├── ./C/leetcode/src/7.c
│   │       ├── ./C/leetcode/src/82.c
│   │       ├── ./C/leetcode/src/83.c
│   │       ├── ./C/leetcode/src/852.c
│   │       ├── ./C/leetcode/src/876.c
│   │       ├── ./C/leetcode/src/8.c
│   │       ├── ./C/leetcode/src/905.c
│   │       ├── ./C/leetcode/src/917.c
│   │       ├── ./C/leetcode/src/938.c
│   │       ├── ./C/leetcode/src/94.c
│   │       ├── ./C/leetcode/src/965.c
│   │       ├── ./C/leetcode/src/977.c
│   │       └── ./C/leetcode/src/9.c
│   ├── ./C/machine_learning
│   │   ├── ./C/machine_learning/adaline_learning.c
│   │   ├── ./C/machine_learning/CMakeLists.txt
│   │   ├── ./C/machine_learning/k_means_clustering.c
│   │   ├── ./C/machine_learning/kohonen_som_topology.c
│   │   └── ./C/machine_learning/kohonen_som_trace.c
│   ├── ./C/misc
│   │   ├── ./C/misc/armstrong_number.c
│   │   ├── ./C/misc/cantor_set.c
│   │   ├── ./C/misc/cartesian_to_polar.c
│   │   ├── ./C/misc/catalan.c
│   │   ├── ./C/misc/CMakeLists.txt
│   │   ├── ./C/misc/collatz.c
│   │   ├── ./C/misc/demonetization.c
│   │   ├── ./C/misc/factorial.c
│   │   ├── ./C/misc/factorial_large_number.c
│   │   ├── ./C/misc/factorial_trailing_zeroes.c
│   │   ├── ./C/misc/fibonacci.c
│   │   ├── ./C/misc/fibonacci_dp.c
│   │   ├── ./C/misc/fibonacci_fast.c
│   │   ├── ./C/misc/gcd.c
│   │   ├── ./C/misc/is_armstrong.c
│   │   ├── ./C/misc/large_factorials.c
│   │   ├── ./C/misc/lcm.c
│   │   ├── ./C/misc/lerp.c
│   │   ├── ./C/misc/lexicographic_permutations.c
│   │   ├── ./C/misc/longest_subsequence.c
│   │   ├── ./C/misc/mirror.c
│   │   ├── ./C/misc/palindrome.c
│   │   ├── ./C/misc/pid.c
│   │   ├── ./C/misc/poly_add.c
│   │   ├── ./C/misc/prime.c
│   │   ├── ./C/misc/prime_factoriziation.c
│   │   ├── ./C/misc/prime_seive.c
│   │   ├── ./C/misc/quartile.c
│   │   ├── ./C/misc/rselect.c
│   │   ├── ./C/misc/strong_number.c
│   │   ├── ./C/misc/sudoku_solver.c
│   │   ├── ./C/misc/tower_of_hanoi.c
│   │   └── ./C/misc/union_find.c
│   ├── ./C/numerical_methods
│   │   ├── ./C/numerical_methods/CMakeLists.txt
│   │   ├── ./C/numerical_methods/durand_kerner_roots.c
│   │   ├── ./C/numerical_methods/gauss_elimination.c
│   │   ├── ./C/numerical_methods/gauss_seidel_method.c
│   │   ├── ./C/numerical_methods/lagrange_theorem.c
│   │   ├── ./C/numerical_methods/lu_decompose.c
│   │   ├── ./C/numerical_methods/mean.c
│   │   ├── ./C/numerical_methods/median.c
│   │   ├── ./C/numerical_methods/newton_raphson_root.c
│   │   ├── ./C/numerical_methods/ode_forward_euler.c
│   │   ├── ./C/numerical_methods/ode_midpoint_euler.c
│   │   ├── ./C/numerical_methods/ode_semi_implicit_euler.c
│   │   ├── ./C/numerical_methods/qr_decompose.h
│   │   ├── ./C/numerical_methods/qr_decomposition.c
│   │   ├── ./C/numerical_methods/qr_eigen_values.c
│   │   ├── ./C/numerical_methods/realtime_stats.c
│   │   ├── ./C/numerical_methods/simpsons_1_3rd_rule.c
│   │   └── ./C/numerical_methods/variance.c
│   ├── ./C/project_euler
│   │   ├── ./C/project_euler/CMakeLists.txt
│   │   ├── ./C/project_euler/problem_1
│   │   │   ├── ./C/project_euler/problem_1/sol1.c
│   │   │   ├── ./C/project_euler/problem_1/sol2.c
│   │   │   ├── ./C/project_euler/problem_1/sol3.c
│   │   │   └── ./C/project_euler/problem_1/sol4.c
│   │   ├── ./C/project_euler/problem_10
│   │   │   ├── ./C/project_euler/problem_10/sol1.c
│   │   │   └── ./C/project_euler/problem_10/sol2.c
│   │   ├── ./C/project_euler/problem_12
│   │   │   └── ./C/project_euler/problem_12/sol1.c
│   │   ├── ./C/project_euler/problem_13
│   │   │   ├── ./C/project_euler/problem_13/num.txt
│   │   │   └── ./C/project_euler/problem_13/sol1.c
│   │   ├── ./C/project_euler/problem_14
│   │   │   └── ./C/project_euler/problem_14/sol1.c
│   │   ├── ./C/project_euler/problem_15
│   │   │   └── ./C/project_euler/problem_15/sol1.c
│   │   ├── ./C/project_euler/problem_16
│   │   │   └── ./C/project_euler/problem_16/sol1.c
│   │   ├── ./C/project_euler/problem_19
│   │   │   └── ./C/project_euler/problem_19/sol1.c
│   │   ├── ./C/project_euler/problem_2
│   │   │   └── ./C/project_euler/problem_2/so1.c
│   │   ├── ./C/project_euler/problem_20
│   │   │   └── ./C/project_euler/problem_20/sol1.c
│   │   ├── ./C/project_euler/problem_21
│   │   │   └── ./C/project_euler/problem_21/sol1.c
│   │   ├── ./C/project_euler/problem_22
│   │   │   ├── ./C/project_euler/problem_22/names.txt
│   │   │   └── ./C/project_euler/problem_22/sol1.c
│   │   ├── ./C/project_euler/problem_23
│   │   │   ├── ./C/project_euler/problem_23/sol1.c
│   │   │   └── ./C/project_euler/problem_23/sol2.c
│   │   ├── ./C/project_euler/problem_24
│   │   │   └── ./C/project_euler/problem_24/sol1
│   │   ├── ./C/project_euler/problem_25
│   │   │   └── ./C/project_euler/problem_25/sol1.c
│   │   ├── ./C/project_euler/problem_26
│   │   │   └── ./C/project_euler/problem_26/sol1.c
│   │   ├── ./C/project_euler/problem_3
│   │   │   ├── ./C/project_euler/problem_3/sol1.c
│   │   │   └── ./C/project_euler/problem_3/sol2.c
│   │   ├── ./C/project_euler/problem_4
│   │   │   └── ./C/project_euler/problem_4/sol.c
│   │   ├── ./C/project_euler/problem_401
│   │   │   └── ./C/project_euler/problem_401/sol1.c
│   │   ├── ./C/project_euler/problem_5
│   │   │   ├── ./C/project_euler/problem_5/sol1.c
│   │   │   ├── ./C/project_euler/problem_5/sol2.c
│   │   │   └── ./C/project_euler/problem_5/sol3.c
│   │   ├── ./C/project_euler/problem_6
│   │   │   └── ./C/project_euler/problem_6/sol.c
│   │   ├── ./C/project_euler/problem_7
│   │   │   ├── ./C/project_euler/problem_7/sol2.c
│   │   │   └── ./C/project_euler/problem_7/sol.c
│   │   ├── ./C/project_euler/problem_8
│   │   │   ├── ./C/project_euler/problem_8/digits.txt
│   │   │   ├── ./C/project_euler/problem_8/sol1.c
│   │   │   └── ./C/project_euler/problem_8/sol2.c
│   │   ├── ./C/project_euler/problem_9
│   │   │   ├── ./C/project_euler/problem_9/sol1.c
│   │   │   └── ./C/project_euler/problem_9/sol2.c
│   │   ├── ./C/project_euler/README.html
│   │   └── ./C/project_euler/README.md
│   ├── ./C/README.html
│   ├── ./C/README.md
│   ├── ./C/REVIEWER_CODE.html
│   ├── ./C/REVIEWER_CODE.md
│   ├── ./C/searching
│   │   ├── ./C/searching/binary_search.c
│   │   ├── ./C/searching/CMakeLists.txt
│   │   ├── ./C/searching/exponential_search.c
│   │   ├── ./C/searching/fibonacci_search.c
│   │   ├── ./C/searching/floyd_cycle_detection_algorithm.c
│   │   ├── ./C/searching/interpolation_search.c
│   │   ├── ./C/searching/jump_search.c
│   │   ├── ./C/searching/linear_search.c
│   │   ├── ./C/searching/modified_binary_search.c
│   │   ├── ./C/searching/other_binary_search.c
│   │   ├── ./C/searching/pattern_search
│   │   │   ├── ./C/searching/pattern_search/boyer_moore_search.c
│   │   │   ├── ./C/searching/pattern_search/CMakeLists.txt
│   │   │   ├── ./C/searching/pattern_search/naive_search.c
│   │   │   └── ./C/searching/pattern_search/rabin_karp_search.c
│   │   └── ./C/searching/ternary_search.c
│   └── ./C/sorting
│       ├── ./C/sorting/bead_sort.c
│       ├── ./C/sorting/binary_insertion_sort.c
│       ├── ./C/sorting/bogo_sort.c
│       ├── ./C/sorting/bubble_sort_2.c
│       ├── ./C/sorting/bubble_sort.c
│       ├── ./C/sorting/bubble_sort_recursion.c
│       ├── ./C/sorting/bucket_sort.c
│       ├── ./C/sorting/CMakeLists.txt
│       ├── ./C/sorting/cocktail_sort.c
│       ├── ./C/sorting/comb_sort.c
│       ├── ./C/sorting/counting_sort.c
│       ├── ./C/sorting/cycle_sort.c
│       ├── ./C/sorting/gnome_sort.c
│       ├── ./C/sorting/heap_sort_2.c
│       ├── ./C/sorting/heap_sort.c
│       ├── ./C/sorting/insertion_sort.c
│       ├── ./C/sorting/insertion_sort_recursive.c
│       ├── ./C/sorting/merge_sort.c
│       ├── ./C/sorting/merge_sort_nr.c
│       ├── ./C/sorting/multikey_quick_sort.c
│       ├── ./C/sorting/pancake_sort.c
│       ├── ./C/sorting/partition_sort.c
│       ├── ./C/sorting/pigeonhole_sort.c
│       ├── ./C/sorting/quick_sort.c
│       ├── ./C/sorting/radix_sort_2.c
│       ├── ./C/sorting/radix_sort.c
│       ├── ./C/sorting/random_quick_sort.c
│       ├── ./C/sorting/selection_sort.c
│       ├── ./C/sorting/selection_sort_recursive.c
│       ├── ./C/sorting/shaker_sort.c
│       ├── ./C/sorting/shell_sort2.c
│       ├── ./C/sorting/shell_sort.c
│       └── ./C/sorting/stooge_sort.c
├── ./Clojure
│   ├── ./Clojure/DIRECTORY.html
│   ├── ./Clojure/DIRECTORY.md
│   ├── ./Clojure/project.clj
│   ├── ./Clojure/README.html
│   ├── ./Clojure/README.md
│   ├── ./Clojure/src
│   │   └── ./Clojure/src/data_structures
│   │       └── ./Clojure/src/data_structures/lists
│   └── ./Clojure/test
│       └── ./Clojure/test/data_structures
│           └── ./Clojure/test/data_structures/lists
├── ./commands.html
├── ./commands.md
├── ./C-Plus-Plus
│   ├── ./C-Plus-Plus/backtracking
│   │   ├── ./C-Plus-Plus/backtracking/CMakeLists.txt
│   │   ├── ./C-Plus-Plus/backtracking/graph_coloring.cpp
│   │   ├── ./C-Plus-Plus/backtracking/knight_tour.cpp
│   │   ├── ./C-Plus-Plus/backtracking/magic_sequence.cpp
│   │   ├── ./C-Plus-Plus/backtracking/minimax.cpp
│   │   ├── ./C-Plus-Plus/backtracking/nqueen_print_all_solutions.cpp
│   │   ├── ./C-Plus-Plus/backtracking/n_queens_all_solution_optimised.cpp
│   │   ├── ./C-Plus-Plus/backtracking/n_queens.cpp
│   │   ├── ./C-Plus-Plus/backtracking/rat_maze.cpp
│   │   ├── ./C-Plus-Plus/backtracking/subarray_sum.cpp
│   │   ├── ./C-Plus-Plus/backtracking/subset_sum.cpp
│   │   ├── ./C-Plus-Plus/backtracking/sudoku_solve.cpp
│   │   └── ./C-Plus-Plus/backtracking/wildcard_matching.cpp
│   ├── ./C-Plus-Plus/bit_manipulation
│   │   ├── ./C-Plus-Plus/bit_manipulation/count_of_set_bits.cpp
│   │   ├── ./C-Plus-Plus/bit_manipulation/count_of_trailing_ciphers_in_factorial_n.cpp
│   │   └── ./C-Plus-Plus/bit_manipulation/hamming_distance.cpp
│   ├── ./C-Plus-Plus/ciphers
│   │   ├── ./C-Plus-Plus/ciphers/base64_encoding.cpp
│   │   ├── ./C-Plus-Plus/ciphers/caesar_cipher.cpp
│   │   ├── ./C-Plus-Plus/ciphers/CMakeLists.txt
│   │   ├── ./C-Plus-Plus/ciphers/elliptic_curve_key_exchange.cpp
│   │   ├── ./C-Plus-Plus/ciphers/hill_cipher.cpp
│   │   ├── ./C-Plus-Plus/ciphers/morse_code.cpp
│   │   ├── ./C-Plus-Plus/ciphers/uint128_t.hpp
│   │   ├── ./C-Plus-Plus/ciphers/uint256_t.hpp
│   │   ├── ./C-Plus-Plus/ciphers/vigenere_cipher.cpp
│   │   └── ./C-Plus-Plus/ciphers/xor_cipher.cpp
│   ├── ./C-Plus-Plus/CMakeLists.txt
│   ├── ./C-Plus-Plus/CodingGuidelines.html
│   ├── ./C-Plus-Plus/CodingGuidelines.md
│   ├── ./C-Plus-Plus/data_structures
│   │   ├── ./C-Plus-Plus/data_structures/avltree.cpp
│   │   ├── ./C-Plus-Plus/data_structures/binaryheap.cpp
│   │   ├── ./C-Plus-Plus/data_structures/binary_search_tree2.cpp
│   │   ├── ./C-Plus-Plus/data_structures/binary_search_tree.cpp
│   │   ├── ./C-Plus-Plus/data_structures/circular_queue_using_linked_list.cpp
│   │   ├── ./C-Plus-Plus/data_structures/cll
│   │   │   ├── ./C-Plus-Plus/data_structures/cll/cll.cpp
│   │   │   ├── ./C-Plus-Plus/data_structures/cll/cll.h
│   │   │   ├── ./C-Plus-Plus/data_structures/cll/CMakeLists.txt
│   │   │   └── ./C-Plus-Plus/data_structures/cll/main_cll.cpp
│   │   ├── ./C-Plus-Plus/data_structures/CMakeLists.txt
│   │   ├── ./C-Plus-Plus/data_structures/disjoint_set.cpp
│   │   ├── ./C-Plus-Plus/data_structures/doubly_linked_list.cpp
│   │   ├── ./C-Plus-Plus/data_structures/linked_list.cpp
│   │   ├── ./C-Plus-Plus/data_structures/linkedlist_implentation_usingarray.cpp
│   │   ├── ./C-Plus-Plus/data_structures/list_array.cpp
│   │   ├── ./C-Plus-Plus/data_structures/morrisinorder.cpp
│   │   ├── ./C-Plus-Plus/data_structures/queue.h
│   │   ├── ./C-Plus-Plus/data_structures/queue_using_array2.cpp
│   │   ├── ./C-Plus-Plus/data_structures/queue_using_array.cpp
│   │   ├── ./C-Plus-Plus/data_structures/queue_using_linked_list.cpp
│   │   ├── ./C-Plus-Plus/data_structures/queue_using_linkedlist.cpp
│   │   ├── ./C-Plus-Plus/data_structures/queue_using_two_stacks.cpp
│   │   ├── ./C-Plus-Plus/data_structures/rb_tree.cpp
│   │   ├── ./C-Plus-Plus/data_structures/skip_list.cpp
│   │   ├── ./C-Plus-Plus/data_structures/sparse_table.cpp
│   │   ├── ./C-Plus-Plus/data_structures/stack.h
│   │   ├── ./C-Plus-Plus/data_structures/stack_using_array.cpp
│   │   ├── ./C-Plus-Plus/data_structures/stack_using_linked_list.cpp
│   │   ├── ./C-Plus-Plus/data_structures/student.txt
│   │   ├── ./C-Plus-Plus/data_structures/test_queue.cpp
│   │   ├── ./C-Plus-Plus/data_structures/test_stack.cpp
│   │   ├── ./C-Plus-Plus/data_structures/test_stack_students.cpp
│   │   ├── ./C-Plus-Plus/data_structures/tree_234.cpp
│   │   ├── ./C-Plus-Plus/data_structures/tree.cpp
│   │   ├── ./C-Plus-Plus/data_structures/trie_modern.cpp
│   │   ├── ./C-Plus-Plus/data_structures/trie_tree.cpp
│   │   └── ./C-Plus-Plus/data_structures/trie_using_hashmap.cpp
│   ├── ./C-Plus-Plus/DIRECTORY.html
│   ├── ./C-Plus-Plus/DIRECTORY.md
│   ├── ./C-Plus-Plus/divide_and_conquer
│   │   └── ./C-Plus-Plus/divide_and_conquer/karatsuba_algorithm_for_fast_multiplication.cpp
│   ├── ./C-Plus-Plus/doc
│   ├── ./C-Plus-Plus/dynamic_programming
│   │   ├── ./C-Plus-Plus/dynamic_programming/0_1_knapsack.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/abbreviation.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/armstrong_number.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/bellman_ford.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/catalan_numbers.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/coin_change.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/coin_change_topdown.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/cut_rod.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/edit_distance.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/egg_dropping_puzzle.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/fibonacci_bottom_up.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/floyd_warshall.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/house_robber.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/kadane2.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/kadane.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/longest_common_string.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/longest_common_subsequence.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/longest_increasing_subsequence.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/longest_increasing_subsequence_(nlogn).cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/longest_palindromic_subsequence.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/matrix_chain_multiplication.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/minimum_edit_distance.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/palindrome_partitioning.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/searching_of_element_in_dynamic_array.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/shortest_common_supersequence.cpp
│   │   ├── ./C-Plus-Plus/dynamic_programming/tree_height.cpp
│   │   └── ./C-Plus-Plus/dynamic_programming/word_break.cpp
│   ├── ./C-Plus-Plus/geometry
│   │   ├── ./C-Plus-Plus/geometry/CMakeLists.txt
│   │   ├── ./C-Plus-Plus/geometry/jarvis_algorithm.cpp
│   │   └── ./C-Plus-Plus/geometry/line_segment_intersection.cpp
│   ├── ./C-Plus-Plus/graph
│   │   ├── ./C-Plus-Plus/graph/bidirectional_dijkstra.cpp
│   │   ├── ./C-Plus-Plus/graph/breadth_first_search.cpp
│   │   ├── ./C-Plus-Plus/graph/bridge_finding_with_tarjan_algorithm.cpp
│   │   ├── ./C-Plus-Plus/graph/CMakeLists.txt
│   │   ├── ./C-Plus-Plus/graph/connected_components.cpp
│   │   ├── ./C-Plus-Plus/graph/connected_components_with_dsu.cpp
│   │   ├── ./C-Plus-Plus/graph/cycle_check_directed_graph.cpp
│   │   ├── ./C-Plus-Plus/graph/depth_first_search.cpp
│   │   ├── ./C-Plus-Plus/graph/depth_first_search_with_stack.cpp
│   │   ├── ./C-Plus-Plus/graph/dijkstra.cpp
│   │   ├── ./C-Plus-Plus/graph/hamiltons_cycle.cpp
│   │   ├── ./C-Plus-Plus/graph/hopcroft_karp.cpp
│   │   ├── ./C-Plus-Plus/graph/is_graph_bipartite.cpp
│   │   ├── ./C-Plus-Plus/graph/kosaraju.cpp
│   │   ├── ./C-Plus-Plus/graph/kruskal.cpp
│   │   ├── ./C-Plus-Plus/graph/lowest_common_ancestor.cpp
│   │   ├── ./C-Plus-Plus/graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp
│   │   ├── ./C-Plus-Plus/graph/prim.cpp
│   │   ├── ./C-Plus-Plus/graph/topological_sort_by_kahns_algo.cpp
│   │   └── ./C-Plus-Plus/graph/topological_sort.cpp
│   ├── ./C-Plus-Plus/graphics
│   │   ├── ./C-Plus-Plus/graphics/CMakeLists.txt
│   │   └── ./C-Plus-Plus/graphics/spirograph.cpp
│   ├── ./C-Plus-Plus/greedy_algorithms
│   │   ├── ./C-Plus-Plus/greedy_algorithms/dijkstra.cpp
│   │   ├── ./C-Plus-Plus/greedy_algorithms/huffman.cpp
│   │   ├── ./C-Plus-Plus/greedy_algorithms/jumpgame.cpp
│   │   ├── ./C-Plus-Plus/greedy_algorithms/knapsack.cpp
│   │   ├── ./C-Plus-Plus/greedy_algorithms/kruskals_minimum_spanning_tree.cpp
│   │   └── ./C-Plus-Plus/greedy_algorithms/prims_minimum_spanning_tree.cpp
│   ├── ./C-Plus-Plus/hashing
│   │   ├── ./C-Plus-Plus/hashing/chaining.cpp
│   │   ├── ./C-Plus-Plus/hashing/CMakeLists.txt
│   │   ├── ./C-Plus-Plus/hashing/double_hash_hash_table.cpp
│   │   ├── ./C-Plus-Plus/hashing/linear_probing_hash_table.cpp
│   │   └── ./C-Plus-Plus/hashing/quadratic_probing_hash_table.cpp
│   ├── ./C-Plus-Plus/linear_algebra
│   │   └── ./C-Plus-Plus/linear_algebra/gram_schmidt.cpp
│   ├── ./C-Plus-Plus/machine_learning
│   │   ├── ./C-Plus-Plus/machine_learning/adaline_learning.cpp
│   │   ├── ./C-Plus-Plus/machine_learning/a_star_search.cpp
│   │   ├── ./C-Plus-Plus/machine_learning/CMakeLists.txt
│   │   ├── ./C-Plus-Plus/machine_learning/iris.csv
│   │   ├── ./C-Plus-Plus/machine_learning/kohonen_som_topology.cpp
│   │   ├── ./C-Plus-Plus/machine_learning/kohonen_som_trace.cpp
│   │   ├── ./C-Plus-Plus/machine_learning/neural_network.cpp
│   │   ├── ./C-Plus-Plus/machine_learning/ordinary_least_squares_regressor.cpp
│   │   └── ./C-Plus-Plus/machine_learning/vector_ops.hpp
│   ├── ./C-Plus-Plus/math
│   │   ├── ./C-Plus-Plus/math/armstrong_number.cpp
│   │   ├── ./C-Plus-Plus/math/binary_exponent.cpp
│   │   ├── ./C-Plus-Plus/math/binomial_calculate.cpp
│   │   ├── ./C-Plus-Plus/math/check_amicable_pair.cpp
│   │   ├── ./C-Plus-Plus/math/check_factorial.cpp
│   │   ├── ./C-Plus-Plus/math/check_prime.cpp
│   │   ├── ./C-Plus-Plus/math/CMakeLists.txt
│   │   ├── ./C-Plus-Plus/math/complex_numbers.cpp
│   │   ├── ./C-Plus-Plus/math/double_factorial.cpp
│   │   ├── ./C-Plus-Plus/math/eulers_totient_function.cpp
│   │   ├── ./C-Plus-Plus/math/extended_euclid_algorithm.cpp
│   │   ├── ./C-Plus-Plus/math/factorial.cpp
│   │   ├── ./C-Plus-Plus/math/fast_power.cpp
│   │   ├── ./C-Plus-Plus/math/fibonacci.cpp
│   │   ├── ./C-Plus-Plus/math/fibonacci_fast.cpp
│   │   ├── ./C-Plus-Plus/math/fibonacci_large.cpp
│   │   ├── ./C-Plus-Plus/math/fibonacci_matrix_exponentiation.cpp
│   │   ├── ./C-Plus-Plus/math/fibonacci_sum.cpp
│   │   ├── ./C-Plus-Plus/math/gcd_iterative_euclidean.cpp
│   │   ├── ./C-Plus-Plus/math/gcd_of_n_numbers.cpp
│   │   ├── ./C-Plus-Plus/math/gcd_recursive_euclidean.cpp
│   │   ├── ./C-Plus-Plus/math/integral_approximation.cpp
│   │   ├── ./C-Plus-Plus/math/large_factorial.cpp
│   │   ├── ./C-Plus-Plus/math/large_number.h
│   │   ├── ./C-Plus-Plus/math/largest_power.cpp
│   │   ├── ./C-Plus-Plus/math/lcm_sum.cpp
│   │   ├── ./C-Plus-Plus/math/least_common_multiple.cpp
│   │   ├── ./C-Plus-Plus/math/linear_recurrence_matrix.cpp
│   │   ├── ./C-Plus-Plus/math/magic_number.cpp
│   │   ├── ./C-Plus-Plus/math/miller_rabin.cpp
│   │   ├── ./C-Plus-Plus/math/modular_division.cpp
│   │   ├── ./C-Plus-Plus/math/modular_exponentiation.cpp
│   │   ├── ./C-Plus-Plus/math/modular_inverse_fermat_little_theorem.cpp
│   │   ├── ./C-Plus-Plus/math/n_bonacci.cpp
│   │   ├── ./C-Plus-Plus/math/n_choose_r.cpp
│   │   ├── ./C-Plus-Plus/math/ncr_modulo_p.cpp
│   │   ├── ./C-Plus-Plus/math/number_of_positive_divisors.cpp
│   │   ├── ./C-Plus-Plus/math/power_for_huge_numbers.cpp
│   │   ├── ./C-Plus-Plus/math/power_of_two.cpp
│   │   ├── ./C-Plus-Plus/math/prime_factorization.cpp
│   │   ├── ./C-Plus-Plus/math/prime_numbers.cpp
│   │   ├── ./C-Plus-Plus/math/primes_up_to_billion.cpp
│   │   ├── ./C-Plus-Plus/math/README.html
│   │   ├── ./C-Plus-Plus/math/README.md
│   │   ├── ./C-Plus-Plus/math/realtime_stats.cpp
│   │   ├── ./C-Plus-Plus/math/sieve_of_eratosthenes.cpp
│   │   ├── ./C-Plus-Plus/math/sqrt_double.cpp
│   │   ├── ./C-Plus-Plus/math/string_fibonacci.cpp
│   │   ├── ./C-Plus-Plus/math/sum_of_binomial_coefficient.cpp
│   │   ├── ./C-Plus-Plus/math/sum_of_digits.cpp
│   │   └── ./C-Plus-Plus/math/vector_cross_product.cpp
│   ├── ./C-Plus-Plus/numerical_methods
│   │   ├── ./C-Plus-Plus/numerical_methods/bisection_method.cpp
│   │   ├── ./C-Plus-Plus/numerical_methods/brent_method_extrema.cpp
│   │   ├── ./C-Plus-Plus/numerical_methods/CMakeLists.txt
│   │   ├── ./C-Plus-Plus/numerical_methods/durand_kerner_roots.cpp
│   │   ├── ./C-Plus-Plus/numerical_methods/false_position.cpp
│   │   ├── ./C-Plus-Plus/numerical_methods/gaussian_elimination.cpp
│   │   ├── ./C-Plus-Plus/numerical_methods/golden_search_extrema.cpp
│   │   ├── ./C-Plus-Plus/numerical_methods/lu_decompose.cpp
│   │   ├── ./C-Plus-Plus/numerical_methods/lu_decomposition.h
│   │   ├── ./C-Plus-Plus/numerical_methods/newton_raphson_method.cpp
│   │   ├── ./C-Plus-Plus/numerical_methods/ode_forward_euler.cpp
│   │   ├── ./C-Plus-Plus/numerical_methods/ode_midpoint_euler.cpp
│   │   ├── ./C-Plus-Plus/numerical_methods/ode_semi_implicit_euler.cpp
│   │   ├── ./C-Plus-Plus/numerical_methods/qr_decompose.h
│   │   ├── ./C-Plus-Plus/numerical_methods/qr_decomposition.cpp
│   │   ├── ./C-Plus-Plus/numerical_methods/qr_eigen_values.cpp
│   │   ├── ./C-Plus-Plus/numerical_methods/rungekutta.cpp
│   │   └── ./C-Plus-Plus/numerical_methods/successive_approximation.cpp
│   ├── ./C-Plus-Plus/operations_on_datastructures
│   │   ├── ./C-Plus-Plus/operations_on_datastructures/array_left_rotation.cpp
│   │   ├── ./C-Plus-Plus/operations_on_datastructures/array_right_rotation.cpp
│   │   ├── ./C-Plus-Plus/operations_on_datastructures/circular_linked_list.cpp
│   │   ├── ./C-Plus-Plus/operations_on_datastructures/circular_queue_using_array.cpp
│   │   ├── ./C-Plus-Plus/operations_on_datastructures/get_size_of_linked_list.cpp
│   │   ├── ./C-Plus-Plus/operations_on_datastructures/inorder_successor_of_bst.cpp
│   │   ├── ./C-Plus-Plus/operations_on_datastructures/intersection_of_2_arrays.cpp
│   │   ├── ./C-Plus-Plus/operations_on_datastructures/reverse_a_linked_list_using_recusion.cpp
│   │   ├── ./C-Plus-Plus/operations_on_datastructures/selectionsortlinkedlist.cpp
│   │   ├── ./C-Plus-Plus/operations_on_datastructures/trie_multiple_search.cpp
│   │   └── ./C-Plus-Plus/operations_on_datastructures/union_of_2_arrays.cpp
│   ├── ./C-Plus-Plus/others
│   │   ├── ./C-Plus-Plus/others/buzz_number.cpp
│   │   ├── ./C-Plus-Plus/others/CMakeLists.txt
│   │   ├── ./C-Plus-Plus/others/decimal_to_binary.cpp
│   │   ├── ./C-Plus-Plus/others/decimal_to_hexadecimal.cpp
│   │   ├── ./C-Plus-Plus/others/decimal_to_roman_numeral.cpp
│   │   ├── ./C-Plus-Plus/others/fast_integer_input.cpp
│   │   ├── ./C-Plus-Plus/others/happy_number.cpp
│   │   ├── ./C-Plus-Plus/others/iterative_tree_traversals.cpp
│   │   ├── ./C-Plus-Plus/others/matrix_exponentiation.cpp
│   │   ├── ./C-Plus-Plus/others/palindrome_of_number.cpp
│   │   ├── ./C-Plus-Plus/others/paranthesis_matching.cpp
│   │   ├── ./C-Plus-Plus/others/pascal_triangle.cpp
│   │   ├── ./C-Plus-Plus/others/postfix_evaluation.cpp
│   │   ├── ./C-Plus-Plus/others/primality_test.cpp
│   │   ├── ./C-Plus-Plus/others/smallest_circle.cpp
│   │   ├── ./C-Plus-Plus/others/sparse_matrix.cpp
│   │   ├── ./C-Plus-Plus/others/spiral_print.cpp
│   │   ├── ./C-Plus-Plus/others/stairs_pattern.cpp
│   │   ├── ./C-Plus-Plus/others/tower_of_hanoi.cpp
│   │   └── ./C-Plus-Plus/others/vector_important_functions.cpp
│   ├── ./C-Plus-Plus/probability
│   │   ├── ./C-Plus-Plus/probability/addition_rule.cpp
│   │   ├── ./C-Plus-Plus/probability/bayes_theorem.cpp
│   │   ├── ./C-Plus-Plus/probability/binomial_dist.cpp
│   │   ├── ./C-Plus-Plus/probability/CMakeLists.txt
│   │   └── ./C-Plus-Plus/probability/poisson_dist.cpp
│   ├── ./C-Plus-Plus/range_queries
│   │   ├── ./C-Plus-Plus/range_queries/fenwick_tree.cpp
│   │   ├── ./C-Plus-Plus/range_queries/heavy_light_decomposition.cpp
│   │   ├── ./C-Plus-Plus/range_queries/mo.cpp
│   │   ├── ./C-Plus-Plus/range_queries/persistent_seg_tree_lazy_prop.cpp
│   │   ├── ./C-Plus-Plus/range_queries/segtree.cpp
│   │   └── ./C-Plus-Plus/range_queries/sparse_table.cpp
│   ├── ./C-Plus-Plus/README.html
│   ├── ./C-Plus-Plus/README.md
│   ├── ./C-Plus-Plus/REVIEWER_CODE.html
│   ├── ./C-Plus-Plus/REVIEWER_CODE.md
│   ├── ./C-Plus-Plus/search
│   │   ├── ./C-Plus-Plus/search/binary_search.cpp
│   │   ├── ./C-Plus-Plus/search/CMakeLists.txt
│   │   ├── ./C-Plus-Plus/search/exponential_search.cpp
│   │   ├── ./C-Plus-Plus/search/fibonacci_search.cpp
│   │   ├── ./C-Plus-Plus/search/floyd_cycle_detection_algo.cpp
│   │   ├── ./C-Plus-Plus/search/hash_search.cpp
│   │   ├── ./C-Plus-Plus/search/interpolation_search2.cpp
│   │   ├── ./C-Plus-Plus/search/interpolation_search.cpp
│   │   ├── ./C-Plus-Plus/search/jump_search.cpp
│   │   ├── ./C-Plus-Plus/search/linear_search.cpp
│   │   ├── ./C-Plus-Plus/search/median_search.cpp
│   │   ├── ./C-Plus-Plus/search/saddleback_search.cpp
│   │   ├── ./C-Plus-Plus/search/sublist_search.cpp
│   │   ├── ./C-Plus-Plus/search/ternary_search.cpp
│   │   └── ./C-Plus-Plus/search/text_search.cpp
│   ├── ./C-Plus-Plus/sorting
│   │   ├── ./C-Plus-Plus/sorting/bead_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/bitonic_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/bogo_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/bubble_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/bucket_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/CMakeLists.txt
│   │   ├── ./C-Plus-Plus/sorting/cocktail_selection_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/comb_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/counting_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/counting_sort_string.cpp
│   │   ├── ./C-Plus-Plus/sorting/count_inversions.cpp
│   │   ├── ./C-Plus-Plus/sorting/cycle_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/gnome_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/heap_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/insertion_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/library_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/merge_insertion_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/merge_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/non_recursive_merge_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/numeric_string_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/odd_even_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/pancake_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/pigeonhole_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/quick_sort_3.cpp
│   │   ├── ./C-Plus-Plus/sorting/quick_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/radix_sort2.cpp
│   │   ├── ./C-Plus-Plus/sorting/radix_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/random_pivot_quick_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/recursive_bubble_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/selection_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/shell_sort2.cpp
│   │   ├── ./C-Plus-Plus/sorting/shell_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/slow_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/strand_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/swap_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/tim_sort.cpp
│   │   ├── ./C-Plus-Plus/sorting/wave_sort.cpp
│   │   └── ./C-Plus-Plus/sorting/wiggle_sort.cpp
│   └── ./C-Plus-Plus/strings
│       ├── ./C-Plus-Plus/strings/brute_force_string_searching.cpp
│       ├── ./C-Plus-Plus/strings/CMakeLists.txt
│       ├── ./C-Plus-Plus/strings/horspool.cpp
│       ├── ./C-Plus-Plus/strings/knuth_morris_pratt.cpp
│       └── ./C-Plus-Plus/strings/rabin_karp.cpp
├── ./C-Sharp
│   ├── ./C-Sharp/Algorithms
│   │   ├── ./C-Sharp/Algorithms/Algorithms.csproj
│   │   ├── ./C-Sharp/Algorithms/DataCompression
│   │   │   ├── ./C-Sharp/Algorithms/DataCompression/BurrowsWheelerTransform.cs
│   │   │   ├── ./C-Sharp/Algorithms/DataCompression/HuffmanCompressor.cs
│   │   │   ├── ./C-Sharp/Algorithms/DataCompression/ShannonFanoCompressor.cs
│   │   │   └── ./C-Sharp/Algorithms/DataCompression/Translator.cs
│   │   ├── ./C-Sharp/Algorithms/Encoders
│   │   │   ├── ./C-Sharp/Algorithms/Encoders/CaesarEncoder.cs
│   │   │   ├── ./C-Sharp/Algorithms/Encoders/HillEncoder.cs
│   │   │   ├── ./C-Sharp/Algorithms/Encoders/IEncoder.cs
│   │   │   ├── ./C-Sharp/Algorithms/Encoders/NysiisEncoder.cs
│   │   │   ├── ./C-Sharp/Algorithms/Encoders/SoundexEncoder.cs
│   │   │   └── ./C-Sharp/Algorithms/Encoders/VigenereEncoder.cs
│   │   ├── ./C-Sharp/Algorithms/Knapsack
│   │   │   ├── ./C-Sharp/Algorithms/Knapsack/BranchAndBoundKnapsackSolver.cs
│   │   │   ├── ./C-Sharp/Algorithms/Knapsack/BranchAndBoundNode.cs
│   │   │   ├── ./C-Sharp/Algorithms/Knapsack/DynamicProgrammingKnapsackSolver.cs
│   │   │   ├── ./C-Sharp/Algorithms/Knapsack/IHeuristicKnapsackSolver.cs
│   │   │   ├── ./C-Sharp/Algorithms/Knapsack/IKnapsackSolver.cs
│   │   │   └── ./C-Sharp/Algorithms/Knapsack/NaiveKnapsackSolver.cs
│   │   ├── ./C-Sharp/Algorithms/LinearAlgebra
│   │   │   └── ./C-Sharp/Algorithms/LinearAlgebra/Eigenvalue
│   │   ├── ./C-Sharp/Algorithms/Numeric
│   │   │   ├── ./C-Sharp/Algorithms/Numeric/AliquotSumCalculator.cs
│   │   │   ├── ./C-Sharp/Algorithms/Numeric/BinomialCoefficient.cs
│   │   │   ├── ./C-Sharp/Algorithms/Numeric/Decomposition
│   │   │   ├── ./C-Sharp/Algorithms/Numeric/EulerMethod.cs
│   │   │   ├── ./C-Sharp/Algorithms/Numeric/Factorial.cs
│   │   │   ├── ./C-Sharp/Algorithms/Numeric/Factorization
│   │   │   ├── ./C-Sharp/Algorithms/Numeric/GaussJordanElimination.cs
│   │   │   ├── ./C-Sharp/Algorithms/Numeric/GreatestCommonDivisor
│   │   │   ├── ./C-Sharp/Algorithms/Numeric/NarcissisticNumberChecker.cs
│   │   │   ├── ./C-Sharp/Algorithms/Numeric/PerfectNumberChecker.cs
│   │   │   ├── ./C-Sharp/Algorithms/Numeric/PerfectSquareChecker.cs
│   │   │   ├── ./C-Sharp/Algorithms/Numeric/Pseudoinverse
│   │   │   └── ./C-Sharp/Algorithms/Numeric/Series
│   │   ├── ./C-Sharp/Algorithms/Other
│   │   │   ├── ./C-Sharp/Algorithms/Other/FermatPrimeChecker.cs
│   │   │   ├── ./C-Sharp/Algorithms/Other/FloodFill.cs
│   │   │   ├── ./C-Sharp/Algorithms/Other/GeoLocation.cs
│   │   │   ├── ./C-Sharp/Algorithms/Other/Int2Binary.cs
│   │   │   ├── ./C-Sharp/Algorithms/Other/KochSnowflake.cs
│   │   │   ├── ./C-Sharp/Algorithms/Other/Luhn.cs
│   │   │   ├── ./C-Sharp/Algorithms/Other/Mandelbrot.cs
│   │   │   ├── ./C-Sharp/Algorithms/Other/RGBHSVConversion.cs
│   │   │   └── ./C-Sharp/Algorithms/Other/SieveOfEratosthenes.cs
│   │   ├── ./C-Sharp/Algorithms/Problems
│   │   │   ├── ./C-Sharp/Algorithms/Problems/NQueens
│   │   │   └── ./C-Sharp/Algorithms/Problems/StableMarriage
│   │   ├── ./C-Sharp/Algorithms/Search
│   │   │   ├── ./C-Sharp/Algorithms/Search/AStar
│   │   │   ├── ./C-Sharp/Algorithms/Search/BinarySearcher.cs
│   │   │   ├── ./C-Sharp/Algorithms/Search/FastSearcher.cs
│   │   │   ├── ./C-Sharp/Algorithms/Search/JumpSearcher.cs
│   │   │   ├── ./C-Sharp/Algorithms/Search/LinearSearcher.cs
│   │   │   └── ./C-Sharp/Algorithms/Search/RecursiveBinarySearcher.cs
│   │   ├── ./C-Sharp/Algorithms/Sequences
│   │   │   ├── ./C-Sharp/Algorithms/Sequences/BinomialSequence.cs
│   │   │   ├── ./C-Sharp/Algorithms/Sequences/FactorialSequence.cs
│   │   │   ├── ./C-Sharp/Algorithms/Sequences/FibonacciSequence.cs
│   │   │   ├── ./C-Sharp/Algorithms/Sequences/ISequence.cs
│   │   │   ├── ./C-Sharp/Algorithms/Sequences/NaturalSequence.cs
│   │   │   └── ./C-Sharp/Algorithms/Sequences/PrimesSequence.cs
│   │   ├── ./C-Sharp/Algorithms/Sorters
│   │   │   ├── ./C-Sharp/Algorithms/Sorters/Comparison
│   │   │   ├── ./C-Sharp/Algorithms/Sorters/External
│   │   │   ├── ./C-Sharp/Algorithms/Sorters/Integer
│   │   │   └── ./C-Sharp/Algorithms/Sorters/String
│   │   └── ./C-Sharp/Algorithms/Strings
│   │       ├── ./C-Sharp/Algorithms/Strings/BoyerMoore.cs
│   │       ├── ./C-Sharp/Algorithms/Strings/GeneralStringAlgorithms.cs
│   │       ├── ./C-Sharp/Algorithms/Strings/KnuthMorrisPrattSearcher.cs
│   │       ├── ./C-Sharp/Algorithms/Strings/NaiveStringSearch.cs
│   │       ├── ./C-Sharp/Algorithms/Strings/palindrome.cs
│   │       └── ./C-Sharp/Algorithms/Strings/RabinKarp.cs
│   ├── ./C-Sharp/Algorithms.Tests
│   │   ├── ./C-Sharp/Algorithms.Tests/Algorithms.Tests.csproj
│   │   ├── ./C-Sharp/Algorithms.Tests/AssemblyInfo.cs
│   │   ├── ./C-Sharp/Algorithms.Tests/Compressors
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Compressors/BurrowsWheelerTransformTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Compressors/HuffmanCompressorTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Compressors/ShannonFanoCompressorTests.cs
│   │   │   └── ./C-Sharp/Algorithms.Tests/Compressors/TranslatorTests.cs
│   │   ├── ./C-Sharp/Algorithms.Tests/Encoders
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Encoders/CaesarEncoderTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Encoders/HillEnconderTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Encoders/NysiisEncoderTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Encoders/SoundexEncoderTest.cs
│   │   │   └── ./C-Sharp/Algorithms.Tests/Encoders/VigenereEncoderTests.cs
│   │   ├── ./C-Sharp/Algorithms.Tests/Helpers
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Helpers/IntComparer.cs
│   │   │   └── ./C-Sharp/Algorithms.Tests/Helpers/RandomHelper.cs
│   │   ├── ./C-Sharp/Algorithms.Tests/Knapsack
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Knapsack/BranchAndBoundKnapsackSolverTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Knapsack/DynamicProgrammingKnapsackSolverTests.cs
│   │   │   └── ./C-Sharp/Algorithms.Tests/Knapsack/NaiveKnapsackSolverTests.cs
│   │   ├── ./C-Sharp/Algorithms.Tests/LinearAlgebra
│   │   │   └── ./C-Sharp/Algorithms.Tests/LinearAlgebra/Eigenvalue
│   │   ├── ./C-Sharp/Algorithms.Tests/Numeric
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Numeric/AliquotSumCalculatorTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Numeric/BinomialCoefficientTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Numeric/Decomposition
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Numeric/EulerMethodTest.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Numeric/FactorialTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Numeric/Factorization
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Numeric/GaussJordanEliminationTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Numeric/GreatestCommonDivisor
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Numeric/NarcissisticNumberTest.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Numeric/PerfectNumberTest.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Numeric/PerfectSquareTest.cs
│   │   │   └── ./C-Sharp/Algorithms.Tests/Numeric/PseudoInverse
│   │   ├── ./C-Sharp/Algorithms.Tests/Other
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Other/FermatPrimeCheckerTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Other/FloodFillTest.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Other/GeoLocationTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Other/Int2BinaryTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Other/KochSnowflakeTest.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Other/LuhnTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Other/MandelbrotTest.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Other/RGBHSVConversionTest.cs
│   │   │   └── ./C-Sharp/Algorithms.Tests/Other/SieveOfEratosthenesTests.cs
│   │   ├── ./C-Sharp/Algorithms.Tests/Problems
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Problems/NQueens
│   │   │   └── ./C-Sharp/Algorithms.Tests/Problems/StableMarriage
│   │   ├── ./C-Sharp/Algorithms.Tests/Search
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Search/BinarySearcherTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Search/FastSearcherTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Search/Helper.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Search/JumpSearcherTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Search/LinearSearcherTests.cs
│   │   │   └── ./C-Sharp/Algorithms.Tests/Search/RecursiveBinarySearcherTests.cs
│   │   ├── ./C-Sharp/Algorithms.Tests/Sequences
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Sequences/BinomialSequenceTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Sequences/FactorialSequenceTest.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Sequences/FibonacciSequenceTests.cs
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Sequences/NaturalSequenceTests.cs
│   │   │   └── ./C-Sharp/Algorithms.Tests/Sequences/PrimesSequenceTests.cs
│   │   ├── ./C-Sharp/Algorithms.Tests/Sorters
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Sorters/Comparison
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Sorters/External
│   │   │   ├── ./C-Sharp/Algorithms.Tests/Sorters/Integer
│   │   │   └── ./C-Sharp/Algorithms.Tests/Sorters/String
│   │   └── ./C-Sharp/Algorithms.Tests/Strings
│   │       ├── ./C-Sharp/Algorithms.Tests/Strings/BoyerMoreTests.cs
│   │       ├── ./C-Sharp/Algorithms.Tests/Strings/GeneralStringAlgorithmsTests.cs
│   │       ├── ./C-Sharp/Algorithms.Tests/Strings/KnuthMorrisPrattSearcherTests.cs
│   │       ├── ./C-Sharp/Algorithms.Tests/Strings/NaiveStringSearchTests.cs
│   │       ├── ./C-Sharp/Algorithms.Tests/Strings/PalindromeTests.cs
│   │       └── ./C-Sharp/Algorithms.Tests/Strings/RabinKarpTests.cs
│   ├── ./C-Sharp/C-Sharp.sln
│   ├── ./C-Sharp/DataStructures
│   │   ├── ./C-Sharp/DataStructures/AATree
│   │   │   ├── ./C-Sharp/DataStructures/AATree/AATree.cs
│   │   │   └── ./C-Sharp/DataStructures/AATree/AATreeNode.cs
│   │   ├── ./C-Sharp/DataStructures/BinarySearchTree
│   │   │   ├── ./C-Sharp/DataStructures/BinarySearchTree/BinarySearchTree.cs
│   │   │   └── ./C-Sharp/DataStructures/BinarySearchTree/BinarySearchTreeNode.cs
│   │   ├── ./C-Sharp/DataStructures/BitArray.cs
│   │   ├── ./C-Sharp/DataStructures/DataStructures.csproj
│   │   ├── ./C-Sharp/DataStructures/Heap
│   │   │   ├── ./C-Sharp/DataStructures/Heap/BinaryHeap.cs
│   │   │   ├── ./C-Sharp/DataStructures/Heap/FibonacciHeap
│   │   │   └── ./C-Sharp/DataStructures/Heap/MinMaxHeap.cs
│   │   ├── ./C-Sharp/DataStructures/LinkedList
│   │   │   ├── ./C-Sharp/DataStructures/LinkedList/DoublyLinkedList
│   │   │   └── ./C-Sharp/DataStructures/LinkedList/SinglyLinkedList
│   │   ├── ./C-Sharp/DataStructures/Queue
│   │   │   ├── ./C-Sharp/DataStructures/Queue/ArrayBasedQueue.cs
│   │   │   ├── ./C-Sharp/DataStructures/Queue/ListBasedQueue.cs
│   │   │   └── ./C-Sharp/DataStructures/Queue/StackBasedQueue.cs
│   │   ├── ./C-Sharp/DataStructures/SegmentTrees
│   │   │   ├── ./C-Sharp/DataStructures/SegmentTrees/SegmentTreeApply.cs
│   │   │   ├── ./C-Sharp/DataStructures/SegmentTrees/SegmentTree.cs
│   │   │   └── ./C-Sharp/DataStructures/SegmentTrees/SegmentTreeUpdate.cs
│   │   ├── ./C-Sharp/DataStructures/Stack
│   │   │   ├── ./C-Sharp/DataStructures/Stack/ArrayBasedStack.cs
│   │   │   └── ./C-Sharp/DataStructures/Stack/ListBasedStack.cs
│   │   └── ./C-Sharp/DataStructures/Timeline.cs
│   ├── ./C-Sharp/DataStructures.Tests
│   │   ├── ./C-Sharp/DataStructures.Tests/AATreeTests.cs
│   │   ├── ./C-Sharp/DataStructures.Tests/BinarySearchTreeTests.cs
│   │   ├── ./C-Sharp/DataStructures.Tests/BitArrayTests.cs
│   │   ├── ./C-Sharp/DataStructures.Tests/DataStructures.Tests.csproj
│   │   ├── ./C-Sharp/DataStructures.Tests/Heap
│   │   │   ├── ./C-Sharp/DataStructures.Tests/Heap/BinaryHeapTests.cs
│   │   │   ├── ./C-Sharp/DataStructures.Tests/Heap/FibonacciHeaps
│   │   │   └── ./C-Sharp/DataStructures.Tests/Heap/MinMaxHeapTests.cs
│   │   ├── ./C-Sharp/DataStructures.Tests/LinkedList
│   │   │   ├── ./C-Sharp/DataStructures.Tests/LinkedList/DoublyLinkedListTests.cs
│   │   │   └── ./C-Sharp/DataStructures.Tests/LinkedList/LinkedListTests.cs
│   │   ├── ./C-Sharp/DataStructures.Tests/Queue
│   │   │   ├── ./C-Sharp/DataStructures.Tests/Queue/ArrayBasedQueueTests.cs
│   │   │   ├── ./C-Sharp/DataStructures.Tests/Queue/ListBasedQueueTests.cs
│   │   │   └── ./C-Sharp/DataStructures.Tests/Queue/StackBasedQueueTests.cs
│   │   ├── ./C-Sharp/DataStructures.Tests/SegmentTrees
│   │   │   ├── ./C-Sharp/DataStructures.Tests/SegmentTrees/SegmentTreeApplyTests.cs
│   │   │   ├── ./C-Sharp/DataStructures.Tests/SegmentTrees/SegmentTreeTests.cs
│   │   │   └── ./C-Sharp/DataStructures.Tests/SegmentTrees/SegmentTreeUpdateTest.cs
│   │   ├── ./C-Sharp/DataStructures.Tests/Stack
│   │   │   ├── ./C-Sharp/DataStructures.Tests/Stack/ArrayBasedStackTests.cs
│   │   │   └── ./C-Sharp/DataStructures.Tests/Stack/ListBasedStackTests.cs
│   │   └── ./C-Sharp/DataStructures.Tests/TimelineTests.cs
│   ├── ./C-Sharp/DIRECTORY.html
│   ├── ./C-Sharp/DIRECTORY.md
│   ├── ./C-Sharp/README.html
│   ├── ./C-Sharp/README.md
│   ├── ./C-Sharp/stylecop.json
│   ├── ./C-Sharp/stylecop.ruleset
│   ├── ./C-Sharp/Utilities
│   │   ├── ./C-Sharp/Utilities/Exceptions
│   │   │   └── ./C-Sharp/Utilities/Exceptions/ItemNotFoundException.cs
│   │   ├── ./C-Sharp/Utilities/Extensions
│   │   │   ├── ./C-Sharp/Utilities/Extensions/DictionaryExtensions.cs
│   │   │   ├── ./C-Sharp/Utilities/Extensions/MatrixExtensions.cs
│   │   │   ├── ./C-Sharp/Utilities/Extensions/RandomExtensions.cs
│   │   │   └── ./C-Sharp/Utilities/Extensions/VectorExtensions.cs
│   │   └── ./C-Sharp/Utilities/Utilities.csproj
│   └── ./C-Sharp/Utilities.Tests
│       ├── ./C-Sharp/Utilities.Tests/Extensions
│       │   └── ./C-Sharp/Utilities.Tests/Extensions/MatrixExtensionsTests.cs
│       └── ./C-Sharp/Utilities.Tests/Utilities.Tests.csproj
├── ./Dart
│   ├── ./Dart/analysis_options.yaml
│   ├── ./Dart/array
│   │   └── ./Dart/array/validate_subsequence.dart
│   ├── ./Dart/backtracking
│   │   └── ./Dart/backtracking/open_knight_tour.dart
│   ├── ./Dart/conversions
│   │   ├── ./Dart/conversions/binary_to_decimal.dart
│   │   ├── ./Dart/conversions/binary_to_hexadecimal.dart
│   │   ├── ./Dart/conversions/binary_to_octal.dart
│   │   ├── ./Dart/conversions/Decimal_To_Any.dart
│   │   ├── ./Dart/conversions/Decimal_To_Binary.dart
│   │   ├── ./Dart/conversions/Decimal_to_Hexadecimal.dart
│   │   ├── ./Dart/conversions/Decimal_to_Octal.dart
│   │   ├── ./Dart/conversions/hexadecimal_to_binary.dart
│   │   ├── ./Dart/conversions/hexadecimal_to_decimal.dart
│   │   ├── ./Dart/conversions/hexadecimal_to_octal.dart
│   │   ├── ./Dart/conversions/Integer_To_Roman.dart
│   │   ├── ./Dart/conversions/octal_to_binary.dart
│   │   ├── ./Dart/conversions/octal_to_decimal.dart
│   │   ├── ./Dart/conversions/octal_to_hexadecimal.dart
│   │   └── ./Dart/conversions/roman_to_integer.dart
│   ├── ./Dart/dart_test.yaml
│   ├── ./Dart/data_structures
│   │   ├── ./Dart/data_structures/binary_tree
│   │   │   ├── ./Dart/data_structures/binary_tree/basic_binary_tree.dart
│   │   │   └── ./Dart/data_structures/binary_tree/binary_tree_traversal.dart
│   │   ├── ./Dart/data_structures/HashMap
│   │   │   └── ./Dart/data_structures/HashMap/Hashing.dart
│   │   ├── ./Dart/data_structures/Heap
│   │   │   └── ./Dart/data_structures/Heap/Binary_Heap
│   │   ├── ./Dart/data_structures/linked_list
│   │   │   ├── ./Dart/data_structures/linked_list/cycle_in_linked_list.dart
│   │   │   └── ./Dart/data_structures/linked_list/linked_list.dart
│   │   ├── ./Dart/data_structures/quad_tree
│   │   │   └── ./Dart/data_structures/quad_tree/quad_tree.dart
│   │   ├── ./Dart/data_structures/Queue
│   │   │   ├── ./Dart/data_structures/Queue/Circular_Queue.dart
│   │   │   ├── ./Dart/data_structures/Queue/List_Queue.dart
│   │   │   └── ./Dart/data_structures/Queue/Priority_Queue.dart
│   │   └── ./Dart/data_structures/Stack
│   │       ├── ./Dart/data_structures/Stack/Array_Stack.dart
│   │       ├── ./Dart/data_structures/Stack/balanced_brackets.dart
│   │       └── ./Dart/data_structures/Stack/Linked_List_Stack.dart
│   ├── ./Dart/DIRECTORY.html
│   ├── ./Dart/DIRECTORY.md
│   ├── ./Dart/dynamic_programming
│   │   ├── ./Dart/dynamic_programming/01knapsack_recursive.dart
│   │   ├── ./Dart/dynamic_programming/coin_change.dart
│   │   ├── ./Dart/dynamic_programming/kadanes_algorithm.dart
│   │   └── ./Dart/dynamic_programming/min_number_of_jumps.dart
│   ├── ./Dart/graphs
│   │   ├── ./Dart/graphs/breadth_first_search.dart
│   │   ├── ./Dart/graphs/depth_first_search.dart
│   │   └── ./Dart/graphs/nearest_neighbour_algorithm.dart
│   ├── ./Dart/maths
│   │   ├── ./Dart/maths/abs.dart
│   │   ├── ./Dart/maths/abs_max.dart
│   │   ├── ./Dart/maths/abs_min.dart
│   │   ├── ./Dart/maths/amicable_numbers.dart
│   │   ├── ./Dart/maths/Armstrong_number.dart
│   │   ├── ./Dart/maths/average.dart
│   │   ├── ./Dart/maths/eulers_totient.dart
│   │   ├── ./Dart/maths/factorial_approximation.dart
│   │   ├── ./Dart/maths/factorial.dart
│   │   ├── ./Dart/maths/factorial_recursion.dart
│   │   ├── ./Dart/maths/factors.dart
│   │   ├── ./Dart/maths/fermats_little_theorem.dart
│   │   ├── ./Dart/maths/fibonacci_dynamic_programming.dart
│   │   ├── ./Dart/maths/fibonacci_recursion.dart
│   │   ├── ./Dart/maths/find_max.dart
│   │   ├── ./Dart/maths/find_max_recursion.dart
│   │   ├── ./Dart/maths/find_min.dart
│   │   ├── ./Dart/maths/find_min_recursion.dart
│   │   ├── ./Dart/maths/hamming_distance.dart
│   │   ├── ./Dart/maths/Kynea_numbers.dart
│   │   ├── ./Dart/maths/LinearDiophantineEqn.dart
│   │   ├── ./Dart/maths/lu_decomposition.dart
│   │   ├── ./Dart/maths/newton_method.dart
│   │   ├── ./Dart/maths/palindrome_number.dart
│   │   ├── ./Dart/maths/palindrome_string.dart
│   │   ├── ./Dart/maths/palindrome_string_recursion.dart
│   │   ├── ./Dart/maths/perfect_number.dart
│   │   ├── ./Dart/maths/pow.dart
│   │   ├── ./Dart/maths/power_of_two.dart
│   │   ├── ./Dart/maths/prime_check.dart
│   │   ├── ./Dart/maths/relu_function.dart
│   │   ├── ./Dart/maths/shreedharacharya.dart
│   │   ├── ./Dart/maths/sieve_of_eratosthenes.dart
│   │   ├── ./Dart/maths/sigmoid.dart
│   │   ├── ./Dart/maths/simpson_rule.dart
│   │   ├── ./Dart/maths/sphenic_number.dart
│   │   ├── ./Dart/maths/symmetric_derivative.dart
│   │   └── ./Dart/maths/Ugly_numbers.dart
│   ├── ./Dart/other
│   │   ├── ./Dart/other/ackermann.dart
│   │   ├── ./Dart/other/binpow.dart
│   │   ├── ./Dart/other/collatz.dart
│   │   ├── ./Dart/other/fisher_yates_shuffle.dart
│   │   ├── ./Dart/other/FizzBuzz.dart
│   │   ├── ./Dart/other/gcd.dart
│   │   ├── ./Dart/other/haversine_formula.dart
│   │   ├── ./Dart/other/heaps_algorithm.dart
│   │   ├── ./Dart/other/kadaneAlgo.dart
│   │   ├── ./Dart/other/LCM.dart
│   │   ├── ./Dart/other/magic_number.dart
│   │   ├── ./Dart/other/Moore_voting_algorithm.dart
│   │   ├── ./Dart/other/N_bonacci.dart
│   │   ├── ./Dart/other/swap_all_odd_and_even_bits.dart
│   │   └── ./Dart/other/tower_of_hanoi.dart
│   ├── ./Dart/project_euler
│   │   ├── ./Dart/project_euler/problem_1
│   │   │   └── ./Dart/project_euler/problem_1/sol1.dart
│   │   ├── ./Dart/project_euler/problem_10
│   │   │   └── ./Dart/project_euler/problem_10/sol10.dart
│   │   ├── ./Dart/project_euler/problem_12
│   │   │   └── ./Dart/project_euler/problem_12/sol12.dart
│   │   ├── ./Dart/project_euler/problem_13
│   │   │   └── ./Dart/project_euler/problem_13/sol13.dart
│   │   ├── ./Dart/project_euler/problem_17
│   │   │   └── ./Dart/project_euler/problem_17/sol17.dart
│   │   ├── ./Dart/project_euler/problem_2
│   │   │   └── ./Dart/project_euler/problem_2/sol2.dart
│   │   ├── ./Dart/project_euler/problem_3
│   │   │   └── ./Dart/project_euler/problem_3/sol3.dart
│   │   ├── ./Dart/project_euler/problem_4
│   │   │   └── ./Dart/project_euler/problem_4/sol4.dart
│   │   ├── ./Dart/project_euler/problem_5
│   │   │   └── ./Dart/project_euler/problem_5/sol5.dart
│   │   ├── ./Dart/project_euler/problem_6
│   │   │   └── ./Dart/project_euler/problem_6/sol6.dart
│   │   ├── ./Dart/project_euler/problem_7
│   │   │   └── ./Dart/project_euler/problem_7/sol7.dart
│   │   ├── ./Dart/project_euler/problem_8
│   │   │   └── ./Dart/project_euler/problem_8/sol8.dart
│   │   └── ./Dart/project_euler/problem_9
│   │       └── ./Dart/project_euler/problem_9/sol9.dart
│   ├── ./Dart/pubspec.yaml
│   ├── ./Dart/README.html
│   ├── ./Dart/README.md
│   ├── ./Dart/search
│   │   ├── ./Dart/search/binary_Search.dart
│   │   ├── ./Dart/search/binary_search_recursion.dart
│   │   ├── ./Dart/search/fibonacci_Search.dart
│   │   ├── ./Dart/search/interpolation_Search.dart
│   │   ├── ./Dart/search/jump_Search.dart
│   │   ├── ./Dart/search/linear_Search.dart
│   │   ├── ./Dart/search/peak_element.dart
│   │   └── ./Dart/search/ternary_Search.dart
│   ├── ./Dart/sort
│   │   ├── ./Dart/sort/bubble_Sort.dart
│   │   ├── ./Dart/sort/cocktail_sort.dart
│   │   ├── ./Dart/sort/comb_sort.dart
│   │   ├── ./Dart/sort/gnome_Sort.dart
│   │   ├── ./Dart/sort/heap_Sort.dart
│   │   ├── ./Dart/sort/insert_Sort.dart
│   │   ├── ./Dart/sort/merge_sort.dart
│   │   ├── ./Dart/sort/pigeonhole_sort.dart
│   │   ├── ./Dart/sort/quick_Sort.dart
│   │   ├── ./Dart/sort/radix_sort.dart
│   │   ├── ./Dart/sort/select_Sort.dart
│   │   ├── ./Dart/sort/shell_Sort.dart
│   │   └── ./Dart/sort/tim_Sort.dart
│   ├── ./Dart/strings
│   │   ├── ./Dart/strings/knuth_morris_prat.dart
│   │   ├── ./Dart/strings/remove duplicates.dart
│   │   ├── ./Dart/strings/reverse_string.dart
│   │   └── ./Dart/strings/reverse_words_of_string.dart
│   └── ./Dart/tests
│       ├── ./Dart/tests/README.html
│       └── ./Dart/tests/README.md
├── ./Elixir
│   ├── ./Elixir/DIRECTORY.html
│   ├── ./Elixir/DIRECTORY.md
│   ├── ./Elixir/lib
│   │   ├── ./Elixir/lib/algorithims.ex
│   │   ├── ./Elixir/lib/codewars
│   │   │   └── ./Elixir/lib/codewars/sort_the_odd.ex
│   │   ├── ./Elixir/lib/data_structures
│   │   │   ├── ./Elixir/lib/data_structures/doubly_linked_list.ex
│   │   │   └── ./Elixir/lib/data_structures/singly_linked_list.ex
│   │   └── ./Elixir/lib/sorting
│   │       ├── ./Elixir/lib/sorting/merge_sort.ex
│   │       └── ./Elixir/lib/sorting/quick_sort.ex
│   ├── ./Elixir/mix.exs
│   ├── ./Elixir/README.html
│   ├── ./Elixir/README.md
│   └── ./Elixir/test
│       ├── ./Elixir/test/algorithims_test.exs
│       ├── ./Elixir/test/codewars
│       │   └── ./Elixir/test/codewars/sort_the_odd_test.exs
│       ├── ./Elixir/test/data_structures
│       │   ├── ./Elixir/test/data_structures/doubly_linked_list_test.exs
│       │   └── ./Elixir/test/data_structures/singly_linked_list_test.exs
│       ├── ./Elixir/test/sorting
│       │   ├── ./Elixir/test/sorting/merge_sort_test.exs
│       │   └── ./Elixir/test/sorting/quick_sort_test.exs
│       └── ./Elixir/test/test_helper.exs
├── ./Elm
│   ├── ./Elm/DIRECTORY.html
│   ├── ./Elm/DIRECTORY.md
│   ├── ./Elm/elm.json
│   ├── ./Elm/README.html
│   ├── ./Elm/README.md
│   └── ./Elm/src
│       ├── ./Elm/src/Main.elm
│       ├── ./Elm/src/Sorting
│       │   ├── ./Elm/src/Sorting/BubbleSort.elm
│       │   ├── ./Elm/src/Sorting/InsertionSort.elm
│       │   ├── ./Elm/src/Sorting/MergeSort.elm
│       │   └── ./Elm/src/Sorting/SelectionSort.elm
│       └── ./Elm/src/Util.elm
├── ./F-Sharp
│   ├── ./F-Sharp/Algorithms
│   │   ├── ./F-Sharp/Algorithms/Algorithms.fsproj
│   │   ├── ./F-Sharp/Algorithms/Math
│   │   │   ├── ./F-Sharp/Algorithms/Math/Abs.fs
│   │   │   ├── ./F-Sharp/Algorithms/Math/AbsMax.fs
│   │   │   ├── ./F-Sharp/Algorithms/Math/AbsMin.fs
│   │   │   ├── ./F-Sharp/Algorithms/Math/Factorial.fs
│   │   │   ├── ./F-Sharp/Algorithms/Math/Fibonacci.fs
│   │   │   ├── ./F-Sharp/Algorithms/Math/Perfect_Numbers.fs
│   │   │   └── ./F-Sharp/Algorithms/Math/Power.fs
│   │   ├── ./F-Sharp/Algorithms/Program.fs
│   │   ├── ./F-Sharp/Algorithms/Search
│   │   │   └── ./F-Sharp/Algorithms/Search/BinarySearch.fs
│   │   ├── ./F-Sharp/Algorithms/Sort
│   │   │   ├── ./F-Sharp/Algorithms/Sort/Bubble_Sort.fs
│   │   │   ├── ./F-Sharp/Algorithms/Sort/Comb_Sort.fs
│   │   │   ├── ./F-Sharp/Algorithms/Sort/Cycle_Sort.fs
│   │   │   ├── ./F-Sharp/Algorithms/Sort/Gnome_Sort.fs
│   │   │   ├── ./F-Sharp/Algorithms/Sort/Heap_Sort.fs
│   │   │   ├── ./F-Sharp/Algorithms/Sort/Insertion_Sort.fs
│   │   │   ├── ./F-Sharp/Algorithms/Sort/Merge_Sort.fs
│   │   │   ├── ./F-Sharp/Algorithms/Sort/Pancake_Sort.fs
│   │   │   └── ./F-Sharp/Algorithms/Sort/Quick_Sort.fs
│   │   └── ./F-Sharp/Algorithms/Strings
│   │       ├── ./F-Sharp/Algorithms/Strings/Capitalize.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/CheckAnagrams.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/CheckPangram.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/IsPalindrome.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/JaroWinkler.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/KnuthMorrisPratt.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/LevenshteinDistance.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/Lower.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/Manacher.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/MinCostStringConversion.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/NaiveStringSearch.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/PrefixFunction.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/RabinKarp.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/RemoveDuplicates.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/ReverseLetters.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/ReverseWords.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/Split.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/SwapCase.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/Upper.fs
│   │       ├── ./F-Sharp/Algorithms/Strings/WordOccurrence.fs
│   │       └── ./F-Sharp/Algorithms/Strings/ZFunction.fs
│   ├── ./F-Sharp/Algorithms.Tests
│   │   ├── ./F-Sharp/Algorithms.Tests/Algorithms.Tests.fsproj
│   │   ├── ./F-Sharp/Algorithms.Tests/Math
│   │   │   ├── ./F-Sharp/Algorithms.Tests/Math/FactorialTests.fs
│   │   │   ├── ./F-Sharp/Algorithms.Tests/Math/PerfectNumbersTests.fs
│   │   │   └── ./F-Sharp/Algorithms.Tests/Math/PowerTests.fs
│   │   ├── ./F-Sharp/Algorithms.Tests/Program.fs
│   │   └── ./F-Sharp/Algorithms.Tests/Strings
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/CapitalizeTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/CheckAnagramsTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/CheckPangramTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/IsPalindromeTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/JaroWinklerTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/KnuthMorrisPrattTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/LevenshteinDistanceTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/LowerTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/ManacherTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/MinCostStringConversionTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/NaiveStringSearchTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/PrefixFunctionTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/RabinKarpTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/RemoveDuplicatesTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/ReverseLettersTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/ReverseWordsTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/SplitTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/SwapCaseTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/UpperTests.fs
│   │       ├── ./F-Sharp/Algorithms.Tests/Strings/WordOccurrenceTests.fs
│   │       └── ./F-Sharp/Algorithms.Tests/Strings/ZFunctionTests.fs
│   ├── ./F-Sharp/DIRECTORY.html
│   ├── ./F-Sharp/DIRECTORY.md
│   ├── ./F-Sharp/F-Sharp.sln
│   ├── ./F-Sharp/README.html
│   └── ./F-Sharp/README.md
├── ./Go
│   ├── ./Go/ciphers
│   │   ├── ./Go/ciphers/caesar
│   │   │   ├── ./Go/ciphers/caesar/CaesarCipher.go
│   │   │   └── ./Go/ciphers/caesar/caesar_test.go
│   │   ├── ./Go/ciphers/diffiehelkeyexchange
│   │   │   ├── ./Go/ciphers/diffiehelkeyexchange/diffieHellmanKeyExchange.go
│   │   │   └── ./Go/ciphers/diffiehelkeyexchange/diffieHellmanKeyExchange_test.go
│   │   ├── ./Go/ciphers/polybius
│   │   │   ├── ./Go/ciphers/polybius/polybius.go
│   │   │   └── ./Go/ciphers/polybius/polybius_test.go
│   │   ├── ./Go/ciphers/rot13
│   │   │   ├── ./Go/ciphers/rot13/rot13.go
│   │   │   └── ./Go/ciphers/rot13/rot13_test.go
│   │   ├── ./Go/ciphers/rsa
│   │   │   ├── ./Go/ciphers/rsa/RSAcipher.go
│   │   │   └── ./Go/ciphers/rsa/rsa_cipher_test.go
│   │   ├── ./Go/ciphers/rsaBig
│   │   │   ├── ./Go/ciphers/rsaBig/RSAcipher(Big).go
│   │   │   └── ./Go/ciphers/rsaBig/rsa_cipher_big_test.go
│   │   └── ./Go/ciphers/xor
│   │       ├── ./Go/ciphers/xor/xorCipher.go
│   │       └── ./Go/ciphers/xor/xor_cipher_test.go
│   ├── ./Go/conversions
│   │   └── ./Go/conversions/roman-to-integer
│   │       ├── ./Go/conversions/roman-to-integer/roman_to_integer.go
│   │       └── ./Go/conversions/roman-to-integer/roman_to_integer_test.go
│   ├── ./Go/datastructures
│   │   ├── ./Go/datastructures/binary-tree
│   │   │   ├── ./Go/datastructures/binary-tree/binarysearchtree.go
│   │   │   ├── ./Go/datastructures/binary-tree/binarytree.go
│   │   │   ├── ./Go/datastructures/binary-tree/btree.go
│   │   │   └── ./Go/datastructures/binary-tree/node.go
│   │   ├── ./Go/datastructures/dynamic-array
│   │   │   └── ./Go/datastructures/dynamic-array/dynamicarray.go
│   │   ├── ./Go/datastructures/hashmap
│   │   │   ├── ./Go/datastructures/hashmap/hashmap.go
│   │   │   └── ./Go/datastructures/hashmap/hashmap_test.go
│   │   ├── ./Go/datastructures/linkedlist
│   │   │   ├── ./Go/datastructures/linkedlist/doublylinkedlist
│   │   │   └── ./Go/datastructures/linkedlist/singlylinkedlist
│   │   └── ./Go/datastructures/trie
│   │       ├── ./Go/datastructures/trie/trie.go
│   │       └── ./Go/datastructures/trie/trie_test.go
│   ├── ./Go/designpatterns
│   │   ├── ./Go/designpatterns/abstractfactory
│   │   │   ├── ./Go/designpatterns/abstractfactory/abstractfactory_test.go
│   │   │   ├── ./Go/designpatterns/abstractfactory/adidas.go
│   │   │   ├── ./Go/designpatterns/abstractfactory/adidasshirt.go
│   │   │   ├── ./Go/designpatterns/abstractfactory/adidasshoe.go
│   │   │   ├── ./Go/designpatterns/abstractfactory/ishirt.go
│   │   │   ├── ./Go/designpatterns/abstractfactory/ishoe.go
│   │   │   ├── ./Go/designpatterns/abstractfactory/isportsFactory.go
│   │   │   ├── ./Go/designpatterns/abstractfactory/nike.go
│   │   │   ├── ./Go/designpatterns/abstractfactory/nikeshirt.go
│   │   │   └── ./Go/designpatterns/abstractfactory/nikeshoe.go
│   │   ├── ./Go/designpatterns/builder
│   │   │   ├── ./Go/designpatterns/builder/builderinterface.go
│   │   │   ├── ./Go/designpatterns/builder/builderpattern_test.go
│   │   │   ├── ./Go/designpatterns/builder/director.go
│   │   │   ├── ./Go/designpatterns/builder/house.go
│   │   │   ├── ./Go/designpatterns/builder/igloobuilder.go
│   │   │   └── ./Go/designpatterns/builder/normalbuilder.go
│   │   ├── ./Go/designpatterns/factorymethod
│   │   │   ├── ./Go/designpatterns/factorymethod/accountingDepartment.go
│   │   │   ├── ./Go/designpatterns/factorymethod/departmentFactory.go
│   │   │   ├── ./Go/designpatterns/factorymethod/department.go
│   │   │   ├── ./Go/designpatterns/factorymethod/factorymethod_test.go
│   │   │   ├── ./Go/designpatterns/factorymethod/financeDepartment.go
│   │   │   └── ./Go/designpatterns/factorymethod/idepartment.go
│   │   └── ./Go/designpatterns/prototype
│   │       ├── ./Go/designpatterns/prototype/file.go
│   │       ├── ./Go/designpatterns/prototype/folder.go
│   │       ├── ./Go/designpatterns/prototype/nodeInterface.go
│   │       └── ./Go/designpatterns/prototype/prototype_test.go
│   ├── ./Go/DIRECTORY.html
│   ├── ./Go/DIRECTORY.md
│   ├── ./Go/dynamicprogramming
│   │   ├── ./Go/dynamicprogramming/binomialcoeffecient.go
│   │   ├── ./Go/dynamicprogramming/fibonacci.go
│   │   ├── ./Go/dynamicprogramming/fibonacc_test.go
│   │   ├── ./Go/dynamicprogramming/knapsack.go
│   │   ├── ./Go/dynamicprogramming/longestCommonSubsequence.go
│   │   ├── ./Go/dynamicprogramming/longest-palindromic-subsequence.go
│   │   ├── ./Go/dynamicprogramming/matrix-multiplication.go
│   │   └── ./Go/dynamicprogramming/rod-cutting.go
│   ├── ./Go/genetic-algorithm
│   │   └── ./Go/genetic-algorithm/genetic_algo.go
│   ├── ./Go/go.mod
│   ├── ./Go/go.sum
│   ├── ./Go/graphs
│   │   ├── ./Go/graphs/depthfirstsearch
│   │   │   └── ./Go/graphs/depthfirstsearch/depthfirstsearch.go
│   │   ├── ./Go/graphs/floydwarshall
│   │   │   └── ./Go/graphs/floydwarshall/floydwarshall.go
│   │   └── ./Go/graphs/search
│   │       ├── ./Go/graphs/search/breadthFirstSearch.go
│   │       └── ./Go/graphs/search/breadthFirstSearch_test.go
│   ├── ./Go/math
│   │   ├── ./Go/math/gcd
│   │   │   ├── ./Go/math/gcd/gcd.go
│   │   │   ├── ./Go/math/gcd/gcditerative.go
│   │   │   └── ./Go/math/gcd/gcd_test.go
│   │   ├── ./Go/math/lcm
│   │   │   └── ./Go/math/lcm/lcm.go
│   │   ├── ./Go/math/modulararithmetic
│   │   │   ├── ./Go/math/modulararithmetic/modularexponentiation.go
│   │   │   └── ./Go/math/modulararithmetic/modularexponentiation_test.go
│   │   ├── ./Go/math/permutation
│   │   │   ├── ./Go/math/permutation/heaps.go
│   │   │   └── ./Go/math/permutation/heaps_test.go
│   │   ├── ./Go/math/power
│   │   │   ├── ./Go/math/power/fastexponent.go
│   │   │   └── ./Go/math/power/fastexponent_test.go
│   │   ├── ./Go/math/prime
│   │   │   ├── ./Go/math/prime/millerrabinprimalitytest.go
│   │   │   ├── ./Go/math/prime/primecheck.go
│   │   │   └── ./Go/math/prime/prime_test.go
│   │   ├── ./Go/math/pythagoras
│   │   │   ├── ./Go/math/pythagoras/pythagoras.go
│   │   │   └── ./Go/math/pythagoras/pythagoras_test.go
│   │   └── ./Go/math/sieve
│   │       ├── ./Go/math/sieve/Sieve.go
│   │       └── ./Go/math/sieve/sieve_test.go
│   ├── ./Go/other
│   │   ├── ./Go/other/maxsubarraysum
│   │   │   └── ./Go/other/maxsubarraysum/maxsubarraysum.go
│   │   ├── ./Go/other/monte_carlo_pi
│   │   │   ├── ./Go/other/monte_carlo_pi/monte_carlo_pi.go
│   │   │   └── ./Go/other/monte_carlo_pi/monte_carlo_pi_test.go
│   │   ├── ./Go/other/nestedbrackets
│   │   │   └── ./Go/other/nestedbrackets/nestedbrackets.go
│   │   ├── ./Go/other/passwordgenerator
│   │   │   └── ./Go/other/passwordgenerator/passwordgenerator.go
│   │   └── ./Go/other/stringcombinations
│   │       └── ./Go/other/stringcombinations/stringcombinations.go
│   ├── ./Go/README.html
│   ├── ./Go/README.md
│   ├── ./Go/searches
│   │   ├── ./Go/searches/binarysearch.go
│   │   ├── ./Go/searches/linearsearch.go
│   │   └── ./Go/searches/search_test.go
│   ├── ./Go/sorts
│   │   ├── ./Go/sorts/bubblesort.go
│   │   ├── ./Go/sorts/heapsort.go
│   │   ├── ./Go/sorts/insertionsort.go
│   │   ├── ./Go/sorts/mergesort.go
│   │   ├── ./Go/sorts/quicksort.go
│   │   ├── ./Go/sorts/radixsort.go
│   │   ├── ./Go/sorts/selectionsort.go
│   │   ├── ./Go/sorts/shellsort.go
│   │   ├── ./Go/sorts/sorts_testcases.go
│   │   └── ./Go/sorts/sorts_test.go
│   └── ./Go/strings
│       ├── ./Go/strings/levenshteindistance
│       │   ├── ./Go/strings/levenshteindistance/levenshteinDistance.go
│       │   └── ./Go/strings/levenshteindistance/levenshteinDistance_test.go
│       ├── ./Go/strings/multiple-string-matching
│       │   ├── ./Go/strings/multiple-string-matching/advanced-aho-corasick
│       │   ├── ./Go/strings/multiple-string-matching/aho-corasick
│       │   ├── ./Go/strings/multiple-string-matching/patterns.txt
│       │   ├── ./Go/strings/multiple-string-matching/sbom
│       │   └── ./Go/strings/multiple-string-matching/text.txt
│       ├── ./Go/strings/naivesearch
│       │   ├── ./Go/strings/naivesearch/naiveStringSearch.go
│       │   └── ./Go/strings/naivesearch/naiveStringSearch_test.go
│       └── ./Go/strings/single-string-matching
│           ├── ./Go/strings/single-string-matching/bom
│           ├── ./Go/strings/single-string-matching/horspool
│           ├── ./Go/strings/single-string-matching/kmp
│           ├── ./Go/strings/single-string-matching/pattern.txt
│           └── ./Go/strings/single-string-matching/text.txt
├── ./Haskell
│   ├── ./Haskell/DIRECTORY.html
│   ├── ./Haskell/DIRECTORY.md
│   ├── ./Haskell/package.yaml
│   ├── ./Haskell/README.html
│   ├── ./Haskell/README.md
│   ├── ./Haskell/Setup.hs
│   ├── ./Haskell/specs
│   │   ├── ./Haskell/specs/SortSpecs
│   │   │   ├── ./Haskell/specs/SortSpecs/BubbleSortSpec.hs
│   │   │   ├── ./Haskell/specs/SortSpecs/HeapSortSpec.hs
│   │   │   ├── ./Haskell/specs/SortSpecs/InsertionSortSpec.hs
│   │   │   ├── ./Haskell/specs/SortSpecs/MergeSortSpec.hs
│   │   │   ├── ./Haskell/specs/SortSpecs/QuickSortSpec.hs
│   │   │   ├── ./Haskell/specs/SortSpecs/SelectionSortSpec.hs
│   │   │   └── ./Haskell/specs/SortSpecs/ShellSortSpec.hs
│   │   └── ./Haskell/specs/Spec.hs
│   ├── ./Haskell/src
│   │   ├── ./Haskell/src/BinaryTree
│   │   │   ├── ./Haskell/src/BinaryTree/BinarySearchTree.hs
│   │   │   └── ./Haskell/src/BinaryTree/BinaryTree.hs
│   │   ├── ./Haskell/src/DataStructures
│   │   │   └── ./Haskell/src/DataStructures/MaxHeap.hs
│   │   ├── ./Haskell/src/Graph
│   │   │   ├── ./Haskell/src/Graph/Dfs.hs
│   │   │   └── ./Haskell/src/Graph/DirectedGraph.hs
│   │   ├── ./Haskell/src/HaskellAlgorithms.hs
│   │   ├── ./Haskell/src/Maths
│   │   │   ├── ./Haskell/src/Maths/Factorial.hs
│   │   │   ├── ./Haskell/src/Maths/Fibonacci.hs
│   │   │   ├── ./Haskell/src/Maths/GraphDist.hs
│   │   │   ├── ./Haskell/src/Maths/KadaneAlgorithm.hs
│   │   │   └── ./Haskell/src/Maths/Palindrome.hs
│   │   ├── ./Haskell/src/Misc
│   │   │   ├── ./Haskell/src/Misc/BinarySearch.hs
│   │   │   ├── ./Haskell/src/Misc/NQueens.hs
│   │   │   ├── ./Haskell/src/Misc/Powerset.hs
│   │   │   └── ./Haskell/src/Misc/TowersOfHanoi.hs
│   │   ├── ./Haskell/src/ProjectEuler
│   │   │   ├── ./Haskell/src/ProjectEuler/Problem1
│   │   │   ├── ./Haskell/src/ProjectEuler/Problem2
│   │   │   ├── ./Haskell/src/ProjectEuler/Problem3
│   │   │   ├── ./Haskell/src/ProjectEuler/Problem4
│   │   │   ├── ./Haskell/src/ProjectEuler/Problem5
│   │   │   ├── ./Haskell/src/ProjectEuler/Problem6
│   │   │   └── ./Haskell/src/ProjectEuler/Problem7
│   │   ├── ./Haskell/src/Robotics
│   │   │   └── ./Haskell/src/Robotics/ComplementaryFilter
│   │   ├── ./Haskell/src/Sorts
│   │   │   ├── ./Haskell/src/Sorts/BubbleSort.hs
│   │   │   ├── ./Haskell/src/Sorts/HeapSort.hs
│   │   │   ├── ./Haskell/src/Sorts/InsertionSort.hs
│   │   │   ├── ./Haskell/src/Sorts/MergeSort.hs
│   │   │   ├── ./Haskell/src/Sorts/QuickSort.hs
│   │   │   ├── ./Haskell/src/Sorts/SelectionSort.hs
│   │   │   └── ./Haskell/src/Sorts/ShellSort.hs
│   │   ├── ./Haskell/src/SpecializedStructure
│   │   │   └── ./Haskell/src/SpecializedStructure/MergeFindSet.hs
│   │   └── ./Haskell/src/Statistics
│   │       ├── ./Haskell/src/Statistics/Center.hs
│   │       └── ./Haskell/src/Statistics/Dispersion.hs
│   ├── ./Haskell/stack.yaml
│   └── ./Haskell/stack.yaml.lock
├── ./Java
│   ├── ./Java/ciphers
│   │   ├── ./Java/ciphers/AESEncryption.java
│   │   ├── ./Java/ciphers/AES.java
│   │   ├── ./Java/ciphers/Caesar.java
│   │   ├── ./Java/ciphers/ColumnarTranspositionCipher.java
│   │   ├── ./Java/ciphers/RSA.java
│   │   ├── ./Java/ciphers/SimpleSubstitutionCipher.java
│   │   └── ./Java/ciphers/Vigenere.java
│   ├── ./Java/Conversions
│   │   ├── ./Java/Conversions/AnyBaseToAnyBase.java
│   │   ├── ./Java/Conversions/AnyBaseToDecimal.java
│   │   ├── ./Java/Conversions/AnytoAny.java
│   │   ├── ./Java/Conversions/BinaryToDecimal.java
│   │   ├── ./Java/Conversions/BinaryToHexadecimal.java
│   │   ├── ./Java/Conversions/BinaryToOctal.java
│   │   ├── ./Java/Conversions/DecimalToAnyBase.java
│   │   ├── ./Java/Conversions/DecimalToBinary.java
│   │   ├── ./Java/Conversions/DecimalToHexaDecimal.java
│   │   ├── ./Java/Conversions/DecimalToOctal.java
│   │   ├── ./Java/Conversions/HexaDecimalToBinary.java
│   │   ├── ./Java/Conversions/HexaDecimalToDecimal.java
│   │   ├── ./Java/Conversions/HexToOct.java
│   │   ├── ./Java/Conversions/IntegerToRoman.java
│   │   ├── ./Java/Conversions/OctalToDecimal.java
│   │   ├── ./Java/Conversions/OctalToHexadecimal.java
│   │   ├── ./Java/Conversions/RgbHsvConversion.java
│   │   └── ./Java/Conversions/RomanToInteger.java
│   ├── ./Java/DataStructures
│   │   ├── ./Java/DataStructures/Bags
│   │   │   └── ./Java/DataStructures/Bags/Bag.java
│   │   ├── ./Java/DataStructures/Buffers
│   │   │   └── ./Java/DataStructures/Buffers/CircularBuffer.java
│   │   ├── ./Java/DataStructures/DynamicArray
│   │   │   └── ./Java/DataStructures/DynamicArray/DynamicArray.java
│   │   ├── ./Java/DataStructures/Graphs
│   │   │   ├── ./Java/DataStructures/Graphs/A_Star.java
│   │   │   ├── ./Java/DataStructures/Graphs/BellmanFord.java
│   │   │   ├── ./Java/DataStructures/Graphs/ConnectedComponent.java
│   │   │   ├── ./Java/DataStructures/Graphs/Cycles.java
│   │   │   ├── ./Java/DataStructures/Graphs/FloydWarshall.java
│   │   │   ├── ./Java/DataStructures/Graphs/Graphs.java
│   │   │   ├── ./Java/DataStructures/Graphs/Kruskal.java
│   │   │   ├── ./Java/DataStructures/Graphs/MatrixGraphs.java
│   │   │   └── ./Java/DataStructures/Graphs/PrimMST.java
│   │   ├── ./Java/DataStructures/HashMap
│   │   │   └── ./Java/DataStructures/HashMap/Hashing
│   │   ├── ./Java/DataStructures/Heaps
│   │   │   ├── ./Java/DataStructures/Heaps/EmptyHeapException.java
│   │   │   ├── ./Java/DataStructures/Heaps/GenericHeap
│   │   │   ├── ./Java/DataStructures/Heaps/HeapElement.java
│   │   │   ├── ./Java/DataStructures/Heaps/Heap.java
│   │   │   ├── ./Java/DataStructures/Heaps/MaxHeap.java
│   │   │   ├── ./Java/DataStructures/Heaps/MinHeap.java
│   │   │   └── ./Java/DataStructures/Heaps/MinPriorityQueue.java
│   │   ├── ./Java/DataStructures/Lists
│   │   │   ├── ./Java/DataStructures/Lists/CircleLinkedList.java
│   │   │   ├── ./Java/DataStructures/Lists/CountSinglyLinkedListRecursion.java
│   │   │   ├── ./Java/DataStructures/Lists/CursorLinkedList.java
│   │   │   ├── ./Java/DataStructures/Lists/DoublyLinkedList.java
│   │   │   ├── ./Java/DataStructures/Lists/Merge_K_SortedLinkedlist.java
│   │   │   ├── ./Java/DataStructures/Lists/MergeSortedArrayList.java
│   │   │   ├── ./Java/DataStructures/Lists/MergeSortedSinglyLinkedList.java
│   │   │   ├── ./Java/DataStructures/Lists/SearchSinglyLinkedListRecursion.java
│   │   │   └── ./Java/DataStructures/Lists/SinglyLinkedList.java
│   │   ├── ./Java/DataStructures/Queues
│   │   │   ├── ./Java/DataStructures/Queues/GenericArrayListQueue.java
│   │   │   ├── ./Java/DataStructures/Queues/LinkedQueue.java
│   │   │   ├── ./Java/DataStructures/Queues/PriorityQueues.java
│   │   │   └── ./Java/DataStructures/Queues/Queues.java
│   │   ├── ./Java/DataStructures/Stacks
│   │   │   ├── ./Java/DataStructures/Stacks/BalancedBrackets.java
│   │   │   ├── ./Java/DataStructures/Stacks/DecimalToAnyUsingStack.java
│   │   │   ├── ./Java/DataStructures/Stacks/InfixToPostfix.java
│   │   │   ├── ./Java/DataStructures/Stacks/NodeStack.java
│   │   │   ├── ./Java/DataStructures/Stacks/StackArray.java
│   │   │   ├── ./Java/DataStructures/Stacks/StackArrayList.java
│   │   │   └── ./Java/DataStructures/Stacks/StackOfLinkedList.java
│   │   └── ./Java/DataStructures/Trees
│   │       ├── ./Java/DataStructures/Trees/AVLSimple
│   │       ├── ./Java/DataStructures/Trees/AVLTree.java
│   │       ├── ./Java/DataStructures/Trees/BinaryTree.java
│   │       ├── ./Java/DataStructures/Trees/BSTIterative.java
│   │       ├── ./Java/DataStructures/Trees/BSTRecursive.java
│   │       ├── ./Java/DataStructures/Trees/GenericTree.java
│   │       ├── ./Java/DataStructures/Trees/LevelOrderTraversal.java
│   │       ├── ./Java/DataStructures/Trees/LevelOrderTraversalQueue.java
│   │       ├── ./Java/DataStructures/Trees/PrintTopViewofTree.java
│   │       ├── ./Java/DataStructures/Trees/RedBlackBST.java
│   │       ├── ./Java/DataStructures/Trees/TreeTraversal.java
│   │       ├── ./Java/DataStructures/Trees/TrieImp.java
│   │       └── ./Java/DataStructures/Trees/ValidBSTOrNot.java
│   ├── ./Java/DIRECTORY.html
│   ├── ./Java/DIRECTORY.md
│   ├── ./Java/divideconquer
│   │   ├── ./Java/divideconquer/ClosestPair.java
│   │   └── ./Java/divideconquer/SkylineAlgorithm.java
│   ├── ./Java/DynamicProgramming
│   │   ├── ./Java/DynamicProgramming/BoardPath.java
│   │   ├── ./Java/DynamicProgramming/CoinChange.java
│   │   ├── ./Java/DynamicProgramming/EditDistance.java
│   │   ├── ./Java/DynamicProgramming/EggDropping.java
│   │   ├── ./Java/DynamicProgramming/Fibonacci.java
│   │   ├── ./Java/DynamicProgramming/FordFulkerson.java
│   │   ├── ./Java/DynamicProgramming/KadaneAlgorithm.java
│   │   ├── ./Java/DynamicProgramming/Knapsack.java
│   │   ├── ./Java/DynamicProgramming/LevenshteinDistance.java
│   │   ├── ./Java/DynamicProgramming/LongestCommonSubsequence.java
│   │   ├── ./Java/DynamicProgramming/LongestIncreasingSubsequence.java
│   │   ├── ./Java/DynamicProgramming/LongestPalindromicSubsequence.java
│   │   ├── ./Java/DynamicProgramming/LongestValidParentheses.java
│   │   ├── ./Java/DynamicProgramming/MatrixChainMultiplication.java
│   │   ├── ./Java/DynamicProgramming/MinimumPathSum.java
│   │   ├── ./Java/DynamicProgramming/MinimumSumPartition.java
│   │   ├── ./Java/DynamicProgramming/RodCutting.java
│   │   └── ./Java/DynamicProgramming/SubsetSum.java
│   ├── ./Java/Maths
│   │   ├── ./Java/Maths/AbsoluteMax.java
│   │   ├── ./Java/Maths/AbsoluteMin.java
│   │   ├── ./Java/Maths/AbsoluteValue.java
│   │   ├── ./Java/Maths/AliquotSum.java
│   │   ├── ./Java/Maths/AmicableNumber.java
│   │   ├── ./Java/Maths/Area.java
│   │   ├── ./Java/Maths/Armstrong.java
│   │   ├── ./Java/Maths/Average.java
│   │   ├── ./Java/Maths/BinaryPow.java
│   │   ├── ./Java/Maths/Ceil.java
│   │   ├── ./Java/Maths/CircularConvolutionFFT.java
│   │   ├── ./Java/Maths/Combinations.java
│   │   ├── ./Java/Maths/ConvolutionFFT.java
│   │   ├── ./Java/Maths/Convolution.java
│   │   ├── ./Java/Maths/EulerMethod.java
│   │   ├── ./Java/Maths/Factorial.java
│   │   ├── ./Java/Maths/FactorialRecursion.java
│   │   ├── ./Java/Maths/FFTBluestein.java
│   │   ├── ./Java/Maths/FFT.java
│   │   ├── ./Java/Maths/FibonacciNumber.java
│   │   ├── ./Java/Maths/FindMax.java
│   │   ├── ./Java/Maths/FindMaxRecursion.java
│   │   ├── ./Java/Maths/FindMin.java
│   │   ├── ./Java/Maths/FindMinRecursion.java
│   │   ├── ./Java/Maths/Floor.java
│   │   ├── ./Java/Maths/GCD.java
│   │   ├── ./Java/Maths/GCDRecursion.java
│   │   ├── ./Java/Maths/LucasSeries.java
│   │   ├── ./Java/Maths/MaxValue.java
│   │   ├── ./Java/Maths/Median.java
│   │   ├── ./Java/Maths/MinValue.java
│   │   ├── ./Java/Maths/Mode.java
│   │   ├── ./Java/Maths/NumberOfDigits.java
│   │   ├── ./Java/Maths/PalindromeNumber.java
│   │   ├── ./Java/Maths/ParseInteger.java
│   │   ├── ./Java/Maths/PerfectCube.java
│   │   ├── ./Java/Maths/PerfectNumber.java
│   │   ├── ./Java/Maths/PerfectSquare.java
│   │   ├── ./Java/Maths/PowerOfTwoOrNot.java
│   │   ├── ./Java/Maths/Pow.java
│   │   ├── ./Java/Maths/PowRecursion.java
│   │   ├── ./Java/Maths/PrimeCheck.java
│   │   ├── ./Java/Maths/PrimeFactorization.java
│   │   ├── ./Java/Maths/PythagoreanTriple.java
│   │   ├── ./Java/Maths/SumOfArithmeticSeries.java
│   │   ├── ./Java/Maths/SumOfDigits.java
│   │   └── ./Java/Maths/VampireNumber.java
│   ├── ./Java/MinimizingLateness
│   │   ├── ./Java/MinimizingLateness/lateness_data.txt
│   │   └── ./Java/MinimizingLateness/MinimizingLateness.java
│   ├── ./Java/Misc
│   │   ├── ./Java/Misc/ColorContrastRatio.java
│   │   ├── ./Java/Misc/MedianOfRunningArray.java
│   │   ├── ./Java/Misc/PalindromePrime.java
│   │   ├── ./Java/Misc/RangeInSortedArray.java
│   │   └── ./Java/Misc/WordBoggle.java
│   ├── ./Java/Others
│   │   ├── ./Java/Others/BestFit.java
│   │   ├── ./Java/Others/BrianKernighanAlgorithm.java
│   │   ├── ./Java/Others/CountChar.java
│   │   ├── ./Java/Others/CountWords.java
│   │   ├── ./Java/Others/CRC32.java
│   │   ├── ./Java/Others/CRCAlgorithm.java
│   │   ├── ./Java/Others/Dijkstra.java
│   │   ├── ./Java/Others/EulersFunction.java
│   │   ├── ./Java/Others/FibToN.java
│   │   ├── ./Java/Others/FirstFit.java
│   │   ├── ./Java/Others/FloydTriangle.java
│   │   ├── ./Java/Others/GuassLegendre.java
│   │   ├── ./Java/Others/InsertDeleteInArray.java
│   │   ├── ./Java/Others/KMP.java
│   │   ├── ./Java/Others/KochSnowflake.java
│   │   ├── ./Java/Others/Krishnamurthy.java
│   │   ├── ./Java/Others/LinearCongruentialGenerator.java
│   │   ├── ./Java/Others/LowestBasePalindrome.java
│   │   ├── ./Java/Others/Mandelbrot.java
│   │   ├── ./Java/Others/PasswordGen.java
│   │   ├── ./Java/Others/PerlinNoise.java
│   │   ├── ./Java/Others/QueueUsingTwoStacks.java
│   │   ├── ./Java/Others/RabinKarp.java
│   │   ├── ./Java/Others/RemoveDuplicateFromString.java
│   │   ├── ./Java/Others/RestrictedTowerOfHanoi
│   │   │   ├── ./Java/Others/RestrictedTowerOfHanoi/Main
│   │   │   ├── ./Java/Others/RestrictedTowerOfHanoi/Resources
│   │   │   └── ./Java/Others/RestrictedTowerOfHanoi/Screenshots
│   │   ├── ./Java/Others/ReturnSubsequence.java
│   │   ├── ./Java/Others/ReverseStackUsingRecursion.java
│   │   ├── ./Java/Others/RootPrecision.java
│   │   ├── ./Java/Others/SieveOfEratosthenes.java
│   │   ├── ./Java/Others/SJF.java
│   │   ├── ./Java/Others/SkylineProblem.java
│   │   ├── ./Java/Others/StackPostfixNotation.java
│   │   ├── ./Java/Others/StringMatchFiniteAutomata.java
│   │   ├── ./Java/Others/ThreeSum.java
│   │   ├── ./Java/Others/TopKWords.java
│   │   ├── ./Java/Others/TowerOfHanoi.java
│   │   ├── ./Java/Others/TwoPointers.java
│   │   └── ./Java/Others/WorstFit.java
│   ├── ./Java/ProjectEuler
│   │   ├── ./Java/ProjectEuler/Problem01.java
│   │   ├── ./Java/ProjectEuler/Problem02.java
│   │   ├── ./Java/ProjectEuler/Problem03.java
│   │   ├── ./Java/ProjectEuler/Problem04.java
│   │   ├── ./Java/ProjectEuler/Problem06.java
│   │   ├── ./Java/ProjectEuler/Problem07.java
│   │   ├── ./Java/ProjectEuler/Problem09.java
│   │   ├── ./Java/ProjectEuler/Problem10.java
│   │   └── ./Java/ProjectEuler/Problem12.java
│   ├── ./Java/README.html
│   ├── ./Java/README-ko.html
│   ├── ./Java/README-ko.md
│   ├── ./Java/README.md
│   ├── ./Java/REVIEWER.html
│   ├── ./Java/REVIEWER.md
│   ├── ./Java/Searches
│   │   ├── ./Java/Searches/BinarySearch.java
│   │   ├── ./Java/Searches/InterpolationSearch.java
│   │   ├── ./Java/Searches/IterativeBinarySearch.java
│   │   ├── ./Java/Searches/IterativeTernarySearch.java
│   │   ├── ./Java/Searches/JumpSearch.java
│   │   ├── ./Java/Searches/LinearSearch.java
│   │   ├── ./Java/Searches/PerfectBinarySearch.java
│   │   ├── ./Java/Searches/SaddlebackSearch.java
│   │   ├── ./Java/Searches/SearchAlgorithm.java
│   │   └── ./Java/Searches/TernarySearch.java
│   ├── ./Java/Sorts
│   │   ├── ./Java/Sorts/BitonicSort.java
│   │   ├── ./Java/Sorts/BogoSort.java
│   │   ├── ./Java/Sorts/BubbleSort.java
│   │   ├── ./Java/Sorts/BubbleSortRecursion.java
│   │   ├── ./Java/Sorts/BucketSort.java
│   │   ├── ./Java/Sorts/CocktailShakerSort.java
│   │   ├── ./Java/Sorts/CombSort.java
│   │   ├── ./Java/Sorts/CountingSort.java
│   │   ├── ./Java/Sorts/CycleSort.java
│   │   ├── ./Java/Sorts/GnomeSort.java
│   │   ├── ./Java/Sorts/HeapSort.java
│   │   ├── ./Java/Sorts/InsertionSort.java
│   │   ├── ./Java/Sorts/MergeSort.java
│   │   ├── ./Java/Sorts/PancakeSort.java
│   │   ├── ./Java/Sorts/QuickSort.java
│   │   ├── ./Java/Sorts/RadixSort.java
│   │   ├── ./Java/Sorts/SelectionSort.java
│   │   ├── ./Java/Sorts/ShellSort.java
│   │   ├── ./Java/Sorts/SortAlgorithm.java
│   │   ├── ./Java/Sorts/SortUtils.java
│   │   └── ./Java/Sorts/TimSort.java
│   └── ./Java/strings
│       ├── ./Java/strings/Alphabetical.java
│       ├── ./Java/strings/CharactersSame.java
│       ├── ./Java/strings/CheckAnagrams.java
│       ├── ./Java/strings/HorspoolSearch.java
│       ├── ./Java/strings/Lower.java
│       ├── ./Java/strings/Palindrome.java
│       ├── ./Java/strings/Pangram.java
│       ├── ./Java/strings/ReverseString.java
│       ├── ./Java/strings/Rotation.java
│       └── ./Java/strings/Upper.java
├── ./Javascript
│   ├── ./Javascript/babel.config.js
│   ├── ./Javascript/Backtracking
│   │   ├── ./Javascript/Backtracking/KnightTour.js
│   │   ├── ./Javascript/Backtracking/NQueen.js
│   │   ├── ./Javascript/Backtracking/Sudoku.js
│   │   └── ./Javascript/Backtracking/tests
│   │       └── ./Javascript/Backtracking/tests/NQueen.test.js
│   ├── ./Javascript/Bit-Manipulation
│   │   ├── ./Javascript/Bit-Manipulation/BinaryCountSetBits.js
│   │   ├── ./Javascript/Bit-Manipulation/SetBit.js
│   │   └── ./Javascript/Bit-Manipulation/test
│   │       └── ./Javascript/Bit-Manipulation/test/SetBit.test.js
│   ├── ./Javascript/Cache
│   │   ├── ./Javascript/Cache/LFUCache.js
│   │   └── ./Javascript/Cache/LRUCache.js
│   ├── ./Javascript/Cellular-Automata
│   │   └── ./Javascript/Cellular-Automata/ConwaysGameOfLife.js
│   ├── ./Javascript/Ciphers
│   │   ├── ./Javascript/Ciphers/Atbash.js
│   │   ├── ./Javascript/Ciphers/CaesarsCipher.js
│   │   ├── ./Javascript/Ciphers/KeyFinder.js
│   │   ├── ./Javascript/Ciphers/KeywordShiftedAlphabet.js
│   │   ├── ./Javascript/Ciphers/ROT13.js
│   │   ├── ./Javascript/Ciphers/VigenereCipher.js
│   │   └── ./Javascript/Ciphers/XORCipher.js
│   ├── ./Javascript/Conversions
│   │   ├── ./Javascript/Conversions/ArbitraryBase.js
│   │   ├── ./Javascript/Conversions/BinaryToDecimal.js
│   │   ├── ./Javascript/Conversions/DecimalToBinary.js
│   │   ├── ./Javascript/Conversions/DecimalToHex.js
│   │   ├── ./Javascript/Conversions/DecimalToOctal.js
│   │   ├── ./Javascript/Conversions/HexToDecimal.js
│   │   ├── ./Javascript/Conversions/HexToRGB.js
│   │   ├── ./Javascript/Conversions/OctToDecimal.js
│   │   ├── ./Javascript/Conversions/RgbHsvConversion.js
│   │   ├── ./Javascript/Conversions/RGBToHex.js
│   │   └── ./Javascript/Conversions/RomanToDecimal.js
│   ├── ./Javascript/Data-Structures
│   │   ├── ./Javascript/Data-Structures/Array
│   │   │   └── ./Javascript/Data-Structures/Array/QuickSelect.js
│   │   ├── ./Javascript/Data-Structures/Graph
│   │   │   ├── ./Javascript/Data-Structures/Graph/Graph2.js
│   │   │   └── ./Javascript/Data-Structures/Graph/Graph.js
│   │   ├── ./Javascript/Data-Structures/Heap
│   │   │   ├── ./Javascript/Data-Structures/Heap/MaxHeap.js
│   │   │   └── ./Javascript/Data-Structures/Heap/MinPriorityQueue.js
│   │   ├── ./Javascript/Data-Structures/Linked-List
│   │   │   ├── ./Javascript/Data-Structures/Linked-List/CycleDetection.js
│   │   │   ├── ./Javascript/Data-Structures/Linked-List/DoublyLinkedList.js
│   │   │   ├── ./Javascript/Data-Structures/Linked-List/RotateListRight.js
│   │   │   ├── ./Javascript/Data-Structures/Linked-List/SingleCircularLinkedList.js.js
│   │   │   └── ./Javascript/Data-Structures/Linked-List/SinglyLinkList.js
│   │   ├── ./Javascript/Data-Structures/Queue
│   │   │   ├── ./Javascript/Data-Structures/Queue/CircularQueue.js
│   │   │   ├── ./Javascript/Data-Structures/Queue/Queue.js
│   │   │   └── ./Javascript/Data-Structures/Queue/QueueUsing2Stacks.js
│   │   ├── ./Javascript/Data-Structures/Stack
│   │   │   ├── ./Javascript/Data-Structures/Stack/StackES6.js
│   │   │   └── ./Javascript/Data-Structures/Stack/Stack.js
│   │   ├── ./Javascript/Data-Structures/Tree
│   │   │   ├── ./Javascript/Data-Structures/Tree/AVLTree.js
│   │   │   ├── ./Javascript/Data-Structures/Tree/BinarySearchTree.js
│   │   │   └── ./Javascript/Data-Structures/Tree/Trie.js
│   │   └── ./Javascript/Data-Structures/Vectors
│   │       └── ./Javascript/Data-Structures/Vectors/Vector2.js
│   ├── ./Javascript/DIRECTORY.html
│   ├── ./Javascript/DIRECTORY.md
│   ├── ./Javascript/Dynamic-Programming
│   │   ├── ./Javascript/Dynamic-Programming/ClimbingStairs.js
│   │   ├── ./Javascript/Dynamic-Programming/CoinChange.js
│   │   ├── ./Javascript/Dynamic-Programming/EditDistance.js
│   │   ├── ./Javascript/Dynamic-Programming/FibonacciNumber.js
│   │   ├── ./Javascript/Dynamic-Programming/FindMonthCalendar.js
│   │   ├── ./Javascript/Dynamic-Programming/KadaneAlgo.js
│   │   ├── ./Javascript/Dynamic-Programming/LevenshteinDistance.js
│   │   ├── ./Javascript/Dynamic-Programming/LongestCommonSubsequence.js
│   │   ├── ./Javascript/Dynamic-Programming/LongestIncreasingSubsequence.js
│   │   ├── ./Javascript/Dynamic-Programming/LongestPalindromicSubsequence.js
│   │   ├── ./Javascript/Dynamic-Programming/LongestValidParentheses.js
│   │   ├── ./Javascript/Dynamic-Programming/MaxNonAdjacentSum.js
│   │   ├── ./Javascript/Dynamic-Programming/MinimumCostPath.js
│   │   ├── ./Javascript/Dynamic-Programming/NumberOfSubsetEqualToGivenSum.js
│   │   ├── ./Javascript/Dynamic-Programming/Shuf.js
│   │   ├── ./Javascript/Dynamic-Programming/SieveOfEratosthenes.js
│   │   ├── ./Javascript/Dynamic-Programming/SudokuSolver.js
│   │   ├── ./Javascript/Dynamic-Programming/TrappingRainWater.js
│   │   └── ./Javascript/Dynamic-Programming/ZeroOneKnapsack.js
│   ├── ./Javascript/Geometry
│   │   └── ./Javascript/Geometry/ConvexHullGraham.js
│   ├── ./Javascript/Graphs
│   │   ├── ./Javascript/Graphs/BreadthFirstSearch.js
│   │   ├── ./Javascript/Graphs/BreadthFirstShortestPath.js
│   │   ├── ./Javascript/Graphs/ConnectedComponents.js
│   │   ├── ./Javascript/Graphs/Density.js
│   │   ├── ./Javascript/Graphs/DepthFirstSearchIterative.js
│   │   ├── ./Javascript/Graphs/DepthFirstSearchRecursive.js
│   │   ├── ./Javascript/Graphs/Dijkstra.js
│   │   ├── ./Javascript/Graphs/DijkstraSmallestPath.js
│   │   ├── ./Javascript/Graphs/FloydWarshall.js
│   │   ├── ./Javascript/Graphs/KruskalMST.js
│   │   ├── ./Javascript/Graphs/NodeNeighbors.js
│   │   ├── ./Javascript/Graphs/NumberOfIslands.js
│   │   └── ./Javascript/Graphs/PrimMST.js
│   ├── ./Javascript/Hashes
│   │   ├── ./Javascript/Hashes/SHA1.js
│   │   └── ./Javascript/Hashes/SHA256.js
│   ├── ./Javascript/Linear-Algebra
│   │   ├── ./Javascript/Linear-Algebra/package.json
│   │   ├── ./Javascript/Linear-Algebra/package-lock.json
│   │   ├── ./Javascript/Linear-Algebra/README.html
│   │   ├── ./Javascript/Linear-Algebra/README.md
│   │   ├── ./Javascript/Linear-Algebra/src
│   │   │   └── ./Javascript/Linear-Algebra/src/la_lib.js
│   │   └── ./Javascript/Linear-Algebra/test
│   │       └── ./Javascript/Linear-Algebra/test/test.js
│   ├── ./Javascript/Maths
│   │   ├── ./Javascript/Maths/Abs.js
│   │   ├── ./Javascript/Maths/Area.js
│   │   ├── ./Javascript/Maths/ArmstrongNumber.js
│   │   ├── ./Javascript/Maths/AverageMean.js
│   │   ├── ./Javascript/Maths/AverageMedian.js
│   │   ├── ./Javascript/Maths/BinaryConvert.js
│   │   ├── ./Javascript/Maths/BinaryExponentiationIterative.js
│   │   ├── ./Javascript/Maths/BinaryExponentiationRecursive.js
│   │   ├── ./Javascript/Maths/Coordinate.js
│   │   ├── ./Javascript/Maths/decimalIsolate.js
│   │   ├── ./Javascript/Maths/DegreeToRadian.js
│   │   ├── ./Javascript/Maths/DigitSum.js
│   │   ├── ./Javascript/Maths/EulerMethod.js
│   │   ├── ./Javascript/Maths/EulersTotientFunction.js
│   │   ├── ./Javascript/Maths/EulersTotient.js
│   │   ├── ./Javascript/Maths/Factorial.js
│   │   ├── ./Javascript/Maths/Factors.js
│   │   ├── ./Javascript/Maths/FareyApproximation.js
│   │   ├── ./Javascript/Maths/Fibonacci.js
│   │   ├── ./Javascript/Maths/FindHcf.js
│   │   ├── ./Javascript/Maths/FindLcm.js
│   │   ├── ./Javascript/Maths/GridGet.js
│   │   ├── ./Javascript/Maths/IsDivisible.js
│   │   ├── ./Javascript/Maths/IsEven.js
│   │   ├── ./Javascript/Maths/isOdd.js
│   │   ├── ./Javascript/Maths/Mandelbrot.js
│   │   ├── ./Javascript/Maths/MatrixExponentiationRecursive.js
│   │   ├── ./Javascript/Maths/MatrixMultiplication.js
│   │   ├── ./Javascript/Maths/MeanSquareError.js
│   │   ├── ./Javascript/Maths/ModularBinaryExponentiationRecursive.js
│   │   ├── ./Javascript/Maths/NumberOfDigits.js
│   │   ├── ./Javascript/Maths/Palindrome.js
│   │   ├── ./Javascript/Maths/PascalTriangle.js
│   │   ├── ./Javascript/Maths/PerfectCube.js
│   │   ├── ./Javascript/Maths/PerfectNumber.js
│   │   ├── ./Javascript/Maths/PerfectSquare.js
│   │   ├── ./Javascript/Maths/PermutationAndCombination.js
│   │   ├── ./Javascript/Maths/PiApproximationMonteCarlo.js
│   │   ├── ./Javascript/Maths/Polynomial.js
│   │   ├── ./Javascript/Maths/Pow.js
│   │   ├── ./Javascript/Maths/PrimeCheck.js
│   │   ├── ./Javascript/Maths/PrimeFactors.js
│   │   ├── ./Javascript/Maths/RadianToDegree.js
│   │   ├── ./Javascript/Maths/ReversePolishNotation.js
│   │   ├── ./Javascript/Maths/SieveOfEratosthenes.js
│   │   ├── ./Javascript/Maths/Softmax.js
│   │   ├── ./Javascript/Maths/SquareRoot.js
│   │   ├── ./Javascript/Maths/test
│   │   │   ├── ./Javascript/Maths/test/Abs.test.js
│   │   │   ├── ./Javascript/Maths/test/Area.test.js
│   │   │   ├── ./Javascript/Maths/test/ArmstrongNumber.test.js
│   │   │   ├── ./Javascript/Maths/test/AverageMean.test.js
│   │   │   ├── ./Javascript/Maths/test/AverageMedian.test.js
│   │   │   ├── ./Javascript/Maths/test/BInaryConvert.test.js
│   │   │   ├── ./Javascript/Maths/test/BinaryExponentiationIterative.test.js
│   │   │   ├── ./Javascript/Maths/test/Coordinate.test.js
│   │   │   ├── ./Javascript/Maths/test/DegreeToRadian.test.js
│   │   │   ├── ./Javascript/Maths/test/DigitSum.test.js
│   │   │   ├── ./Javascript/Maths/test/EulersTotientFunction.test.js
│   │   │   ├── ./Javascript/Maths/test/Factorial.test.js
│   │   │   ├── ./Javascript/Maths/test/Factors.test.js
│   │   │   ├── ./Javascript/Maths/test/FareyApproximation.test.js
│   │   │   ├── ./Javascript/Maths/test/Fibonacci.test.js
│   │   │   ├── ./Javascript/Maths/test/FindHcf.test.js
│   │   │   ├── ./Javascript/Maths/test/FindLcm.test.js
│   │   │   ├── ./Javascript/Maths/test/GridGet.test.js
│   │   │   ├── ./Javascript/Maths/test/IsDivisible.test.js
│   │   │   ├── ./Javascript/Maths/test/IsEven.test.js
│   │   │   ├── ./Javascript/Maths/test/MeanSquareError.test.js
│   │   │   ├── ./Javascript/Maths/test/ModularBinaryExponentiationRecursive.test.js
│   │   │   ├── ./Javascript/Maths/test/NumberOfDigits.test.js
│   │   │   ├── ./Javascript/Maths/test/Palindrome.test.js
│   │   │   ├── ./Javascript/Maths/test/PascalTriangle.test.js
│   │   │   ├── ./Javascript/Maths/test/PerfectCube.test.js
│   │   │   ├── ./Javascript/Maths/test/PerfectNumber.test.js
│   │   │   ├── ./Javascript/Maths/test/PerfectSquare.test.js
│   │   │   ├── ./Javascript/Maths/test/PiApproximationMonteCarlo.test.js
│   │   │   ├── ./Javascript/Maths/test/Polynomial.test.js
│   │   │   ├── ./Javascript/Maths/test/Pow.test.js
│   │   │   ├── ./Javascript/Maths/test/PrimeCheck.test.js
│   │   │   ├── ./Javascript/Maths/test/RadianToDegree.test.js
│   │   │   ├── ./Javascript/Maths/test/ReversePolishNotation.test.js
│   │   │   ├── ./Javascript/Maths/test/SieveOfEratosthenes.test.js
│   │   │   ├── ./Javascript/Maths/test/Softmax.test.js
│   │   │   └── ./Javascript/Maths/test/Volume.test.js
│   │   ├── ./Javascript/Maths/Volume.js
│   │   └── ./Javascript/Maths/WhileLoopFactorial.js
│   ├── ./Javascript/Navigation
│   │   ├── ./Javascript/Navigation/Haversine.js
│   │   └── ./Javascript/Navigation/Haversine.test.js
│   ├── ./Javascript/package.json
│   ├── ./Javascript/Project-Euler
│   │   ├── ./Javascript/Project-Euler/Problem013.js
│   │   ├── ./Javascript/Project-Euler/Problem014.js
│   │   ├── ./Javascript/Project-Euler/Problem015.js
│   │   ├── ./Javascript/Project-Euler/Problem020.js
│   │   ├── ./Javascript/Project-Euler/Problem10.js
│   │   ├── ./Javascript/Project-Euler/Problem1.js
│   │   ├── ./Javascript/Project-Euler/Problem2.js
│   │   ├── ./Javascript/Project-Euler/Problem3.js
│   │   ├── ./Javascript/Project-Euler/Problem4.js
│   │   ├── ./Javascript/Project-Euler/Problem5.js
│   │   ├── ./Javascript/Project-Euler/Problem6.js
│   │   ├── ./Javascript/Project-Euler/Problem7.js
│   │   ├── ./Javascript/Project-Euler/Problem9.js
│   │   └── ./Javascript/Project-Euler/test
│   │       └── ./Javascript/Project-Euler/test/Problem10.test.js
│   ├── ./Javascript/README.html
│   ├── ./Javascript/README.md
│   ├── ./Javascript/Recursive
│   │   ├── ./Javascript/Recursive/BinarySearch.js
│   │   ├── ./Javascript/Recursive/EucledianGCD.js
│   │   ├── ./Javascript/Recursive/factorial.js
│   │   ├── ./Javascript/Recursive/FibonacciNumberRecursive.js
│   │   ├── ./Javascript/Recursive/FloodFill.js
│   │   ├── ./Javascript/Recursive/KochSnowflake.js
│   │   ├── ./Javascript/Recursive/Palindrome.js
│   │   └── ./Javascript/Recursive/TowerOfHanoi.js
│   ├── ./Javascript/Search
│   │   ├── ./Javascript/Search/BinarySearch.js
│   │   ├── ./Javascript/Search/ExponentialSearch.js
│   │   ├── ./Javascript/Search/FibonacciSearch.js
│   │   ├── ./Javascript/Search/InterpolationSearch.js
│   │   ├── ./Javascript/Search/JumpSearch.js
│   │   ├── ./Javascript/Search/LinearSearch.js
│   │   ├── ./Javascript/Search/QuickSelectSearch.js
│   │   ├── ./Javascript/Search/StringSearch.js
│   │   ├── ./Javascript/Search/TernarySearch.js
│   │   └── ./Javascript/Search/test
│   │       └── ./Javascript/Search/test/TernarySearch.test.js
│   ├── ./Javascript/Sorts
│   │   ├── ./Javascript/Sorts/BeadSort.js
│   │   ├── ./Javascript/Sorts/BogoSort.js
│   │   ├── ./Javascript/Sorts/BubbleSort.js
│   │   ├── ./Javascript/Sorts/BucketSort.js
│   │   ├── ./Javascript/Sorts/CocktailShakerSort.js
│   │   ├── ./Javascript/Sorts/CombSort.js
│   │   ├── ./Javascript/Sorts/CountingSort.js
│   │   ├── ./Javascript/Sorts/CycleSort.js
│   │   ├── ./Javascript/Sorts/FindSecondLargestElement.js
│   │   ├── ./Javascript/Sorts/FlashSort.js
│   │   ├── ./Javascript/Sorts/GnomeSort.js
│   │   ├── ./Javascript/Sorts/HeapSort.js
│   │   ├── ./Javascript/Sorts/HeapSortV2.js
│   │   ├── ./Javascript/Sorts/InsertionSort.js
│   │   ├── ./Javascript/Sorts/IntroSort.js
│   │   ├── ./Javascript/Sorts/MergeSort.js
│   │   ├── ./Javascript/Sorts/OddEvenSort.js
│   │   ├── ./Javascript/Sorts/PigeonHoleSort.js
│   │   ├── ./Javascript/Sorts/QuickSort.js
│   │   ├── ./Javascript/Sorts/RadixSort.js
│   │   ├── ./Javascript/Sorts/SelectionSort.js
│   │   ├── ./Javascript/Sorts/SelectionSort.test.js
│   │   ├── ./Javascript/Sorts/ShellSort.js
│   │   ├── ./Javascript/Sorts/TimSort.js
│   │   ├── ./Javascript/Sorts/TopologicalSort.js
│   │   └── ./Javascript/Sorts/WiggleSort.js
│   ├── ./Javascript/String
│   │   ├── ./Javascript/String/CheckAnagram.js
│   │   ├── ./Javascript/String/CheckPalindrome.js
│   │   ├── ./Javascript/String/CheckPangram.js
│   │   ├── ./Javascript/String/CheckRearrangePalindrome.js
│   │   ├── ./Javascript/String/CheckVowels.js
│   │   ├── ./Javascript/String/CheckVowels.test.js
│   │   ├── ./Javascript/String/CheckWordOccurrence.js
│   │   ├── ./Javascript/String/CheckWordOcurrence.test.js
│   │   ├── ./Javascript/String/CreatePermutations.js
│   │   ├── ./Javascript/String/FormatPhoneNumber.js
│   │   ├── ./Javascript/String/FormatPhoneNumber.test.js
│   │   ├── ./Javascript/String/GenerateGUID.js
│   │   ├── ./Javascript/String/HammingDistance.js
│   │   ├── ./Javascript/String/KMPPatternSearching.js
│   │   ├── ./Javascript/String/LevenshteinDistance.js
│   │   ├── ./Javascript/String/LevenshteinDistance.test.js
│   │   ├── ./Javascript/String/MaxCharacter.js
│   │   ├── ./Javascript/String/MaxCharacter.test.js
│   │   ├── ./Javascript/String/PatternMatching.js
│   │   ├── ./Javascript/String/PermutateString.js
│   │   ├── ./Javascript/String/PermutateString.test.js
│   │   ├── ./Javascript/String/ReverseString.js
│   │   ├── ./Javascript/String/ReverseWords.js
│   │   ├── ./Javascript/String/test
│   │   │   ├── ./Javascript/String/test/CheckAnagram.test.js
│   │   │   ├── ./Javascript/String/test/CheckPalindrome.test.js
│   │   │   ├── ./Javascript/String/test/CheckPangram.test.js
│   │   │   ├── ./Javascript/String/test/CreatePermutations.test.js
│   │   │   ├── ./Javascript/String/test/HammingDistance.test.js
│   │   │   ├── ./Javascript/String/test/KMPPatternSearching.test.js
│   │   │   ├── ./Javascript/String/test/PatternMatching.test.js
│   │   │   ├── ./Javascript/String/test/ReverseString.test.js
│   │   │   ├── ./Javascript/String/test/ReverseWords.test.js
│   │   │   └── ./Javascript/String/test/ValidateEmail.test.js
│   │   └── ./Javascript/String/ValidateEmail.js
│   ├── ./Javascript/Timing-Functions
│   │   ├── ./Javascript/Timing-Functions/GetMonthDays.js
│   │   ├── ./Javascript/Timing-Functions/GetMonthDays.test.js
│   │   └── ./Javascript/Timing-Functions/IntervalTimer.js
│   ├── ./Javascript/Trees
│   │   ├── ./Javascript/Trees/BreadthFirstTreeTraversal.js
│   │   └── ./Javascript/Trees/DepthFirstSearch.js
│   └── ./Javascript/Web-Programming
│       ├── ./Javascript/Web-Programming/OpenWeatherMaps.js
│       └── ./Javascript/Web-Programming/StockPrice.js
├── ./Julia
│   ├── ./Julia/docs
│   │   ├── ./Julia/docs/make.jl
│   │   ├── ./Julia/docs/Project.toml
│   │   └── ./Julia/docs/src
│   │       ├── ./Julia/docs/src/index.html
│   │       └── ./Julia/docs/src/index.md
│   ├── ./Julia/Project.toml
│   ├── ./Julia/README.html
│   ├── ./Julia/README.md
│   ├── ./Julia/src
│   │   ├── ./Julia/src/basic
│   │   │   └── ./Julia/src/basic/prefix_sum.jl
│   │   ├── ./Julia/src/conversions
│   │   │   ├── ./Julia/src/conversions/temparature_conversion.jl
│   │   │   └── ./Julia/src/conversions/weight_conversion.jl
│   │   ├── ./Julia/src/data_structures
│   │   │   ├── ./Julia/src/data_structures/binary_tree
│   │   │   └── ./Julia/src/data_structures/disjoint_set
│   │   ├── ./Julia/src/knapsack
│   │   │   ├── ./Julia/src/knapsack/dynamic_programming.jl
│   │   │   └── ./Julia/src/knapsack/greedy_algorithm.jl
│   │   ├── ./Julia/src/math
│   │   │   ├── ./Julia/src/math/abs.jl
│   │   │   ├── ./Julia/src/math/area.jl
│   │   │   ├── ./Julia/src/math/armstrong_number.jl
│   │   │   ├── ./Julia/src/math/average_mean.jl
│   │   │   ├── ./Julia/src/math/average_median.jl
│   │   │   ├── ./Julia/src/math/average_mode.jl
│   │   │   ├── ./Julia/src/math/ceil_floor.jl
│   │   │   ├── ./Julia/src/math/collatz_sequence.jl
│   │   │   ├── ./Julia/src/math/combination.jl
│   │   │   ├── ./Julia/src/math/euler_method.jl
│   │   │   ├── ./Julia/src/math/factorial.jl
│   │   │   ├── ./Julia/src/math/krishnamurthy_number.jl
│   │   │   ├── ./Julia/src/math/line_length.jl
│   │   │   ├── ./Julia/src/math/monte_carlo_integration.jl
│   │   │   ├── ./Julia/src/math/perfect_cube.jl
│   │   │   ├── ./Julia/src/math/perfect_number.jl
│   │   │   ├── ./Julia/src/math/perfect_square.jl
│   │   │   ├── ./Julia/src/math/permutation.jl
│   │   │   ├── ./Julia/src/math/prime_check.jl
│   │   │   ├── ./Julia/src/math/prime_factors.jl
│   │   │   ├── ./Julia/src/math/sieve_of_eratosthenes.jl
│   │   │   ├── ./Julia/src/math/sir_model.jl
│   │   │   ├── ./Julia/src/math/sum_of_arithmetic_series.jl
│   │   │   ├── ./Julia/src/math/sum_of_geometric_progression.jl
│   │   │   ├── ./Julia/src/math/verlet.jl
│   │   │   └── ./Julia/src/math/volume.jl
│   │   ├── ./Julia/src/matrix
│   │   │   ├── ./Julia/src/matrix/determinant.jl
│   │   │   ├── ./Julia/src/matrix/lu_decompose.jl
│   │   │   └── ./Julia/src/matrix/rotation-matrix.jl
│   │   ├── ./Julia/src/project-rosalind
│   │   │   ├── ./Julia/src/project-rosalind/count_nucleotide.jl
│   │   │   ├── ./Julia/src/project-rosalind/dna2rna.jl
│   │   │   └── ./Julia/src/project-rosalind/reverse_complement.jl
│   │   ├── ./Julia/src/scheduling
│   │   │   └── ./Julia/src/scheduling/fcfs.jl
│   │   ├── ./Julia/src/searches
│   │   │   ├── ./Julia/src/searches/binary_search.jl
│   │   │   ├── ./Julia/src/searches/exponential_search.jl
│   │   │   ├── ./Julia/src/searches/interpolation_search.jl
│   │   │   ├── ./Julia/src/searches/jump_search.jl
│   │   │   └── ./Julia/src/searches/linear_search.jl
│   │   ├── ./Julia/src/sorts
│   │   │   ├── ./Julia/src/sorts/bubble_sort.jl
│   │   │   ├── ./Julia/src/sorts/counting_sort.jl
│   │   │   ├── ./Julia/src/sorts/exchange_sort.jl
│   │   │   ├── ./Julia/src/sorts/insertion_sort.jl
│   │   │   ├── ./Julia/src/sorts/merge_sort.jl
│   │   │   ├── ./Julia/src/sorts/quick_sort.jl
│   │   │   └── ./Julia/src/sorts/selection_sort.jl
│   │   ├── ./Julia/src/statistics
│   │   │   ├── ./Julia/src/statistics/ordinary_least_squares.jl
│   │   │   ├── ./Julia/src/statistics/pearson_correlation.jl
│   │   │   └── ./Julia/src/statistics/variance.jl
│   │   ├── ./Julia/src/strings
│   │   │   ├── ./Julia/src/strings/detect_anagrams.jl
│   │   │   ├── ./Julia/src/strings/is_palindrome.jl
│   │   │   └── ./Julia/src/strings/kmp_substring_search.jl
│   │   └── ./Julia/src/TheAlgorithms.jl
│   └── ./Julia/test
│       ├── ./Julia/test/basic.jl
│       ├── ./Julia/test/conversions.jl
│       ├── ./Julia/test/data_structures.jl
│       ├── ./Julia/test/knapsack.jl
│       ├── ./Julia/test/math.jl
│       ├── ./Julia/test/matrix.jl
│       ├── ./Julia/test/project-rosalind.jl
│       ├── ./Julia/test/Project.toml
│       ├── ./Julia/test/runtests.jl
│       ├── ./Julia/test/scheduling.jl
│       ├── ./Julia/test/searches.jl
│       ├── ./Julia/test/sorts.jl
│       ├── ./Julia/test/statistics.jl
│       └── ./Julia/test/strings.jl
├── ./Jupyter
│   ├── ./Jupyter/assets
│   │   └── ./Jupyter/assets/images
│   │       ├── ./Jupyter/assets/images/clone.png
│   │       ├── ./Jupyter/assets/images/compare-and-pull.png
│   │       ├── ./Jupyter/assets/images/fork.png
│   │       ├── ./Jupyter/assets/images/git-status.png
│   │       └── ./Jupyter/assets/images/url.JPG
│   ├── ./Jupyter/Automaton
│   │   ├── ./Jupyter/Automaton/Netflix_Scrapper.ipynb
│   │   ├── ./Jupyter/Automaton/Pushdown_Automata_Implementation.ipynb
│   │   └── ./Jupyter/Automaton/ScrapNewsfromIndiaToday.ipynb
│   ├── ./Jupyter/Contributing.html
│   ├── ./Jupyter/Contributing.md
│   ├── ./Jupyter/DIRECTORY.html
│   ├── ./Jupyter/DIRECTORY.md
│   ├── ./Jupyter/machine_learning
│   │   ├── ./Jupyter/machine_learning/ARIMA
│   │   │   ├── ./Jupyter/machine_learning/ARIMA/ARIMA with pyramid.ipynb
│   │   │   └── ./Jupyter/machine_learning/ARIMA/data
│   │   ├── ./Jupyter/machine_learning/Associative Mining
│   │   │   ├── ./Jupyter/machine_learning/Associative Mining/Association.ipynb
│   │   │   ├── ./Jupyter/machine_learning/Associative Mining/grocery_data.csv
│   │   │   └── ./Jupyter/machine_learning/Associative Mining/transformed_data.csv
│   │   ├── ./Jupyter/machine_learning/Basics of tensorflow
│   │   │   └── ./Jupyter/machine_learning/Basics of tensorflow/Basic of TensorFlow.ipynb
│   │   ├── ./Jupyter/machine_learning/Cosine-Similarity
│   │   │   └── ./Jupyter/machine_learning/Cosine-Similarity/Similarity.ipynb
│   │   ├── ./Jupyter/machine_learning/dbscan
│   │   │   ├── ./Jupyter/machine_learning/dbscan/dbscan.ipynb
│   │   │   └── ./Jupyter/machine_learning/dbscan/dbscan.py
│   │   ├── ./Jupyter/machine_learning/Decision tree
│   │   │   └── ./Jupyter/machine_learning/Decision tree/Decision_Tree.ipynb
│   │   ├── ./Jupyter/machine_learning/Decision Tree regression with k-fold cross validation
│   │   │   └── ./Jupyter/machine_learning/Decision Tree regression with k-fold cross validation/2019.csv
│   │   ├── ./Jupyter/machine_learning/Fundamentals of python
│   │   │   └── ./Jupyter/machine_learning/Fundamentals of python/Python basics.ipynb
│   │   ├── ./Jupyter/machine_learning/Linear_Regression
│   │   │   └── ./Jupyter/machine_learning/Linear_Regression/LinearRegression.ipynb
│   │   ├── ./Jupyter/machine_learning/Matplotlib
│   │   ├── ./Jupyter/machine_learning/Movie_recommendation_system
│   │   │   └── ./Jupyter/machine_learning/Movie_recommendation_system/Movie_Recommendation_System.ipynb
│   │   ├── ./Jupyter/machine_learning/Naive_Bayes
│   │   │   └── ./Jupyter/machine_learning/Naive_Bayes/naive_bayes.ipynb
│   │   ├── ./Jupyter/machine_learning/Naive Bayes Classification
│   │   │   ├── ./Jupyter/machine_learning/Naive Bayes Classification/Customer_Behaviour.csv
│   │   │   └── ./Jupyter/machine_learning/Naive Bayes Classification/Naive_Bayes_Classification.ipynb
│   │   ├── ./Jupyter/machine_learning/Natural language processing
│   │   │   ├── ./Jupyter/machine_learning/Natural language processing/intents.json
│   │   │   └── ./Jupyter/machine_learning/Natural language processing/Movie_recommendation_Sentance_Embedding.ipynb
│   │   ├── ./Jupyter/machine_learning/Numpy
│   │   │   └── ./Jupyter/machine_learning/Numpy/Fundamentals of Numpy.ipynb
│   │   ├── ./Jupyter/machine_learning/Pandas
│   │   │   └── ./Jupyter/machine_learning/Pandas/Pandas.ipynb
│   │   ├── ./Jupyter/machine_learning/Prophet
│   │   │   └── ./Jupyter/machine_learning/Prophet/data
│   │   ├── ./Jupyter/machine_learning/random_forest_classification
│   │   │   ├── ./Jupyter/machine_learning/random_forest_classification/__pycache__
│   │   │   ├── ./Jupyter/machine_learning/random_forest_classification/random_forest_classification.py
│   │   │   ├── ./Jupyter/machine_learning/random_forest_classification/random_forest_classifier.ipynb
│   │   │   └── ./Jupyter/machine_learning/random_forest_classification/Social_Network_Ads.csv
│   │   ├── ./Jupyter/machine_learning/random_forest_regression
│   │   │   ├── ./Jupyter/machine_learning/random_forest_regression/Position_Salaries.csv
│   │   │   ├── ./Jupyter/machine_learning/random_forest_regression/__pycache__
│   │   │   ├── ./Jupyter/machine_learning/random_forest_regression/random_forest_regression.ipynb
│   │   │   └── ./Jupyter/machine_learning/random_forest_regression/random_forest_regression.py
│   │   ├── ./Jupyter/machine_learning/Reuters_one_vs_rest_classifier
│   │   ├── ./Jupyter/machine_learning/Scikit-learn
│   │   │   └── ./Jupyter/machine_learning/Scikit-learn/Scikit-learn.ipynb
│   │   └── ./Jupyter/machine_learning/Support_Vector_Machine
│   ├── ./Jupyter/neural_network
│   │   ├── ./Jupyter/neural_network/02-imdb-binary-classification.ipynb
│   │   ├── ./Jupyter/neural_network/A-simple-GAN.ipynb
│   │   ├── ./Jupyter/neural_network/autoencoder.ipynb
│   │   ├── ./Jupyter/neural_network/CNN-using keras.ipynb
│   │   ├── ./Jupyter/neural_network/fully_connected_neural_network.ipynb
│   │   ├── ./Jupyter/neural_network/GANs-PyTorch-Vanilla-LS-DC
│   │   │   ├── ./Jupyter/neural_network/GANs-PyTorch-Vanilla-LS-DC/gan-checks-tf.npz
│   │   │   ├── ./Jupyter/neural_network/GANs-PyTorch-Vanilla-LS-DC/gan_outputs_pytorch.png
│   │   │   ├── ./Jupyter/neural_network/GANs-PyTorch-Vanilla-LS-DC/README.html
│   │   │   └── ./Jupyter/neural_network/GANs-PyTorch-Vanilla-LS-DC/README.md
│   │   ├── ./Jupyter/neural_network/Logistic_Regression.ipynb
│   │   ├── ./Jupyter/neural_network/Neural_network_Mnist_Dataset.ipynb
│   │   ├── ./Jupyter/neural_network/qlearning.ipynb
│   │   ├── ./Jupyter/neural_network/RNN
│   │   │   └── ./Jupyter/neural_network/RNN/Google_test.csv
│   │   └── ./Jupyter/neural_network/Sequence Labelling with a BiLSTM in PyTorch.ipynb
│   ├── ./Jupyter/numerical_methods
│   │   ├── ./Jupyter/numerical_methods/euler_method_for_the_Cauchy_problem.ipynb
│   │   ├── ./Jupyter/numerical_methods/newton_forward_divided_difference_formula.ipynb
│   │   ├── ./Jupyter/numerical_methods/the_rectangular_method.ipynb
│   │   ├── ./Jupyter/numerical_methods/the_Simpson’s_method.ipynb
│   │   └── ./Jupyter/numerical_methods/the_trapezium_method.ipynb
│   ├── ./Jupyter/other
│   │   ├── ./Jupyter/other/clothing_detection.ipynb
│   │   └── ./Jupyter/other/Simplex_standard.ipynb
│   ├── ./Jupyter/README.html
│   ├── ./Jupyter/README.md
│   └── ./Jupyter/requirements.txt
├── ./Kotlin
│   ├── ./Kotlin/build.gradle
│   ├── ./Kotlin/DIRECTORY.html
│   ├── ./Kotlin/DIRECTORY.md
│   ├── ./Kotlin/gradle
│   │   └── ./Kotlin/gradle/wrapper
│   │       ├── ./Kotlin/gradle/wrapper/gradle-wrapper.jar
│   │       └── ./Kotlin/gradle/wrapper/gradle-wrapper.properties
│   ├── ./Kotlin/gradle.properties
│   ├── ./Kotlin/gradlew
│   ├── ./Kotlin/gradlew.bat
│   ├── ./Kotlin/README.html
│   ├── ./Kotlin/README.md
│   ├── ./Kotlin/settings.gradle
│   └── ./Kotlin/src
│       ├── ./Kotlin/src/main
│       │   └── ./Kotlin/src/main/kotlin
│       └── ./Kotlin/src/test
│           └── ./Kotlin/src/test/kotlin
├── ./MATLAB-Octave
│   ├── ./MATLAB-Octave/algorithms
│   │   ├── ./MATLAB-Octave/algorithms/arithmetic_analysis
│   │   │   ├── ./MATLAB-Octave/algorithms/arithmetic_analysis/bisection.m
│   │   │   ├── ./MATLAB-Octave/algorithms/arithmetic_analysis/false_position.m
│   │   │   ├── ./MATLAB-Octave/algorithms/arithmetic_analysis/newton.m
│   │   │   └── ./MATLAB-Octave/algorithms/arithmetic_analysis/secant.m
│   │   ├── ./MATLAB-Octave/algorithms/crypto
│   │   │   └── ./MATLAB-Octave/algorithms/crypto/sdbm-hash
│   │   ├── ./MATLAB-Octave/algorithms/Divisibility_of_integers
│   │   │   └── ./MATLAB-Octave/algorithms/Divisibility_of_integers/multiple.m
│   │   ├── ./MATLAB-Octave/algorithms/Genetic-Algorithm
│   │   │   └── ./MATLAB-Octave/algorithms/Genetic-Algorithm/Minimization of polynomial function
│   │   ├── ./MATLAB-Octave/algorithms/ImageProcessing
│   │   │   ├── ./MATLAB-Octave/algorithms/ImageProcessing/LSB based Image Steganography
│   │   │   └── ./MATLAB-Octave/algorithms/ImageProcessing/Nearest Neighbhor Interpolation
│   │   ├── ./MATLAB-Octave/algorithms/machine_learning
│   │   │   ├── ./MATLAB-Octave/algorithms/machine_learning/Activation Functions
│   │   │   ├── ./MATLAB-Octave/algorithms/machine_learning/Gradient-Descent
│   │   │   ├── ./MATLAB-Octave/algorithms/machine_learning/kmeans
│   │   │   ├── ./MATLAB-Octave/algorithms/machine_learning/Linear-Regression
│   │   │   ├── ./MATLAB-Octave/algorithms/machine_learning/Logistic-Regression
│   │   │   └── ./MATLAB-Octave/algorithms/machine_learning/Nearest-Neighbor
│   │   ├── ./MATLAB-Octave/algorithms/maths
│   │   │   ├── ./MATLAB-Octave/algorithms/maths/euclidean_distance.m
│   │   │   ├── ./MATLAB-Octave/algorithms/maths/fibonacci_sequence.m
│   │   │   ├── ./MATLAB-Octave/algorithms/maths/find_factorial.m
│   │   │   ├── ./MATLAB-Octave/algorithms/maths/highest_common_factor.m
│   │   │   ├── ./MATLAB-Octave/algorithms/maths/is_armstrong.m
│   │   │   ├── ./MATLAB-Octave/algorithms/maths/jaccard_similarity.m
│   │   │   ├── ./MATLAB-Octave/algorithms/maths/lcm.m
│   │   │   ├── ./MATLAB-Octave/algorithms/maths/linear_diophantine_eqn.m
│   │   │   ├── ./MATLAB-Octave/algorithms/maths/prime_check.m
│   │   │   ├── ./MATLAB-Octave/algorithms/maths/prime_factorial.m
│   │   │   ├── ./MATLAB-Octave/algorithms/maths/shreeDharacharyaFormula.m
│   │   │   ├── ./MATLAB-Octave/algorithms/maths/sum_of_digits.m
│   │   │   ├── ./MATLAB-Octave/algorithms/maths/to_polar.m
│   │   │   └── ./MATLAB-Octave/algorithms/maths/twos_complement_of_binary.m
│   │   ├── ./MATLAB-Octave/algorithms/other
│   │   │   └── ./MATLAB-Octave/algorithms/other/tic_tac_toe.m
│   │   ├── ./MATLAB-Octave/algorithms/Particle_Swarm_Optimization
│   │   │   └── ./MATLAB-Octave/algorithms/Particle_Swarm_Optimization/Polynomial Minimization
│   │   ├── ./MATLAB-Octave/algorithms/Searching
│   │   │   ├── ./MATLAB-Octave/algorithms/Searching/binary_search.m
│   │   │   ├── ./MATLAB-Octave/algorithms/Searching/jump_search.m
│   │   │   ├── ./MATLAB-Octave/algorithms/Searching/linear_search.m
│   │   │   ├── ./MATLAB-Octave/algorithms/Searching/random_search.m
│   │   │   └── ./MATLAB-Octave/algorithms/Searching/ternarySearch.m
│   │   ├── ./MATLAB-Octave/algorithms/Sieve_of_Eratosthenes
│   │   │   └── ./MATLAB-Octave/algorithms/Sieve_of_Eratosthenes/sieveER.m
│   │   ├── ./MATLAB-Octave/algorithms/sorting
│   │   │   ├── ./MATLAB-Octave/algorithms/sorting/bubble_sort.m
│   │   │   ├── ./MATLAB-Octave/algorithms/sorting/cocktail_sort.m
│   │   │   ├── ./MATLAB-Octave/algorithms/sorting/comb_sort.m
│   │   │   ├── ./MATLAB-Octave/algorithms/sorting/counting_sort.m
│   │   │   ├── ./MATLAB-Octave/algorithms/sorting/gnome_sort.m
│   │   │   ├── ./MATLAB-Octave/algorithms/sorting/heap_sort.m
│   │   │   ├── ./MATLAB-Octave/algorithms/sorting/insertion_sort.m
│   │   │   ├── ./MATLAB-Octave/algorithms/sorting/merge_sort.m
│   │   │   ├── ./MATLAB-Octave/algorithms/sorting/permutationSort.m
│   │   │   ├── ./MATLAB-Octave/algorithms/sorting/quick_sort.m
│   │   │   ├── ./MATLAB-Octave/algorithms/sorting/select_sort.m
│   │   │   └── ./MATLAB-Octave/algorithms/sorting/shell_sort.m
│   │   └── ./MATLAB-Octave/algorithms/Strings
│   │       └── ./MATLAB-Octave/algorithms/Strings/isPalindrome.m
│   ├── ./MATLAB-Octave/DIRECTORY.html
│   ├── ./MATLAB-Octave/DIRECTORY.md
│   ├── ./MATLAB-Octave/image-processing
│   │   └── ./MATLAB-Octave/image-processing/Blob-detection-using-Matlab
│   │       ├── ./MATLAB-Octave/image-processing/Blob-detection-using-Matlab/assets
│   │       ├── ./MATLAB-Octave/image-processing/Blob-detection-using-Matlab/blobDetection.m
│   │       ├── ./MATLAB-Octave/image-processing/Blob-detection-using-Matlab/blob.slx
│   │       ├── ./MATLAB-Octave/image-processing/Blob-detection-using-Matlab/BlobUsingVideo.m
│   │       ├── ./MATLAB-Octave/image-processing/Blob-detection-using-Matlab/README.html
│   │       └── ./MATLAB-Octave/image-processing/Blob-detection-using-Matlab/README.md
│   ├── ./MATLAB-Octave/matlab_for_beginners
│   │   ├── ./MATLAB-Octave/matlab_for_beginners/matlab_introduction.html
│   │   ├── ./MATLAB-Octave/matlab_for_beginners/matlab_introduction.md
│   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/add.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/array.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/comment.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/continuation.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/equal_add.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/equal.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/formatted_output.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/individual_eL_add.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/intr_math_fun.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/make_graph.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/math.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/nam_var.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/print.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/README.html
│   │   │   └── ./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)/README.md
│   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_2(basic_looping)
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_2(basic_looping)/program1.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_2(basic_looping)/program2.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_2(basic_looping)/program3.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_2(basic_looping)/program4.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_2(basic_looping)/program5.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_2(basic_looping)/program6.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_2(basic_looping)/program7.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_2(basic_looping)/README.html
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_2(basic_looping)/README.md
│   │   │   └── ./MATLAB-Octave/matlab_for_beginners/part_2(basic_looping)/wh_loop.m
│   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_3(basic_branching)
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_3(basic_branching)/program1.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_3(basic_branching)/program2.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_3(basic_branching)/program3.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_3(basic_branching)/program4.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_3(basic_branching)/README.html
│   │   │   └── ./MATLAB-Octave/matlab_for_beginners/part_3(basic_branching)/README.md
│   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)/program10.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)/program11.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)/program12.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)/program1.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)/program2.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)/program3.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)/program4.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)/program5.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)/program6.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)/program7.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)/program8.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)/program9.m
│   │   │   ├── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)/README.html
│   │   │   └── ./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)/README.md
│   │   ├── ./MATLAB-Octave/matlab_for_beginners/README.html
│   │   └── ./MATLAB-Octave/matlab_for_beginners/README.md
│   ├── ./MATLAB-Octave/project-euler
│   │   ├── ./MATLAB-Octave/project-euler/Problem1
│   │   │   ├── ./MATLAB-Octave/project-euler/Problem1/multiple.m
│   │   │   └── ./MATLAB-Octave/project-euler/Problem1/solv.m
│   │   ├── ./MATLAB-Octave/project-euler/Problem2
│   │   │   ├── ./MATLAB-Octave/project-euler/Problem2/fib.m
│   │   │   └── ./MATLAB-Octave/project-euler/Problem2/solv.m
│   │   ├── ./MATLAB-Octave/project-euler/Problem3
│   │   │   ├── ./MATLAB-Octave/project-euler/Problem3/isPrime.m
│   │   │   ├── ./MATLAB-Octave/project-euler/Problem3/myResult.mat
│   │   │   ├── ./MATLAB-Octave/project-euler/Problem3/pfz.m
│   │   │   └── ./MATLAB-Octave/project-euler/Problem3/solv.m
│   │   └── ./MATLAB-Octave/project-euler/Problem4
│   │       ├── ./MATLAB-Octave/project-euler/Problem4/isPalindromeNumber.m
│   │       └── ./MATLAB-Octave/project-euler/Problem4/solv.m
│   ├── ./MATLAB-Octave/README.html
│   └── ./MATLAB-Octave/README.md
├── ./OCaml
│   ├── ./OCaml/DIRECTORY.html
│   ├── ./OCaml/DIRECTORY.md
│   ├── ./OCaml/README.html
│   ├── ./OCaml/README.md
│   ├── ./OCaml/searches
│   │   └── ./OCaml/searches/linear_search.ml
│   └── ./OCaml/Sorts
│       └── ./OCaml/Sorts/quicksort.ml
├── ./PHP
│   ├── ./PHP/ciphers
│   │   ├── ./PHP/ciphers/caesarCipher.php
│   │   └── ./PHP/ciphers/XORCipher.php
│   ├── ./PHP/composer.json
│   ├── ./PHP/Conversions
│   │   ├── ./PHP/Conversions/BinaryToDecimal.php
│   │   ├── ./PHP/Conversions/HexadecimalToDecimal.php
│   │   └── ./PHP/Conversions/OctalToDecimal.php
│   ├── ./PHP/DIRECTORY.html
│   ├── ./PHP/DIRECTORY.md
│   ├── ./PHP/Maths
│   │   ├── ./PHP/Maths/AbsoluteMax.php
│   │   ├── ./PHP/Maths/AbsoluteMin.php
│   │   ├── ./PHP/Maths/CheckPrime.php
│   │   ├── ./PHP/Maths/Factorial.php
│   │   ├── ./PHP/Maths/FastExponentiation.php
│   │   ├── ./PHP/Maths/Fibonacci.php
│   │   └── ./PHP/Maths/PerfectSquare.php
│   ├── ./PHP/README.html
│   ├── ./PHP/README.md
│   ├── ./PHP/searches
│   │   ├── ./PHP/searches/binary_search.php
│   │   ├── ./PHP/searches/linear_search.php
│   │   ├── ./PHP/searches/lower_bound.php
│   │   └── ./PHP/searches/upper_bound.php
│   ├── ./PHP/sorting
│   │   ├── ./PHP/sorting/bubbleSort.php
│   │   ├── ./PHP/sorting/countSort.php
│   │   ├── ./PHP/sorting/insertionSort.php
│   │   ├── ./PHP/sorting/mergeSort.php
│   │   ├── ./PHP/sorting/radixSort.php
│   │   └── ./PHP/sorting/selectionSort.php
│   ├── ./PHP/String
│   │   ├── ./PHP/String/CheckAnagram.php
│   │   ├── ./PHP/String/CheckPalindrome.php
│   │   ├── ./PHP/String/CountVowels.php
│   │   ├── ./PHP/String/EditDistance.php
│   │   ├── ./PHP/String/MaxCharacter.php
│   │   ├── ./PHP/String/ReverseString.php
│   │   └── ./PHP/String/ReverseWords.php
│   └── ./PHP/tests
│       ├── ./PHP/tests/CiphersTest.php
│       ├── ./PHP/tests/CipherTest.php
│       ├── ./PHP/tests/ConversionsTest.php
│       ├── ./PHP/tests/MathTest.php
│       ├── ./PHP/tests/sorting
│       │   └── ./PHP/tests/sorting/countSortTest.php
│       └── ./PHP/tests/StringTest.php
├── ./Python
│   ├── ./Python/arithmetic_analysis
│   │   ├── ./Python/arithmetic_analysis/bisection.py
│   │   ├── ./Python/arithmetic_analysis/gaussian_elimination.py
│   │   ├── ./Python/arithmetic_analysis/image_data
│   │   │   ├── ./Python/arithmetic_analysis/image_data/2D_problems_1.jpg
│   │   │   ├── ./Python/arithmetic_analysis/image_data/2D_problems.jpg
│   │   │   └── ./Python/arithmetic_analysis/image_data/__init__.py
│   │   ├── ./Python/arithmetic_analysis/__init__.py
│   │   ├── ./Python/arithmetic_analysis/in_static_equilibrium.py
│   │   ├── ./Python/arithmetic_analysis/intersection.py
│   │   ├── ./Python/arithmetic_analysis/lu_decomposition.py
│   │   ├── ./Python/arithmetic_analysis/newton_forward_interpolation.py
│   │   ├── ./Python/arithmetic_analysis/newton_method.py
│   │   ├── ./Python/arithmetic_analysis/newton_raphson.py
│   │   └── ./Python/arithmetic_analysis/secant_method.py
│   ├── ./Python/backtracking
│   │   ├── ./Python/backtracking/all_combinations.py
│   │   ├── ./Python/backtracking/all_permutations.py
│   │   ├── ./Python/backtracking/all_subsequences.py
│   │   ├── ./Python/backtracking/coloring.py
│   │   ├── ./Python/backtracking/hamiltonian_cycle.py
│   │   ├── ./Python/backtracking/__init__.py
│   │   ├── ./Python/backtracking/knight_tour.py
│   │   ├── ./Python/backtracking/minimax.py
│   │   ├── ./Python/backtracking/n_queens_math.py
│   │   ├── ./Python/backtracking/n_queens.py
│   │   ├── ./Python/backtracking/rat_in_maze.py
│   │   ├── ./Python/backtracking/sudoku.py
│   │   └── ./Python/backtracking/sum_of_subsets.py
│   ├── ./Python/bit_manipulation
│   │   ├── ./Python/bit_manipulation/binary_and_operator.py
│   │   ├── ./Python/bit_manipulation/binary_count_setbits.py
│   │   ├── ./Python/bit_manipulation/binary_count_trailing_zeros.py
│   │   ├── ./Python/bit_manipulation/binary_or_operator.py
│   │   ├── ./Python/bit_manipulation/binary_shifts.py
│   │   ├── ./Python/bit_manipulation/binary_twos_complement.py
│   │   ├── ./Python/bit_manipulation/binary_xor_operator.py
│   │   ├── ./Python/bit_manipulation/count_number_of_one_bits.py
│   │   ├── ./Python/bit_manipulation/__init__.py
│   │   ├── ./Python/bit_manipulation/README.html
│   │   ├── ./Python/bit_manipulation/README.md
│   │   ├── ./Python/bit_manipulation/reverse_bits.py
│   │   └── ./Python/bit_manipulation/single_bit_manipulation_operations.py
│   ├── ./Python/blockchain
│   │   ├── ./Python/blockchain/chinese_remainder_theorem.py
│   │   ├── ./Python/blockchain/diophantine_equation.py
│   │   ├── ./Python/blockchain/__init__.py
│   │   └── ./Python/blockchain/modular_division.py
│   ├── ./Python/boolean_algebra
│   │   ├── ./Python/boolean_algebra/__init__.py
│   │   └── ./Python/boolean_algebra/quine_mc_cluskey.py
│   ├── ./Python/cellular_automata
│   │   ├── ./Python/cellular_automata/conways_game_of_life.py
│   │   ├── ./Python/cellular_automata/game_of_life.py
│   │   ├── ./Python/cellular_automata/__init__.py
│   │   ├── ./Python/cellular_automata/one_dimensional.py
│   │   ├── ./Python/cellular_automata/README.html
│   │   └── ./Python/cellular_automata/README.md
│   ├── ./Python/ciphers
│   │   ├── ./Python/ciphers/a1z26.py
│   │   ├── ./Python/ciphers/affine_cipher.py
│   │   ├── ./Python/ciphers/atbash.py
│   │   ├── ./Python/ciphers/base16.py
│   │   ├── ./Python/ciphers/base32.py
│   │   ├── ./Python/ciphers/base64_encoding.py
│   │   ├── ./Python/ciphers/base85.py
│   │   ├── ./Python/ciphers/beaufort_cipher.py
│   │   ├── ./Python/ciphers/brute_force_caesar_cipher.py
│   │   ├── ./Python/ciphers/caesar_cipher.py
│   │   ├── ./Python/ciphers/cryptomath_module.py
│   │   ├── ./Python/ciphers/decrypt_caesar_with_chi_squared.py
│   │   ├── ./Python/ciphers/deterministic_miller_rabin.py
│   │   ├── ./Python/ciphers/diffie_hellman.py
│   │   ├── ./Python/ciphers/diffie.py
│   │   ├── ./Python/ciphers/elgamal_key_generator.py
│   │   ├── ./Python/ciphers/enigma_machine2.py
│   │   ├── ./Python/ciphers/hill_cipher.py
│   │   ├── ./Python/ciphers/__init__.py
│   │   ├── ./Python/ciphers/mixed_keyword_cypher.py
│   │   ├── ./Python/ciphers/mono_alphabetic_ciphers.py
│   │   ├── ./Python/ciphers/morse_code_implementation.py
│   │   ├── ./Python/ciphers/onepad_cipher.py
│   │   ├── ./Python/ciphers/playfair_cipher.py
│   │   ├── ./Python/ciphers/porta_cipher.py
│   │   ├── ./Python/ciphers/rabin_miller.py
│   │   ├── ./Python/ciphers/rail_fence_cipher.py
│   │   ├── ./Python/ciphers/rot13.py
│   │   ├── ./Python/ciphers/rsa_cipher.py
│   │   ├── ./Python/ciphers/rsa_factorization.py
│   │   ├── ./Python/ciphers/rsa_key_generator.py
│   │   ├── ./Python/ciphers/shuffled_shift_cipher.py
│   │   ├── ./Python/ciphers/simple_keyword_cypher.py
│   │   ├── ./Python/ciphers/simple_substitution_cipher.py
│   │   ├── ./Python/ciphers/trafid_cipher.py
│   │   ├── ./Python/ciphers/transposition_cipher_encrypt_decrypt_file.py
│   │   ├── ./Python/ciphers/transposition_cipher.py
│   │   ├── ./Python/ciphers/vigenere_cipher.py
│   │   └── ./Python/ciphers/xor_cipher.py
│   ├── ./Python/compression
│   │   ├── ./Python/compression/burrows_wheeler.py
│   │   ├── ./Python/compression/huffman.py
│   │   ├── ./Python/compression/image_data
│   │   │   ├── ./Python/compression/image_data/compressed_image.png
│   │   │   ├── ./Python/compression/image_data/example_image.jpg
│   │   │   ├── ./Python/compression/image_data/__init__.py
│   │   │   └── ./Python/compression/image_data/original_image.png
│   │   ├── ./Python/compression/__init__.py
│   │   ├── ./Python/compression/lempel_ziv_decompress.py
│   │   ├── ./Python/compression/lempel_ziv.py
│   │   └── ./Python/compression/peak_signal_to_noise_ratio.py
│   ├── ./Python/computer_vision
│   │   ├── ./Python/computer_vision/cnn_classification.py
│   │   ├── ./Python/computer_vision/harris_corner.py
│   │   ├── ./Python/computer_vision/__init__.py
│   │   ├── ./Python/computer_vision/mean_threshold.py
│   │   ├── ./Python/computer_vision/README.html
│   │   └── ./Python/computer_vision/README.md
│   ├── ./Python/conversions
│   │   ├── ./Python/conversions/binary_to_decimal.py
│   │   ├── ./Python/conversions/binary_to_octal.py
│   │   ├── ./Python/conversions/decimal_to_any.py
│   │   ├── ./Python/conversions/decimal_to_binary.py
│   │   ├── ./Python/conversions/decimal_to_binary_recursion.py
│   │   ├── ./Python/conversions/decimal_to_hexadecimal.py
│   │   ├── ./Python/conversions/decimal_to_octal.py
│   │   ├── ./Python/conversions/hexadecimal_to_decimal.py
│   │   ├── ./Python/conversions/hex_to_bin.py
│   │   ├── ./Python/conversions/__init__.py
│   │   ├── ./Python/conversions/molecular_chemistry.py
│   │   ├── ./Python/conversions/octal_to_decimal.py
│   │   ├── ./Python/conversions/prefix_conversions.py
│   │   ├── ./Python/conversions/rgb_hsv_conversion.py
│   │   ├── ./Python/conversions/roman_numerals.py
│   │   ├── ./Python/conversions/temperature_conversions.py
│   │   └── ./Python/conversions/weight_conversion.py
│   ├── ./Python/data_structures
│   │   ├── ./Python/data_structures/binary_tree
│   │   │   ├── ./Python/data_structures/binary_tree/avl_tree.py
│   │   │   ├── ./Python/data_structures/binary_tree/basic_binary_tree.py
│   │   │   ├── ./Python/data_structures/binary_tree/binary_search_tree.py
│   │   │   ├── ./Python/data_structures/binary_tree/binary_search_tree_recursive.py
│   │   │   ├── ./Python/data_structures/binary_tree/binary_tree_mirror.py
│   │   │   ├── ./Python/data_structures/binary_tree/binary_tree_traversals.py
│   │   │   ├── ./Python/data_structures/binary_tree/fenwick_tree.py
│   │   │   ├── ./Python/data_structures/binary_tree/__init__.py
│   │   │   ├── ./Python/data_structures/binary_tree/lazy_segment_tree.py
│   │   │   ├── ./Python/data_structures/binary_tree/lowest_common_ancestor.py
│   │   │   ├── ./Python/data_structures/binary_tree/merge_two_binary_trees.py
│   │   │   ├── ./Python/data_structures/binary_tree/non_recursive_segment_tree.py
│   │   │   ├── ./Python/data_structures/binary_tree/number_of_possible_binary_trees.py
│   │   │   ├── ./Python/data_structures/binary_tree/red_black_tree.py
│   │   │   ├── ./Python/data_structures/binary_tree/segment_tree_other.py
│   │   │   ├── ./Python/data_structures/binary_tree/segment_tree.py
│   │   │   ├── ./Python/data_structures/binary_tree/treap.py
│   │   │   └── ./Python/data_structures/binary_tree/wavelet_tree.py
│   │   ├── ./Python/data_structures/disjoint_set
│   │   │   ├── ./Python/data_structures/disjoint_set/alternate_disjoint_set.py
│   │   │   ├── ./Python/data_structures/disjoint_set/disjoint_set.py
│   │   │   └── ./Python/data_structures/disjoint_set/__init__.py
│   │   ├── ./Python/data_structures/hashing
│   │   │   ├── ./Python/data_structures/hashing/double_hash.py
│   │   │   ├── ./Python/data_structures/hashing/hash_table.py
│   │   │   ├── ./Python/data_structures/hashing/hash_table_with_linked_list.py
│   │   │   ├── ./Python/data_structures/hashing/__init__.py
│   │   │   ├── ./Python/data_structures/hashing/number_theory
│   │   │   └── ./Python/data_structures/hashing/quadratic_probing.py
│   │   ├── ./Python/data_structures/heap
│   │   │   ├── ./Python/data_structures/heap/binomial_heap.py
│   │   │   ├── ./Python/data_structures/heap/heap_generic.py
│   │   │   ├── ./Python/data_structures/heap/heap.py
│   │   │   ├── ./Python/data_structures/heap/__init__.py
│   │   │   ├── ./Python/data_structures/heap/max_heap.py
│   │   │   ├── ./Python/data_structures/heap/min_heap.py
│   │   │   ├── ./Python/data_structures/heap/randomized_heap.py
│   │   │   └── ./Python/data_structures/heap/skew_heap.py
│   │   ├── ./Python/data_structures/__init__.py
│   │   ├── ./Python/data_structures/linked_list
│   │   │   ├── ./Python/data_structures/linked_list/circular_linked_list.py
│   │   │   ├── ./Python/data_structures/linked_list/deque_doubly.py
│   │   │   ├── ./Python/data_structures/linked_list/doubly_linked_list.py
│   │   │   ├── ./Python/data_structures/linked_list/doubly_linked_list_two.py
│   │   │   ├── ./Python/data_structures/linked_list/from_sequence.py
│   │   │   ├── ./Python/data_structures/linked_list/has_loop.py
│   │   │   ├── ./Python/data_structures/linked_list/__init__.py
│   │   │   ├── ./Python/data_structures/linked_list/is_palindrome.py
│   │   │   ├── ./Python/data_structures/linked_list/merge_two_lists.py
│   │   │   ├── ./Python/data_structures/linked_list/middle_element_of_linked_list.py
│   │   │   ├── ./Python/data_structures/linked_list/print_reverse.py
│   │   │   ├── ./Python/data_structures/linked_list/singly_linked_list.py
│   │   │   ├── ./Python/data_structures/linked_list/skip_list.py
│   │   │   └── ./Python/data_structures/linked_list/swap_nodes.py
│   │   ├── ./Python/data_structures/queue
│   │   │   ├── ./Python/data_structures/queue/circular_queue.py
│   │   │   ├── ./Python/data_structures/queue/double_ended_queue.py
│   │   │   ├── ./Python/data_structures/queue/__init__.py
│   │   │   ├── ./Python/data_structures/queue/linked_queue.py
│   │   │   ├── ./Python/data_structures/queue/priority_queue_using_list.py
│   │   │   ├── ./Python/data_structures/queue/queue_on_list.py
│   │   │   └── ./Python/data_structures/queue/queue_on_pseudo_stack.py
│   │   ├── ./Python/data_structures/stacks
│   │   │   ├── ./Python/data_structures/stacks/balanced_parentheses.py
│   │   │   ├── ./Python/data_structures/stacks/dijkstras_two_stack_algorithm.py
│   │   │   ├── ./Python/data_structures/stacks/evaluate_postfix_notations.py
│   │   │   ├── ./Python/data_structures/stacks/infix_to_postfix_conversion.py
│   │   │   ├── ./Python/data_structures/stacks/infix_to_prefix_conversion.py
│   │   │   ├── ./Python/data_structures/stacks/__init__.py
│   │   │   ├── ./Python/data_structures/stacks/linked_stack.py
│   │   │   ├── ./Python/data_structures/stacks/next_greater_element.py
│   │   │   ├── ./Python/data_structures/stacks/postfix_evaluation.py
│   │   │   ├── ./Python/data_structures/stacks/prefix_evaluation.py
│   │   │   ├── ./Python/data_structures/stacks/stack.py
│   │   │   ├── ./Python/data_structures/stacks/stack_using_dll.py
│   │   │   └── ./Python/data_structures/stacks/stock_span_problem.py
│   │   └── ./Python/data_structures/trie
│   │       ├── ./Python/data_structures/trie/__init__.py
│   │       └── ./Python/data_structures/trie/trie.py
│   ├── ./Python/digital_image_processing
│   │   ├── ./Python/digital_image_processing/change_brightness.py
│   │   ├── ./Python/digital_image_processing/change_contrast.py
│   │   ├── ./Python/digital_image_processing/convert_to_negative.py
│   │   ├── ./Python/digital_image_processing/dithering
│   │   │   ├── ./Python/digital_image_processing/dithering/burkes.py
│   │   │   └── ./Python/digital_image_processing/dithering/__init__.py
│   │   ├── ./Python/digital_image_processing/edge_detection
│   │   │   ├── ./Python/digital_image_processing/edge_detection/canny.py
│   │   │   └── ./Python/digital_image_processing/edge_detection/__init__.py
│   │   ├── ./Python/digital_image_processing/filters
│   │   │   ├── ./Python/digital_image_processing/filters/bilateral_filter.py
│   │   │   ├── ./Python/digital_image_processing/filters/convolve.py
│   │   │   ├── ./Python/digital_image_processing/filters/gaussian_filter.py
│   │   │   ├── ./Python/digital_image_processing/filters/__init__.py
│   │   │   ├── ./Python/digital_image_processing/filters/median_filter.py
│   │   │   └── ./Python/digital_image_processing/filters/sobel_filter.py
│   │   ├── ./Python/digital_image_processing/histogram_equalization
│   │   │   ├── ./Python/digital_image_processing/histogram_equalization/histogram_stretch.py
│   │   │   ├── ./Python/digital_image_processing/histogram_equalization/image_data
│   │   │   ├── ./Python/digital_image_processing/histogram_equalization/__init__.py
│   │   │   └── ./Python/digital_image_processing/histogram_equalization/output_data
│   │   ├── ./Python/digital_image_processing/image_data
│   │   │   ├── ./Python/digital_image_processing/image_data/__init__.py
│   │   │   └── ./Python/digital_image_processing/image_data/lena_small.jpg
│   │   ├── ./Python/digital_image_processing/index_calculation.py
│   │   ├── ./Python/digital_image_processing/__init__.py
│   │   ├── ./Python/digital_image_processing/resize
│   │   │   ├── ./Python/digital_image_processing/resize/__init__.py
│   │   │   └── ./Python/digital_image_processing/resize/resize.py
│   │   ├── ./Python/digital_image_processing/rotation
│   │   │   ├── ./Python/digital_image_processing/rotation/__init__.py
│   │   │   └── ./Python/digital_image_processing/rotation/rotation.py
│   │   ├── ./Python/digital_image_processing/sepia.py
│   │   └── ./Python/digital_image_processing/test_digital_image_processing.py
│   ├── ./Python/DIRECTORY.html
│   ├── ./Python/DIRECTORY.md
│   ├── ./Python/divide_and_conquer
│   │   ├── ./Python/divide_and_conquer/closest_pair_of_points.py
│   │   ├── ./Python/divide_and_conquer/convex_hull.py
│   │   ├── ./Python/divide_and_conquer/heaps_algorithm_iterative.py
│   │   ├── ./Python/divide_and_conquer/heaps_algorithm.py
│   │   ├── ./Python/divide_and_conquer/__init__.py
│   │   ├── ./Python/divide_and_conquer/inversions.py
│   │   ├── ./Python/divide_and_conquer/kth_order_statistic.py
│   │   ├── ./Python/divide_and_conquer/max_difference_pair.py
│   │   ├── ./Python/divide_and_conquer/max_subarray_sum.py
│   │   ├── ./Python/divide_and_conquer/mergesort.py
│   │   ├── ./Python/divide_and_conquer/peak.py
│   │   ├── ./Python/divide_and_conquer/power.py
│   │   └── ./Python/divide_and_conquer/strassen_matrix_multiplication.py
│   ├── ./Python/dynamic_programming
│   │   ├── ./Python/dynamic_programming/abbreviation.py
│   │   ├── ./Python/dynamic_programming/bitmask.py
│   │   ├── ./Python/dynamic_programming/catalan_numbers.py
│   │   ├── ./Python/dynamic_programming/climbing_stairs.py
│   │   ├── ./Python/dynamic_programming/edit_distance.py
│   │   ├── ./Python/dynamic_programming/factorial.py
│   │   ├── ./Python/dynamic_programming/fast_fibonacci.py
│   │   ├── ./Python/dynamic_programming/fibonacci.py
│   │   ├── ./Python/dynamic_programming/floyd_warshall.py
│   │   ├── ./Python/dynamic_programming/fractional_knapsack_2.py
│   │   ├── ./Python/dynamic_programming/fractional_knapsack.py
│   │   ├── ./Python/dynamic_programming/__init__.py
│   │   ├── ./Python/dynamic_programming/integer_partition.py
│   │   ├── ./Python/dynamic_programming/iterating_through_submasks.py
│   │   ├── ./Python/dynamic_programming/k_means_clustering_tensorflow.py_tf
│   │   ├── ./Python/dynamic_programming/knapsack.py
│   │   ├── ./Python/dynamic_programming/longest_common_subsequence.py
│   │   ├── ./Python/dynamic_programming/longest_increasing_subsequence_o(nlogn).py
│   │   ├── ./Python/dynamic_programming/longest_increasing_subsequence.py
│   │   ├── ./Python/dynamic_programming/longest_sub_array.py
│   │   ├── ./Python/dynamic_programming/matrix_chain_order.py
│   │   ├── ./Python/dynamic_programming/max_non_adjacent_sum.py
│   │   ├── ./Python/dynamic_programming/max_sub_array.py
│   │   ├── ./Python/dynamic_programming/max_sum_contiguous_subsequence.py
│   │   ├── ./Python/dynamic_programming/minimum_coin_change.py
│   │   ├── ./Python/dynamic_programming/minimum_cost_path.py
│   │   ├── ./Python/dynamic_programming/minimum_partition.py
│   │   ├── ./Python/dynamic_programming/minimum_steps_to_one.py
│   │   ├── ./Python/dynamic_programming/optimal_binary_search_tree.py
│   │   ├── ./Python/dynamic_programming/rod_cutting.py
│   │   ├── ./Python/dynamic_programming/subset_generation.py
│   │   └── ./Python/dynamic_programming/sum_of_subset.py
│   ├── ./Python/electronics
│   │   ├── ./Python/electronics/electric_power.py
│   │   └── ./Python/electronics/ohms_law.py
│   ├── ./Python/file_transfer
│   │   ├── ./Python/file_transfer/__init__.py
│   │   ├── ./Python/file_transfer/mytext.txt
│   │   ├── ./Python/file_transfer/receive_file.py
│   │   ├── ./Python/file_transfer/send_file.py
│   │   └── ./Python/file_transfer/tests
│   │       ├── ./Python/file_transfer/tests/__init__.py
│   │       └── ./Python/file_transfer/tests/test_send_file.py
│   ├── ./Python/fractals
│   │   ├── ./Python/fractals/koch_snowflake.py
│   │   ├── ./Python/fractals/mandelbrot.py
│   │   └── ./Python/fractals/sierpinski_triangle.py
│   ├── ./Python/fuzzy_logic
│   │   ├── ./Python/fuzzy_logic/fuzzy_operations.py
│   │   └── ./Python/fuzzy_logic/__init__.py
│   ├── ./Python/genetic_algorithm
│   │   ├── ./Python/genetic_algorithm/basic_string.py
│   │   └── ./Python/genetic_algorithm/__init__.py
│   ├── ./Python/geodesy
│   │   ├── ./Python/geodesy/haversine_distance.py
│   │   ├── ./Python/geodesy/__init__.py
│   │   └── ./Python/geodesy/lamberts_ellipsoidal_distance.py
│   ├── ./Python/graphics
│   │   ├── ./Python/graphics/bezier_curve.py
│   │   ├── ./Python/graphics/__init__.py
│   │   └── ./Python/graphics/vector3_for_2d_rendering.py
│   ├── ./Python/graphs
│   │   ├── ./Python/graphs/articulation_points.py
│   │   ├── ./Python/graphs/a_star.py
│   │   ├── ./Python/graphs/basic_graphs.py
│   │   ├── ./Python/graphs/bellman_ford.py
│   │   ├── ./Python/graphs/bfs_shortest_path.py
│   │   ├── ./Python/graphs/bfs_zero_one_shortest_path.py
│   │   ├── ./Python/graphs/bidirectional_a_star.py
│   │   ├── ./Python/graphs/bidirectional_breadth_first_search.py
│   │   ├── ./Python/graphs/breadth_first_search_2.py
│   │   ├── ./Python/graphs/breadth_first_search.py
│   │   ├── ./Python/graphs/breadth_first_search_shortest_path.py
│   │   ├── ./Python/graphs/check_bipartite_graph_bfs.py
│   │   ├── ./Python/graphs/check_bipartite_graph_dfs.py
│   │   ├── ./Python/graphs/connected_components.py
│   │   ├── ./Python/graphs/depth_first_search_2.py
│   │   ├── ./Python/graphs/depth_first_search.py
│   │   ├── ./Python/graphs/dijkstra_2.py
│   │   ├── ./Python/graphs/dijkstra_algorithm.py
│   │   ├── ./Python/graphs/dijkstra.py
│   │   ├── ./Python/graphs/dinic.py
│   │   ├── ./Python/graphs/directed_and_undirected_(weighted)_graph.py
│   │   ├── ./Python/graphs/edmonds_karp_multiple_source_and_sink.py
│   │   ├── ./Python/graphs/eulerian_path_and_circuit_for_undirected_graph.py
│   │   ├── ./Python/graphs/even_tree.py
│   │   ├── ./Python/graphs/finding_bridges.py
│   │   ├── ./Python/graphs/frequent_pattern_graph_miner.py
│   │   ├── ./Python/graphs/gale_shapley_bigraph.py
│   │   ├── ./Python/graphs/graph_list.py
│   │   ├── ./Python/graphs/graph_matrix.py
│   │   ├── ./Python/graphs/graphs_floyd_warshall.py
│   │   ├── ./Python/graphs/greedy_best_first.py
│   │   ├── ./Python/graphs/g_topological_sort.py
│   │   ├── ./Python/graphs/__init__.py
│   │   ├── ./Python/graphs/kahns_algorithm_long.py
│   │   ├── ./Python/graphs/kahns_algorithm_topo.py
│   │   ├── ./Python/graphs/karger.py
│   │   ├── ./Python/graphs/markov_chain.py
│   │   ├── ./Python/graphs/minimum_spanning_tree_boruvka.py
│   │   ├── ./Python/graphs/minimum_spanning_tree_kruskal2.py
│   │   ├── ./Python/graphs/minimum_spanning_tree_kruskal.py
│   │   ├── ./Python/graphs/minimum_spanning_tree_prims2.py
│   │   ├── ./Python/graphs/minimum_spanning_tree_prims.py
│   │   ├── ./Python/graphs/multi_heuristic_astar.py
│   │   ├── ./Python/graphs/page_rank.py
│   │   ├── ./Python/graphs/prim.py
│   │   ├── ./Python/graphs/scc_kosaraju.py
│   │   ├── ./Python/graphs/strongly_connected_components.py
│   │   ├── ./Python/graphs/tarjans_scc.py
│   │   └── ./Python/graphs/tests
│   │       ├── ./Python/graphs/tests/test_min_spanning_tree_kruskal.py
│   │       └── ./Python/graphs/tests/test_min_spanning_tree_prim.py
│   ├── ./Python/hashes
│   │   ├── ./Python/hashes/adler32.py
│   │   ├── ./Python/hashes/chaos_machine.py
│   │   ├── ./Python/hashes/djb2.py
│   │   ├── ./Python/hashes/enigma_machine.py
│   │   ├── ./Python/hashes/hamming_code.py
│   │   ├── ./Python/hashes/__init__.py
│   │   ├── ./Python/hashes/luhn.py
│   │   ├── ./Python/hashes/md5.py
│   │   ├── ./Python/hashes/sdbm.py
│   │   └── ./Python/hashes/sha1.py
│   ├── ./Python/knapsack
│   │   ├── ./Python/knapsack/greedy_knapsack.py
│   │   ├── ./Python/knapsack/__init__.py
│   │   ├── ./Python/knapsack/knapsack.py
│   │   ├── ./Python/knapsack/README.html
│   │   ├── ./Python/knapsack/README.md
│   │   └── ./Python/knapsack/tests
│   │       ├── ./Python/knapsack/tests/__init__.py
│   │       ├── ./Python/knapsack/tests/test_greedy_knapsack.py
│   │       └── ./Python/knapsack/tests/test_knapsack.py
│   ├── ./Python/linear_algebra
│   │   ├── ./Python/linear_algebra/__init__.py
│   │   ├── ./Python/linear_algebra/README.html
│   │   ├── ./Python/linear_algebra/README.md
│   │   └── ./Python/linear_algebra/src
│   │       ├── ./Python/linear_algebra/src/conjugate_gradient.py
│   │       ├── ./Python/linear_algebra/src/__init__.py
│   │       ├── ./Python/linear_algebra/src/lib.py
│   │       ├── ./Python/linear_algebra/src/polynom_for_points.py
│   │       ├── ./Python/linear_algebra/src/power_iteration.py
│   │       ├── ./Python/linear_algebra/src/rayleigh_quotient.py
│   │       ├── ./Python/linear_algebra/src/test_linear_algebra.py
│   │       └── ./Python/linear_algebra/src/transformations_2d.py
│   ├── ./Python/machine_learning
│   │   ├── ./Python/machine_learning/astar.py
│   │   ├── ./Python/machine_learning/data_transformations.py
│   │   ├── ./Python/machine_learning/decision_tree.py
│   │   ├── ./Python/machine_learning/forecasting
│   │   │   ├── ./Python/machine_learning/forecasting/ex_data.csv
│   │   │   ├── ./Python/machine_learning/forecasting/__init__.py
│   │   │   └── ./Python/machine_learning/forecasting/run.py
│   │   ├── ./Python/machine_learning/gaussian_naive_bayes.py
│   │   ├── ./Python/machine_learning/gradient_boosting_regressor.py
│   │   ├── ./Python/machine_learning/gradient_descent.py
│   │   ├── ./Python/machine_learning/__init__.py
│   │   ├── ./Python/machine_learning/k_means_clust.py
│   │   ├── ./Python/machine_learning/k_nearest_neighbours.py
│   │   ├── ./Python/machine_learning/knn_sklearn.py
│   │   ├── ./Python/machine_learning/linear_discriminant_analysis.py
│   │   ├── ./Python/machine_learning/linear_regression.py
│   │   ├── ./Python/machine_learning/logistic_regression.py
│   │   ├── ./Python/machine_learning/lstm
│   │   │   ├── ./Python/machine_learning/lstm/__init__.py
│   │   │   ├── ./Python/machine_learning/lstm/lstm_prediction.py
│   │   │   └── ./Python/machine_learning/lstm/sample_data.csv
│   │   ├── ./Python/machine_learning/multilayer_perceptron_classifier.py
│   │   ├── ./Python/machine_learning/polymonial_regression.py
│   │   ├── ./Python/machine_learning/random_forest_classifier.py
│   │   ├── ./Python/machine_learning/random_forest_regressor.py
│   │   ├── ./Python/machine_learning/scoring_functions.py
│   │   ├── ./Python/machine_learning/sequential_minimum_optimization.py
│   │   ├── ./Python/machine_learning/similarity_search.py
│   │   ├── ./Python/machine_learning/support_vector_machines.py
│   │   └── ./Python/machine_learning/word_frequency_functions.py
│   ├── ./Python/maths
│   │   ├── ./Python/maths/3n_plus_1.py
│   │   ├── ./Python/maths/abs_max.py
│   │   ├── ./Python/maths/abs_min.py
│   │   ├── ./Python/maths/abs.py
│   │   ├── ./Python/maths/add.py
│   │   ├── ./Python/maths/aliquot_sum.py
│   │   ├── ./Python/maths/allocation_number.py
│   │   ├── ./Python/maths/area.py
│   │   ├── ./Python/maths/area_under_curve.py
│   │   ├── ./Python/maths/armstrong_numbers.py
│   │   ├── ./Python/maths/average_mean.py
│   │   ├── ./Python/maths/average_median.py
│   │   ├── ./Python/maths/average_mode.py
│   │   ├── ./Python/maths/bailey_borwein_plouffe.py
│   │   ├── ./Python/maths/basic_maths.py
│   │   ├── ./Python/maths/binary_exp_mod.py
│   │   ├── ./Python/maths/binary_exponentiation_2.py
│   │   ├── ./Python/maths/binary_exponentiation_3.py
│   │   ├── ./Python/maths/binary_exponentiation.py
│   │   ├── ./Python/maths/binomial_coefficient.py
│   │   ├── ./Python/maths/binomial_distribution.py
│   │   ├── ./Python/maths/bisection.py
│   │   ├── ./Python/maths/ceil.py
│   │   ├── ./Python/maths/check_valid_ip_address.py
│   │   ├── ./Python/maths/chudnovsky_algorithm.py
│   │   ├── ./Python/maths/collatz_sequence.py
│   │   ├── ./Python/maths/combinations.py
│   │   ├── ./Python/maths/decimal_isolate.py
│   │   ├── ./Python/maths/double_factorial_recursive.py
│   │   ├── ./Python/maths/entropy.py
│   │   ├── ./Python/maths/euclidean_distance.py
│   │   ├── ./Python/maths/euclidean_gcd.py
│   │   ├── ./Python/maths/euler_method.py
│   │   ├── ./Python/maths/eulers_totient.py
│   │   ├── ./Python/maths/extended_euclidean_algorithm.py
│   │   ├── ./Python/maths/factorial_iterative.py
│   │   ├── ./Python/maths/factorial_python.py
│   │   ├── ./Python/maths/factorial_recursive.py
│   │   ├── ./Python/maths/factors.py
│   │   ├── ./Python/maths/fermat_little_theorem.py
│   │   ├── ./Python/maths/fibonacci.py
│   │   ├── ./Python/maths/fibonacci_sequence_recursion.py
│   │   ├── ./Python/maths/find_max.py
│   │   ├── ./Python/maths/find_max_recursion.py
│   │   ├── ./Python/maths/find_min.py
│   │   ├── ./Python/maths/find_min_recursion.py
│   │   ├── ./Python/maths/floor.py
│   │   ├── ./Python/maths/gamma.py
│   │   ├── ./Python/maths/gaussian.py
│   │   ├── ./Python/maths/greatest_common_divisor.py
│   │   ├── ./Python/maths/greedy_coin_change.py
│   │   ├── ./Python/maths/hardy_ramanujanalgo.py
│   │   ├── ./Python/maths/images
│   │   │   ├── ./Python/maths/images/gaussian.png
│   │   │   └── ./Python/maths/images/__init__.py
│   │   ├── ./Python/maths/__init__.py
│   │   ├── ./Python/maths/integration_by_simpson_approx.py
│   │   ├── ./Python/maths/is_square_free.py
│   │   ├── ./Python/maths/jaccard_similarity.py
│   │   ├── ./Python/maths/kadanes.py
│   │   ├── ./Python/maths/karatsuba.py
│   │   ├── ./Python/maths/krishnamurthy_number.py
│   │   ├── ./Python/maths/kth_lexicographic_permutation.py
│   │   ├── ./Python/maths/largest_of_very_large_numbers.py
│   │   ├── ./Python/maths/largest_subarray_sum.py
│   │   ├── ./Python/maths/least_common_multiple.py
│   │   ├── ./Python/maths/line_length.py
│   │   ├── ./Python/maths/lucas_lehmer_primality_test.py
│   │   ├── ./Python/maths/lucas_series.py
│   │   ├── ./Python/maths/matrix_exponentiation.py
│   │   ├── ./Python/maths/max_sum_sliding_window.py
│   │   ├── ./Python/maths/median_of_two_arrays.py
│   │   ├── ./Python/maths/miller_rabin.py
│   │   ├── ./Python/maths/mobius_function.py
│   │   ├── ./Python/maths/modular_exponential.py
│   │   ├── ./Python/maths/monte_carlo_dice.py
│   │   ├── ./Python/maths/monte_carlo.py
│   │   ├── ./Python/maths/newton_raphson.py
│   │   ├── ./Python/maths/number_of_digits.py
│   │   ├── ./Python/maths/numerical_integration.py
│   │   ├── ./Python/maths/perfect_cube.py
│   │   ├── ./Python/maths/perfect_number.py
│   │   ├── ./Python/maths/perfect_square.py
│   │   ├── ./Python/maths/pi_monte_carlo_estimation.py
│   │   ├── ./Python/maths/polynomial_evaluation.py
│   │   ├── ./Python/maths/power_using_recursion.py
│   │   ├── ./Python/maths/prime_check.py
│   │   ├── ./Python/maths/prime_factors.py
│   │   ├── ./Python/maths/primelib.py
│   │   ├── ./Python/maths/prime_numbers.py
│   │   ├── ./Python/maths/prime_sieve_eratosthenes.py
│   │   ├── ./Python/maths/pythagoras.py
│   │   ├── ./Python/maths/qr_decomposition.py
│   │   ├── ./Python/maths/quadratic_equations_complex_numbers.py
│   │   ├── ./Python/maths/radians.py
│   │   ├── ./Python/maths/radix2_fft.py
│   │   ├── ./Python/maths/relu.py
│   │   ├── ./Python/maths/runge_kutta.py
│   │   ├── ./Python/maths/segmented_sieve.py
│   │   ├── ./Python/maths/series
│   │   │   ├── ./Python/maths/series/arithmetic_mean.py
│   │   │   ├── ./Python/maths/series/geometric_mean.py
│   │   │   ├── ./Python/maths/series/geometric_series.py
│   │   │   ├── ./Python/maths/series/harmonic_series.py
│   │   │   ├── ./Python/maths/series/__init__.py
│   │   │   └── ./Python/maths/series/p_series.py
│   │   ├── ./Python/maths/sieve_of_eratosthenes.py
│   │   ├── ./Python/maths/sigmoid.py
│   │   ├── ./Python/maths/simpson_rule.py
│   │   ├── ./Python/maths/softmax.py
│   │   ├── ./Python/maths/square_root.py
│   │   ├── ./Python/maths/sum_of_arithmetic_series.py
│   │   ├── ./Python/maths/sum_of_digits.py
│   │   ├── ./Python/maths/sum_of_geometric_progression.py
│   │   ├── ./Python/maths/test_prime_check.py
│   │   ├── ./Python/maths/trapezoidal_rule.py
│   │   ├── ./Python/maths/triplet_sum.py
│   │   ├── ./Python/maths/two_pointer.py
│   │   ├── ./Python/maths/two_sum.py
│   │   ├── ./Python/maths/ugly_numbers.py
│   │   ├── ./Python/maths/volume.py
│   │   └── ./Python/maths/zellers_congruence.py
│   ├── ./Python/matrix
│   │   ├── ./Python/matrix/count_islands_in_matrix.py
│   │   ├── ./Python/matrix/__init__.py
│   │   ├── ./Python/matrix/inverse_of_matrix.py
│   │   ├── ./Python/matrix/matrix_class.py
│   │   ├── ./Python/matrix/matrix_operation.py
│   │   ├── ./Python/matrix/nth_fibonacci_using_matrix_exponentiation.py
│   │   ├── ./Python/matrix/rotate_matrix.py
│   │   ├── ./Python/matrix/searching_in_sorted_matrix.py
│   │   ├── ./Python/matrix/sherman_morrison.py
│   │   ├── ./Python/matrix/spiral_print.py
│   │   └── ./Python/matrix/tests
│   │       ├── ./Python/matrix/tests/__init__.py
│   │       ├── ./Python/matrix/tests/pytest.ini
│   │       └── ./Python/matrix/tests/test_matrix_operation.py
│   ├── ./Python/mypy.ini
│   ├── ./Python/networking_flow
│   │   ├── ./Python/networking_flow/ford_fulkerson.py
│   │   ├── ./Python/networking_flow/__init__.py
│   │   └── ./Python/networking_flow/minimum_cut.py
│   ├── ./Python/neural_network
│   │   ├── ./Python/neural_network/2_hidden_layers_neural_network.py
│   │   ├── ./Python/neural_network/back_propagation_neural_network.py
│   │   ├── ./Python/neural_network/convolution_neural_network.py
│   │   ├── ./Python/neural_network/gan.py_tf
│   │   ├── ./Python/neural_network/__init__.py
│   │   ├── ./Python/neural_network/input_data.py_tf
│   │   └── ./Python/neural_network/perceptron.py
│   ├── ./Python/other
│   │   ├── ./Python/other/activity_selection.py
│   │   ├── ./Python/other/davis–putnam–logemann–loveland.py
│   │   ├── ./Python/other/dijkstra_bankers_algorithm.py
│   │   ├── ./Python/other/doomsday.py
│   │   ├── ./Python/other/fischer_yates_shuffle.py
│   │   ├── ./Python/other/gauss_easter.py
│   │   ├── ./Python/other/graham_scan.py
│   │   ├── ./Python/other/greedy.py
│   │   ├── ./Python/other/__init__.py
│   │   ├── ./Python/other/least_recently_used.py
│   │   ├── ./Python/other/lfu_cache.py
│   │   ├── ./Python/other/linear_congruential_generator.py
│   │   ├── ./Python/other/lru_cache.py
│   │   ├── ./Python/other/magicdiamondpattern.py
│   │   ├── ./Python/other/nested_brackets.py
│   │   ├── ./Python/other/password_generator.py
│   │   ├── ./Python/other/scoring_algorithm.py
│   │   ├── ./Python/other/sdes.py
│   │   └── ./Python/other/tower_of_hanoi.py
│   ├── ./Python/physics
│   │   └── ./Python/physics/n_body_simulation.py
│   ├── ./Python/project_euler
│   │   ├── ./Python/project_euler/__init__.py
│   │   ├── ./Python/project_euler/problem_001
│   │   │   ├── ./Python/project_euler/problem_001/__init__.py
│   │   │   ├── ./Python/project_euler/problem_001/sol1.py
│   │   │   ├── ./Python/project_euler/problem_001/sol2.py
│   │   │   ├── ./Python/project_euler/problem_001/sol3.py
│   │   │   ├── ./Python/project_euler/problem_001/sol4.py
│   │   │   ├── ./Python/project_euler/problem_001/sol5.py
│   │   │   ├── ./Python/project_euler/problem_001/sol6.py
│   │   │   └── ./Python/project_euler/problem_001/sol7.py
│   │   ├── ./Python/project_euler/problem_002
│   │   │   ├── ./Python/project_euler/problem_002/__init__.py
│   │   │   ├── ./Python/project_euler/problem_002/sol1.py
│   │   │   ├── ./Python/project_euler/problem_002/sol2.py
│   │   │   ├── ./Python/project_euler/problem_002/sol3.py
│   │   │   ├── ./Python/project_euler/problem_002/sol4.py
│   │   │   └── ./Python/project_euler/problem_002/sol5.py
│   │   ├── ./Python/project_euler/problem_003
│   │   │   ├── ./Python/project_euler/problem_003/__init__.py
│   │   │   ├── ./Python/project_euler/problem_003/sol1.py
│   │   │   ├── ./Python/project_euler/problem_003/sol2.py
│   │   │   └── ./Python/project_euler/problem_003/sol3.py
│   │   ├── ./Python/project_euler/problem_004
│   │   │   ├── ./Python/project_euler/problem_004/__init__.py
│   │   │   ├── ./Python/project_euler/problem_004/sol1.py
│   │   │   └── ./Python/project_euler/problem_004/sol2.py
│   │   ├── ./Python/project_euler/problem_005
│   │   │   ├── ./Python/project_euler/problem_005/__init__.py
│   │   │   ├── ./Python/project_euler/problem_005/sol1.py
│   │   │   └── ./Python/project_euler/problem_005/sol2.py
│   │   ├── ./Python/project_euler/problem_006
│   │   │   ├── ./Python/project_euler/problem_006/__init__.py
│   │   │   ├── ./Python/project_euler/problem_006/sol1.py
│   │   │   ├── ./Python/project_euler/problem_006/sol2.py
│   │   │   ├── ./Python/project_euler/problem_006/sol3.py
│   │   │   └── ./Python/project_euler/problem_006/sol4.py
│   │   ├── ./Python/project_euler/problem_007
│   │   │   ├── ./Python/project_euler/problem_007/__init__.py
│   │   │   ├── ./Python/project_euler/problem_007/sol1.py
│   │   │   ├── ./Python/project_euler/problem_007/sol2.py
│   │   │   └── ./Python/project_euler/problem_007/sol3.py
│   │   ├── ./Python/project_euler/problem_008
│   │   │   ├── ./Python/project_euler/problem_008/__init__.py
│   │   │   ├── ./Python/project_euler/problem_008/sol1.py
│   │   │   ├── ./Python/project_euler/problem_008/sol2.py
│   │   │   └── ./Python/project_euler/problem_008/sol3.py
│   │   ├── ./Python/project_euler/problem_009
│   │   │   ├── ./Python/project_euler/problem_009/__init__.py
│   │   │   ├── ./Python/project_euler/problem_009/sol1.py
│   │   │   ├── ./Python/project_euler/problem_009/sol2.py
│   │   │   └── ./Python/project_euler/problem_009/sol3.py
│   │   ├── ./Python/project_euler/problem_010
│   │   │   ├── ./Python/project_euler/problem_010/__init__.py
│   │   │   ├── ./Python/project_euler/problem_010/sol1.py
│   │   │   ├── ./Python/project_euler/problem_010/sol2.py
│   │   │   └── ./Python/project_euler/problem_010/sol3.py
│   │   ├── ./Python/project_euler/problem_011
│   │   │   ├── ./Python/project_euler/problem_011/grid.txt
│   │   │   ├── ./Python/project_euler/problem_011/__init__.py
│   │   │   ├── ./Python/project_euler/problem_011/sol1.py
│   │   │   └── ./Python/project_euler/problem_011/sol2.py
│   │   ├── ./Python/project_euler/problem_012
│   │   │   ├── ./Python/project_euler/problem_012/__init__.py
│   │   │   ├── ./Python/project_euler/problem_012/sol1.py
│   │   │   └── ./Python/project_euler/problem_012/sol2.py
│   │   ├── ./Python/project_euler/problem_013
│   │   │   ├── ./Python/project_euler/problem_013/__init__.py
│   │   │   ├── ./Python/project_euler/problem_013/num.txt
│   │   │   └── ./Python/project_euler/problem_013/sol1.py
│   │   ├── ./Python/project_euler/problem_014
│   │   │   ├── ./Python/project_euler/problem_014/__init__.py
│   │   │   ├── ./Python/project_euler/problem_014/sol1.py
│   │   │   └── ./Python/project_euler/problem_014/sol2.py
│   │   ├── ./Python/project_euler/problem_015
│   │   │   ├── ./Python/project_euler/problem_015/__init__.py
│   │   │   └── ./Python/project_euler/problem_015/sol1.py
│   │   ├── ./Python/project_euler/problem_016
│   │   │   ├── ./Python/project_euler/problem_016/__init__.py
│   │   │   ├── ./Python/project_euler/problem_016/sol1.py
│   │   │   └── ./Python/project_euler/problem_016/sol2.py
│   │   ├── ./Python/project_euler/problem_017
│   │   │   ├── ./Python/project_euler/problem_017/__init__.py
│   │   │   └── ./Python/project_euler/problem_017/sol1.py
│   │   ├── ./Python/project_euler/problem_018
│   │   │   ├── ./Python/project_euler/problem_018/__init__.py
│   │   │   ├── ./Python/project_euler/problem_018/solution.py
│   │   │   └── ./Python/project_euler/problem_018/triangle.txt
│   │   ├── ./Python/project_euler/problem_019
│   │   │   ├── ./Python/project_euler/problem_019/__init__.py
│   │   │   └── ./Python/project_euler/problem_019/sol1.py
│   │   ├── ./Python/project_euler/problem_020
│   │   │   ├── ./Python/project_euler/problem_020/__init__.py
│   │   │   ├── ./Python/project_euler/problem_020/sol1.py
│   │   │   ├── ./Python/project_euler/problem_020/sol2.py
│   │   │   ├── ./Python/project_euler/problem_020/sol3.py
│   │   │   └── ./Python/project_euler/problem_020/sol4.py
│   │   ├── ./Python/project_euler/problem_021
│   │   │   ├── ./Python/project_euler/problem_021/__init__.py
│   │   │   └── ./Python/project_euler/problem_021/sol1.py
│   │   ├── ./Python/project_euler/problem_022
│   │   │   ├── ./Python/project_euler/problem_022/__init__.py
│   │   │   ├── ./Python/project_euler/problem_022/p022_names.txt
│   │   │   ├── ./Python/project_euler/problem_022/sol1.py
│   │   │   └── ./Python/project_euler/problem_022/sol2.py
│   │   ├── ./Python/project_euler/problem_023
│   │   │   ├── ./Python/project_euler/problem_023/__init__.py
│   │   │   └── ./Python/project_euler/problem_023/sol1.py
│   │   ├── ./Python/project_euler/problem_024
│   │   │   ├── ./Python/project_euler/problem_024/__init__.py
│   │   │   └── ./Python/project_euler/problem_024/sol1.py
│   │   ├── ./Python/project_euler/problem_025
│   │   │   ├── ./Python/project_euler/problem_025/__init__.py
│   │   │   ├── ./Python/project_euler/problem_025/sol1.py
│   │   │   ├── ./Python/project_euler/problem_025/sol2.py
│   │   │   └── ./Python/project_euler/problem_025/sol3.py
│   │   ├── ./Python/project_euler/problem_026
│   │   │   ├── ./Python/project_euler/problem_026/__init__.py
│   │   │   └── ./Python/project_euler/problem_026/sol1.py
│   │   ├── ./Python/project_euler/problem_027
│   │   │   ├── ./Python/project_euler/problem_027/__init__.py
│   │   │   └── ./Python/project_euler/problem_027/sol1.py
│   │   ├── ./Python/project_euler/problem_028
│   │   │   ├── ./Python/project_euler/problem_028/__init__.py
│   │   │   └── ./Python/project_euler/problem_028/sol1.py
│   │   ├── ./Python/project_euler/problem_029
│   │   │   ├── ./Python/project_euler/problem_029/__init__.py
│   │   │   └── ./Python/project_euler/problem_029/sol1.py
│   │   ├── ./Python/project_euler/problem_030
│   │   │   ├── ./Python/project_euler/problem_030/__init__.py
│   │   │   └── ./Python/project_euler/problem_030/sol1.py
│   │   ├── ./Python/project_euler/problem_031
│   │   │   ├── ./Python/project_euler/problem_031/__init__.py
│   │   │   ├── ./Python/project_euler/problem_031/sol1.py
│   │   │   └── ./Python/project_euler/problem_031/sol2.py
│   │   ├── ./Python/project_euler/problem_032
│   │   │   ├── ./Python/project_euler/problem_032/__init__.py
│   │   │   └── ./Python/project_euler/problem_032/sol32.py
│   │   ├── ./Python/project_euler/problem_033
│   │   │   ├── ./Python/project_euler/problem_033/__init__.py
│   │   │   └── ./Python/project_euler/problem_033/sol1.py
│   │   ├── ./Python/project_euler/problem_034
│   │   │   ├── ./Python/project_euler/problem_034/__init__.py
│   │   │   └── ./Python/project_euler/problem_034/sol1.py
│   │   ├── ./Python/project_euler/problem_035
│   │   │   ├── ./Python/project_euler/problem_035/__init__.py
│   │   │   └── ./Python/project_euler/problem_035/sol1.py
│   │   ├── ./Python/project_euler/problem_036
│   │   │   ├── ./Python/project_euler/problem_036/__init__.py
│   │   │   └── ./Python/project_euler/problem_036/sol1.py
│   │   ├── ./Python/project_euler/problem_037
│   │   │   ├── ./Python/project_euler/problem_037/__init__.py
│   │   │   └── ./Python/project_euler/problem_037/sol1.py
│   │   ├── ./Python/project_euler/problem_038
│   │   │   ├── ./Python/project_euler/problem_038/__init__.py
│   │   │   └── ./Python/project_euler/problem_038/sol1.py
│   │   ├── ./Python/project_euler/problem_039
│   │   │   ├── ./Python/project_euler/problem_039/__init__.py
│   │   │   └── ./Python/project_euler/problem_039/sol1.py
│   │   ├── ./Python/project_euler/problem_040
│   │   │   ├── ./Python/project_euler/problem_040/__init__.py
│   │   │   └── ./Python/project_euler/problem_040/sol1.py
│   │   ├── ./Python/project_euler/problem_041
│   │   │   ├── ./Python/project_euler/problem_041/__init__.py
│   │   │   └── ./Python/project_euler/problem_041/sol1.py
│   │   ├── ./Python/project_euler/problem_042
│   │   │   ├── ./Python/project_euler/problem_042/__init__.py
│   │   │   ├── ./Python/project_euler/problem_042/solution42.py
│   │   │   └── ./Python/project_euler/problem_042/words.txt
│   │   ├── ./Python/project_euler/problem_043
│   │   │   ├── ./Python/project_euler/problem_043/__init__.py
│   │   │   └── ./Python/project_euler/problem_043/sol1.py
│   │   ├── ./Python/project_euler/problem_044
│   │   │   ├── ./Python/project_euler/problem_044/__init__.py
│   │   │   └── ./Python/project_euler/problem_044/sol1.py
│   │   ├── ./Python/project_euler/problem_045
│   │   │   ├── ./Python/project_euler/problem_045/__init__.py
│   │   │   └── ./Python/project_euler/problem_045/sol1.py
│   │   ├── ./Python/project_euler/problem_046
│   │   │   ├── ./Python/project_euler/problem_046/__init__.py
│   │   │   └── ./Python/project_euler/problem_046/sol1.py
│   │   ├── ./Python/project_euler/problem_047
│   │   │   ├── ./Python/project_euler/problem_047/__init__.py
│   │   │   └── ./Python/project_euler/problem_047/sol1.py
│   │   ├── ./Python/project_euler/problem_048
│   │   │   ├── ./Python/project_euler/problem_048/__init__.py
│   │   │   └── ./Python/project_euler/problem_048/sol1.py
│   │   ├── ./Python/project_euler/problem_049
│   │   │   ├── ./Python/project_euler/problem_049/__init__.py
│   │   │   └── ./Python/project_euler/problem_049/sol1.py
│   │   ├── ./Python/project_euler/problem_050
│   │   │   ├── ./Python/project_euler/problem_050/__init__.py
│   │   │   └── ./Python/project_euler/problem_050/sol1.py
│   │   ├── ./Python/project_euler/problem_051
│   │   │   ├── ./Python/project_euler/problem_051/__init__.py
│   │   │   └── ./Python/project_euler/problem_051/sol1.py
│   │   ├── ./Python/project_euler/problem_052
│   │   │   ├── ./Python/project_euler/problem_052/__init__.py
│   │   │   └── ./Python/project_euler/problem_052/sol1.py
│   │   ├── ./Python/project_euler/problem_053
│   │   │   ├── ./Python/project_euler/problem_053/__init__.py
│   │   │   └── ./Python/project_euler/problem_053/sol1.py
│   │   ├── ./Python/project_euler/problem_054
│   │   │   ├── ./Python/project_euler/problem_054/__init__.py
│   │   │   ├── ./Python/project_euler/problem_054/poker_hands.txt
│   │   │   ├── ./Python/project_euler/problem_054/sol1.py
│   │   │   └── ./Python/project_euler/problem_054/test_poker_hand.py
│   │   ├── ./Python/project_euler/problem_055
│   │   │   ├── ./Python/project_euler/problem_055/__init__.py
│   │   │   └── ./Python/project_euler/problem_055/sol1.py
│   │   ├── ./Python/project_euler/problem_056
│   │   │   ├── ./Python/project_euler/problem_056/__init__.py
│   │   │   └── ./Python/project_euler/problem_056/sol1.py
│   │   ├── ./Python/project_euler/problem_057
│   │   │   ├── ./Python/project_euler/problem_057/__init__.py
│   │   │   └── ./Python/project_euler/problem_057/sol1.py
│   │   ├── ./Python/project_euler/problem_058
│   │   │   ├── ./Python/project_euler/problem_058/__init__.py
│   │   │   └── ./Python/project_euler/problem_058/sol1.py
│   │   ├── ./Python/project_euler/problem_059
│   │   │   ├── ./Python/project_euler/problem_059/__init__.py
│   │   │   ├── ./Python/project_euler/problem_059/p059_cipher.txt
│   │   │   ├── ./Python/project_euler/problem_059/sol1.py
│   │   │   └── ./Python/project_euler/problem_059/test_cipher.txt
│   │   ├── ./Python/project_euler/problem_062
│   │   │   ├── ./Python/project_euler/problem_062/__init__.py
│   │   │   └── ./Python/project_euler/problem_062/sol1.py
│   │   ├── ./Python/project_euler/problem_063
│   │   │   ├── ./Python/project_euler/problem_063/__init__.py
│   │   │   └── ./Python/project_euler/problem_063/sol1.py
│   │   ├── ./Python/project_euler/problem_064
│   │   │   ├── ./Python/project_euler/problem_064/__init__.py
│   │   │   └── ./Python/project_euler/problem_064/sol1.py
│   │   ├── ./Python/project_euler/problem_065
│   │   │   ├── ./Python/project_euler/problem_065/__init__.py
│   │   │   └── ./Python/project_euler/problem_065/sol1.py
│   │   ├── ./Python/project_euler/problem_067
│   │   │   ├── ./Python/project_euler/problem_067/__init__.py
│   │   │   ├── ./Python/project_euler/problem_067/sol1.py
│   │   │   └── ./Python/project_euler/problem_067/triangle.txt
│   │   ├── ./Python/project_euler/problem_069
│   │   │   ├── ./Python/project_euler/problem_069/__init__.py
│   │   │   └── ./Python/project_euler/problem_069/sol1.py
│   │   ├── ./Python/project_euler/problem_070
│   │   │   ├── ./Python/project_euler/problem_070/__init__.py
│   │   │   └── ./Python/project_euler/problem_070/sol1.py
│   │   ├── ./Python/project_euler/problem_071
│   │   │   ├── ./Python/project_euler/problem_071/__init__.py
│   │   │   └── ./Python/project_euler/problem_071/sol1.py
│   │   ├── ./Python/project_euler/problem_072
│   │   │   ├── ./Python/project_euler/problem_072/__init__.py
│   │   │   ├── ./Python/project_euler/problem_072/sol1.py
│   │   │   └── ./Python/project_euler/problem_072/sol2.py
│   │   ├── ./Python/project_euler/problem_074
│   │   │   ├── ./Python/project_euler/problem_074/__init__.py
│   │   │   ├── ./Python/project_euler/problem_074/sol1.py
│   │   │   └── ./Python/project_euler/problem_074/sol2.py
│   │   ├── ./Python/project_euler/problem_075
│   │   │   ├── ./Python/project_euler/problem_075/__init__.py
│   │   │   └── ./Python/project_euler/problem_075/sol1.py
│   │   ├── ./Python/project_euler/problem_076
│   │   │   ├── ./Python/project_euler/problem_076/__init__.py
│   │   │   └── ./Python/project_euler/problem_076/sol1.py
│   │   ├── ./Python/project_euler/problem_077
│   │   │   ├── ./Python/project_euler/problem_077/__init__.py
│   │   │   └── ./Python/project_euler/problem_077/sol1.py
│   │   ├── ./Python/project_euler/problem_080
│   │   │   ├── ./Python/project_euler/problem_080/__init__.py
│   │   │   └── ./Python/project_euler/problem_080/sol1.py
│   │   ├── ./Python/project_euler/problem_081
│   │   │   ├── ./Python/project_euler/problem_081/__init__.py
│   │   │   ├── ./Python/project_euler/problem_081/matrix.txt
│   │   │   └── ./Python/project_euler/problem_081/sol1.py
│   │   ├── ./Python/project_euler/problem_085
│   │   │   ├── ./Python/project_euler/problem_085/__init__.py
│   │   │   └── ./Python/project_euler/problem_085/sol1.py
│   │   ├── ./Python/project_euler/problem_086
│   │   │   ├── ./Python/project_euler/problem_086/__init__.py
│   │   │   └── ./Python/project_euler/problem_086/sol1.py
│   │   ├── ./Python/project_euler/problem_087
│   │   │   ├── ./Python/project_euler/problem_087/__init__.py
│   │   │   └── ./Python/project_euler/problem_087/sol1.py
│   │   ├── ./Python/project_euler/problem_089
│   │   │   ├── ./Python/project_euler/problem_089/__init__.py
│   │   │   ├── ./Python/project_euler/problem_089/numeralcleanup_test.txt
│   │   │   ├── ./Python/project_euler/problem_089/p089_roman.txt
│   │   │   └── ./Python/project_euler/problem_089/sol1.py
│   │   ├── ./Python/project_euler/problem_091
│   │   │   ├── ./Python/project_euler/problem_091/__init__.py
│   │   │   └── ./Python/project_euler/problem_091/sol1.py
│   │   ├── ./Python/project_euler/problem_097
│   │   │   ├── ./Python/project_euler/problem_097/__init__.py
│   │   │   └── ./Python/project_euler/problem_097/sol1.py
│   │   ├── ./Python/project_euler/problem_099
│   │   │   ├── ./Python/project_euler/problem_099/base_exp.txt
│   │   │   ├── ./Python/project_euler/problem_099/__init__.py
│   │   │   └── ./Python/project_euler/problem_099/sol1.py
│   │   ├── ./Python/project_euler/problem_101
│   │   │   ├── ./Python/project_euler/problem_101/__init__.py
│   │   │   └── ./Python/project_euler/problem_101/sol1.py
│   │   ├── ./Python/project_euler/problem_102
│   │   │   ├── ./Python/project_euler/problem_102/__init__.py
│   │   │   ├── ./Python/project_euler/problem_102/p102_triangles.txt
│   │   │   ├── ./Python/project_euler/problem_102/sol1.py
│   │   │   └── ./Python/project_euler/problem_102/test_triangles.txt
│   │   ├── ./Python/project_euler/problem_107
│   │   │   ├── ./Python/project_euler/problem_107/__init__.py
│   │   │   ├── ./Python/project_euler/problem_107/p107_network.txt
│   │   │   ├── ./Python/project_euler/problem_107/sol1.py
│   │   │   └── ./Python/project_euler/problem_107/test_network.txt
│   │   ├── ./Python/project_euler/problem_109
│   │   │   ├── ./Python/project_euler/problem_109/__init__.py
│   │   │   └── ./Python/project_euler/problem_109/sol1.py
│   │   ├── ./Python/project_euler/problem_112
│   │   │   ├── ./Python/project_euler/problem_112/__init__.py
│   │   │   └── ./Python/project_euler/problem_112/sol1.py
│   │   ├── ./Python/project_euler/problem_113
│   │   │   ├── ./Python/project_euler/problem_113/__init__.py
│   │   │   └── ./Python/project_euler/problem_113/sol1.py
│   │   ├── ./Python/project_euler/problem_119
│   │   │   ├── ./Python/project_euler/problem_119/__init__.py
│   │   │   └── ./Python/project_euler/problem_119/sol1.py
│   │   ├── ./Python/project_euler/problem_120
│   │   │   ├── ./Python/project_euler/problem_120/__init__.py
│   │   │   └── ./Python/project_euler/problem_120/sol1.py
│   │   ├── ./Python/project_euler/problem_121
│   │   │   ├── ./Python/project_euler/problem_121/__init__.py
│   │   │   └── ./Python/project_euler/problem_121/sol1.py
│   │   ├── ./Python/project_euler/problem_123
│   │   │   ├── ./Python/project_euler/problem_123/__init__.py
│   │   │   └── ./Python/project_euler/problem_123/sol1.py
│   │   ├── ./Python/project_euler/problem_125
│   │   │   ├── ./Python/project_euler/problem_125/__init__.py
│   │   │   └── ./Python/project_euler/problem_125/sol1.py
│   │   ├── ./Python/project_euler/problem_129
│   │   │   ├── ./Python/project_euler/problem_129/__init__.py
│   │   │   └── ./Python/project_euler/problem_129/sol1.py
│   │   ├── ./Python/project_euler/problem_135
│   │   │   ├── ./Python/project_euler/problem_135/__init__.py
│   │   │   └── ./Python/project_euler/problem_135/sol1.py
│   │   ├── ./Python/project_euler/problem_144
│   │   │   ├── ./Python/project_euler/problem_144/__init__.py
│   │   │   └── ./Python/project_euler/problem_144/sol1.py
│   │   ├── ./Python/project_euler/problem_173
│   │   │   ├── ./Python/project_euler/problem_173/__init__.py
│   │   │   └── ./Python/project_euler/problem_173/sol1.py
│   │   ├── ./Python/project_euler/problem_174
│   │   │   ├── ./Python/project_euler/problem_174/__init__.py
│   │   │   └── ./Python/project_euler/problem_174/sol1.py
│   │   ├── ./Python/project_euler/problem_180
│   │   │   ├── ./Python/project_euler/problem_180/__init__.py
│   │   │   └── ./Python/project_euler/problem_180/sol1.py
│   │   ├── ./Python/project_euler/problem_188
│   │   │   ├── ./Python/project_euler/problem_188/__init__.py
│   │   │   └── ./Python/project_euler/problem_188/sol1.py
│   │   ├── ./Python/project_euler/problem_191
│   │   │   ├── ./Python/project_euler/problem_191/__init__.py
│   │   │   └── ./Python/project_euler/problem_191/sol1.py
│   │   ├── ./Python/project_euler/problem_203
│   │   │   ├── ./Python/project_euler/problem_203/__init__.py
│   │   │   └── ./Python/project_euler/problem_203/sol1.py
│   │   ├── ./Python/project_euler/problem_206
│   │   │   ├── ./Python/project_euler/problem_206/__init__.py
│   │   │   └── ./Python/project_euler/problem_206/sol1.py
│   │   ├── ./Python/project_euler/problem_207
│   │   │   ├── ./Python/project_euler/problem_207/__init__.py
│   │   │   └── ./Python/project_euler/problem_207/sol1.py
│   │   ├── ./Python/project_euler/problem_234
│   │   │   ├── ./Python/project_euler/problem_234/__init__.py
│   │   │   └── ./Python/project_euler/problem_234/sol1.py
│   │   ├── ./Python/project_euler/problem_301
│   │   │   ├── ./Python/project_euler/problem_301/__init__.py
│   │   │   └── ./Python/project_euler/problem_301/sol1.py
│   │   ├── ./Python/project_euler/problem_551
│   │   │   ├── ./Python/project_euler/problem_551/__init__.py
│   │   │   └── ./Python/project_euler/problem_551/sol1.py
│   │   ├── ./Python/project_euler/README.html
│   │   └── ./Python/project_euler/README.md
│   ├── ./Python/pytest.ini
│   ├── ./Python/quantum
│   │   ├── ./Python/quantum/deutsch_jozsa.py
│   │   ├── ./Python/quantum/half_adder.py
│   │   ├── ./Python/quantum/__init__.py
│   │   ├── ./Python/quantum/not_gate.py
│   │   ├── ./Python/quantum/quantum_entanglement.py
│   │   ├── ./Python/quantum/README.html
│   │   ├── ./Python/quantum/README.md
│   │   ├── ./Python/quantum/ripple_adder_classic.py
│   │   └── ./Python/quantum/single_qubit_measure.py
│   ├── ./Python/README.html
│   ├── ./Python/README.md
│   ├── ./Python/requirements.txt
│   ├── ./Python/scheduling
│   │   ├── ./Python/scheduling/first_come_first_served.py
│   │   ├── ./Python/scheduling/__init__.py
│   │   ├── ./Python/scheduling/round_robin.py
│   │   └── ./Python/scheduling/shortest_job_first.py
│   ├── ./Python/scripts
│   │   ├── ./Python/scripts/build_directory_md.py
│   │   ├── ./Python/scripts/__init__.py
│   │   ├── ./Python/scripts/project_euler_answers.json
│   │   ├── ./Python/scripts/validate_filenames.py
│   │   └── ./Python/scripts/validate_solutions.py
│   ├── ./Python/searches
│   │   ├── ./Python/searches/binary_search.py
│   │   ├── ./Python/searches/binary_tree_traversal.py
│   │   ├── ./Python/searches/double_linear_search.py
│   │   ├── ./Python/searches/double_linear_search_recursion.py
│   │   ├── ./Python/searches/fibonacci_search.py
│   │   ├── ./Python/searches/hill_climbing.py
│   │   ├── ./Python/searches/__init__.py
│   │   ├── ./Python/searches/interpolation_search.py
│   │   ├── ./Python/searches/jump_search.py
│   │   ├── ./Python/searches/linear_search.py
│   │   ├── ./Python/searches/quick_select.py
│   │   ├── ./Python/searches/sentinel_linear_search.py
│   │   ├── ./Python/searches/simple_binary_search.py
│   │   ├── ./Python/searches/simulated_annealing.py
│   │   ├── ./Python/searches/tabu_search.py
│   │   ├── ./Python/searches/tabu_test_data.txt
│   │   └── ./Python/searches/ternary_search.py
│   ├── ./Python/sorts
│   │   ├── ./Python/sorts/bead_sort.py
│   │   ├── ./Python/sorts/bitonic_sort.py
│   │   ├── ./Python/sorts/bogo_sort.py
│   │   ├── ./Python/sorts/bubble_sort.py
│   │   ├── ./Python/sorts/bucket_sort.py
│   │   ├── ./Python/sorts/cocktail_shaker_sort.py
│   │   ├── ./Python/sorts/comb_sort.py
│   │   ├── ./Python/sorts/counting_sort.py
│   │   ├── ./Python/sorts/cycle_sort.py
│   │   ├── ./Python/sorts/double_sort.py
│   │   ├── ./Python/sorts/external_sort.py
│   │   ├── ./Python/sorts/gnome_sort.py
│   │   ├── ./Python/sorts/heap_sort.py
│   │   ├── ./Python/sorts/__init__.py
│   │   ├── ./Python/sorts/insertion_sort.py
│   │   ├── ./Python/sorts/intro_sort.py
│   │   ├── ./Python/sorts/iterative_merge_sort.py
│   │   ├── ./Python/sorts/merge_insertion_sort.py
│   │   ├── ./Python/sorts/merge_sort.py
│   │   ├── ./Python/sorts/msd_radix_sort.py
│   │   ├── ./Python/sorts/natural_sort.py
│   │   ├── ./Python/sorts/normal_distribution_quick_sort.html
│   │   ├── ./Python/sorts/normal_distribution_quick_sort.md
│   │   ├── ./Python/sorts/odd_even_sort.py
│   │   ├── ./Python/sorts/odd_even_transposition_parallel.py
│   │   ├── ./Python/sorts/odd_even_transposition_single_threaded.py
│   │   ├── ./Python/sorts/pancake_sort.py
│   │   ├── ./Python/sorts/patience_sort.py
│   │   ├── ./Python/sorts/pigeonhole_sort.py
│   │   ├── ./Python/sorts/pigeon_sort.py
│   │   ├── ./Python/sorts/quick_sort_3_partition.py
│   │   ├── ./Python/sorts/quick_sort.py
│   │   ├── ./Python/sorts/radix_sort.py
│   │   ├── ./Python/sorts/random_normal_distribution_quicksort.py
│   │   ├── ./Python/sorts/random_pivot_quick_sort.py
│   │   ├── ./Python/sorts/recursive_bubble_sort.py
│   │   ├── ./Python/sorts/recursive_insertion_sort.py
│   │   ├── ./Python/sorts/recursive_mergesort_array.py
│   │   ├── ./Python/sorts/recursive_quick_sort.py
│   │   ├── ./Python/sorts/selection_sort.py
│   │   ├── ./Python/sorts/shell_sort.py
│   │   ├── ./Python/sorts/slowsort.py
│   │   ├── ./Python/sorts/stooge_sort.py
│   │   ├── ./Python/sorts/strand_sort.py
│   │   ├── ./Python/sorts/tim_sort.py
│   │   ├── ./Python/sorts/topological_sort.py
│   │   ├── ./Python/sorts/tree_sort.py
│   │   ├── ./Python/sorts/unknown_sort.py
│   │   └── ./Python/sorts/wiggle_sort.py
│   ├── ./Python/strings
│   │   ├── ./Python/strings/aho_corasick.py
│   │   ├── ./Python/strings/alternative_string_arrange.py
│   │   ├── ./Python/strings/anagrams.py
│   │   ├── ./Python/strings/autocomplete_using_trie.py
│   │   ├── ./Python/strings/boyer_moore_search.py
│   │   ├── ./Python/strings/can_string_be_rearranged_as_palindrome.py
│   │   ├── ./Python/strings/capitalize.py
│   │   ├── ./Python/strings/check_anagrams.py
│   │   ├── ./Python/strings/check_pangram.py
│   │   ├── ./Python/strings/detecting_english_programmatically.py
│   │   ├── ./Python/strings/frequency_finder.py
│   │   ├── ./Python/strings/indian_phone_validator.py
│   │   ├── ./Python/strings/__init__.py
│   │   ├── ./Python/strings/is_palindrome.py
│   │   ├── ./Python/strings/jaro_winkler.py
│   │   ├── ./Python/strings/knuth_morris_pratt.py
│   │   ├── ./Python/strings/levenshtein_distance.py
│   │   ├── ./Python/strings/lower.py
│   │   ├── ./Python/strings/manacher.py
│   │   ├── ./Python/strings/min_cost_string_conversion.py
│   │   ├── ./Python/strings/naive_string_search.py
│   │   ├── ./Python/strings/palindrome.py
│   │   ├── ./Python/strings/prefix_function.py
│   │   ├── ./Python/strings/rabin_karp.py
│   │   ├── ./Python/strings/remove_duplicate.py
│   │   ├── ./Python/strings/reverse_letters.py
│   │   ├── ./Python/strings/reverse_words.py
│   │   ├── ./Python/strings/split.py
│   │   ├── ./Python/strings/swap_case.py
│   │   ├── ./Python/strings/upper.py
│   │   ├── ./Python/strings/word_occurrence.py
│   │   ├── ./Python/strings/word_patterns.py
│   │   └── ./Python/strings/z_function.py
│   └── ./Python/web_programming
│       ├── ./Python/web_programming/co2_emission.py
│       ├── ./Python/web_programming/covid_stats_via_xpath.py
│       ├── ./Python/web_programming/crawl_google_results.py
│       ├── ./Python/web_programming/crawl_google_scholar_citation.py
│       ├── ./Python/web_programming/currency_converter.py
│       ├── ./Python/web_programming/current_stock_price.py
│       ├── ./Python/web_programming/current_weather.py
│       ├── ./Python/web_programming/daily_horoscope.py
│       ├── ./Python/web_programming/emails_from_url.py
│       ├── ./Python/web_programming/fetch_bbc_news.py
│       ├── ./Python/web_programming/fetch_github_info.py
│       ├── ./Python/web_programming/fetch_jobs.py
│       ├── ./Python/web_programming/get_imdb_top_250_movies_csv.py
│       ├── ./Python/web_programming/get_imdbtop.py
│       ├── ./Python/web_programming/__init__.py
│       ├── ./Python/web_programming/instagram_crawler.py
│       ├── ./Python/web_programming/instagram_pic.py
│       ├── ./Python/web_programming/instagram_video.py
│       ├── ./Python/web_programming/random_anime_character.py
│       ├── ./Python/web_programming/recaptcha_verification.py
│       ├── ./Python/web_programming/slack_message.py
│       ├── ./Python/web_programming/test_fetch_github_info.py
│       └── ./Python/web_programming/world_covid19_stats.py
├── ./R
│   ├── ./R/Association-Algorithms
│   │   └── ./R/Association-Algorithms/apriori.R
│   ├── ./R/Classification-Algorithms
│   │   ├── ./R/Classification-Algorithms/decision_tree.R
│   │   ├── ./R/Classification-Algorithms/gradient_boosting_algorithms.R
│   │   ├── ./R/Classification-Algorithms/KNN.R
│   │   ├── ./R/Classification-Algorithms/lasso.R
│   │   ├── ./R/Classification-Algorithms/LightGBM.R
│   │   ├── ./R/Classification-Algorithms/naive_bayes.R
│   │   ├── ./R/Classification-Algorithms/random_forest.R
│   │   ├── ./R/Classification-Algorithms/SVM.R
│   │   └── ./R/Classification-Algorithms/xgboost.R
│   ├── ./R/Clustering-Algorithms
│   │   ├── ./R/Clustering-Algorithms/dbscan_clustering.R
│   │   ├── ./R/Clustering-Algorithms/gmm.R
│   │   ├── ./R/Clustering-Algorithms/heirarchical_clustering.R
│   │   ├── ./R/Clustering-Algorithms/kmeans_clustering.R
│   │   ├── ./R/Clustering-Algorithms/K-Means.R
│   │   ├── ./R/Clustering-Algorithms/kmeans_raw_R.R
│   │   └── ./R/Clustering-Algorithms/pam.R
│   ├── ./R/Data-Manipulation
│   │   ├── ./R/Data-Manipulation/LabelEncode.R
│   │   └── ./R/Data-Manipulation/OneHotEncode.R
│   ├── ./R/Data-Mining
│   │   ├── ./R/Data-Mining/README.html
│   │   └── ./R/Data-Mining/README.md
│   ├── ./R/Data-Preprocessing
│   │   ├── ./R/Data-Preprocessing/data_normalization_standardization.R
│   │   ├── ./R/Data-Preprocessing/data_processing.R
│   │   ├── ./R/Data-Preprocessing/dimensionality_reduction_algorithms.R
│   │   ├── ./R/Data-Preprocessing/K_Folds.R
│   │   └── ./R/Data-Preprocessing/lasso.R
│   ├── ./R/DIRECTORY.html
│   ├── ./R/DIRECTORY.md
│   ├── ./R/Machine-Learning
│   │   ├── ./R/Machine-Learning/README.html
│   │   └── ./R/Machine-Learning/README.md
│   ├── ./R/Mathematics
│   │   ├── ./R/Mathematics/EuclideanDistance.R
│   │   ├── ./R/Mathematics/Factorial.R
│   │   ├── ./R/Mathematics/Fibonacci.R
│   │   ├── ./R/Mathematics/PerfectSquare.R
│   │   ├── ./R/Mathematics/PiMonteCarlo.R
│   │   └── ./R/Mathematics/Prime.R
│   ├── ./R/README.html
│   ├── ./R/README.md
│   ├── ./R/Regression-Algorithms
│   │   ├── ./R/Regression-Algorithms/ANN.R
│   │   ├── ./R/Regression-Algorithms/gradient_boosting_algorithms.R
│   │   ├── ./R/Regression-Algorithms/KNN.R
│   │   ├── ./R/Regression-Algorithms/LightGBM.R
│   │   ├── ./R/Regression-Algorithms/linear_regression.R
│   │   ├── ./R/Regression-Algorithms/linearRegressionRawR.R
│   │   ├── ./R/Regression-Algorithms/logistic_regression2.R
│   │   ├── ./R/Regression-Algorithms/logistic_regression.R
│   │   └── ./R/Regression-Algorithms/multiple_linear_regression.R
│   └── ./R/Sorting-Algorithms
│       ├── ./R/Sorting-Algorithms/bubble_sort.R
│       ├── ./R/Sorting-Algorithms/comb_sort.R
│       ├── ./R/Sorting-Algorithms/heap_sort.R
│       ├── ./R/Sorting-Algorithms/insertion_sort.R
│       ├── ./R/Sorting-Algorithms/merge_sort.R
│       ├── ./R/Sorting-Algorithms/quick_sort.R
│       ├── ./R/Sorting-Algorithms/radix_sort.R
│       ├── ./R/Sorting-Algorithms/selection_sort.R
│       └── ./R/Sorting-Algorithms/stooge_sort.R
├── ./README.md
├── ./Ruby
│   ├── ./Ruby/backtracking
│   │   └── ./Ruby/backtracking/generate_paranthesis.rb
│   ├── ./Ruby/bit_manipulation
│   │   ├── ./Ruby/bit_manipulation/binary_and_operator.rb
│   │   ├── ./Ruby/bit_manipulation/binary_count_setbits.rb
│   │   ├── ./Ruby/bit_manipulation/binary_count_trailing_zeroes.rb
│   │   ├── ./Ruby/bit_manipulation/binary_or_operator.rb
│   │   ├── ./Ruby/bit_manipulation/binary_xor_operator.rb
│   │   ├── ./Ruby/bit_manipulation/power_of_two.rb
│   │   └── ./Ruby/bit_manipulation/single_bit_binary_operations.rb
│   ├── ./Ruby/ciphers
│   │   └── ./Ruby/ciphers/merkle_hellman_cryptosystem.rb
│   ├── ./Ruby/conversions
│   │   ├── ./Ruby/conversions/temperature_conversions.rb
│   │   └── ./Ruby/conversions/weight_conversions.rb
│   ├── ./Ruby/data_structures
│   │   ├── ./Ruby/data_structures/arrays
│   │   │   ├── ./Ruby/data_structures/arrays/add_digits.rb
│   │   │   ├── ./Ruby/data_structures/arrays/find_all_duplicates_in_an_array.rb
│   │   │   ├── ./Ruby/data_structures/arrays/find_the_highest_altitude.rb
│   │   │   ├── ./Ruby/data_structures/arrays/fizz_buzz.rb
│   │   │   ├── ./Ruby/data_structures/arrays/get_products_of_all_other_elements.rb
│   │   │   ├── ./Ruby/data_structures/arrays/good_pairs.rb
│   │   │   ├── ./Ruby/data_structures/arrays/intersection.rb
│   │   │   ├── ./Ruby/data_structures/arrays/next_greater_element.rb
│   │   │   ├── ./Ruby/data_structures/arrays/remove_elements.rb
│   │   │   ├── ./Ruby/data_structures/arrays/richest_customer_wealth.rb
│   │   │   ├── ./Ruby/data_structures/arrays/shortest_word_distance.rb
│   │   │   ├── ./Ruby/data_structures/arrays/shuffle_array.rb
│   │   │   ├── ./Ruby/data_structures/arrays/single_number.rb
│   │   │   ├── ./Ruby/data_structures/arrays/sorted_arrays_intersection.rb
│   │   │   ├── ./Ruby/data_structures/arrays/sort_squares_of_an_array.rb
│   │   │   ├── ./Ruby/data_structures/arrays/strings
│   │   │   ├── ./Ruby/data_structures/arrays/sudoku.rb
│   │   │   ├── ./Ruby/data_structures/arrays/two_sum_ii.rb
│   │   │   └── ./Ruby/data_structures/arrays/two_sum.rb
│   │   ├── ./Ruby/data_structures/binary_trees
│   │   │   ├── ./Ruby/data_structures/binary_trees/inorder_traversal.rb
│   │   │   ├── ./Ruby/data_structures/binary_trees/invert.rb
│   │   │   ├── ./Ruby/data_structures/binary_trees/postorder_traversal.rb
│   │   │   └── ./Ruby/data_structures/binary_trees/preorder_traversal.rb
│   │   ├── ./Ruby/data_structures/hash_table
│   │   │   ├── ./Ruby/data_structures/hash_table/anagram_checker.rb
│   │   │   ├── ./Ruby/data_structures/hash_table/arrays_intersection.rb
│   │   │   ├── ./Ruby/data_structures/hash_table/common_characters.rb
│   │   │   ├── ./Ruby/data_structures/hash_table/find_all_duplicates_in_an_array.rb
│   │   │   ├── ./Ruby/data_structures/hash_table/good_pairs.rb
│   │   │   ├── ./Ruby/data_structures/hash_table/isomorphic_strings.rb
│   │   │   ├── ./Ruby/data_structures/hash_table/richest_customer_wealth.rb
│   │   │   ├── ./Ruby/data_structures/hash_table/two_sum.rb
│   │   │   └── ./Ruby/data_structures/hash_table/uncommon_words.rb
│   │   ├── ./Ruby/data_structures/linked_lists
│   │   │   ├── ./Ruby/data_structures/linked_lists/circular_linked_list.rb
│   │   │   ├── ./Ruby/data_structures/linked_lists/doubly_linked_list.rb
│   │   │   └── ./Ruby/data_structures/linked_lists/singly_linked_list.rb
│   │   ├── ./Ruby/data_structures/queues
│   │   │   ├── ./Ruby/data_structures/queues/circular_queue.rb
│   │   │   └── ./Ruby/data_structures/queues/queue.rb
│   │   ├── ./Ruby/data_structures/stacks
│   │   │   └── ./Ruby/data_structures/stacks/stack.rb
│   │   └── ./Ruby/data_structures/tries
│   │       └── ./Ruby/data_structures/tries/trie.rb
│   ├── ./Ruby/DIRECTORY.html
│   ├── ./Ruby/DIRECTORY.md
│   ├── ./Ruby/discrete_mathematics
│   │   ├── ./Ruby/discrete_mathematics/euclidean_gcd.rb
│   │   ├── ./Ruby/discrete_mathematics/exteded_euclidean_algorithm.rb
│   │   └── ./Ruby/discrete_mathematics/lcm.rb
│   ├── ./Ruby/dynamic_programming
│   │   ├── ./Ruby/dynamic_programming/coin_change.rb
│   │   ├── ./Ruby/dynamic_programming/count_sorted_vowel_strings.rb
│   │   ├── ./Ruby/dynamic_programming/fibonacci.rb
│   │   └── ./Ruby/dynamic_programming/pascal_triangle_ii.rb
│   ├── ./Ruby/maths
│   │   ├── ./Ruby/maths/abs_max.rb
│   │   ├── ./Ruby/maths/abs_min.rb
│   │   ├── ./Ruby/maths/abs.rb
│   │   ├── ./Ruby/maths/abs_test.rb
│   │   ├── ./Ruby/maths/add_digits.rb
│   │   ├── ./Ruby/maths/add.rb
│   │   ├── ./Ruby/maths/aliquot_sum.rb
│   │   ├── ./Ruby/maths/aliquot_sum_test.rb
│   │   ├── ./Ruby/maths/armstrong_number.rb
│   │   ├── ./Ruby/maths/average_mean.rb
│   │   ├── ./Ruby/maths/average_median.rb
│   │   ├── ./Ruby/maths/binary_to_decimal.rb
│   │   ├── ./Ruby/maths/ceil.rb
│   │   ├── ./Ruby/maths/ceil_test.rb
│   │   ├── ./Ruby/maths/count_sorted_vowel_strings.rb
│   │   ├── ./Ruby/maths/decimal_to_binary.rb
│   │   ├── ./Ruby/maths/factorial_non_recursive_non_iterative.rb
│   │   ├── ./Ruby/maths/factorial.rb
│   │   ├── ./Ruby/maths/fibonacci.rb
│   │   ├── ./Ruby/maths/find_max.rb
│   │   ├── ./Ruby/maths/find_min.rb
│   │   ├── ./Ruby/maths/lucas_series.rb
│   │   ├── ./Ruby/maths/number_of_digits.rb
│   │   ├── ./Ruby/maths/pascal_triangle_ii.rb
│   │   ├── ./Ruby/maths/power_of_two.rb
│   │   ├── ./Ruby/maths/prime_number.rb
│   │   ├── ./Ruby/maths/roman_to_integer.rb
│   │   ├── ./Ruby/maths/square_root.rb
│   │   ├── ./Ruby/maths/square_root_test.rb
│   │   └── ./Ruby/maths/sum_of_digits.rb
│   ├── ./Ruby/other
│   │   └── ./Ruby/other/fisher_yates.rb
│   ├── ./Ruby/project_euler
│   │   ├── ./Ruby/project_euler/problem_1
│   │   │   └── ./Ruby/project_euler/problem_1/sol1.rb
│   │   ├── ./Ruby/project_euler/problem_2
│   │   │   └── ./Ruby/project_euler/problem_2/sol1.rb
│   │   ├── ./Ruby/project_euler/problem_20
│   │   │   └── ./Ruby/project_euler/problem_20/sol1.rb
│   │   ├── ./Ruby/project_euler/problem_21
│   │   │   └── ./Ruby/project_euler/problem_21/sol1.rb
│   │   ├── ./Ruby/project_euler/problem_22
│   │   │   ├── ./Ruby/project_euler/problem_22/p022_names.txt
│   │   │   └── ./Ruby/project_euler/problem_22/sol1.rb
│   │   ├── ./Ruby/project_euler/problem_3
│   │   │   ├── ./Ruby/project_euler/problem_3/sol1.rb
│   │   │   └── ./Ruby/project_euler/problem_3/sol2.rb
│   │   ├── ./Ruby/project_euler/problem_4
│   │   │   ├── ./Ruby/project_euler/problem_4/sol1.rb
│   │   │   └── ./Ruby/project_euler/problem_4/sol2.rb
│   │   ├── ./Ruby/project_euler/problem_5
│   │   │   └── ./Ruby/project_euler/problem_5/sol1.rb
│   │   ├── ./Ruby/project_euler/README.html
│   │   └── ./Ruby/project_euler/README.md
│   ├── ./Ruby/Rakefile
│   ├── ./Ruby/README.html
│   ├── ./Ruby/README.md
│   ├── ./Ruby/searches
│   │   ├── ./Ruby/searches/binary_search.rb
│   │   ├── ./Ruby/searches/depth_first_search.rb
│   │   ├── ./Ruby/searches/double_linear_search.rb
│   │   ├── ./Ruby/searches/jump_search.rb
│   │   ├── ./Ruby/searches/linear_search.rb
│   │   ├── ./Ruby/searches/recursive_double_linear_search.rb
│   │   ├── ./Ruby/searches/recursive_linear_search.rb
│   │   └── ./Ruby/searches/ternary_search.rb
│   └── ./Ruby/sorting
│       ├── ./Ruby/sorting/bead_sort.rb
│       ├── ./Ruby/sorting/bead_sort_test.rb
│       ├── ./Ruby/sorting/bogo_sort.rb
│       ├── ./Ruby/sorting/bogo_sort_test.rb
│       ├── ./Ruby/sorting/bubble_sort.rb
│       ├── ./Ruby/sorting/bubble_sort_test.rb
│       ├── ./Ruby/sorting/bucket_sort.rb
│       ├── ./Ruby/sorting/bucket_sort_test.rb
│       ├── ./Ruby/sorting/cocktail_sort.rb
│       ├── ./Ruby/sorting/cocktail_sort_test.rb
│       ├── ./Ruby/sorting/comb_sort.rb
│       ├── ./Ruby/sorting/comb_sort_test.rb
│       ├── ./Ruby/sorting/heap_sort.rb
│       ├── ./Ruby/sorting/heap_sort_test.rb
│       ├── ./Ruby/sorting/insertion_sort.rb
│       ├── ./Ruby/sorting/insertion_sort_test.rb
│       ├── ./Ruby/sorting/merge_sort.rb
│       ├── ./Ruby/sorting/merge_sort_test.rb
│       ├── ./Ruby/sorting/pancake_sort.rb
│       ├── ./Ruby/sorting/pancake_sort_test.rb
│       ├── ./Ruby/sorting/quicksort.rb
│       ├── ./Ruby/sorting/quicksort_test.rb
│       ├── ./Ruby/sorting/radix_sort.rb
│       ├── ./Ruby/sorting/radix_sort_test.rb
│       ├── ./Ruby/sorting/selection_sort.rb
│       ├── ./Ruby/sorting/selection_sort_test.rb
│       ├── ./Ruby/sorting/shell_sort.rb
│       ├── ./Ruby/sorting/shell_sort_test.rb
│       ├── ./Ruby/sorting/sort_color.rb
│       └── ./Ruby/sorting/sort_tests.rb
├── ./Rust
│   ├── ./Rust/Cargo.toml
│   ├── ./Rust/DIRECTORY.html
│   ├── ./Rust/DIRECTORY.md
│   ├── ./Rust/git_hooks
│   │   └── ./Rust/git_hooks/pre-commit
│   ├── ./Rust/README.html
│   ├── ./Rust/README.md
│   └── ./Rust/src
│       ├── ./Rust/src/ciphers
│       │   ├── ./Rust/src/ciphers/caesar.rs
│       │   ├── ./Rust/src/ciphers/mod.rs
│       │   ├── ./Rust/src/ciphers/README.html
│       │   ├── ./Rust/src/ciphers/README.md
│       │   ├── ./Rust/src/ciphers/rot13.rs
│       │   └── ./Rust/src/ciphers/vigenere.rs
│       ├── ./Rust/src/data_structures
│       │   ├── ./Rust/src/data_structures/binary_search_tree.rs
│       │   ├── ./Rust/src/data_structures/b_tree.rs
│       │   ├── ./Rust/src/data_structures/heap.rs
│       │   ├── ./Rust/src/data_structures/linked_list.rs
│       │   ├── ./Rust/src/data_structures/mod.rs
│       │   ├── ./Rust/src/data_structures/README.html
│       │   └── ./Rust/src/data_structures/README.md
│       ├── ./Rust/src/dynamic_programming
│       │   ├── ./Rust/src/dynamic_programming/edit_distance.rs
│       │   ├── ./Rust/src/dynamic_programming/egg_dropping.rs
│       │   ├── ./Rust/src/dynamic_programming/fibonacci.rs
│       │   ├── ./Rust/src/dynamic_programming/knapsack.rs
│       │   ├── ./Rust/src/dynamic_programming/longest_common_subsequence.rs
│       │   └── ./Rust/src/dynamic_programming/mod.rs
│       ├── ./Rust/src/general
│       │   ├── ./Rust/src/general/convex_hull.rs
│       │   ├── ./Rust/src/general/hanoi.rs
│       │   ├── ./Rust/src/general/kmeans.rs
│       │   └── ./Rust/src/general/mod.rs
│       ├── ./Rust/src/lib.rs
│       ├── ./Rust/src/searching
│       │   ├── ./Rust/src/searching/binary_search.rs
│       │   ├── ./Rust/src/searching/linear_search.rs
│       │   ├── ./Rust/src/searching/mod.rs
│       │   ├── ./Rust/src/searching/README.html
│       │   └── ./Rust/src/searching/README.md
│       ├── ./Rust/src/sorting
│       │   ├── ./Rust/src/sorting/bubble_sort.rs
│       │   ├── ./Rust/src/sorting/counting_sort.rs
│       │   ├── ./Rust/src/sorting/heap_sort.rs
│       │   ├── ./Rust/src/sorting/insertion.rs
│       │   ├── ./Rust/src/sorting/merge_sort.rs
│       │   ├── ./Rust/src/sorting/mod.rs
│       │   ├── ./Rust/src/sorting/quick_sort.rs
│       │   ├── ./Rust/src/sorting/radix_sort.rs
│       │   ├── ./Rust/src/sorting/README.html
│       │   ├── ./Rust/src/sorting/README.md
│       │   ├── ./Rust/src/sorting/selection_sort.rs
│       │   └── ./Rust/src/sorting/shell_sort.rs
│       └── ./Rust/src/string
│           ├── ./Rust/src/string/knuth_morris_pratt.rs
│           ├── ./Rust/src/string/mod.rs
│           ├── ./Rust/src/string/README.html
│           └── ./Rust/src/string/README.md
├── ./Scala
│   ├── ./Scala/Algorithms Visualization.html
│   ├── ./Scala/Algorithms Visualization.md
│   ├── ./Scala/build.sbt
│   ├── ./Scala/DIRECTORY.html
│   ├── ./Scala/DIRECTORY.md
│   ├── ./Scala/License
│   ├── ./Scala/project
│   │   ├── ./Scala/project/build.properties
│   │   └── ./Scala/project/plugins.sbt
│   ├── ./Scala/Readme.html
│   ├── ./Scala/Readme.md
│   └── ./Scala/src
│       ├── ./Scala/src/main
│       │   └── ./Scala/src/main/scala
│       └── ./Scala/src/test
│           └── ./Scala/src/test/scala
├── ./scrap.md
├── ./scripts
│   ├── ./scripts/build_directory_md.py
│   ├── ./scripts/README.html
│   └── ./scripts/README.md
├── ./Swift
│   ├── ./Swift/algorithms
│   │   └── ./Swift/algorithms/parsing
│   │       └── ./Swift/algorithms/parsing/shunting_yard
│   ├── ./Swift/data_structures
│   │   ├── ./Swift/data_structures/heap
│   │   │   └── ./Swift/data_structures/heap/heap.swift
│   │   ├── ./Swift/data_structures/Linked List
│   │   │   └── ./Swift/data_structures/Linked List/LinkedList.swift
│   │   ├── ./Swift/data_structures/queue
│   │   │   └── ./Swift/data_structures/queue/queue.swift
│   │   ├── ./Swift/data_structures/Stack
│   │   │   └── ./Swift/data_structures/Stack/stack.swift
│   │   └── ./Swift/data_structures/union_find
│   │       └── ./Swift/data_structures/union_find/union_find.swift
│   ├── ./Swift/DIRECTORY.html
│   ├── ./Swift/DIRECTORY.md
│   ├── ./Swift/graph
│   │   └── ./Swift/graph/spanning_tree
│   │       └── ./Swift/graph/spanning_tree/kruskal.swift
│   ├── ./Swift/README.html
│   ├── ./Swift/README.md
│   ├── ./Swift/recursion
│   │   └── ./Swift/recursion/fibonacci.swift
│   ├── ./Swift/sorts
│   │   ├── ./Swift/sorts/BubbleSort.swift
│   │   ├── ./Swift/sorts/InsertionSort.swift
│   │   ├── ./Swift/sorts/MergeSort.swift
│   │   ├── ./Swift/sorts/QuickSort.swift
│   │   └── ./Swift/sorts/SelectionSort.swift
│   └── ./Swift/trees
│       └── ./Swift/trees/tree.swift
├── ./TheAlgorithms.github.io
│   ├── ./TheAlgorithms.github.io/ideas.html
│   ├── ./TheAlgorithms.github.io/images
│   │   └── ./TheAlgorithms.github.io/images/svg
│   │       ├── ./TheAlgorithms.github.io/images/svg/c-lang.svg
│   │       ├── ./TheAlgorithms.github.io/images/svg/cpp-lang.svg
│   │       ├── ./TheAlgorithms.github.io/images/svg/c-sharp-lang.svg
│   │       ├── ./TheAlgorithms.github.io/images/svg/dart.png
│   │       ├── ./TheAlgorithms.github.io/images/svg/gitter-brands.svg
│   │       ├── ./TheAlgorithms.github.io/images/svg/golang.svg
│   │       ├── ./TheAlgorithms.github.io/images/svg/javascript.svg
│   │       ├── ./TheAlgorithms.github.io/images/svg/java.svg
│   │       ├── ./TheAlgorithms.github.io/images/svg/python.svg
│   │       ├── ./TheAlgorithms.github.io/images/svg/r-lang.svg
│   │       ├── ./TheAlgorithms.github.io/images/svg/ruby.svg
│   │       ├── ./TheAlgorithms.github.io/images/svg/rust.svg
│   │       └── ./TheAlgorithms.github.io/images/svg/scala.svg
│   ├── ./TheAlgorithms.github.io/index.html
│   ├── ./TheAlgorithms.github.io/index-old.html
│   ├── ./TheAlgorithms.github.io/README.html
│   ├── ./TheAlgorithms.github.io/README.md
│   └── ./TheAlgorithms.github.io/static
│       ├── ./TheAlgorithms.github.io/static/css
│       │   └── ./TheAlgorithms.github.io/static/css/main.css
│       └── ./TheAlgorithms.github.io/static/img
│           ├── ./TheAlgorithms.github.io/static/img/arrow.png
│           ├── ./TheAlgorithms.github.io/static/img/default_cur.png
│           ├── ./TheAlgorithms.github.io/static/img/logo.png
│           └── ./TheAlgorithms.github.io/static/img/rsz_default_cur.png
├── ./TREE.md
├── ./website
└── ./website-old
    ├── ./website-old/css
    │   └── ./website-old/css/style.css
    ├── ./website-old/images
    │   ├── ./website-old/images/favicon.png
    │   └── ./website-old/images/svg
    │       ├── ./website-old/images/svg/c-lang.svg
    │       ├── ./website-old/images/svg/cpp-lang.svg
    │       ├── ./website-old/images/svg/c-sharp-lang.svg
    │       ├── ./website-old/images/svg/dart.png
    │       ├── ./website-old/images/svg/golang.svg
    │       ├── ./website-old/images/svg/javascript.svg
    │       ├── ./website-old/images/svg/java.svg
    │       ├── ./website-old/images/svg/python.svg
    │       ├── ./website-old/images/svg/r-lang.svg
    │       ├── ./website-old/images/svg/ruby.svg
    │       ├── ./website-old/images/svg/rust.svg
    │       └── ./website-old/images/svg/scala.svg
    ├── ./website-old/index.html
    ├── ./website-old/README.html
    └── ./website-old/README.md

768 directories, 3490 files

Name		Name	Last commit message	Last commit date
Latest commit History 116 Commits
AArch64_Assembly		AArch64_Assembly
Algorithms-Explanation		Algorithms-Explanation
C-Plus-Plus		C-Plus-Plus
C-Sharp		C-Sharp
C		C
Clojure		Clojure
Dart		Dart
Elixir		Elixir
Elm		Elm
F-Sharp		F-Sharp
Go		Go
Haskell		Haskell
Java		Java
Javascript		Javascript
Julia		Julia
Jupyter		Jupyter
Kotlin		Kotlin
MATLAB-Octave		MATLAB-Octave
Markdown		Markdown
OCaml		OCaml
PHP		PHP
Python		Python
R		R
Ruby		Ruby
Rust		Rust
Scala		Scala
Swift		Swift
TheAlgorithms.github.io		TheAlgorithms.github.io
algorithms-keeper		algorithms-keeper
scripts		scripts
website-old		website-old
website/.next/cache/webpack		website/.next/cache/webpack
.gitattributes		.gitattributes
README.md		README.md
TREE.md		TREE.md
The-Algorithms-Clone.html		The-Algorithms-Clone.html
commands.html		commands.html
commands.md		commands.md
directories.md		directories.md
file-list.html		file-list.html
file-list.md		file-list.md
index-temp.html		index-temp.html
index.html		index.html
makefile		makefile
renovate.json		renovate.json
scrap.md		scrap.md
template.html		template.html

bgoonz/The-Algorithms

Folders and files

Latest commit

History

Repository files navigation

Algorithms For Each Major CS Language:

Folders:

Deploy: https://bgoonz-branch-the-algos.vercel.app/

- Link To Filelist

Navigation:

Arithmetic Progression

Source

YouTube

Average (Mean)

Applications

Steps

Example

Step 1

Step 2

Step 3

Step 4

Step 5

Implementation

Video URL

Others

Calculating Fibonacci numbers

Applications

Steps

Example

Step 0

Step 1

Step 2

Step 3

Step 4

Step 5

Implementation

Video URL

Others

Finding the number of digits in a number

1st Solution

Simple Solution

2nd Solution

Better Solution

Source

YouTube

Source

YouTube

Caesar Cipher

Steps

Encryption

Decryption