The-Algorithms

KO | EN

gitlite — search

#hacktoberfest #react #typescript #golang #android #rust #docker #macos #java #awesome-list #vue #pytorch #security #mcp

(★ 14)

taken from TheAlgorithms

The-Algorithms 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Algorithms For Each Major CS Language:

# Folders:

# Deploy: [https://bgoonz-branch-the-algos.vercel.app/](https://bgoonz-branch-the-algos.vercel.app/)
---
---

### - [Link To Filelist](./file-list.md)

- [NETLIFY](https://app.netlify.com/teams/bgoonz/overview)

<details>
<summary>                         FOLDERS                              </summary>

- [./Algorithms-Explanation](./Algorithms-Explanation)
- [./Algorithms-Explanation/en](./Algorithms-Explanation/en)
- [./Algorithms-Explanation/en/BasicMath](./Algorithms-Explanation/en/BasicMath)
- [./Algorithms-Explanation/en/Ciphers](./Algorithms-Explanation/en/Ciphers)
- [./Algorithms-Explanation/en/DataStructures](./Algorithms-Explanation/en/DataStructures)
- [./Algorithms-Explanation/en/DataStructures/Graph](./Algorithms-Explanation/en/DataStructures/Graph)
- [./Algorithms-Explanation/en/DataStructures/LinkedLists](./Algorithms-Explanation/en/DataStructures/LinkedLists)
- [./Algorithms-Explanation/en/DynamicProgramming](./Algorithms-Explanation/en/DynamicProgramming)
- [./Algorithms-Explanation/en/ImageProcessing](./Algorithms-Explanation/en/ImageProcessing)
- [./Algorithms-Explanation/en/SearchAlgorithms](./Algorithms-Explanation/en/SearchAlgorithms)
- [./Algorithms-Explanation/en/SelectionAlgorithms](./Algorithms-Explanation/en/SelectionAlgorithms)
- [./Algorithms-Explanation/en/SortingAlgorithms](./Algorithms-Explanation/en/SortingAlgorithms)
- [./Algorithms-Explanation/en/SortingAlgorithms/RecursiveVersions](./Algorithms-Explanation/en/SortingAlgorithms/RecursiveVersions)
- [./algorithms-keeper](./algorithms-keeper)
- [./algorithms-keeper/algorithms_keeper](./algorithms-keeper/algorithms_keeper)
- [./algorithms-keeper/algorithms_keeper/event](./algorithms-keeper/algorithms_keeper/event)
- [./algorithms-keeper/algorithms_keeper/parser](./algorithms-keeper/algorithms_keeper/parser)
- [./algorithms-keeper/algorithms_keeper/parser/rules](./algorithms-keeper/algorithms_keeper/parser/rules)
- [./algorithms-keeper/tests](./algorithms-keeper/tests)
- [./algorithms-keeper/tests/data](./algorithms-keeper/tests/data)

---

- [./AArch64_Assembly](./AArch64_Assembly)
- [./AArch64_Assembly/misc](./AArch64_Assembly/misc)
- [./AArch64_Assembly/sorters](./AArch64_Assembly/sorters)
- [./AArch64_Assembly/string](./AArch64_Assembly/string)

---

- [./C](./C)
- [./C/client_server](./C/client_server)
- [./C/conversions](./C/conversions)
- [./C/data_structures](./C/data_structures)
- [./C/data_structures/array](./C/data_structures/array)
- [./C/data_structures/binary_trees](./C/data_structures/binary_trees)
- [./C/data_structures/dictionary](./C/data_structures/dictionary)
- [./C/data_structures/dynamic_array](./C/data_structures/dynamic_array)
- [./C/data_structures/graphs](./C/data_structures/graphs)
- [./C/data_structures/hash_set](./C/data_structures/hash_set)
- [./C/data_structures/heap](./C/data_structures/heap)
- [./C/data_structures/linked_list](./C/data_structures/linked_list)
- [./C/data_structures/list](./C/data_structures/list)
- [./C/data_structures/stack](./C/data_structures/stack)
- [./C/data_structures/stack/stack_linked_list](./C/data_structures/stack/stack_linked_list)
- [./C/data_structures/trie](./C/data_structures/trie)
- [./C/developer_tools](./C/developer_tools)
- [./C/exercism](./C/exercism)
- [./C/exercism/acronym](./C/exercism/acronym)
- [./C/exercism/hello_world](./C/exercism/hello_world)
- [./C/exercism/isogram](./C/exercism/isogram)
- [./C/exercism/rna_transcription](./C/exercism/rna_transcription)
- [./C/exercism/word_count](./C/exercism/word_count)
- [./C/games](./C/games)
- [./C/geometry](./C/geometry)
- [./C/graphics](./C/graphics)
- [./C/greedy_approach](./C/greedy_approach)
- [./C/hash](./C/hash)
- [./C/leetcode](./C/leetcode)
- [./C/leetcode/src](./C/leetcode/src)
- [./C/machine_learning](./C/machine_learning)
- [./C/misc](./C/misc)
- [./C/numerical_methods](./C/numerical_methods)
- [./C/project_euler](./C/project_euler)
- [./C/project_euler/problem_1](./C/project_euler/problem_1)
- [./C/project_euler/problem_10](./C/project_euler/problem_10)
- [./C/project_euler/problem_12](./C/project_euler/problem_12)
- [./C/project_euler/problem_13](./C/project_euler/problem_13)
- [./C/project_euler/problem_14](./C/project_euler/problem_14)
- [./C/project_euler/problem_15](./C/project_euler/problem_15)
- [./C/project_euler/problem_16](./C/project_euler/problem_16)
- [./C/project_euler/problem_19](./C/project_euler/problem_19)
- [./C/project_euler/problem_2](./C/project_euler/problem_2)
- [./C/project_euler/problem_20](./C/project_euler/problem_20)
- [./C/project_euler/problem_21](./C/project_euler/problem_21)
- [./C/project_euler/problem_22](./C/project_euler/problem_22)
- [./C/project_euler/problem_23](./C/project_euler/problem_23)
- [./C/project_euler/problem_24](./C/project_euler/problem_24)
- [./C/project_euler/problem_25](./C/project_euler/problem_25)
- [./C/project_euler/problem_26](./C/project_euler/problem_26)
- [./C/project_euler/problem_3](./C/project_euler/problem_3)
- [./C/project_euler/problem_4](./C/project_euler/problem_4)
- [./C/project_euler/problem_401](./C/project_euler/problem_401)
- [./C/project_euler/problem_5](./C/project_euler/problem_5)
- [./C/project_euler/problem_6](./C/project_euler/problem_6)
- [./C/project_euler/problem_7](./C/project_euler/problem_7)
- [./C/project_euler/problem_8](./C/project_euler/problem_8)
- [./C/project_euler/problem_9](./C/project_euler/problem_9)
- [./C/searching](./C/searching)
- [./C/searching/pattern_search](./C/searching/pattern_search)
- [./C/sorting](./C/sorting)
- ***

***

- [./Clojure](./Clojure)
- [./Clojure/src](./Clojure/src)
- [./Clojure/src/data_structures](./Clojure/src/data_structures)
- [./Clojure/src/data_structures/lists](./Clojure/src/data_structures/lists)
- [./Clojure/test](./Clojure/test)
- [./Clojure/test/data_structures](./Clojure/test/data_structures)
- [./Clojure/test/data_structures/lists](./Clojure/test/data_structures/lists)
- ***

***

- [./C-Plus-Plus](./C-Plus-Plus)
- [./C-Plus-Plus/backtracking](./C-Plus-Plus/backtracking)
- [./C-Plus-Plus/bit_manipulation](./C-Plus-Plus/bit_manipulation)
- [./C-Plus-Plus/ciphers](./C-Plus-Plus/ciphers)
- [./C-Plus-Plus/data_structures](./C-Plus-Plus/data_structures)
- [./C-Plus-Plus/data_structures/cll](./C-Plus-Plus/data_structures/cll)
- [./C-Plus-Plus/divide_and_conquer](./C-Plus-Plus/divide_and_conquer)
- [./C-Plus-Plus/doc](./C-Plus-Plus/doc)
- [./C-Plus-Plus/dynamic_programming](./C-Plus-Plus/dynamic_programming)
- [./C-Plus-Plus/geometry](./C-Plus-Plus/geometry)
- [./C-Plus-Plus/graph](./C-Plus-Plus/graph)
- [./C-Plus-Plus/graphics](./C-Plus-Plus/graphics)
- [./C-Plus-Plus/greedy_algorithms](./C-Plus-Plus/greedy_algorithms)
- [./C-Plus-Plus/hashing](./C-Plus-Plus/hashing)
- [./C-Plus-Plus/linear_algebra](./C-Plus-Plus/linear_algebra)
- [./C-Plus-Plus/machine_learning](./C-Plus-Plus/machine_learning)
- [./C-Plus-Plus/math](./C-Plus-Plus/math)
- [./C-Plus-Plus/numerical_methods](./C-Plus-Plus/numerical_methods)
- [./C-Plus-Plus/operations_on_datastructures](./C-Plus-Plus/operations_on_datastructures)
- [./C-Plus-Plus/others](./C-Plus-Plus/others)
- [./C-Plus-Plus/probability](./C-Plus-Plus/probability)
- [./C-Plus-Plus/range_queries](./C-Plus-Plus/range_queries)
- [./C-Plus-Plus/search](./C-Plus-Plus/search)
- [./C-Plus-Plus/sorting](./C-Plus-Plus/sorting)
- [./C-Plus-Plus/strings](./C-Plus-Plus/strings)
- ***

***

- [./C-Sharp](./C-Sharp)
- [./C-Sharp/Algorithms](./C-Sharp/Algorithms)
- [./C-Sharp/Algorithms/DataCompression](./C-Sharp/Algorithms/DataCompression)
- [./C-Sharp/Algorithms/Encoders](./C-Sharp/Algorithms/Encoders)
- [./C-Sharp/Algorithms/Knapsack](./C-Sharp/Algorithms/Knapsack)
- [./C-Sharp/Algorithms/LinearAlgebra](./C-Sharp/Algorithms/LinearAlgebra)
- [./C-Sharp/Algorithms/LinearAlgebra/Eigenvalue](./C-Sharp/Algorithms/LinearAlgebra/Eigenvalue)
- [./C-Sharp/Algorithms/Numeric](./C-Sharp/Algorithms/Numeric)
- [./C-Sharp/Algorithms/Numeric/Decomposition](./C-Sharp/Algorithms/Numeric/Decomposition)
- [./C-Sharp/Algorithms/Numeric/Factorization](./C-Sharp/Algorithms/Numeric/Factorization)
- [./C-Sharp/Algorithms/Numeric/GreatestCommonDivisor](./C-Sharp/Algorithms/Numeric/GreatestCommonDivisor)
- [./C-Sharp/Algorithms/Numeric/Pseudoinverse](./C-Sharp/Algorithms/Numeric/Pseudoinverse)
- [./C-Sharp/Algorithms/Numeric/Series](./C-Sharp/Algorithms/Numeric/Series)
- [./C-Sharp/Algorithms/Other](./C-Sharp/Algorithms/Other)
- [./C-Sharp/Algorithms/Problems](./C-Sharp/Algorithms/Problems)
- [./C-Sharp/Algorithms/Problems/NQueens](./C-Sharp/Algorithms/Problems/NQueens)
- [./C-Sharp/Algorithms/Problems/StableMarriage](./C-Sharp/Algorithms/Problems/StableMarriage)
- [./C-Sharp/Algorithms/Search](./C-Sharp/Algorithms/Search)
- [./C-Sharp/Algorithms/Search/AStar](./C-Sharp/Algorithms/Search/AStar)
- [./C-Sharp/Algorithms/Sequences](./C-Sharp/Algorithms/Sequences)
- [./C-Sharp/Algorithms/Sorters](./C-Sharp/Algorithms/Sorters)
- [./C-Sharp/Algorithms/Sorters/Comparison](./C-Sharp/Algorithms/Sorters/Comparison)
- [./C-Sharp/Algorithms/Sorters/External](./C-Sharp/Algorithms/Sorters/External)
- [./C-Sharp/Algorithms/Sorters/Integer](./C-Sharp/Algorithms/Sorters/Integer)
- [./C-Sharp/Algorithms/Sorters/String](./C-Sharp/Algorithms/Sorters/String)
- [./C-Sharp/Algorithms/Strings](./C-Sharp/Algorithms/Strings)
- [./C-Sharp/Algorithms.Tests](./C-Sharp/Algorithms.Tests)
- [./C-Sharp/Algorithms.Tests/Compressors](./C-Sharp/Algorithms.Tests/Compressors)
- [./C-Sharp/Algorithms.Tests/Encoders](./C-Sharp/Algorithms.Tests/Encoders)
- [./C-Sharp/Algorithms.Tests/Helpers](./C-Sharp/Algorithms.Tests/Helpers)
- [./C-Sharp/Algorithms.Tests/Knapsack](./C-Sharp/Algorithms.Tests/Knapsack)
- [./C-Sharp/Algorithms.Tests/LinearAlgebra](./C-Sharp/Algorithms.Tests/LinearAlgebra)
- [./C-Sharp/Algorithms.Tests/LinearAlgebra/Eigenvalue](./C-Sharp/Algorithms.Tests/LinearAlgebra/Eigenvalue)
- [./C-Sharp/Algorithms.Tests/Numeric](./C-Sharp/Algorithms.Tests/Numeric)
- [./C-Sharp/Algorithms.Tests/Numeric/Decomposition](./C-Sharp/Algorithms.Tests/Numeric/Decomposition)
- [./C-Sharp/Algorithms.Tests/Numeric/Factorization](./C-Sharp/Algorithms.Tests/Numeric/Factorization)
- [./C-Sharp/Algorithms.Tests/Numeric/GreatestCommonDivisor](./C-Sharp/Algorithms.Tests/Numeric/GreatestCommonDivisor)
- [./C-Sharp/Algorithms.Tests/Numeric/PseudoInverse](./C-Sharp/Algorithms.Tests/Numeric/PseudoInverse)
- [./C-Sharp/Algorithms.Tests/Other](./C-Sharp/Algorithms.Tests/Other)
- [./C-Sharp/Algorithms.Tests/Problems](./C-Sharp/Algorithms.Tests/Problems)
- [./C-Sharp/Algorithms.Tests/Problems/NQueens](./C-Sharp/Algorithms.Tests/Problems/NQueens)
- [./C-Sharp/Algorithms.Tests/Problems/StableMarriage](./C-Sharp/Algorithms.Tests/Problems/StableMarriage)
- [./C-Sharp/Algorithms.Tests/Search](./C-Sharp/Algorithms.Tests/Search)
- [./C-Sharp/Algorithms.Tests/Sequences](./C-Sharp/Algorithms.Tests/Sequences)
- [./C-Sharp/Algorithms.Tests/Sorters](./C-Sharp/Algorithms.Tests/Sorters)
- [./C-Sharp/Algorithms.Tests/Sorters/Comparison](./C-Sharp/Algorithms.Tests/Sorters/Comparison)
- [./C-Sharp/Algorithms.Tests/Sorters/External](./C-Sharp/Algorithms.Tests/Sorters/External)
- [./C-Sharp/Algorithms.Tests/Sorters/Integer](./C-Sharp/Algorithms.Tests/Sorters/Integer)
- [./C-Sharp/Algorithms.Tests/Sorters/String](./C-Sharp/Algorithms.Tests/Sorters/String)
- [./C-Sharp/Algorithms.Tests/Strings](./C-Sharp/Algorithms.Tests/Strings)
- [./C-Sharp/DataStructures](./C-Sharp/DataStructures)
- [./C-Sharp/DataStructures/AATree](./C-Sharp/DataStructures/AATree)
- [./C-Sharp/DataStructures/BinarySearchTree](./C-Sharp/DataStructures/BinarySearchTree)
- [./C-Sharp/DataStructures/Heap](./C-Sharp/DataStructures/Heap)
- [./C-Sharp/DataStructures/Heap/FibonacciHeap](./C-Sharp/DataStructures/Heap/FibonacciHeap)
- [./C-Sharp/DataStructures/LinkedList](./C-Sharp/DataStructures/LinkedList)
- [./C-Sharp/DataStructures/LinkedList/DoublyLinkedList](./C-Sharp/DataStructures/LinkedList/DoublyLinkedList)
- [./C-Sharp/DataStructures/LinkedList/SinglyLinkedList](./C-Sharp/DataStructures/LinkedList/SinglyLinkedList)
- [./C-Sharp/DataStructures/Queue](./C-Sharp/DataStructures/Queue)
- [./C-Sharp/DataStructures/SegmentTrees](./C-Sharp/DataStructures/SegmentTrees)
- [./C-Sharp/DataStructures/Stack](./C-Sharp/DataStructures/Stack)
- [./C-Sharp/DataStructures.Tests](./C-Sharp/DataStructures.Tests)
- [./C-Sharp/DataStructures.Tests/Heap](./C-Sharp/DataStructures.Tests/Heap)
- [./C-Sharp/DataStructures.Tests/Heap/FibonacciHeaps](./C-Sharp/DataStructures.Tests/Heap/FibonacciHeaps)
- [./C-Sharp/DataStructures.Tests/LinkedList](./C-Sharp/DataStructures.Tests/LinkedList)
- [./C-Sharp/DataStructures.Tests/Queue](./C-Sharp/DataStructures.Tests/Queue)
- [./C-Sharp/DataStructures.Tests/SegmentTrees](./C-Sharp/DataStructures.Tests/SegmentTrees)
- [./C-Sharp/DataStructures.Tests/Stack](./C-Sharp/DataStructures.Tests/Stack)
- [./C-Sharp/Utilities](./C-Sharp/Utilities)
- [./C-Sharp/Utilities/Exceptions](./C-Sharp/Utilities/Exceptions)
- [./C-Sharp/Utilities/Extensions](./C-Sharp/Utilities/Extensions)
- [./C-Sharp/Utilities.Tests](./C-Sharp/Utilities.Tests)
- [./C-Sharp/Utilities.Tests/Extensions](./C-Sharp/Utilities.Tests/Extensions)
- ***

***

- [./Dart](./Dart)
- [./Dart/array](./Dart/array)
- [./Dart/backtracking](./Dart/backtracking)
- [./Dart/conversions](./Dart/conversions)
- [./Dart/data_structures](./Dart/data_structures)
- [./Dart/data_structures/binary_tree](./Dart/data_structures/binary_tree)
- [./Dart/data_structures/HashMap](./Dart/data_structures/HashMap)
- [./Dart/data_structures/Heap](./Dart/data_structures/Heap)
- [./Dart/data_structures/Heap/Binary_Heap](./Dart/data_structures/Heap/Binary_Heap)
- [./Dart/data_structures/linked_list](./Dart/data_structures/linked_list)
- [./Dart/data_structures/quad_tree](./Dart/data_structures/quad_tree)
- [./Dart/data_structures/Queue](./Dart/data_structures/Queue)
- [./Dart/data_structures/Stack](./Dart/data_structures/Stack)
- [./Dart/dynamic_programming](./Dart/dynamic_programming)
- [./Dart/graphs](./Dart/graphs)
- [./Dart/maths](./Dart/maths)
- [./Dart/other](./Dart/other)
- [./Dart/project_euler](./Dart/project_euler)
- [./Dart/project_euler/problem_1](./Dart/project_euler/problem_1)
- [./Dart/project_euler/problem_10](./Dart/project_euler/problem_10)
- [./Dart/project_euler/problem_12](./Dart/project_euler/problem_12)
- [./Dart/project_euler/problem_13](./Dart/project_euler/problem_13)
- [./Dart/project_euler/problem_17](./Dart/project_euler/problem_17)
- [./Dart/project_euler/problem_2](./Dart/project_euler/problem_2)
- [./Dart/project_euler/problem_3](./Dart/project_euler/problem_3)
- [./Dart/project_euler/problem_4](./Dart/project_euler/problem_4)
- [./Dart/project_euler/problem_5](./Dart/project_euler/problem_5)
- [./Dart/project_euler/problem_6](./Dart/project_euler/problem_6)
- [./Dart/project_euler/problem_7](./Dart/project_euler/problem_7)
- [./Dart/project_euler/problem_8](./Dart/project_euler/problem_8)
- [./Dart/project_euler/problem_9](./Dart/project_euler/problem_9)
- [./Dart/search](./Dart/search)
- [./Dart/sort](./Dart/sort)
- [./Dart/strings](./Dart/strings)
- [./Dart/tests](./Dart/tests)
- ***

***

- [./Elixir](./Elixir)
- [./Elixir/lib](./Elixir/lib)
- [./Elixir/lib/codewars](./Elixir/lib/codewars)
- [./Elixir/lib/data_structures](./Elixir/lib/data_structures)
- [./Elixir/lib/sorting](./Elixir/lib/sorting)
- [./Elixir/test](./Elixir/test)
- [./Elixir/test/codewars](./Elixir/test/codewars)
- [./Elixir/test/data_structures](./Elixir/test/data_structures)
- [./Elixir/test/sorting](./Elixir/test/sorting)
- [./Elm](./Elm)
- [./Elm/src](./Elm/src)
- [./Elm/src/Sorting](./Elm/src/Sorting)
- ***

***

- [./F-Sharp](./F-Sharp)
- [./F-Sharp/Algorithms](./F-Sharp/Algorithms)
- [./F-Sharp/Algorithms/Math](./F-Sharp/Algorithms/Math)
- [./F-Sharp/Algorithms/Search](./F-Sharp/Algorithms/Search)
- [./F-Sharp/Algorithms/Sort](./F-Sharp/Algorithms/Sort)
- [./F-Sharp/Algorithms/Strings](./F-Sharp/Algorithms/Strings)
- [./F-Sharp/Algorithms.Tests](./F-Sharp/Algorithms.Tests)
- [./F-Sharp/Algorithms.Tests/Math](./F-Sharp/Algorithms.Tests/Math)
- [./F-Sharp/Algorithms.Tests/Strings](./F-Sharp/Algorithms.Tests/Strings)
- ***

***

- [./Go](./Go)
- [./Go/ciphers](./Go/ciphers)
- [./Go/ciphers/caesar](./Go/ciphers/caesar)
- [./Go/ciphers/diffiehelkeyexchange](./Go/ciphers/diffiehelkeyexchange)
- [./Go/ciphers/polybius](./Go/ciphers/polybius)
- [./Go/ciphers/rot13](./Go/ciphers/rot13)
- [./Go/ciphers/rsa](./Go/ciphers/rsa)
- [./Go/ciphers/rsaBig](./Go/ciphers/rsaBig)
- [./Go/ciphers/xor](./Go/ciphers/xor)
- [./Go/conversions](./Go/conversions)
- [./Go/conversions/roman-to-integer](./Go/conversions/roman-to-integer)
- [./Go/datastructures](./Go/datastructures)
- [./Go/datastructures/binary-tree](./Go/datastructures/binary-tree)
- [./Go/datastructures/dynamic-array](./Go/datastructures/dynamic-array)
- [./Go/datastructures/hashmap](./Go/datastructures/hashmap)
- [./Go/datastructures/linkedlist](./Go/datastructures/linkedlist)
- [./Go/datastructures/linkedlist/doublylinkedlist](./Go/datastructures/linkedlist/doublylinkedlist)
- [./Go/datastructures/linkedlist/singlylinkedlist](./Go/datastructures/linkedlist/singlylinkedlist)
- [./Go/datastructures/trie](./Go/datastructures/trie)
- [./Go/designpatterns](./Go/designpatterns)
- [./Go/designpatterns/abstractfactory](./Go/designpatterns/abstractfactory)
- [./Go/designpatterns/builder](./Go/designpatterns/builder)
- [./Go/designpatterns/factorymethod](./Go/designpatterns/factorymethod)
- [./Go/designpatterns/prototype](./Go/designpatterns/prototype)
- [./Go/dynamicprogramming](./Go/dynamicprogramming)
- [./Go/genetic-algorithm](./Go/genetic-algorithm)
- [./Go/graphs](./Go/graphs)
- [./Go/graphs/depthfirstsearch](./Go/graphs/depthfirstsearch)
- [./Go/graphs/floydwarshall](./Go/graphs/floydwarshall)
- [./Go/graphs/search](./Go/graphs/search)
- [./Go/math](./Go/math)
- [./Go/math/gcd](./Go/math/gcd)
- [./Go/math/lcm](./Go/math/lcm)
- [./Go/math/modulararithmetic](./Go/math/modulararithmetic)
- [./Go/math/permutation](./Go/math/permutation)
- [./Go/math/power](./Go/math/power)
- [./Go/math/prime](./Go/math/prime)
- [./Go/math/pythagoras](./Go/math/pythagoras)
- [./Go/math/sieve](./Go/math/sieve)
- [./Go/other](./Go/other)
- [./Go/other/maxsubarraysum](./Go/other/maxsubarraysum)
- [./Go/other/monte_carlo_pi](./Go/other/monte_carlo_pi)
- [./Go/other/nestedbrackets](./Go/other/nestedbrackets)
- [./Go/other/passwordgenerator](./Go/other/passwordgenerator)
- [./Go/other/stringcombinations](./Go/other/stringcombinations)
- [./Go/searches](./Go/searches)
- [./Go/sorts](./Go/sorts)
- [./Go/strings](./Go/strings)
- [./Go/strings/levenshteindistance](./Go/strings/levenshteindistance)
- [./Go/strings/multiple-string-matching](./Go/strings/multiple-string-matching)
- [./Go/strings/multiple-string-matching/advanced-aho-corasick](./Go/strings/multiple-string-matching/advanced-aho-corasick)
- [./Go/strings/multiple-string-matching/aho-corasick](./Go/strings/multiple-string-matching/aho-corasick)
- [./Go/strings/multiple-string-matching/sbom](./Go/strings/multiple-string-matching/sbom)
- [./Go/strings/naivesearch](./Go/strings/naivesearch)
- [./Go/strings/single-string-matching](./Go/strings/single-string-matching)
- [./Go/strings/single-string-matching/bom](./Go/strings/single-string-matching/bom)
- [./Go/strings/single-string-matching/horspool](./Go/strings/single-string-matching/horspool)
- [./Go/strings/single-string-matching/kmp](./Go/strings/single-string-matching/kmp)
- ***

***

- [./Haskell](./Haskell)
- [./Haskell/specs](./Haskell/specs)
- [./Haskell/specs/SortSpecs](./Haskell/specs/SortSpecs)
- [./Haskell/src](./Haskell/src)
- [./Haskell/src/BinaryTree](./Haskell/src/BinaryTree)
- [./Haskell/src/DataStructures](./Haskell/src/DataStructures)
- [./Haskell/src/Graph](./Haskell/src/Graph)
- [./Haskell/src/Maths](./Haskell/src/Maths)
- [./Haskell/src/Misc](./Haskell/src/Misc)
- [./Haskell/src/ProjectEuler](./Haskell/src/ProjectEuler)
- [./Haskell/src/ProjectEuler/Problem1](./Haskell/src/ProjectEuler/Problem1)
- [./Haskell/src/ProjectEuler/Problem2](./Haskell/src/ProjectEuler/Problem2)
- [./Haskell/src/ProjectEuler/Problem3](./Haskell/src/ProjectEuler/Problem3)
- [./Haskell/src/ProjectEuler/Problem4](./Haskell/src/ProjectEuler/Problem4)
- [./Haskell/src/ProjectEuler/Problem5](./Haskell/src/ProjectEuler/Problem5)
- [./Haskell/src/ProjectEuler/Problem6](./Haskell/src/ProjectEuler/Problem6)
- [./Haskell/src/ProjectEuler/Problem7](./Haskell/src/ProjectEuler/Problem7)
- [./Haskell/src/Robotics](./Haskell/src/Robotics)
- [./Haskell/src/Robotics/ComplementaryFilter](./Haskell/src/Robotics/ComplementaryFilter)
- [./Haskell/src/Sorts](./Haskell/src/Sorts)
- [./Haskell/src/SpecializedStructure](./Haskell/src/SpecializedStructure)
- [./Haskell/src/Statistics](./Haskell/src/Statistics)
- ***

***

- [./Java](./Java)
- [./Java/ciphers](./Java/ciphers)
- [./Java/Conversions](./Java/Conversions)
- [./Java/DataStructures](./Java/DataStructures)
- [./Java/DataStructures/Bags](./Java/DataStructures/Bags)
- [./Java/DataStructures/Buffers](./Java/DataStructures/Buffers)
- [./Java/DataStructures/DynamicArray](./Java/DataStructures/DynamicArray)
- [./Java/DataStructures/Graphs](./Java/DataStructures/Graphs)
- [./Java/DataStructures/HashMap](./Java/DataStructures/HashMap)
- [./Java/DataStructures/HashMap/Hashing](./Java/DataStructures/HashMap/Hashing)
- [./Java/DataStructures/Heaps](./Java/DataStructures/Heaps)
- [./Java/DataStructures/Lists](./Java/DataStructures/Lists)
- [./Java/DataStructures/Queues](./Java/DataStructures/Queues)
- [./Java/DataStructures/Stacks](./Java/DataStructures/Stacks)
- [./Java/DataStructures/Trees](./Java/DataStructures/Trees)
- [./Java/divideconquer](./Java/divideconquer)
- [./Java/DynamicProgramming](./Java/DynamicProgramming)
- [./Java/Maths](./Java/Maths)
- [./Java/MinimizingLateness](./Java/MinimizingLateness)
- [./Java/Misc](./Java/Misc)
- [./Java/Others](./Java/Others)
- [./Java/Others/RestrictedTowerOfHanoi](./Java/Others/RestrictedTowerOfHanoi)
- [./Java/Others/RestrictedTowerOfHanoi/Main](./Java/Others/RestrictedTowerOfHanoi/Main)
- [./Java/Others/RestrictedTowerOfHanoi/Resources](./Java/Others/RestrictedTowerOfHanoi/Resources)
- [./Java/Others/RestrictedTowerOfHanoi/Screenshots](./Java/Others/RestrictedTowerOfHanoi/Screenshots)
- [./Java/ProjectEuler](./Java/ProjectEuler)
- [./Java/Searches](./Java/Searches)
- [./Java/Sorts](./Java/Sorts)
- [./Java/strings](./Java/strings)
- ***

***

- [./Javascript](./Javascript)
- [./Javascript/Backtracking](./Javascript/Backtracking)
- [./Javascript/Backtracking/tests](./Javascript/Backtracking/tests)
- [./Javascript/Bit-Manipulation](./Javascript/Bit-Manipulation)
- [./Javascript/Bit-Manipulation/test](./Javascript/Bit-Manipulation/test)
- [./Javascript/Cache](./Javascript/Cache)
- [./Javascript/Cellular-Automata](./Javascript/Cellular-Automata)
- [./Javascript/Ciphers](./Javascript/Ciphers)
- [./Javascript/Conversions](./Javascript/Conversions)
- [./Javascript/Data-Structures](./Javascript/Data-Structures)
- [./Javascript/Data-Structures/Array](./Javascript/Data-Structures/Array)
- [./Javascript/Data-Structures/Graph](./Javascript/Data-Structures/Graph)
- [./Javascript/Data-Structures/Heap](./Javascript/Data-Structures/Heap)
- [./Javascript/Data-Structures/Linked-List](./Javascript/Data-Structures/Linked-List)
- [./Javascript/Data-Structures/Queue](./Javascript/Data-Structures/Queue)
- [./Javascript/Data-Structures/Stack](./Javascript/Data-Structures/Stack)
- [./Javascript/Data-Structures/Tree](./Javascript/Data-Structures/Tree)
- [./Javascript/Data-Structures/Vectors](./Javascript/Data-Structures/Vectors)
- [./Javascript/Dynamic-Programming](./Javascript/Dynamic-Programming)
- [./Javascript/Geometry](./Javascript/Geometry)
- [./Javascript/Graphs](./Javascript/Graphs)
- [./Javascript/Hashes](./Javascript/Hashes)
- [./Javascript/Linear-Algebra](./Javascript/Linear-Algebra)
- [./Javascript/Linear-Algebra/src](./Javascript/Linear-Algebra/src)
- [./Javascript/Linear-Algebra/test](./Javascript/Linear-Algebra/test)
- [./Javascript/Maths](./Javascript/Maths)
- [./Javascript/Maths/test](./Javascript/Maths/test)
- [./Javascript/Navigation](./Javascript/Navigation)
- [./Javascript/Project-Euler](./Javascript/Project-Euler)
- [./Javascript/Project-Euler/test](./Javascript/Project-Euler/test)
- [./Javascript/Recursive](./Javascript/Recursive)
- [./Javascript/Search](./Javascript/Search)
- [./Javascript/Search/test](./Javascript/Search/test)
- [./Javascript/Sorts](./Javascript/Sorts)
- [./Javascript/String](./Javascript/String)
- [./Javascript/String/test](./Javascript/String/test)
- [./Javascript/Timing-Functions](./Javascript/Timing-Functions)
- [./Javascript/Trees](./Javascript/Trees)
- [./Javascript/Web-Programming](./Javascript/Web-Programming)
- ***

***

- [./Julia](./Julia)
- [./Julia/docs](./Julia/docs)
- [./Julia/docs/src](./Julia/docs/src)
- [./Julia/src](./Julia/src)
- [./Julia/src/basic](./Julia/src/basic)
- [./Julia/src/conversions](./Julia/src/conversions)
- [./Julia/src/data_structures](./Julia/src/data_structures)
- [./Julia/src/data_structures/binary_tree](./Julia/src/data_structures/binary_tree)
- [./Julia/src/data_structures/disjoint_set](./Julia/src/data_structures/disjoint_set)
- [./Julia/src/knapsack](./Julia/src/knapsack)
- [./Julia/src/math](./Julia/src/math)
- [./Julia/src/matrix](./Julia/src/matrix)
- [./Julia/src/project-rosalind](./Julia/src/project-rosalind)
- [./Julia/src/scheduling](./Julia/src/scheduling)
- [./Julia/src/searches](./Julia/src/searches)
- [./Julia/src/sorts](./Julia/src/sorts)
- [./Julia/src/statistics](./Julia/src/statistics)
- [./Julia/src/strings](./Julia/src/strings)
- [./Julia/test](./Julia/test)
- ***

***

- [./Jupyter](./Jupyter)
- [./Jupyter/assets](./Jupyter/assets)
- [./Jupyter/assets/images](./Jupyter/assets/images)
- [./Jupyter/Automaton](./Jupyter/Automaton)
- [./Jupyter/machine_learning](./Jupyter/machine_learning)
- [./Jupyter/machine_learning/ARIMA](./Jupyter/machine_learning/ARIMA)
- [./Jupyter/machine_learning/ARIMA/data](./Jupyter/machine_learning/ARIMA/data)
- [./Jupyter/machine_learning/AssociativeMining](./Jupyter/machine_learning/AssociativeMining)
- [./Jupyter/machine_learning/Basicsoftensorflow](./Jupyter/machine_learning/Basicsoftensorflow)
- [./Jupyter/machine_learning/Cosine-Similarity](./Jupyter/machine_learning/Cosine-Similarity)
- [./Jupyter/machine_learning/dbscan](./Jupyter/machine_learning/dbscan)
- [./Jupyter/machine_learning/Decisiontree](./Jupyter/machine_learning/Decisiontree)
- [./Jupyter/machine_learning/DecisionTreeregressionwithk-foldcrossvalidation](./Jupyter/machine_learning/DecisionTreeregressionwithk-foldcrossvalidation)
- [./Jupyter/machine_learning/Fundamentalsofpython](./Jupyter/machine_learning/Fundamentalsofpython)
- [./Jupyter/machine_learning/Linear_Regression](./Jupyter/machine_learning/Linear_Regression)
- [./Jupyter/machine_learning/Matplotlib](./Jupyter/machine_learning/Matplotlib)
- [./Jupyter/machine_learning/Movie_recommendation_system](./Jupyter/machine_learning/Movie_recommendation_system)
- [./Jupyter/machine_learning/Naive_Bayes](./Jupyter/machine_learning/Naive_Bayes)
- [./Jupyter/machine_learning/NaiveBayesClassification](./Jupyter/machine_learning/NaiveBayesClassification)
- [./Jupyter/machine_learning/Naturallanguageprocessing](./Jupyter/machine_learning/Naturallanguageprocessing)
- [./Jupyter/machine_learning/Numpy](./Jupyter/machine_learning/Numpy)
- [./Jupyter/machine_learning/Pandas](./Jupyter/machine_learning/Pandas)
- [./Jupyter/machine_learning/Prophet](./Jupyter/machine_learning/Prophet)
- [./Jupyter/machine_learning/Prophet/data](./Jupyter/machine_learning/Prophet/data)
- [./Jupyter/machine_learning/random_forest_classification](./Jupyter/machine_learning/random_forest_classification)
- [./Jupyter/machine_learning/random_forest_classification/**pycache**](./Jupyter/machine_learning/random_forest_classification/__pycache__)
- [./Jupyter/machine_learning/random_forest_regression](./Jupyter/machine_learning/random_forest_regression)
- [./Jupyter/machine_learning/random_forest_regression/**pycache**](./Jupyter/machine_learning/random_forest_regression/__pycache__)
- [./Jupyter/machine_learning/Reuters_one_vs_rest_classifier](./Jupyter/machine_learning/Reuters_one_vs_rest_classifier)
- [./Jupyter/machine_learning/Scikit-learn](./Jupyter/machine_learning/Scikit-learn)
- [./Jupyter/machine_learning/Support_Vector_Machine](./Jupyter/machine_learning/Support_Vector_Machine)
- [./Jupyter/neural_network](./Jupyter/neural_network)
- [./Jupyter/neural_network/GANs-PyTorch-Vanilla-LS-DC](./Jupyter/neural_network/GANs-PyTorch-Vanilla-LS-DC)
- [./Jupyter/neural_network/RNN](./Jupyter/neural_network/RNN)
- [./Jupyter/numerical_methods](./Jupyter/numerical_methods)
- [./Jupyter/other](./Jupyter/other)
- ***

***

- [./Kotlin](./Kotlin)
- [./Kotlin/gradle](./Kotlin/gradle)
- [./Kotlin/gradle/wrapper](./Kotlin/gradle/wrapper)
- [./Kotlin/src](./Kotlin/src)
- [./Kotlin/src/main](./Kotlin/src/main)
- [./Kotlin/src/main/kotlin](./Kotlin/src/main/kotlin)
- [./Kotlin/src/test](./Kotlin/src/test)
- [./Kotlin/src/test/kotlin](./Kotlin/src/test/kotlin)
- ***

***

- [./MATLAB-Octave](./MATLAB-Octave)
- [./MATLAB-Octave/algorithms](./MATLAB-Octave/algorithms)
- [./MATLAB-Octave/algorithms/arithmetic_analysis](./MATLAB-Octave/algorithms/arithmetic_analysis)
- [./MATLAB-Octave/algorithms/crypto](./MATLAB-Octave/algorithms/crypto)
- [./MATLAB-Octave/algorithms/crypto/sdbm-hash](./MATLAB-Octave/algorithms/crypto/sdbm-hash)
- [./MATLAB-Octave/algorithms/Divisibility_of_integers](./MATLAB-Octave/algorithms/Divisibility_of_integers)
- [./MATLAB-Octave/algorithms/Genetic-Algorithm](./MATLAB-Octave/algorithms/Genetic-Algorithm)
- [./MATLAB-Octave/algorithms/Genetic-Algorithm/Minimizationofpolynomialfunction](./MATLAB-Octave/algorithms/Genetic-Algorithm/Minimizationofpolynomialfunction)
- [./MATLAB-Octave/algorithms/ImageProcessing](./MATLAB-Octave/algorithms/ImageProcessing)
- [./MATLAB-Octave/algorithms/ImageProcessing/LSBbasedImageSteganography](./MATLAB-Octave/algorithms/ImageProcessing/LSBbasedImageSteganography)
- [./MATLAB-Octave/algorithms/ImageProcessing/NearestNeighbhorInterpolation](./MATLAB-Octave/algorithms/ImageProcessing/NearestNeighbhorInterpolation)
- [./MATLAB-Octave/algorithms/machine_learning](./MATLAB-Octave/algorithms/machine_learning)
- [./MATLAB-Octave/algorithms/machine_learning/ActivationFunctions](./MATLAB-Octave/algorithms/machine_learning/ActivationFunctions)
- [./MATLAB-Octave/algorithms/machine_learning/Gradient-Descent](./MATLAB-Octave/algorithms/machine_learning/Gradient-Descent)
- [./MATLAB-Octave/algorithms/machine_learning/kmeans](./MATLAB-Octave/algorithms/machine_learning/kmeans)
- [./MATLAB-Octave/algorithms/machine_learning/Linear-Regression](./MATLAB-Octave/algorithms/machine_learning/Linear-Regression)
- [./MATLAB-Octave/algorithms/machine_learning/Logistic-Regression](./MATLAB-Octave/algorithms/machine_learning/Logistic-Regression)
- [./MATLAB-Octave/algorithms/machine_learning/Nearest-Neighbor](./MATLAB-Octave/algorithms/machine_learning/Nearest-Neighbor)
- [./MATLAB-Octave/algorithms/maths](./MATLAB-Octave/algorithms/maths)
- [./MATLAB-Octave/algorithms/other](./MATLAB-Octave/algorithms/other)
- [./MATLAB-Octave/algorithms/Particle_Swarm_Optimization](./MATLAB-Octave/algorithms/Particle_Swarm_Optimization)
- [./MATLAB-Octave/algorithms/Particle_Swarm_Optimization/PolynomialMinimization](./MATLAB-Octave/algorithms/Particle_Swarm_Optimization/PolynomialMinimization)
- [./MATLAB-Octave/algorithms/Searching](./MATLAB-Octave/algorithms/Searching)
- [./MATLAB-Octave/algorithms/Sieve_of_Eratosthenes](./MATLAB-Octave/algorithms/Sieve_of_Eratosthenes)
- [./MATLAB-Octave/algorithms/sorting](./MATLAB-Octave/algorithms/sorting)
- [./MATLAB-Octave/algorithms/Strings](./MATLAB-Octave/algorithms/Strings)
- [./MATLAB-Octave/image-processing](./MATLAB-Octave/image-processing)
- [./MATLAB-Octave/image-processing/Blob-detection-using-Matlab](./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/assets)
- [./MATLAB-Octave/matlab_for_beginners](./MATLAB-Octave/matlab_for_beginners)
- [./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)](<./MATLAB-Octave/matlab_for_beginners/part_1(learn_basic_programing)>)
- [./MATLAB-Octave/matlab_for_beginners/part_2(basic_looping)](<./MATLAB-Octave/matlab_for_beginners/part_2(basic_looping)>)
- [./MATLAB-Octave/matlab_for_beginners/part_3(basic_branching)](<./MATLAB-Octave/matlab_for_beginners/part_3(basic_branching)>)
- [./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)](<./MATLAB-Octave/matlab_for_beginners/part_4(array_nd_matrix)>)
- [./MATLAB-Octave/project-euler](./MATLAB-Octave/project-euler)
- [./MATLAB-Octave/project-euler/Problem1](./MATLAB-Octave/project-euler/Problem1)
- [./MATLAB-Octave/project-euler/Problem2](./MATLAB-Octave/project-euler/Problem2)
- [./MATLAB-Octave/project-euler/Problem3](./MATLAB-Octave/project-euler/Problem3)
- [./MATLAB-Octave/project-euler/Problem4](./MATLAB-Octave/project-euler/Problem4)
- ***

***

- [./OCaml](./OCaml)
- [./OCaml/searches](./OCaml/searches)
- [./OCaml/Sorts](./OCaml/Sorts)
- [./PHP](./PHP)
- [./PHP/ciphers](./PHP/ciphers)
- [./PHP/Conversions](./PHP/Conversions)
- [./PHP/Maths](./PHP/Maths)
- [./PHP/searches](./PHP/searches)
- [./PHP/sorting](./PHP/sorting)
- [./PHP/String](./PHP/String)
- [./PHP/tests](./PHP/tests)
- [./PHP/tests/sorting](./PHP/tests/sorting)
- ***

***

- [./Python](./Python)
- [./Python/arithmetic_analysis](./Python/arithmetic_analysis)
- [./Python/arithmetic_analysis/image_data](./Python/arithmetic_analysis/image_data)
- [./Python/backtracking](./Python/backtracking)
- [./Python/bit_manipulation](./Python/bit_manipulation)
- [./Python/blockchain](./Python/blockchain)
- [./Python/boolean_algebra](./Python/boolean_algebra)
- [./Python/cellular_automata](./Python/cellular_automata)
- [./Python/ciphers](./Python/ciphers)
- [./Python/compression](./Python/compression)
- [./Python/compression/image_data](./Python/compression/image_data)
- [./Python/computer_vision](./Python/computer_vision)
- [./Python/conversions](./Python/conversions)
- [./Python/data_structures](./Python/data_structures)
- [./Python/data_structures/binary_tree](./Python/data_structures/binary_tree)
- [./Python/data_structures/disjoint_set](./Python/data_structures/disjoint_set)
- [./Python/data_structures/hashing](./Python/data_structures/hashing)
- [./Python/data_structures/hashing/number_theory](./Python/data_structures/hashing/number_theory)
- [./Python/data_structures/heap](./Python/data_structures/heap)
- [./Python/data_structures/linked_list](./Python/data_structures/linked_list)
- [./Python/data_structures/queue](./Python/data_structures/queue)
- [./Python/data_structures/stacks](./Python/data_structures/stacks)
- [./Python/data_structures/trie](./Python/data_structures/trie)
- [./Python/digital_image_processing](./Python/digital_image_processing)
- [./Python/digital_image_processing/dithering](./Python/digital_image_processing/dithering)
- [./Python/digital_image_processing/edge_detection](./Python/digital_image_processing/edge_detection)
- [./Python/digital_image_processing/filters](./Python/digital_image_processing/filters)
- [./Python/digital_image_processing/histogram_equalization](./Python/digital_image_processing/histogram_equalization)
- [./Python/digital_image_processing/histogram_equalization/image_data](./Python/digital_image_processing/histogram_equalization/image_data)
- [./Python/digital_image_processing/histogram_equalization/output_data](./Python/digital_image_processing/histogram_equalization/output_data)
- [./Python/digital_image_processing/image_data](./Python/digital_image_processing/image_data)
- [./Python/digital_image_processing/resize](./Python/digital_image_processing/resize)
- [./Python/digital_image_processing/rotation](./Python/digital_image_processing/rotation)
- [./Python/divide_and_conquer](./Python/divide_and_conquer)
- [./Python/dynamic_programming](./Python/dynamic_programming)
- [./Python/electronics](./Python/electronics)
- [./Python/file_transfer](./Python/file_transfer)
- [./Python/file_transfer/tests](./Python/file_transfer/tests)
- [./Python/fractals](./Python/fractals)
- [./Python/fuzzy_logic](./Python/fuzzy_logic)
- [./Python/genetic_algorithm](./Python/genetic_algorithm)
- [./Python/geodesy](./Python/geodesy)
- [./Python/graphics](./Python/graphics)
- [./Python/graphs](./Python/graphs)
- [./Python/graphs/tests](./Python/graphs/tests)
- [./Python/hashes](./Python/hashes)
- [./Python/knapsack](./Python/knapsack)
- [./Python/knapsack/tests](./Python/knapsack/tests)
- [./Python/linear_algebra](./Python/linear_algebra)
- [./Python/linear_algebra/src](./Python/linear_algebra/src)
- [./Python/machine_learning](./Python/machine_learning)
- [./Python/machine_learning/forecasting](./Python/machine_learning/forecasting)
- [./Python/machine_learning/lstm](./Python/machine_learning/lstm)
- [./Python/maths](./Python/maths)
- [./Python/maths/images](./Python/maths/images)
- [./Python/maths/series](./Python/maths/series)
- [./Python/matrix](./Python/matrix)
- [./Python/matrix/tests](./Python/matrix/tests)
- [./Python/networking_flow](./Python/networking_flow)
- [./Python/neural_network](./Python/neural_network)
- [./Python/other](./Python/other)
- [./Python/physics](./Python/physics)
- [./Python/project_euler](./Python/project_euler)
- [./Python/project_euler/problem_001](./Python/project_euler/problem_001)
- [./Python/project_euler/problem_002](./Python/project_euler/problem_002)
- [./Python/project_euler/problem_003](./Python/project_euler/problem_003)
- [./Python/project_euler/problem_004](./Python/project_euler/problem_004)
- [./Python/project_euler/problem_005](./Python/project_euler/problem_005)
- [./Python/project_euler/problem_006](./Python/project_euler/problem_006)
- [./Python/project_euler/problem_007](./Python/project_euler/problem_007)
- [./Python/project_euler/problem_008](./Python/project_euler/problem_008)
- [./Python/project_euler/problem_009](./Python/project_euler/problem_009)
- [./Python/project_euler/problem_010](./Python/project_euler/problem_010)
- [./Python/project_euler/problem_011](./Python/project_euler/problem_011)
- [./Python/project_euler/problem_012](./Python/project_euler/problem_012)
- [./Python/project_euler/problem_013](./Python/project_euler/problem_013)
- [./Python/project_euler/problem_014](./Python/project_euler/problem_014)
- [./Python/project_euler/problem_015](./Python/project_euler/problem_015)
- [./Python/project_euler/problem_016](./Python/project_euler/problem_016)
- [./Python/project_euler/problem_017](./Python/project_euler/problem_017)
- [./Python/project_euler/problem_018](./Python/project_euler/problem_018)
- [./Python/project_euler/problem_019](./Python/project_euler/problem_019)
- [./Python/project_euler/problem_020](./Python/project_euler/problem_020)
- [./Python/project_euler/problem_021](./Python/project_euler/problem_021)
- [./Python/project_euler/problem_022](./Python/project_euler/problem_022)
- [./Python/project_euler/problem_023](./Python/project_euler/problem_023)
- [./Python/project_euler/problem_024](./Python/project_euler/problem_024)
- [./Python/project_euler/problem_025](./Python/project_euler/problem_025)
- [./Python/project_euler/problem_026](./Python/project_euler/problem_026)
- [./Python/project_euler/problem_027](./Python/project_euler/problem_027)
- [./Python/project_euler/problem_028](./Python/project_euler/problem_028)
- [./Python/project_euler/problem_029](./Python/project_euler/problem_029)
- [./Python/project_euler/problem_030](./Python/project_euler/problem_030)
- [./Python/project_euler/problem_031](./Python/project_euler/problem_031)
- [./Python/project_euler/problem_032](./Python/project_euler/problem_032)
- [./Python/project_euler/problem_033](./Python/project_euler/problem_033)
- [./Python/project_euler/problem_034](./Python/project_euler/problem_034)
- [./Python/project_euler/problem_035](./Python/project_euler/problem_035)
- [./Python/project_euler/problem_036](./Python/project_euler/problem_036)
- [./Python/project_euler/problem_037](./Python/project_euler/problem_037)
- [./Python/project_euler/problem_038](./Python/project_euler/problem_038)
- [./Python/project_euler/problem_039](./Python/project_euler/problem_039)
- [./Python/project_euler/problem_040](./Python/project_euler/problem_040)
- [./Python/project_euler/problem_041](./Python/project_euler/problem_041)
- [./Python/project_euler/problem_042](./Python/project_euler/problem_042)
- [./Python/project_euler/problem_043](./Python/project_euler/problem_043)
- [./Python/project_euler/problem_044](./Python/project_euler/problem_044)
- [./Python/project_euler/problem_045](./Python/project_euler/problem_045)
- [./Python/project_euler/problem_046](./Python/project_euler/problem_046)
- [./Python/project_euler/problem_047](./Python/project_euler/problem_047)
- [./Python/project_euler/problem_048](./Python/project_euler/problem_048)
- [./Python/project_euler/problem_049](./Python/project_euler/problem_049)
- [./Python/project_euler/problem_050](./Python/project_euler/problem_050)
- [./Python/project_euler/problem_051](./Python/project_euler/problem_051)
- [./Python/project_euler/problem_052](./Python/project_euler/problem_052)
- [./Python/project_euler/problem_053](./Python/project_euler/problem_053)
- [./Python/project_euler/problem_054](./Python/project_euler/problem_054)
- [./Python/project_euler/problem_055](./Python/project_euler/problem_055)
- [./Python/project_euler/problem_056](./Python/project_euler/problem_056)
- [./Python/project_euler/problem_057](./Python/project_euler/problem_057)
- [./Python/project_euler/problem_058](./Python/project_euler/problem_058)
- [./Python/project_euler/problem_059](./Python/project_euler/problem_059)
- [./Python/project_euler/problem_062](./Python/project_euler/problem_062)
- [./Python/project_euler/problem_063](./Python/project_euler/problem_063)
- [./Python/project_euler/problem_064](./Python/project_euler/problem_064)
- [./Python/project_euler/problem_065](./Python/project_euler/problem_065)
- [./Python/project_euler/problem_067](./Python/project_euler/problem_067)
- [./Python/project_euler/problem_069](./Python/project_euler/problem_069)
- [./Python/project_euler/problem_070](./Python/project_euler/problem_070)
- [./Python/project_euler/problem_071](./Python/project_euler/problem_071)
- [./Python/project_euler/problem_072](./Python/project_euler/problem_072)
- [./Python/project_euler/problem_074](./Python/project_euler/problem_074)
- [./Python/project_euler/problem_075](./Python/project_euler/problem_075)
- [./Python/project_euler/problem_076](./Python/project_euler/problem_076)
- [./Python/project_euler/problem_077](./Python/project_euler/problem_077)
- [./Python/project_euler/problem_080](./Python/project_euler/problem_080)
- [./Python/project_euler/problem_081](./Python/project_euler/problem_081)
- [./Python/project_euler/problem_085](./Python/project_euler/problem_085)
- [./Python/project_euler/problem_086](./Python/project_euler/problem_086)
- [./Python/project_euler/problem_087](./Python/project_euler/problem_087)
- [./Python/project_euler/problem_089](./Python/project_euler/problem_089)
- [./Python/project_euler/problem_091](./Python/project_euler/problem_091)
- [./Python/project_euler/problem_097](./Python/project_euler/problem_097)
- [./Python/project_euler/problem_099](./Python/project_euler/problem_099)
- [./Python/project_euler/problem_101](./Python/project_euler/problem_101)
- [./Python/project_euler/problem_102](./Python/project_euler/problem_102)
- [./Python/project_euler/problem_107](./Python/project_euler/problem_107)
- [./Python/project_euler/problem_109](./Python/project_euler/problem_109)
- [./Python/project_euler/problem_112](./Python/project_euler/problem_112)
- [./Python/project_euler/problem_113](./Python/project_euler/problem_113)
- [./Python/project_euler/problem_119](./Python/project_euler/problem_119)
- [./Python/project_euler/problem_120](./Python/project_euler/problem_120)
- [./Python/project_euler/problem_121](./Python/project_euler/problem_121)
- [./Python/project_euler/problem_123](./Python/project_euler/problem_123)
- [./Python/project_euler/problem_125](./Python/project_euler/problem_125)
- [./Python/project_euler/problem_129](./Python/project_euler/problem_129)
- [./Python/project_euler/problem_135](./Python/project_euler/problem_135)
- [./Python/project_euler/problem_144](./Python/project_euler/problem_144)
- [./Python/project_euler/problem_173](./Python/project_euler/problem_173)
- [./Python/project_euler/problem_174](./Python/project_euler/problem_174)
- [./Python/project_euler/problem_180](./Python/project_euler/problem_180)
- [./Python/project_euler/problem_188](./Python/project_euler/problem_188)
- [./Python/project_euler/problem_191](./Python/project_euler/problem_191)
- [./Python/project_euler/problem_203](./Python/project_euler/problem_203)
- [./Python/project_euler/problem_206](./Python/project_euler/problem_206)
- [./Python/project_euler/problem_207](./Python/project_euler/problem_207)
- [./Python/project_euler/problem_234](./Python/project_euler/problem_234)
- [./Python/project_euler/problem_301](./Python/project_euler/problem_301)
- [./Python/project_euler/problem_551](./Python/project_euler/problem_551)
- [./Python/quantum](./Python/quantum)
- [./Python/scheduling](./Python/scheduling)
- [./Python/scripts](./Python/scripts)
- [./Python/searches](./Python/searches)
- [./Python/sorts](./Python/sorts)
- [./Python/strings](./Python/strings)
- [./Python/web_programming](./Python/web_programming)
- ***

***

- [./R](./R)
- [./R/Association-Algorithms](./R/Association-Algorithms)
- [./R/Classification-Algorithms](./R/Classification-Algorithms)
- [./R/Clustering-Algorithms](./R/Clustering-Algorithms)
- [./R/Data-Manipulation](./R/Data-Manipulation)
- [./R/Data-Mining](./R/Data-Mining)
- [./R/Data-Preprocessing](./R/Data-Preprocessing)
- [./R/Machine-Learning](./R/Machine-Learning)
- [./R/Mathematics](./R/Mathematics)
- [./R/Regression-Algorithms](./R/Regression-Algorithms)
- [./R/Sorting-Algorithms](./R/Sorting-Algorithms)
- ***

***

- [./Ruby](./Ruby)
- [./Ruby/backtracking](./Ruby/backtracking)
- [./Ruby/bit_manipulation](./Ruby/bit_manipulation)
- [./Ruby/ciphers](./Ruby/ciphers)
- [./Ruby/conversions](./Ruby/conversions)
- [./Ruby/data_structures](./Ruby/data_structures)
- [./Ruby/data_structures/arrays](./Ruby/data_structures/arrays)
- [./Ruby/data_structures/arrays/strings](./Ruby/data_structures/arrays/strings)
- [./Ruby/data_structures/binary_trees](./Ruby/data_structures/binary_trees)
- [./Ruby/data_structures/hash_table](./Ruby/data_structures/hash_table)
- [./Ruby/data_structures/linked_lists](./Ruby/data_structures/linked_lists)
- [./Ruby/data_structures/queues](./Ruby/data_structures/queues)
- [./Ruby/data_structures/stacks](./Ruby/data_structures/stacks)
- [./Ruby/data_structures/tries](./Ruby/data_structures/tries)
- [./Ruby/discrete_mathematics](./Ruby/discrete_mathematics)
- [./Ruby/dynamic_programming](./Ruby/dynamic_programming)
- [./Ruby/maths](./Ruby/maths)
- [./Ruby/other](./Ruby/other)
- [./Ruby/project_euler](./Ruby/project_euler)
- [./Ruby/project_euler/problem_1](./Ruby/project_euler/problem_1)
- [./Ruby/project_euler/problem_2](./Ruby/project_euler/problem_2)
- [./Ruby/project_euler/problem_20](./Ruby/project_euler/problem_20)
- [./Ruby/project_euler/problem_21](./Ruby/project_euler/problem_21)
- [./Ruby/project_euler/problem_22](./Ruby/project_euler/problem_22)
- [./Ruby/project_euler/problem_3](./Ruby/project_euler/problem_3)
- [./Ruby/project_euler/problem_4](./Ruby/project_euler/problem_4)
- [./Ruby/project_euler/problem_5](./Ruby/project_euler/problem_5)
- [./Ruby/searches](./Ruby/searches)
- [./Ruby/sorting](./Ruby/sorting)
- ***

***

- [./Rust](./Rust)
- [./Rust/git_hooks](./Rust/git_hooks)
- [./Rust/src](./Rust/src)
- [./Rust/src/ciphers](./Rust/src/ciphers)
- [./Rust/src/data_structures](./Rust/src/data_structures)
- [./Rust/src/dynamic_programming](./Rust/src/dynamic_programming)
- [./Rust/src/general](./Rust/src/general)
- [./Rust/src/searching](./Rust/src/searching)
- [./Rust/src/sorting](./Rust/src/sorting)
- [./Rust/src/string](./Rust/src/string)
- ***

***

- [./Scala](./Scala)
- [./Scala/project](./Scala/project)
- [./Scala/src](./Scala/src)
- [./Scala/src/main](./Scala/src/main)
- [./Scala/src/main/scala](./Scala/src/main/scala)
- [./Scala/src/test](./Scala/src/test)
- [./Scala/src/test/scala](./Scala/src/test/scala)
- ***

***

- [./scripts](./scripts)
- ***

***

- [./Swift](./Swift)
- [./Swift/algorithms](./Swift/algorithms)
- [./Swift/algorithms/parsing](./Swift/algorithms/parsing)
- [./Swift/algorithms/parsing/shunting_yard](./Swift/algorithms/parsing/shunting_yard)
- [./Swift/data_structures](./Swift/data_structures)
- [./Swift/data_structures/heap](./Swift/data_structures/heap)
- [./Swift/data_structures/LinkedList](./Swift/data_structures/LinkedList)
- [./Swift/data_structures/queue](./Swift/data_structures/queue)
- [./Swift/data_structures/Stack](./Swift/data_structures/Stack)
- [./Swift/data_structures/union_find](./Swift/data_structures/union_find)
- [./Swift/graph](./Swift/graph)
- [./Swift/graph/spanning_tree](./Swift/graph/spanning_tree)
- [./Swift/recursion](./Swift/recursion)
- [./Swift/sorts](./Swift/sorts)
- [./Swift/trees](./Swift/trees)
- ***

***

- [./TheAlgorithms.github.io](./TheAlgorithms.github.io)
- [./TheAlgorithms.github.io/images](./TheAlgorithms.github.io/images)
- [./TheAlgorithms.github.io/images/svg](./TheAlgorithms.github.io/images/svg)
- [./TheAlgorithms.github.io/static](./TheAlgorithms.github.io/static)
- [./TheAlgorithms.github.io/static/css](./TheAlgorithms.github.io/static/css)
- [./TheAlgorithms.github.io/static/img](./TheAlgorithms.github.io/static/img)
- ***

***

- [./website](./website)
- [./website-old](./website-old)
- [./website-old/css](./website-old/css)
- [./website-old/images](./website-old/images)
- [./website-old/images/svg](./website-old/images/svg)

---

</details>

---

---
## Navigation:

---

<details>
<summary>Arithmetic Progression</summary>

# 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:**

1. Initial term: In an arithmetic progression, the first number in the series is called the initial term.
2. Common difference: The value by which consecutive terms increase or decrease is called the `common difference`.
3. 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](https://www.geeksforgeeks.org/arithmetic-progression)

# YouTube

- [Video URL for concept](https://youtu.be/gua96ju_FBk)
- [Video for understanding AP Dynamic Programming in C++](https://youtu.be/U_qtSRQYoPs)

</details>

---
---

<details>
<summary>                     Average (Mean)                                       </summary>

# 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

1.  Input a list of numbers.
2.  Calculate the sum of all numbers in the list.
3.  Count the numbers in the list.
4.  Divide the sum by the total count of numbers in the list.
5.  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.<u>857142</u>

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

### Step 5

Return the value of 22.<u>857142</u> or `23`.

## Implementation

- [Python](https://github.com/TheAlgorithms/Python/blob/master/maths/average_mean.py)
- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/maths/average_mean.rb)

## Video URL

- [Mean on Khan Academy](https://www.khanacademy.org/math/ap-statistics/summarizing-quantitative-data-ap/measuring-center-quantitative/v/mean-median-and-mode)

## Others

- [Mean on Wikipedia](https://en.wikipedia.org/wiki/Mean)

</details>

---
---

<details>
<summary>                          Fibonacci                             </summary>

# 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

1.  Prepare Base Matrice
2.  Calculate the power of this Matrice
3.  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

- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/fibonacci.cpp)
- [Java](https://github.com/TheAlgorithms/Java/blob/master/Maths/FibonacciNumber.java)
- [Javascript](https://github.com/TheAlgorithms/Javascript/blob/80c2dc85d714f73783f133964d6acd9b5625ddd9/Maths/Fibonacci.js)
- [Python](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci.py)

## Video URL

- [Youtube](https://www.youtube.com/watch?v=EEb6JP3NXBI)

## Others

- [Proof](https://brilliant.org/wiki/fast-fibonacci-transform/)

</details>

---
---

<details>
<summary>                              Finding the number of digits in a number                         </summary>

# 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
```

<div align="center">
  <h2 align="center"> 1st Solution </h2>
</div>

### 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.
```

<div align="center">
  <h2 align="center"> 2nd Solution </h2>
</div>

### 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](https://www.geeksforgeeks.org/program-count-digits-integer-3-different-methods/)

# YouTube

- [Video URL](https://www.youtube.com/watch?v=ngWnvWR8NkE)

</details>

---
---

<details>
<summary>                       Geometric Progression                                </summary>
# 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:**

1. **Initial term:** In a geometric progression, the first number is called the initial term.
2. **Common ratio:** The ratio of any two consecutive terms by taking the previous term in the denominator.
3. 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](https://www.geeksforgeeks.org/geometric-progression/)

# YouTube

- [Video URL for concept](https://youtu.be/gua96ju_FBk)
- [Video for understanding GP Dynamic Programming in C++](https://youtu.be/92ZldzuGUHs)

</details>

---
---

<details>
<summary>                     Caesar Cipher                                  </summary>

# 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!**

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

## Steps

### Encryption

1. Choose the alphabet you are going to use.
2. Choose a secret key (shift) that you are going to use in this case `n`.
3. 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.)
4. The message should now be encoded.

### Decryption

1. Choose the alphabet that the message was encrypted with.
2. Let `n` be the secret key the message is encoded in.
3. 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`.
4. 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](https://github.com/TheAlgorithms/Python/blob/master/ciphers/caesar_cipher.py)

</details>

---
---

<details>
<summary>                         Hill Cipher                              </summary>

# Hill Cipher

The Hill cipher was invented by [Lester S. Hill](https://en.wikipedia.org/wiki/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

1. We have to write key as an `n × n` matrix as

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

2. Same way convert PT into a vector as

```
    [0]
    [2]
    [19]
```

3. 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

1. 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]
```

2. 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**](https://github.com/TheAlgorithms/Python/blob/master/ciphers/hill_cipher.py)

## Video Explanation

[Video explanation of the Hill Cipher](https://www.youtube.com/watch?v=6T46sgty4Mk)

</details>

---
---

<details>
<summary>                         Bellman-Ford                              </summary>

# 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

- [Java](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/BellmanFord.java)
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/Dynamic%20Programming/Bellman-Ford.cpp)
- [Python](https://github.com/TheAlgorithms/Python/blob/master/data_structures/graph/bellman_ford.py)
- [C](https://github.com/TheAlgorithms/C/blob/master/data_structures/graphs/Bellman-Ford.c)

#### Video Explanation

[A video explaining the Bellman-Ford Algorithm](https://www.youtube.com/watch?v=hxMWBBCpR6A)

#### Others

Sources Used:

- https://www.geeksforgeeks.org/bellman-ford-algorithm-dp-23/
- https://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm

</details>

---
---

<details>
<summary>                             Singly Linked List                          </summary>
# 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

```.java
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

- [Java](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Lists/SinglyLinkedList.java)
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/Data%20Structure/Linked%20List.cpp)
- [Python](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/singly_linked_list.py)
- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/linked_lists/single_list.rb)

## Video Explanation

[A CS50 video explaining the Linked List Data Structure](https://www.youtube.com/watch?v=5nsKtQuT6E8)

</details>

---
---

<details>
<summary>                  Doubly Linked List
                                     </summary>

# Doubly Linked List

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

```java
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

![Tracing of algorithm](https://www.geeksforgeeks.org/wp-content/uploads/gq/2014/03/DLL_add_front1.png)

### Add a node after a given node

![Tracing of algorithm](https://www.geeksforgeeks.org/wp-content/uploads/gq/2014/03/DLL_add_middle1.png)

## Code Implementation Links

- [Java](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Lists/DoublyLinkedList.java)
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/Data%20Structure/Doubly%20Linked%20List.cpp)
- [Python](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/doubly_linked_list.py)
- [Go](https://github.com/TheAlgorithms/Go/blob/master/data-structures/linked-list/double-linkedlist.go)
- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/linked_lists/double_list.rb)

## Video Explanation

[A CS50 video explaining the Doubly Linked List Data Structure](https://www.youtube.com/watch?v=FHMPswJDCvU)

</details>

---
---

<details>
<summary>                         Coin Change                              </summary>

# 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](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/coin_change.py)

#### Video Explanation

[Total Unique Ways To Make Change by Back To Back SWE](https://www.youtube.com/watch?v=DJ4a7cmjZY0)

</details>

---
---

<details>
<summary>                              Longest Common Subsequence                         </summary>

# Longest Common Subsequence

#### Problem Statement

Given two strings `S` and `T`, find the length of the longest common subsequence (<b>LCS</b>).

#### 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 <b>Longest</b> common subsequence, we will pick <b>the maximum value</b> 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]` <b>plus</b> 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

- [Java](https://github.com/TheAlgorithms/Java/blob/master/Dynamic%20Programming/LongestCommonSubsequence.java)
- [Python](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_common_subsequence.py)
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/Dynamic%20Programming/Longest%20Common%20Subsequence.cpp)

#### Video Explanation

[Video explanation by Tushar Roy](https://youtu.be/NnD96abizww)

</details>

---
---

<details>
<summary>                        Binary Search (A divide and conquer algorithm)
                               </summary>
# 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

- [Java](https://github.com/TheAlgorithms/Java/blob/master/Searches/BinarySearch.java)
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/Search/Binary%20Search.cpp)
- [Python](https://github.com/TheAlgorithms/Python/blob/master/searches/binary_search.py)
- [C-Sharp](https://github.com/TheAlgorithms/C-Sharp/blob/master/searches/binary_search.cs)
- [C](https://github.com/TheAlgorithms/C/blob/master/searching/Binary_Search.c)

#### Video Explanation

[A CS50 video explaining the Binary Search Algorithm](https://www.youtube.com/watch?v=5xlIPT1FRcA)

#### Animation Explanation

- [Tute Board](https://boardhub.github.io/tute/?wd=binarySearchAlgo2)

</details>

---
---

<details>
<summary>                  Exponential Search                                      </summary>

# Exponential Search

#### Prerequisites

- [Binary Search algorithm](https://github.com/faridevnz/Algorithms-Explanation/blob/master/en/Search%20Algorithms/Binary%20Search.md)

#### 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

```markdown
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](https://github.com/faridevnz/Algorithms-Explanation/blob/master/en/Search%20Algorithms/Binary%20Search.md) ) 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:

```mathematica
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 with`1_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

- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/exponential_search.cpp)
- [JavaScript](https://github.com/TheAlgorithms/Javascript/blob/master/Search/ExponentialSearch.js)

</details>

---
---

<details>
<summary>                     Linear Search                                  </summary>
# 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

- [Java](https://github.com/TheAlgorithms/Java/blob/master/Searches/LinearSearch.java)
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/Search/Linear%20Search.cpp)
- [Python](https://github.com/TheAlgorithms/Python/blob/master/searches/linear_search.py)

#### Video Explanation

[A CS50 video explaining the Linear Search Algorithm](https://www.youtube.com/watch?v=CX2CYIJLwfg)

#### Animation Explanation

- [Tute Board](https://boardhub.github.io/tute/?wd=linearSearchAlgo)

</details>

---
---

<details>
<summary>                          Quick Sort                              </summary>

# 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

- [Java](https://github.com/TheAlgorithms/Java/blob/master/Sorts/QuickSort.java)
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/Sorting/Quick%20Sort.cpp)
- [Python](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort.py)
- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/sorting/quicksort.rb)

#### Video Explanation

[A video explaining the Quick Sort Algorithm](https://www.youtube.com/watch?v=COk73cpQbFQ)

</details>

---
---

<details>
<summary>                                        Recursive Bubble Sort               </summary>

# 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](https://github.com/TheAlgorithms/Java/blob/master/Sorts/BubbleSortRecursion.java)
- [C](https://github.com/TheAlgorithms/C/blob/master/sorting/bubble_sort_recursion.c)

## Video Explanation

[A video explaining iterative as well as recursive bubble sort](https://www.youtube.com/watch?v=gDMDVLBfCI0)

</details>

---
---

<details>
<summary>                   Bubble Sort                                    </summary>

# 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

- [Java](https://github.com/TheAlgorithms/Java/blob/master/Sorts/BubbleSort.java)
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bubble_sort.cpp)
- [Python](https://github.com/TheAlgorithms/Python/blob/master/sorts/bubble_sort.py)
- [C-Sharp](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Sorters/Comparison/BubbleSorter.cs)
- [Go](https://github.com/TheAlgorithms/Go/blob/master/sorts/bubblesort.go)
- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/sorting/bubble_sort.rb)
- [C](https://github.com/TheAlgorithms/C/blob/master/sorting/bubble_sort.c)
- [Scala](https://github.com/TheAlgorithms/Scala/blob/master/src/main/scala/Sort/BubbleSort.scala)
- [Javascript](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/BubbleSort.js)

#### Video Explanation

[A video explaining the Bubble Sort Algorithm](https://www.youtube.com/watch?v=Jdtq5uKz-w4)

#### Others

Bubble sort is also known as Sinking sort.

#### Animation Explanation

- [Tute Board](https://boardhub.github.io/tute/?wd=bubbleSortAlgo2)

</details>

---
---

</details>

---
---

</details>

---
---

</details>

---
---

</details>

---
---

</details>

---
---

</details>

---
---

</details>

---
---

</details>

---
---

</details>

---
---

</details>

---
---

</details>

---
---

</details>

---
---

</details>

---
---

</details>

---
---

</details>

---
---

#### 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
```

The-Algorithms

The-Algorithms 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

The-Algorithms

The-Algorithms 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README