gitextract_qpjjgosa/ ├── .github/ │ ├── ISSUE_TEMPLATE/ │ │ ├── Documentation.yml │ │ ├── New-Submission.yml │ │ └── config.yml │ ├── pull_request_template.md │ └── workflows/ │ ├── contributors.yml │ └── welcome.yml ├── 404.md ├── Algorithms/ │ ├── Array/ │ │ ├── Arr4 right shift.c │ │ ├── InsertArray.c │ │ ├── LinearSearch.java │ │ ├── Merge-Sorted-Array.c │ │ ├── Merge-Sorted-Array.cpp │ │ ├── Merge-Sorted-Array.js │ │ ├── Merge-Sorted-Array.py │ │ ├── Merge_Sorted_Arrays.rb │ │ ├── Rearrange-High-Low.js │ │ ├── Rearrange-High-Low.kt │ │ ├── Remove-Dublicate.js │ │ ├── Remove-Duplicates-from-Sorted-Array.c │ │ ├── Remove-Duplicates-from-Sorted-Array.cpp │ │ ├── Shuffle.c │ │ ├── Two-Arrays-And-Swaps.c │ │ ├── check_two_equal_array.cpp │ │ ├── copyarray.c │ │ ├── counting_frequency_of_char_in_string.c │ │ ├── findpos.py │ │ ├── high-low-rearrangement.c │ │ ├── high-low-rearrangement.c++ │ │ ├── high-low-rearrangement.py │ │ ├── largest-smallest-number-and-sum-of-all-elements-in-array.java │ │ ├── merge-sorted-arrays-algo-only.py │ │ ├── merge_without_extraspace.cpp │ │ ├── merging_2_arrays.c │ │ ├── rearrange-high-low.java │ │ ├── revering_array.c │ │ ├── rotate_matrix_90degree.cpp │ │ ├── rotated_sorted_array_search.cpp │ │ ├── twoSum.cpp │ │ ├── twoSum.kt │ │ └── wave_form_array │ ├── Backtracking/ │ │ ├── Crossword/ │ │ │ └── Crossword.cpp │ │ ├── Nqueen/ │ │ │ ├── N_Queen.java │ │ │ ├── Nqueens.c │ │ │ ├── Nqueens.cpp │ │ │ ├── Nqueens_optimized.cpp │ │ │ ├── nqueen.cpp │ │ │ └── nqueens.py │ │ ├── Permutation/ │ │ │ ├── Permutations.c │ │ │ ├── permutation.py │ │ │ ├── permutations.cpp │ │ │ └── permutations.js │ │ ├── README.md │ │ └── Rat-In-A-Maze/ │ │ └── Rat-In-A-Maze.cpp │ ├── Cryptography/ │ │ ├── AES_Cipher/ │ │ │ ├── AES_Cipher.py │ │ │ └── README.md │ │ ├── Affine_Cipher/ │ │ │ ├── Affine_Cipher.cpp │ │ │ ├── Affine_Cipher.py │ │ │ ├── README.md │ │ │ └── affine_cipher.c │ │ ├── Bifid_Cipher/ │ │ │ ├── Bifid_Cipher.py │ │ │ └── README.md │ │ ├── CIA_Triad_Ciper/ │ │ │ └── README.md │ │ ├── Caesar_Cipher/ │ │ │ ├── Caesar Cypher.cpp │ │ │ ├── Caesar Cypher.py │ │ │ ├── CaesarCipher.java │ │ │ ├── Caesar_Cipher.c │ │ │ ├── Caesar_Cipher.cs │ │ │ ├── Caesar_Cipher.js │ │ │ ├── Caesar_Cipher.php │ │ │ ├── Caesar_Cypher.rb │ │ │ └── README.md │ │ ├── README.md │ │ ├── RSA_Cipher/ │ │ │ ├── README.md │ │ │ ├── RSA_Cipher.py │ │ │ ├── RSA_cipher.cpp │ │ │ └── RSA_cipher.java │ │ ├── Shamir_Cipher/ │ │ │ ├── Shamir_Cipher.c │ │ │ └── Shamir_Cipher.cpp │ │ ├── Vernam_Cipher/ │ │ │ ├── README.md │ │ │ ├── Vernam_Cipher.cpp │ │ │ ├── Vernam_Cipher.js │ │ │ └── Vernam_Cipher.py │ │ └── Vigenere_Cipher/ │ │ ├── README.md │ │ ├── Vigenere_Cipher.cpp │ │ ├── Vigenere_Cipher.py │ │ ├── Vignere_Cipher.cs │ │ └── vigenereCipher.py │ ├── DP/ │ │ ├── 0-1_Knapsack_Problem/ │ │ │ ├── 0-1 Knapsack Problem.java │ │ │ ├── Branch_And_Bound/ │ │ │ │ └── 0-1_knapsack.cpp │ │ │ ├── knapsackProblem.java │ │ │ ├── knapsack_problem_0_1.cpp │ │ │ └── knapsack_problem_0_1.py │ │ ├── AdjacentBitCounts.cpp │ │ ├── AdjacentBitCounts.js │ │ ├── Bitmask DP/ │ │ │ └── TravellingSalesman.cpp │ │ ├── Branch_And_Bound/ │ │ │ ├── 0_1_KnapSack.py │ │ │ └── Knapsack_Branch_and_Bound.java │ │ ├── Count_Square_Matrices.cpp │ │ ├── Count_Square_Matrices.py │ │ ├── Edit_Distance/ │ │ │ ├── Edit_Distance.js │ │ │ ├── Edit_distance.cpp │ │ │ ├── README.md │ │ │ └── edit_distance.py │ │ ├── Egg_Drop/ │ │ │ ├── Egg_Drop.cpp │ │ │ ├── Egg_Drop.cs │ │ │ ├── egg drop.java │ │ │ ├── egg_drop.py │ │ │ └── egg_drop.ts │ │ ├── Fibonacci_Series/ │ │ │ ├── Fibonacci.c │ │ │ ├── Fibonacci.php │ │ │ ├── fibonacci.go │ │ │ ├── fibonacci.js │ │ │ └── fibonacci.py │ │ ├── Gauss_Easter_Date/ │ │ │ ├── CalculateEasterDate.java │ │ │ ├── Gauss_Easter_Date.cpp │ │ │ ├── Gauss_Easter_Date.php │ │ │ ├── Gauss_Easter_Date.py │ │ │ ├── Gauss_Easter_Date.rb │ │ │ ├── easterDate.cpp │ │ │ ├── easterDate.go │ │ │ ├── easterDate.java │ │ │ └── easterDate.js │ │ ├── Generate_ATM_Codes.py │ │ ├── Gold_Mine_Problem/ │ │ │ ├── goldmine.java │ │ │ └── goldmine.py │ │ ├── Golomb_Sequence/ │ │ │ ├── Golomb Sequence.cpp │ │ │ ├── Golomb.cpp │ │ │ ├── Golomb.java │ │ │ └── golomb.py │ │ ├── Knight_Probability/ │ │ │ ├── Knight_Probability_in_a_ChessBoard.cpp │ │ │ └── Problem_Statement.md │ │ ├── LCS/ │ │ │ ├── LCS_of_three_strings.py │ │ │ ├── LongestCommonSubsequence.cpp │ │ │ ├── LongestCommonSubsequenceLength.java │ │ │ ├── Longest_Common_Subsequence_of_Three_String.java │ │ │ ├── Longest_Common_Subsequence_of_Two_Sequences.c │ │ │ ├── Longest_Common_Subsequence_of_Two_Sequences.cpp │ │ │ ├── lcs.py │ │ │ └── lcs_of_3_strings.cpp │ │ ├── LIS/ │ │ │ ├── LIS.c │ │ │ ├── LIS.cpp │ │ │ ├── LIS.go │ │ │ ├── LIS.java │ │ │ ├── LongestIncreaseSubSequence.cpp │ │ │ ├── README.md │ │ │ └── lis.py │ │ ├── LSCS/ │ │ │ ├── LSCS.c │ │ │ ├── LSCS.cpp │ │ │ ├── lscs.go │ │ │ ├── lscs.py │ │ │ └── shortest_common_supersequence.c │ │ ├── Largest Divisible Subset.cpp │ │ ├── Largest divisible subset in array/ │ │ │ └── file.py │ │ ├── Largest_Divisible_Subset.js │ │ ├── Largest_Divisible_Subsets.java │ │ ├── Largest_Divisible_Subsets.py │ │ ├── Largest_Sum_Contiguous_Subarray/ │ │ │ ├── .vscode/ │ │ │ │ ├── c_cpp_properties.json │ │ │ │ ├── launch.json │ │ │ │ └── tasks.json │ │ │ ├── C++_Implementation/ │ │ │ │ ├── Kadane │ │ │ │ ├── makefile │ │ │ │ ├── obj/ │ │ │ │ │ ├── functions.o │ │ │ │ │ └── main.o │ │ │ │ └── src/ │ │ │ │ ├── functions.cpp │ │ │ │ ├── include/ │ │ │ │ │ └── functions.h │ │ │ │ └── main.cpp │ │ │ ├── Kadane's Algorithm.cpp │ │ │ ├── LSCS.cpp │ │ │ ├── LSCS.js │ │ │ ├── LSCS.swift │ │ │ └── lscs.c │ │ ├── MOS_Algorithm.cpp │ │ ├── Max_Product_Subarray/ │ │ │ └── max_product_subarray.py │ │ ├── Maximum_Achievable_Coins/ │ │ │ ├── Maximum_Achievable_Coins.php │ │ │ ├── Maximum_Achievable_coins.c │ │ │ ├── Maximum_Achievable_coins.java │ │ │ ├── Maximum_Achievable_coins.py │ │ │ └── maximum_achievable_coins.cpp │ │ ├── Minimum_Sum_Descent/ │ │ │ ├── min-sum.c │ │ │ ├── minsum.cs │ │ │ ├── minsum.go │ │ │ └── minsum.ts │ │ ├── Partition_Sum/ │ │ │ ├── DP_PartitionSum.java │ │ │ ├── partition_sum.c │ │ │ ├── partition_sum.cpp │ │ │ ├── partition_sum.cs │ │ │ └── partition_sum.php │ │ ├── README.md │ │ ├── Recaman's Sequence.c │ │ ├── Scramble Strings/ │ │ │ └── ScrambleString.cpp │ │ ├── Shortest_Common_Supersequence/ │ │ │ ├── shortest_common_sequence.java │ │ │ ├── shortest_common_supersequence.cpp │ │ │ ├── shortest_common_supersequence.cs │ │ │ ├── shortest_common_supersequence.js │ │ │ └── shortest_common_supersequence.py │ │ ├── Sudoku_Solver/ │ │ │ ├── README.md │ │ │ ├── SudokuSolver.java │ │ │ ├── SudokuSolver.py │ │ │ ├── Sudoku_Solver.cpp │ │ │ ├── Sudoku_Solver.cs │ │ │ └── Sudoku_Solver.js │ │ ├── Target_Sum/ │ │ │ ├── Target_Sum.c │ │ │ ├── Target_Sum.cpp │ │ │ ├── Target_Sum.java │ │ │ ├── Target_Sum.js │ │ │ └── Target_Sum.py │ │ ├── Tower_Of_Hanoi/ │ │ │ ├── README.md │ │ │ ├── TOH.java │ │ │ ├── Tower_Of_Hanoi.cs │ │ │ ├── Tower_Of_Hanoi.js │ │ │ ├── Tower_of_hanoi.ts │ │ │ ├── tower_of_hanoi.c │ │ │ ├── tower_of_hanoi.cpp │ │ │ ├── tower_of_hanoi.go │ │ │ └── tower_of_hanoi.py │ │ ├── TrappingWater/ │ │ │ └── TrappingWater.cpp │ │ ├── Water_Area/ │ │ │ ├── QUESTION.md │ │ │ ├── Water-area.py │ │ │ └── water_area.rb │ │ ├── Z_Algorithm/ │ │ │ ├── README.md │ │ │ ├── Z-Algorithm.c++ │ │ │ └── Z_Algo.py │ │ ├── creating an string input function in C.c │ │ ├── partition_sum.py │ │ └── rod-cutting-problem.cpp │ ├── Graph/ │ │ ├── A_Star/ │ │ │ ├── A_star.cpp │ │ │ ├── A_star.cs │ │ │ ├── A_star.py │ │ │ ├── A_star.ts │ │ │ └── astar.py │ │ ├── BFS/ │ │ │ ├── BFS.c │ │ │ ├── BFS.cpp │ │ │ ├── BFS.go │ │ │ ├── BFS.java │ │ │ ├── BFS.py │ │ │ ├── BFS.rb │ │ │ ├── README.md │ │ │ └── bfs.js │ │ ├── Bellman_Ford/ │ │ │ ├── BellMan_Ford.py │ │ │ ├── README.md │ │ │ ├── bellmanFord.cpp │ │ │ └── bellman_ford.c │ │ ├── Bidirectional_search/ │ │ │ ├── Bidirectional_Search.py │ │ │ └── Bidirectional_search.cpp │ │ ├── Bidirectional_search_algo.py │ │ ├── DFS/ │ │ │ ├── DFS.cpp │ │ │ ├── DFS.java │ │ │ ├── Depth First Search[DFS].cpp │ │ │ ├── README.md │ │ │ ├── dfs.js │ │ │ └── dfs.py │ │ ├── DSU/ │ │ │ ├── dsu.cpp │ │ │ └── dsu.py │ │ ├── Depth First Transversal/ │ │ │ └── DFT.py │ │ ├── Dijkstra/ │ │ │ ├── Dijikstra.java │ │ │ ├── Dijkstra.c │ │ │ ├── Dijkstra.cpp │ │ │ ├── Dijkstra.cs │ │ │ ├── Dijkstra.go │ │ │ ├── Dijkstra.js │ │ │ ├── Dijkstra.php │ │ │ ├── README.md │ │ │ ├── dijkstra_leftist_heap/ │ │ │ │ ├── README.txt │ │ │ │ ├── WDGraph.cpp │ │ │ │ ├── WDGraph.h │ │ │ │ ├── dijkstra.cpp │ │ │ │ ├── leftistHeap.cpp │ │ │ │ └── leftistHeap.h │ │ │ └── djikstra.py │ │ ├── Flood_Fill/ │ │ │ ├── Flood_Fill.cpp │ │ │ ├── Flood_Fill.java │ │ │ ├── Flood_Fill.js │ │ │ └── flood_fill_algorithm.cs │ │ ├── Floyd_Warshall/ │ │ │ ├── Floyd_Warshall.c │ │ │ ├── Floyd_Warshall.cpp │ │ │ ├── Floyd_Warshall.java │ │ │ ├── Floyd_Warshall.py │ │ │ └── README.md │ │ ├── Hopcroft_Karp/ │ │ │ └── Hopcroft_Karp_algorithm.cpp │ │ ├── Hungarian_algorithm/ │ │ │ └── Hungarian_algorithm.cpp │ │ ├── Johnson_algorithm/ │ │ │ └── Johnson_algorithm.cpp │ │ ├── Karger_algorithm/ │ │ │ ├── Karger_algorithm.cpp │ │ │ └── sample.txt │ │ ├── Kosarajus_Algorithm/ │ │ │ ├── kosajaru.rs │ │ │ ├── kosaraju.ts │ │ │ └── kosaraju_algorithm_strongly_connected_components.cpp │ │ ├── Kruskal's_MST/ │ │ │ ├── KruskalMST.c │ │ │ ├── Kruskal_Algorithm.cpp │ │ │ ├── README.md │ │ │ ├── cpp/ │ │ │ │ └── kruskal.cpp │ │ │ ├── python/ │ │ │ │ └── KruskalMST.py │ │ │ └── rust/ │ │ │ └── kruskal.rs │ │ ├── LIS/ │ │ │ └── README.md │ │ ├── Level order traversal.cpp │ │ ├── Lowest_Common_Manager/ │ │ │ ├── Lowest_Common_Manager.py │ │ │ └── QUESTION.md │ │ ├── Prim's_MST/ │ │ │ ├── Prim's_MST.py │ │ │ ├── Prims_MST.java │ │ │ └── README.md │ │ ├── README.md │ │ ├── Tarjan's Algorithm/ │ │ │ └── StronglyConnectedComponents.cpp │ │ ├── Topological Sort/ │ │ │ ├── QUESTION.md │ │ │ └── topo_sort.py │ │ ├── Topological sort/ │ │ │ ├── README.md │ │ │ └── Topological_sort.cpp │ │ ├── Youngest_Common_Ancestor/ │ │ │ ├── QUESTION.md │ │ │ ├── YoungerCommonAncestor.cpp │ │ │ ├── YoungestCommonAncestor.java │ │ │ └── youngest-comm-anc.py │ │ ├── articulation_points.py │ │ ├── flood_fill.py │ │ ├── lagrange_interpolation.cpp │ │ ├── lowest_common_manager/ │ │ │ └── lowest_common_manager.java │ │ └── newton_raphson_method.c │ ├── Hashing/ │ │ ├── Amicable/ │ │ │ ├── Amicable_Number.rb │ │ │ ├── Amicable_Numbers..c │ │ │ ├── Amicable_Numbers.cpp │ │ │ ├── Amicable_Numbers.java │ │ │ ├── amicable.cs │ │ │ ├── amicable.js │ │ │ ├── amicable.swift │ │ │ ├── amicable_numbers.php │ │ │ └── amicable_numbers.py │ │ ├── Brick_Wall/ │ │ │ ├── Brick_wall.cpp │ │ │ └── QUESTION.md │ │ ├── Chaining/ │ │ │ └── chainingHashing.cpp │ │ ├── Cuckoo_Hashing/ │ │ │ ├── Cuckoo_Hashing.cpp │ │ │ └── Cuckoo_Hashing.java │ │ ├── Divisible_Pair_Count/ │ │ │ ├── DivisiblePairCount.c │ │ │ ├── DivisiblePairCount.go │ │ │ ├── DivisiblePairCount.java │ │ │ ├── DivisiblePairCount.js │ │ │ ├── DivisiblePairCount.py │ │ │ └── DivsiblePairCount.cpp │ │ ├── Group_Anagrams/ │ │ │ ├── Group_Anagrams.cpp │ │ │ ├── QUESTIONS.md │ │ │ ├── group_anagrams.js │ │ │ └── group_anagrams.py │ │ ├── Open Addressing/ │ │ │ ├── doubleHashHashingTable.cpp │ │ │ ├── linearProbingHashTable.cpp │ │ │ └── quadraticProbingHashTable.cpp │ │ └── Recaman_Sequence/ │ │ ├── Recamans_Sequence.java │ │ ├── Recamans_Sequence.ts │ │ ├── recaman.py │ │ ├── recaman_sequence.cpp │ │ └── recamans_sequence.cs │ ├── Heap/ │ │ └── README.md │ ├── LinkedList/ │ │ └── Floyd_Cylce_detection/ │ │ ├── floyd_cycle_detection.cpp │ │ ├── floyd_cycle_detection.java │ │ ├── floyd_cycle_detection.kt │ │ ├── floyd_cycle_detection.py │ │ └── floyd_cycle_detection.swift │ ├── Matrix/ │ │ ├── README.md │ │ └── Spiral-Matrix/ │ │ └── Spiral-Matrix.cpp │ ├── Merging-Interval/ │ │ ├── #999 merging_intervals.py │ │ ├── Merging_Intervals.java │ │ ├── README.md │ │ ├── merge_intervals.cpp │ │ └── merge_intervals.js │ ├── Pattern-Searching/ │ │ ├── Aho-Corasick/ │ │ │ └── Readme.md │ │ ├── Binary_Search/ │ │ │ └── search_in_2D_matrix.java │ │ ├── README.md │ │ └── Substring_Check/ │ │ └── search.php │ ├── Queue/ │ │ ├── first_negative_integer_in_window.cpp │ │ ├── first_nonrepeating_char_in_stream.cpp │ │ └── reversing a queue.cpp │ ├── README.md │ ├── Recursion/ │ │ ├── All_Subsets.c │ │ ├── Combination_Sum/ │ │ │ ├── Combination_Sum.php │ │ │ └── combination_sum.cpp │ │ ├── Factorial/ │ │ │ ├── Factorial.c │ │ │ ├── Factorial.cs │ │ │ ├── Factorial.go │ │ │ ├── Factorial_Algorithm.cpp │ │ │ ├── Factorial_Algorithm.py │ │ │ ├── factorial.js │ │ │ └── factorial.py │ │ ├── Josephus/ │ │ │ ├── Josephus.c │ │ │ ├── Josephus.cs │ │ │ ├── Josephus.java │ │ │ ├── josephus.cpp │ │ │ └── josephus.kt │ │ ├── Keypadcodes.cpp │ │ ├── Permutation/ │ │ │ ├── Permutation.cs │ │ │ ├── Permutation.js │ │ │ ├── Permutation.ts │ │ │ ├── Permutations_Recursion.cpp │ │ │ └── Permutations_Recursion.py │ │ └── README.md │ ├── Searching/ │ │ ├── A-Star Search/ │ │ │ ├── A_Star.ipynb │ │ │ └── README.md │ │ ├── Binary-Search/ │ │ │ ├── Binary_Search_CubicRoot.cpp │ │ │ ├── Binary_search_javascript.js │ │ │ ├── Koko_Eating_Bananas/ │ │ │ │ ├── KEB.java │ │ │ │ ├── Koko_Eating_Bananas.cpp │ │ │ │ ├── Koko_Eating_Bananas.py │ │ │ │ └── QUESTION.md │ │ │ ├── README.md │ │ │ ├── Rotated-Sorted-Array-Search.cs │ │ │ ├── Rotated-Sorted-Array-Search.js │ │ │ ├── Rotated-Sorted-Array-Search.py │ │ │ ├── binarySearch.c │ │ │ ├── binarySearch.cpp │ │ │ ├── binarySearch.js │ │ │ ├── binarySearch.kt │ │ │ ├── binarySearch.scala │ │ │ ├── binary_search.cpp │ │ │ ├── binary_search.java │ │ │ ├── binarysearch.java │ │ │ ├── binarysearch.js │ │ │ ├── binarysearch.php │ │ │ ├── binarysearch.py │ │ │ ├── binarysearch.sh │ │ │ ├── matrix_binary_search.py │ │ │ └── search_in_2d_matrix.cpp │ │ ├── Exponential-Search/ │ │ │ ├── exponential_search.cpp │ │ │ ├── exponential_search.php │ │ │ └── exponential_search.py │ │ ├── Fibonacci-Search/ │ │ │ ├── Fibonacci_Search.cpp │ │ │ ├── Fibonacci_search.java │ │ │ ├── Fibonacci_search.php │ │ │ ├── Fibonacci_search_in_C.c │ │ │ ├── fibonacciSearch.py │ │ │ ├── fibonacci_search.c │ │ │ └── fibonacci_search.js │ │ ├── Interpolation-Search/ │ │ │ ├── IS.cpp │ │ │ └── IS.py │ │ ├── Jump-Search/ │ │ │ ├── JumpSearch.java │ │ │ ├── Jump_Search.cpp │ │ │ ├── jumpSearch.cs │ │ │ ├── jumpSearch.go │ │ │ ├── jumpSearch.js │ │ │ ├── jumpSearch.ts │ │ │ └── jump_search.py │ │ ├── Linear-Search/ │ │ │ ├── LINEAR_SEARH.cpp │ │ │ ├── LinearSearch.js │ │ │ ├── Linear_Search.cpp │ │ │ ├── Linear_Search.go │ │ │ ├── Linear_Search.py │ │ │ ├── Linearsearch.c │ │ │ ├── README.md │ │ │ ├── linear_search.java │ │ │ └── linear_search.sh │ │ ├── README.md │ │ ├── Sublist-Search/ │ │ │ ├── Sublist_Search.php │ │ │ ├── sublist_search.cpp │ │ │ ├── sublist_search.cs │ │ │ ├── sublist_search.java │ │ │ ├── sublist_search.js │ │ │ └── sublist_search.py │ │ ├── Ternary-Search/ │ │ │ ├── README.md │ │ │ ├── Ternary-String.c │ │ │ ├── ternarySearch.cpp │ │ │ ├── unimodal_func.cpp │ │ │ ├── unimodal_func.java │ │ │ ├── unimodal_func.js │ │ │ └── unimodal_func.py │ │ └── Trie-Search/ │ │ ├── Trie Data Structure.cpp │ │ ├── Trie1_HashMap.java │ │ ├── TrieDataStructure.java │ │ ├── Trie_Search.cpp │ │ ├── Trie_Search.go │ │ └── Trie_Search.py │ ├── Sorting/ │ │ ├── 3-Way_Quick_Sort/ │ │ │ ├── 3-Way_Quick_Sort.cpp │ │ │ ├── 3-Way_Quick_Sort.cs │ │ │ ├── 3-Way_Quick_Sort.java │ │ │ └── 3_Way_Quick_Sort.c │ │ ├── Bead_Sort/ │ │ │ ├── Bead_Sort.php │ │ │ ├── Bead_Sort.rb │ │ │ ├── Bead_sort.cpp │ │ │ ├── README.md │ │ │ └── bead_sort.py │ │ ├── Binary_Insertion_Sort/ │ │ │ ├── Binary Insertion Sort.c │ │ │ ├── Binary_Insertion_Sort.cpp │ │ │ ├── Binary_Insertion_Sort.py │ │ │ └── Readme.md │ │ ├── Bitonic_Search/ │ │ │ ├── BitonicSort.java │ │ │ ├── Bitonic_sort.c │ │ │ ├── Readme.md │ │ │ └── bitonic_search.py │ │ ├── Brick_Sort/ │ │ │ ├── BrickSort.js │ │ │ ├── Brick_Sort.c │ │ │ ├── Readme.md │ │ │ └── brickSort.py │ │ ├── Bubble_Sort/ │ │ │ ├── BubbleSort.js │ │ │ ├── BubbleSort.scala │ │ │ ├── Bubble_Sort.c │ │ │ ├── Bubble_Sort.cs │ │ │ ├── Bubble_Sort.py │ │ │ ├── Bubble_sort_optimised.cpp │ │ │ ├── bubbleSort.cpp │ │ │ ├── bubble_sort.java │ │ │ ├── bubble_sort.sh │ │ │ └── readme.md │ │ ├── Bucket_Sort/ │ │ │ ├── BucketSort.c │ │ │ ├── BucketSort.java │ │ │ ├── BucketSort.js │ │ │ ├── BucketSort.py │ │ │ ├── README.md │ │ │ ├── bucket_sort.cpp │ │ │ ├── bucketsort.php │ │ │ ├── bucketsort.rb │ │ │ └── bucketsortinC.c │ │ ├── Circle_Sort/ │ │ │ ├── Circle_Sort.c │ │ │ ├── Circle_Sort.cs │ │ │ ├── Circle_Sort.java │ │ │ ├── Circle_Sort.rb │ │ │ └── README.md │ │ ├── Cocktail_Sort/ │ │ │ ├── Cocktail_Sort.c │ │ │ ├── Cocktail_Sort.cpp │ │ │ ├── Cocktail_Sort.java │ │ │ ├── Cocktail_Sort.py │ │ │ ├── README.md │ │ │ └── cocktail_sort.js │ │ ├── Comb_Sort/ │ │ │ ├── Comb_Sort.c │ │ │ ├── Comb_Sort.cpp │ │ │ ├── README.md │ │ │ ├── comb.py │ │ │ └── comb_sort.rb │ │ ├── Counting_Sort/ │ │ │ ├── Count_sort.py │ │ │ ├── Counting_Sort.c │ │ │ ├── Counting_Sort.cs │ │ │ ├── Counting_Sort.java │ │ │ ├── Counting_sort.js │ │ │ ├── README.md │ │ │ ├── counting_sort.py │ │ │ └── countingsort.py │ │ ├── Cycle_Sort/ │ │ │ ├── CYCLESort.cs │ │ │ ├── Cyclesort.py │ │ │ ├── README.md │ │ │ ├── cyclesort.c │ │ │ └── stoogesort.java │ │ ├── Gnome_Sort/ │ │ │ ├── Gnome_Sort.cs │ │ │ ├── Gnome_Sort.java │ │ │ ├── Gnome_Sort.php │ │ │ ├── Gnome_Sort.py │ │ │ └── gnomeSort.java │ │ ├── Heap_Sort/ │ │ │ ├── Heap_Sort.js │ │ │ ├── Heap_Sort.swift │ │ │ ├── Max_heap_sort.cpp │ │ │ ├── README.md │ │ │ ├── heap-sort.c │ │ │ ├── heap-sort.php │ │ │ ├── heap-sort.py │ │ │ ├── heap-sort.rb │ │ │ ├── heap_sort.cpp │ │ │ ├── heap_sort.go │ │ │ ├── heap_sort.java │ │ │ └── heapsorting.py │ │ ├── Insertion_Sort/ │ │ │ ├── InsertSort.py │ │ │ ├── Insertion Sort.cpp │ │ │ ├── InsertionSort.java │ │ │ ├── InsertionSort.py │ │ │ ├── InsertionSort.scala │ │ │ ├── Insertion_Sort.cpp │ │ │ ├── Insertion_Sort.swift │ │ │ ├── Insertion_sort_2.cpp │ │ │ ├── README.md │ │ │ ├── insertion_sort.py │ │ │ └── insertion_sort.ts │ │ ├── Merge_Sort/ │ │ │ ├── Application of Merge Sort/ │ │ │ │ ├── Count_Inversions.c │ │ │ │ └── Count_Inversions.cpp │ │ │ ├── MERGE_SORT.c │ │ │ ├── MERGE_SORT.cpp │ │ │ ├── MERGE_SORT.java │ │ │ ├── MERGE_SORT.js │ │ │ ├── MergeSort.scala │ │ │ ├── Non_recursive_merge_sort.cpp │ │ │ ├── README.md │ │ │ ├── mergeSort.py │ │ │ ├── merge_Sort.rb │ │ │ ├── mergesort.sh │ │ │ ├── non_recursive_merge_sort.c │ │ │ ├── non_recursive_merge_sort.cs │ │ │ └── non_recursive_merge_sort.py │ │ ├── Merge_Sort_on_Doubly_Linked_List/ │ │ │ ├── Mergesort_doubly.c │ │ │ ├── Mergesort_doubly.cpp │ │ │ ├── Mergesort_doubly.java │ │ │ └── Mergesort_doubly.py │ │ ├── Pancake_Sort/ │ │ │ ├── PancakeSort.java │ │ │ ├── Pancake_Sort.c │ │ │ ├── Pancake_Sort.c++ │ │ │ ├── Pancake_Sort.cs │ │ │ ├── Pancake_Sort.js │ │ │ ├── Pancake_Sort.py │ │ │ ├── Pancake_Sort.rb │ │ │ └── README.md │ │ ├── Patience_Sort/ │ │ │ ├── PatienceSort.cs │ │ │ ├── Patience_sort.cpp │ │ │ └── README.md │ │ ├── Patience_sort.py │ │ ├── Pigeonhole_Sort/ │ │ │ ├── PigeonholeSort.cpp │ │ │ ├── PigeonholeSort.ts │ │ │ ├── Pigeonhole_Sort.c │ │ │ ├── Pigeonhole_Sort.java │ │ │ └── pigeonhole.py │ │ ├── Quick_Select/ │ │ │ ├── QuickSelect.cpp │ │ │ ├── Quick_Select.js │ │ │ ├── Quick_Select.php │ │ │ ├── Quick_select.py │ │ │ ├── README.md │ │ │ ├── quick_select.java │ │ │ └── quick_select.rb │ │ ├── Quick_Sort/ │ │ │ ├── QuickSort.java │ │ │ ├── QuickSort.js │ │ │ ├── QuickSort.py │ │ │ ├── Quick_Sort.cpp │ │ │ ├── Quick_Sort.go │ │ │ ├── Quick_Sort.sh │ │ │ ├── README.md │ │ │ ├── quicksort.C │ │ │ └── quicksort.c │ │ ├── README.md │ │ ├── Radix_Sort/ │ │ │ ├── README.md │ │ │ ├── Radix Sort With C (Mayukh Mitra)/ │ │ │ │ ├── Radix_sort.c │ │ │ │ └── r │ │ │ ├── RadixSort.java │ │ │ ├── RadixSort.py │ │ │ ├── Radix_Sort.js │ │ │ ├── Radix_Sort.rb │ │ │ ├── Radix_sort.cs │ │ │ ├── radixSort.php │ │ │ └── radixsort.cpp │ │ ├── Selection_Algorithms.cpp │ │ ├── Selection_Sort/ │ │ │ ├── README.md │ │ │ ├── Selection Sort.py │ │ │ ├── SelectionSort.java │ │ │ ├── SelectionSort.py │ │ │ ├── SelectionSort.scala │ │ │ ├── Selection_Sort.cpp │ │ │ ├── Selection_Sort.go │ │ │ ├── selection sort.cs │ │ │ ├── selection_sort.c │ │ │ └── selection_sort.rb │ │ ├── Shell_Sort/ │ │ │ ├── README.md │ │ │ ├── Shell_Sort.c │ │ │ ├── Shell_Sort.cpp │ │ │ ├── Shell_Sort.cs │ │ │ ├── Shell_Sort.java │ │ │ ├── Shell_Sort.js │ │ │ ├── Shell_Sort.swift │ │ │ ├── shell_sort.py │ │ │ └── shell_sort.sh │ │ ├── Stooge_Sort/ │ │ │ ├── README.md │ │ │ ├── Stooge_Sort.cs │ │ │ ├── Stooge_Sort.go │ │ │ └── Stooge_Sort.py │ │ ├── Strand_Sort/ │ │ │ ├── README.md │ │ │ ├── Strand_Sort.cpp │ │ │ ├── Strand_sort.java │ │ │ ├── strand_sort.c │ │ │ └── strand_sort.ts │ │ ├── Tim_Sort/ │ │ │ ├── README.md │ │ │ ├── Tim_Sort.c │ │ │ ├── Tim_Sort.java │ │ │ └── Tim_Sort.py │ │ ├── Topological_Sort/ │ │ │ ├── README.md │ │ │ ├── Topological_Sort.cpp │ │ │ ├── Topological_sort.cs │ │ │ └── Topological_sort.py │ │ ├── Tree_Sort/ │ │ │ ├── README.md │ │ │ ├── Tree_Sort.c │ │ │ ├── tree sort.cpp │ │ │ └── treesort.java │ │ └── Wave_Sort/ │ │ ├── Wave_Sort.py │ │ ├── wave_sort.c │ │ └── wave_sort.cpp │ ├── Stack-Algorithm/ │ │ ├── Next_Greater_Element.cpp │ │ ├── RemoveKDigitsToGetSmallestPossibleInteger.java │ │ ├── Simplify-Path/ │ │ │ ├── QUESTION.md │ │ │ └── Simplify_Path.cpp │ │ ├── balanced_brackets_stack.cpp │ │ ├── immediate_smaller_element.cpp │ │ └── longest_valid_substring.cpp │ ├── String/ │ │ ├── Anagram/ │ │ │ ├── AnagramChecker.c │ │ │ ├── anagram c#.cs │ │ │ ├── anagram.c │ │ │ ├── anagram.java │ │ │ ├── anagram.py │ │ │ ├── anagram.swift │ │ │ └── anagrams.sh │ │ ├── Isomorphic/ │ │ │ ├── Isomorphic-String.java │ │ │ └── isomorphic.cpp │ │ ├── KMP/ │ │ │ ├── KMP_Algorithm.php │ │ │ ├── kmp.cpp │ │ │ └── kmp.js │ │ ├── LCS/ │ │ │ ├── LCS.py │ │ │ └── lcs.cpp │ │ ├── LPS/ │ │ │ ├── longest_palindromic_substring.c │ │ │ ├── longest_palindromic_substring.cpp │ │ │ ├── longest_palindromic_substring.java │ │ │ ├── longest_palindromic_substring.js │ │ │ ├── longest_palindromic_substring.py │ │ │ └── longest_palindromic_substring.rb │ │ ├── Palindrome/ │ │ │ ├── Palindrome.c │ │ │ ├── Palindrome.cs │ │ │ ├── Palindrome.java │ │ │ ├── isPalindrome.cpp │ │ │ ├── isPalindrome.py │ │ │ ├── palindrome.go │ │ │ ├── palindrome.java │ │ │ ├── palindrome.js │ │ │ ├── palindrome.php │ │ │ ├── palindrome.py │ │ │ ├── palindrome.swift │ │ │ ├── palindrome.ts │ │ │ └── palindromecheck.go │ │ ├── README.md │ │ ├── Rabin-Karp/ │ │ │ ├── RabinKarpAlgo.java │ │ │ ├── Rabin_Karp.cpp │ │ │ ├── Rabin_Karp.ts │ │ │ ├── Rabin_karp.c │ │ │ └── rabin_karp.py │ │ ├── SCS/ │ │ │ └── SCS.cpp │ │ ├── ScrambleString.java │ │ └── suffix_array.cpp │ └── Tree/ │ ├── Binary_Lifting/ │ │ ├── Binary Lifting.py │ │ └── Binary-Lifting.cpp │ ├── GenericTreeImplementation/ │ │ ├── GenericTree.c │ │ ├── GenericTree.cpp │ │ └── GenericTree.java │ ├── LCA/ │ │ ├── LCA.cpp │ │ ├── LCA.cs │ │ ├── LCA.js │ │ └── LCA.py │ ├── Max_Heap_Construction/ │ │ └── minmaxheap.cpp │ ├── Max_Path_Sum_BST/ │ │ ├── Max_Path_Sum_BST.cpp │ │ └── Max_Path_Sum_BST.py │ ├── Min_Heap_Construction/ │ │ ├── README.md │ │ ├── min-heap-construc.cpp │ │ └── min-heap-construc.py │ ├── README.md │ ├── Sorted-Array-To-BST/ │ │ └── Sorted-Array-To-BST.cpp │ ├── Sorted_Array_To_BST/ │ │ └── SortedArrayToBST.java │ ├── Validate_BST/ │ │ ├── Validate_BST.cpp │ │ ├── Validate_BST.cs │ │ └── Validate_BST.java │ └── level_traversing/ │ ├── level_traversing.php │ └── level_traversing.py ├── CNAME ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── CONTRIBUTORS.md ├── Collection/ │ ├── ArrayDeque/ │ │ ├── ArrayDeque.java │ │ └── README.md │ ├── ArrayList/ │ │ ├── ArrayList .java │ │ └── README.md │ ├── HashMap/ │ │ ├── HashMap.java │ │ └── README.md │ ├── HashSet/ │ │ ├── HashSet.java │ │ └── README.md │ ├── LinkedList/ │ │ ├── LinkedHashSet/ │ │ │ └── README.md │ │ ├── LinkedList.java │ │ └── README.md │ ├── Queue/ │ │ ├── Deque/ │ │ │ ├── Deque.java │ │ │ └── README.md │ │ ├── PriorityQueue/ │ │ │ ├── PriorityQueue.java │ │ │ └── README.md │ │ ├── Queue.java │ │ └── README.md │ ├── README.md │ ├── Stack/ │ │ ├── README.md │ │ └── StackCollection.java │ └── Vector/ │ ├── README.md │ └── Vector.java ├── DOCUMENTATION.md ├── Data-Structures/ │ ├── Array/ │ │ ├── Array.c │ │ ├── Array.cpp │ │ ├── Array.go │ │ ├── Array.java │ │ ├── Array.js │ │ ├── Array.py │ │ ├── Array.ts │ │ ├── README.md │ │ └── array_menudriven.cpp │ ├── Graph/ │ │ ├── GraphUsingList.kt │ │ ├── README.md │ │ ├── UsingList.cpp │ │ ├── UsingList.py │ │ ├── UsingMatrix.cpp │ │ └── graph_implementation_in_C_bfs_dfs.c │ ├── HashMap/ │ │ └── README.md │ ├── HashSet/ │ │ ├── Hash-Set.c │ │ └── README.md │ ├── Heap/ │ │ └── README.md │ ├── LinkedList/ │ │ ├── Circular_Linked_List/ │ │ │ ├── CircularLinkedList.c │ │ │ ├── CircularLinkedList.java │ │ │ ├── Circular_Link_List.cpp │ │ │ ├── README.md │ │ │ ├── circularLinkedList.js │ │ │ ├── circularLinkedList.py │ │ │ └── csharp/ │ │ │ └── CircularLinkedList.cs │ │ ├── Doubly_Linked_List/ │ │ │ ├── Double linked List circular with double headers C++/ │ │ │ │ ├── LDLCCED.cbp │ │ │ │ ├── LDLCCED.layout │ │ │ │ ├── dllist.cpp │ │ │ │ ├── dllist.h │ │ │ │ ├── dlnode.cpp │ │ │ │ ├── dlnode.h │ │ │ │ ├── listexception.h │ │ │ │ ├── main.cpp │ │ │ │ └── nodeexception.h │ │ │ ├── DoubleLinkedList.java │ │ │ ├── DoublyLinkedList.cs │ │ │ ├── DoublyLinkedList.hs │ │ │ ├── DoublyLinkedList_C++_Template/ │ │ │ │ ├── DLL.h │ │ │ │ └── DLLtest.cpp │ │ │ ├── Doubly_Linked_List.py │ │ │ ├── README.md │ │ │ ├── double_linked_list.c │ │ │ ├── doubly.c │ │ │ ├── doubly_ll.py │ │ │ └── simple linked list circular without header/ │ │ │ ├── LSLCSE.cbp │ │ │ ├── LSLCSE.layout │ │ │ ├── main.cpp │ │ │ ├── sllist.cpp │ │ │ ├── sllist.h │ │ │ ├── slnode.cpp │ │ │ └── slnode.h │ │ ├── README.md │ │ ├── Singly_Linked_List/ │ │ │ ├── Delete_Kth_Node_From_End/ │ │ │ │ ├── Delete_Kth_Node_From_End.cpp │ │ │ │ ├── Delete_Kth_Node_From_End.java │ │ │ │ ├── Delete_Kth_Node_From_End.py │ │ │ │ └── Delete_Kth_Node_From_End.rb │ │ │ ├── Detect_Cycle/ │ │ │ │ ├── CycleDetection.c │ │ │ │ ├── CycleDetection.java │ │ │ │ ├── DetectCycle.cpp │ │ │ │ ├── DetectCycle.py │ │ │ │ ├── DetectCycle.ts │ │ │ │ ├── Detect_Cycle.js │ │ │ │ ├── detect_cycle.cs │ │ │ │ └── detect_cycle.go │ │ │ ├── Java/ │ │ │ │ └── PalindromeLinkedList.java │ │ │ ├── LinkedList.cs │ │ │ ├── LinkedList.java │ │ │ ├── LinkedList.py │ │ │ ├── LinkedListAndOperations.cpp │ │ │ ├── LoopDetection.cpp │ │ │ ├── MiddleElementLL.cpp │ │ │ ├── MiddleElementLinkedList.java │ │ │ ├── Palindrome.ts │ │ │ ├── PalindromeLinkedList.cpp │ │ │ ├── PalindromeLinkedList.js │ │ │ ├── README.md │ │ │ ├── Remove duplicates from linked_list.c │ │ │ ├── Remove duplicates in a Linked List.cpp │ │ │ ├── Remove_Duplicates_in_LL.py │ │ │ ├── Reversed_Linked_List/ │ │ │ │ ├── ReversedLinkedList.js │ │ │ │ └── reverseLinkedList.c │ │ │ ├── Sublist_Search.rb │ │ │ ├── linked list.c │ │ │ ├── linked.cpp │ │ │ ├── linkedlist.cpp │ │ │ ├── merge2sortedlinkedlists.cpp │ │ │ ├── middle.ts │ │ │ └── singly_linked_list.hs │ │ ├── detect_cycle.rb │ │ └── sparce matrix/ │ │ └── sparce addition.cpp │ ├── Queue/ │ │ ├── Circular-Queue/ │ │ │ ├── circular_queue.c │ │ │ ├── circular_queue.cs │ │ │ ├── circular_queue_LL.c │ │ │ ├── circular_queue_array_implementation.c │ │ │ └── cirqueue.cpp │ │ ├── Deque/ │ │ │ ├── Deque.cpp │ │ │ ├── Deque.java │ │ │ ├── Deque.js │ │ │ ├── Deque.py │ │ │ ├── Deque.ts │ │ │ └── README.md │ │ ├── Priority-Queue/ │ │ │ ├── Priority-Queue.cpp │ │ │ ├── PriorityQueue.php │ │ │ ├── README.md │ │ │ └── priorityQueue.js │ │ ├── QueueUsingArray.c │ │ ├── QueueUsingArray.cpp │ │ ├── QueueUsingArray.go │ │ ├── QueueUsingArray.java │ │ ├── QueueUsingArray.js │ │ ├── QueueUsingArray.py │ │ ├── QueueUsingArray.rb │ │ ├── QueueUsingArray.swift │ │ ├── QueueUsingLL.c │ │ ├── QueueUsingLL.cpp │ │ ├── QueueUsingLL.cs │ │ ├── QueueUsingLL.php │ │ ├── QueueUsingStacks.cpp │ │ └── README.md │ ├── README.md │ ├── Stack/ │ │ ├── Infix_to_prefix_postfix.cpp │ │ ├── README.md │ │ ├── StackUsingArray.c │ │ ├── StackUsingArray.cpp │ │ ├── StackUsingArray.cs │ │ ├── StackUsingArray.go │ │ ├── StackUsingArray.hs │ │ ├── StackUsingArray.java │ │ ├── StackUsingArray.js │ │ ├── StackUsingArray.php │ │ ├── StackUsingArray.rb │ │ ├── StackUsingArray.swift │ │ ├── StackUsingLL.cpp │ │ ├── StackUsingLL.go │ │ ├── StackUsingLL.java │ │ ├── StackUsingLL.js │ │ ├── StackUsingLL.py │ │ ├── stackUsingLinkedList.c │ │ └── stackusingLL.c │ └── Tree/ │ ├── 23-Tree/ │ │ ├── 23Tree.cpp │ │ └── 23Tree.py │ ├── AVL-Tree/ │ │ ├── AVL_Tree.java │ │ ├── AVL_Tree.py │ │ ├── AVLtree.c │ │ ├── README.md │ │ └── avl_tree.py │ ├── Binary-Indexed-Tree/ │ │ ├── Binary-Indexed-Tree.c │ │ ├── Binary-Indexed-Tree.go │ │ ├── Binary-Indexed-Tree.java │ │ └── Binary-Indexed-Tree.py │ ├── Binary-Search-Tree/ │ │ ├── BST.cs │ │ ├── BST_balanced.cpp │ │ ├── BinarySearchTree.go │ │ ├── BinarySearchTree.java │ │ ├── Binary_Search_Tree.cpp │ │ ├── Binary_Search_Tree.py │ │ ├── Binary_Search_Tree_operations.cpp │ │ ├── LCA.py │ │ ├── README.md │ │ ├── Validate_BST.py │ │ ├── Vertcal_order_traversal.py │ │ ├── inorder_transversal.c │ │ ├── operationBST.cpp │ │ ├── postorder_transversal.c │ │ └── valid BST │ ├── Binary-Tree/ │ │ ├── BTree.cpp │ │ ├── Binary tree using C.c │ │ ├── Btree.java │ │ ├── Check_duplicates_in _BTree.java │ │ ├── Density/ │ │ │ ├── DensityBtree.c │ │ │ └── DensityBtree.cpp │ │ ├── Deserialize/ │ │ │ └── Deserialize.rb │ │ ├── Duplicate_values.cs │ │ ├── Invert_Binary_Tree/ │ │ │ ├── Invert_Binary_Tree.py │ │ │ ├── invertBinTree.rb │ │ │ └── invert_binary_tree.cpp │ │ ├── Invert_Binary_tree/ │ │ │ └── invert_btree.swift │ │ ├── Right_View/ │ │ │ ├── RightViewBTree.java │ │ │ ├── rightViewBinTree.rb │ │ │ ├── right_view.py │ │ │ ├── right_view.swift │ │ │ └── right_view_of_binary_tree.cpp │ │ ├── Serialize/ │ │ │ ├── Serialize.cpp │ │ │ └── Serialize.py │ │ ├── Subtree_check/ │ │ │ └── Subtree_check.cpp │ │ ├── SymmetricBTree.java │ │ ├── SymmetryBTree/ │ │ │ └── SymmetryBTree.rb │ │ ├── SymmetryBTree.cs │ │ ├── SymmetryBTree.py │ │ ├── Two_level_Node/ │ │ │ └── two_level_Node.cpp │ │ ├── Two_level_Node.java │ │ ├── VerticalOrderTraversal.java │ │ ├── VerticalOrderTraversal.py │ │ ├── Vertical_Sum/ │ │ │ ├── Verticle_sum_of_BinaryTree.java │ │ │ └── Verticle_sum_of_Binary_Tree.cpp │ │ ├── b_tree.cpp │ │ ├── b_tree.java │ │ ├── b_tree.js │ │ ├── b_tree.py │ │ ├── binary_tree_trans.cpp │ │ ├── duplicate_values.cpp │ │ ├── duplicate_values.py │ │ ├── duplicate_values.rb │ │ ├── subtree_check.cpp │ │ ├── symmetry_bTree.cpp │ │ └── two_level_node.py │ ├── Expression Tree/ │ │ └── Expression_Tree.cpp │ ├── Fibonacci-Heap/ │ │ └── Fibonacci-Heap.c │ ├── Generic Tree/ │ │ └── GenericTree.cpp │ ├── README.md │ ├── Red-Black-Tree/ │ │ ├── Red-Black-Tree.c │ │ ├── Red-Black-Tree.cpp │ │ ├── Red-Black-Tree.java │ │ └── Red-Black-Tree.py │ ├── Segment-Tree/ │ │ └── Segment-Tree.c │ ├── Splay-Tree/ │ │ └── Splay-Tree.c │ ├── Threaded Binary Tree/ │ │ └── Threaded_Binary_Tree.cpp │ └── Trie/ │ ├── README.md │ ├── Trie.c │ ├── trie.cpp │ └── trie.py ├── LICENSE ├── Maths/ │ ├── Algebra/ │ │ ├── Babylionian/ │ │ │ ├── Babylionian.cs │ │ │ ├── Babylionian.go │ │ │ └── Babylonian.java │ │ ├── Babylonian/ │ │ │ ├── Babylonian.js │ │ │ └── babylonian_square_root.c │ │ ├── Derivative_Of_Polynomial/ │ │ │ ├── Matrix_Multiplication.c │ │ │ └── README.md │ │ ├── Diophantine/ │ │ │ └── README.md │ │ ├── Factorial/ │ │ │ ├── Factorial.hs │ │ │ ├── Factorial.java │ │ │ ├── README.md │ │ │ ├── factorial.c │ │ │ ├── factorial.cpp │ │ │ ├── factorial.cs │ │ │ ├── factorial.go │ │ │ ├── factorial.js │ │ │ ├── factorial.php │ │ │ ├── factorial.py │ │ │ ├── factorial.rb │ │ │ ├── factorial.sh │ │ │ ├── factorial.swift │ │ │ └── factorial.ts │ │ ├── Factorial_of_Large_Number/ │ │ │ ├── Factorial_of_Large_Number.cs │ │ │ ├── Factorial_of_Large_Number.hs │ │ │ ├── Factorial_of_Large_Number.js │ │ │ ├── Factorial_of_Large_Number.php │ │ │ ├── Factorial_of_large_number.c │ │ │ ├── README.md │ │ │ ├── bigfactorial.cpp │ │ │ └── largeFactorial.java │ │ ├── GCD/ │ │ │ ├── EuclidGCD.swift │ │ │ ├── Euclidean_gcd.py │ │ │ ├── EuclidianGCD.py │ │ │ ├── GCD.cpp │ │ │ ├── GCD.cs │ │ │ ├── GCD.js │ │ │ ├── GCD.php │ │ │ ├── GCD.py │ │ │ ├── GCD.rb │ │ │ ├── GCD.sh │ │ │ ├── README.md │ │ │ └── gcd.java │ │ ├── Inverse_of_a_Matrix/ │ │ │ └── README.md │ │ ├── LCM/ │ │ │ ├── LCM.c │ │ │ ├── LCM.cpp │ │ │ ├── LCM.java │ │ │ ├── LCM.js │ │ │ ├── LCM.py │ │ │ ├── LCM.sh │ │ │ ├── LCM_GCD.c │ │ │ ├── LCM_python.py │ │ │ └── README.md │ │ ├── Markov_Matrix/ │ │ │ ├── MarkovMatrix.java │ │ │ ├── Markov_Matrix.c++ │ │ │ ├── Markov_Matrix.cs │ │ │ └── Markov_Matrix.js │ │ ├── Matrix_Multipication/ │ │ │ ├── MatMul.cpp │ │ │ ├── MatrixMultipication.py │ │ │ ├── MatrixMultiply.java │ │ │ ├── Matrix_Multiplication.js │ │ │ ├── README.md │ │ │ ├── multiply.c │ │ │ ├── multiply.cpp │ │ │ ├── multiply.java │ │ │ ├── multiply.php │ │ │ └── multiply.py │ │ ├── Permutation_And_Combination/ │ │ │ ├── Permutations_Combinations.ipynb │ │ │ ├── README.md │ │ │ ├── permutation_combination.cpp │ │ │ └── permutation_combination.js │ │ ├── Prime_Factorization/ │ │ │ ├── PrimeFactorisation.cpp │ │ │ ├── Prime_Factor.c │ │ │ ├── Prime_Factorisation.cpp │ │ │ ├── Prime_Factorization.cs │ │ │ ├── README.md │ │ │ ├── prime-factorisation.js │ │ │ ├── prime.cpp │ │ │ ├── prime_factorization.cpp │ │ │ ├── prime_factorization.java │ │ │ ├── prime_factorization.py │ │ │ └── prime_factorization.ts │ │ ├── Quadratic_Formula/ │ │ │ ├── Quadratic_Formula.cpp │ │ │ ├── Quadratic_Formula.hs │ │ │ ├── Quadratic_Formula.sh │ │ │ ├── README.md │ │ │ └── quadraticformula.py │ │ ├── README.md │ │ ├── Sieve of Eratosthenes/ │ │ │ ├── SieveOfEratosthenes.cpp │ │ │ ├── SieveOfEratosthenes.py │ │ │ ├── SieveOfEratosthens.c │ │ │ └── SieveofEratosthenes.java │ │ ├── Strassens_Algorithm/ │ │ │ ├── README.md │ │ │ ├── Strassen.java │ │ │ ├── Strassens_Algorithm.c++ │ │ │ └── strassens.py │ │ ├── Taylor-Expansion/ │ │ │ └── README.md │ │ └── Vertex_Formula/ │ │ └── README.md │ ├── Calculus/ │ │ ├── Euler_Approximation/ │ │ │ ├── Euler_Approximation.c │ │ │ ├── Euler_Approximation.cpp │ │ │ ├── Euler_Approximation.java │ │ │ ├── Euler_Approximation.py │ │ │ └── README.md │ │ ├── Leibniz_formula/ │ │ │ ├── LeibnizFormula.py │ │ │ ├── Leibniz_Formula.java │ │ │ ├── Leibniz_formula.cpp │ │ │ └── README.md │ │ ├── Probability_Density_Functions/ │ │ │ └── README.md │ │ ├── README.md │ │ ├── Riemann_Sum/ │ │ │ ├── README.md │ │ │ ├── Riemann.py │ │ │ ├── Riemann_Sum.cpp │ │ │ ├── Riemann_Sum.cs │ │ │ └── riemann_sum.py │ │ └── Runge–Kutta_Method/ │ │ ├── Range-Kutta.c │ │ ├── Runge-Kutta.cpp │ │ └── Runge-Kutta.py │ ├── Discrete/ │ │ ├── Ackermann_Peter/ │ │ │ ├── Ackermann_Peter.c │ │ │ ├── Ackermann_Peter.cpp │ │ │ ├── Ackermann_Peter.js │ │ │ ├── Ackermann_Peter.py │ │ │ ├── Python/ │ │ │ │ └── ackermann.py │ │ │ └── README.md │ │ └── README.md │ ├── Geometry/ │ │ ├── Clock_Angle/ │ │ │ ├── ClockAngle.cs │ │ │ ├── Clock_Angle.c │ │ │ ├── Clock_Angle.cpp │ │ │ ├── Clock_Angle.hs │ │ │ ├── Clock_Angle.java │ │ │ ├── Clock_Angle.js │ │ │ ├── README.md │ │ │ ├── clock_angle.go │ │ │ └── clock_angle.py │ │ ├── Distance_Formula/ │ │ │ ├── Distance_Formula.c │ │ │ ├── Distance_Formula.cpp │ │ │ ├── Distance_Formula.cs │ │ │ ├── Distance_Formula.go │ │ │ ├── Distance_Formula.hs │ │ │ ├── Distance_Formula.java │ │ │ ├── Distance_Formula.js │ │ │ ├── Distance_Formula.php │ │ │ ├── Distance_Formula.py │ │ │ └── README.md │ │ ├── Manhattan_Distance/ │ │ │ ├── ManhattanDistance.java │ │ │ ├── ManhattanDistance.js │ │ │ ├── Manhattan_Distance.c │ │ │ ├── Manhattan_Distance.hs │ │ │ ├── README.md │ │ │ ├── manhattan_dist.cpp │ │ │ ├── manhattan_dist.go │ │ │ ├── manhattan_dist.py │ │ │ └── manhattan_distance.py │ │ ├── N_Dimensional_Distance/ │ │ │ └── N_Dimensional_Distance.c │ │ ├── Polar_Cartesian_Conversion/ │ │ │ ├── Polar_Cartesian_Conversion.go │ │ │ ├── Polar_Cartesian_Conversion.hs │ │ │ ├── Polar_Cartesian_Conversion.java │ │ │ └── Polar_Cartesian_Conversion.py │ │ ├── Pythagorean_theorem/ │ │ │ ├── PythagoreanTheorem.cs │ │ │ ├── Pythagorean_theorem.cpp │ │ │ ├── Pythagorean_theorem.hs │ │ │ ├── Pythagorean_theorem.js │ │ │ ├── Pythagorean_theorem.py │ │ │ ├── Pythagorean_theorem.rb │ │ │ ├── Pythagorean_theorem.swift │ │ │ ├── README.md │ │ │ └── pythogoras_theorem.java │ │ ├── README.md │ │ ├── Radians_Degrees_Conversion/ │ │ │ ├── README.md │ │ │ ├── Radians_Degree_Conversion.c │ │ │ ├── Radians_Degrees_Conversion.c │ │ │ ├── Radians_Degrees_Conversion.cpp │ │ │ ├── Radians_Degrees_Conversion.hs │ │ │ ├── Radians_Degrees_Conversion.java │ │ │ ├── Radians_Degrees_Conversion.js │ │ │ └── Radians_Degrees_Conversion.py │ │ ├── Scalar_Product/ │ │ │ ├── README.md │ │ │ ├── Scalar_Product.c │ │ │ ├── Scalar_Product.hs │ │ │ ├── Scalar_Product.java │ │ │ ├── Scalar_Product.js │ │ │ ├── Scalar_Product.py │ │ │ ├── scalar_product.cpp │ │ │ └── scalar_product.rb │ │ └── Vector_Product/ │ │ ├── README.md │ │ ├── Vector_Product.c │ │ ├── Vector_Product.cpp │ │ ├── Vector_Product.hs │ │ ├── Vector_Product.js │ │ ├── Vector_Product.py │ │ └── Vector_Product.ts │ ├── MOs-Algorithm/ │ │ ├── Mos_Algorithm.c │ │ ├── Mos_Algorithm.cpp │ │ └── README.md │ ├── Number-Theory/ │ │ ├── Armstrong_Number/ │ │ │ ├── ArmstrongNumber.java │ │ │ ├── Armstrong_Number.c │ │ │ ├── armstrong.py │ │ │ ├── armstrongin.java │ │ │ ├── armstrongnumber.cpp │ │ │ └── armstrongnumber.js │ │ ├── Extended Euclidean Algorithm/ │ │ │ ├── extendEuclid.cpp │ │ │ └── extendEuclid.py │ │ ├── Fibonacci_Number/ │ │ │ ├── Fibonacci.cs │ │ │ ├── FibonacciNumbers.java │ │ │ ├── Fibonacci_Number.clj │ │ │ ├── Fibonacci_Number.cpp │ │ │ ├── Fibonacci_Number.py │ │ │ └── fibonacci.sh │ │ ├── Perfect_Number/ │ │ │ ├── Perfect Number.cpp │ │ │ ├── PerfectNumber.py │ │ │ ├── Perfect_Number,sh │ │ │ ├── Perfect_Number.java │ │ │ ├── perfec_numper.py │ │ │ ├── perfectnumber.cpp │ │ │ ├── perfectnumber.js │ │ │ └── perfectnumber.php │ │ ├── README.md │ │ ├── Segmented_Sieve/ │ │ │ ├── README.md │ │ │ ├── Segmented_Sieve.php │ │ │ ├── segmented_sieve.js │ │ │ └── segmented_sieve.py │ │ ├── Sieve_of_Eratosthenes/ │ │ │ ├── SieveOfEratosthenes.c │ │ │ ├── SieveOfEratosthenes.cs │ │ │ ├── Sieve_of_Erastosthenes.rb │ │ │ ├── Sieve_of_Erastosthenes.ts │ │ │ ├── Sieve_of_Eratosthenes.c │ │ │ ├── Sieve_of_Eratosthenes.cpp │ │ │ ├── Sieve_of_Eratosthenes.go │ │ │ ├── SieveofErastosthenes.java │ │ │ └── prime_and_base.py │ │ ├── Smith_number/ │ │ │ ├── SmithNumber.py │ │ │ └── smith_numbers_till_n.cpp │ │ ├── Strong_Number/ │ │ │ ├── strong_number.c │ │ │ ├── strong_number.cpp │ │ │ ├── strong_number.java │ │ │ ├── strong_number.py │ │ │ └── strong_number.sh │ │ ├── Tribonacci_Number/ │ │ │ └── nthTribonacci.kt │ │ └── Ugly_Number/ │ │ ├── README.md │ │ ├── UglyNumber.go │ │ ├── UglyNumbers.sh │ │ ├── Ugly_Number.c │ │ ├── Ugly_Number.java │ │ ├── Ugly_Number.js │ │ ├── Ugly_Number.php │ │ ├── Ugly_Number.py │ │ ├── Ugly_Number.rb │ │ ├── Ugly_Number_Till_N.cpp │ │ └── Ugly_Numbers.sh │ ├── README.md │ ├── Series/ │ │ ├── Arithmetic_Progression/ │ │ │ ├── AP.py │ │ │ ├── Arithematic_Progression.cpp │ │ │ ├── Arithmetic_Progression.c │ │ │ ├── Arithmetic_Progression.java │ │ │ ├── Arithmetic_Progression.js │ │ │ ├── Arithmetic_Progression.php │ │ │ ├── Arithmetic_Progression.sh │ │ │ ├── Arithmetic_Progression.ts │ │ │ └── README.md │ │ ├── Fibonacci/ │ │ │ ├── Fibonacci.c │ │ │ ├── Fibonacci.cpp │ │ │ ├── Fibonacci.sh │ │ │ ├── Fiboncci.py │ │ │ ├── README.md │ │ │ ├── fibonacci.cpp │ │ │ └── fibonacci.java │ │ ├── Geometric_Progression/ │ │ │ ├── Geometric Progression.py │ │ │ ├── GeometricProgression.cs │ │ │ ├── GeometricProgression.java │ │ │ ├── Geometric_Progression.sh │ │ │ └── README.md │ │ ├── Harmonic_Progression/ │ │ │ ├── Harmonic Progression.cpp │ │ │ ├── HarmonicProgresion.c │ │ │ ├── Harmonic_Expression.java │ │ │ ├── README.md │ │ │ ├── SumOfHP.swift │ │ │ └── harmonic_progression.py │ │ ├── Lucas_Series/ │ │ │ ├── Lucas_Series.c │ │ │ ├── Lucas_Series.cpp │ │ │ ├── Lucas_Series.go │ │ │ ├── Lucas_Series.php │ │ │ ├── README.md │ │ │ ├── lucas_series.cs │ │ │ ├── lucas_series.py │ │ │ └── lucas_series.ts │ │ ├── Modular_Exponentiation/ │ │ │ ├── Modular_Exponentiation.cpp │ │ │ ├── Modular_Exponentiation.py │ │ │ ├── README.md │ │ │ ├── modular_exponentiation.c │ │ │ ├── modular_exponentiation.cpp │ │ │ └── modular_exponentiation.java │ │ ├── README.md │ │ ├── Relative_Primes/ │ │ │ ├── README.md │ │ │ ├── RelativePrimes.c │ │ │ ├── RelativePrimes.java │ │ │ ├── RelativePrimes.php │ │ │ ├── RelativePrimes.py │ │ │ ├── Relative_Prime.cpp │ │ │ └── Relative_Primes.go │ │ ├── Sum_of_AP/ │ │ │ ├── Sum_Of_AP.CPP │ │ │ ├── Sum_Of_AP.py │ │ │ ├── Sum_of_AP.c │ │ │ ├── Sum_of_AP.go │ │ │ ├── Sum_of_AP.js │ │ │ └── Sum_of_AP_JAVA/ │ │ │ ├── SumOfAP.ctxt │ │ │ └── Sum_of_AP.java │ │ ├── Sum_of_GP/ │ │ │ ├── README.md │ │ │ ├── Sum_Of_GP.c │ │ │ ├── Sum_Of_GP.cpp │ │ │ ├── Sum_of_GP.java │ │ │ └── Sum_of_GP.py │ │ ├── Sum_of_HP/ │ │ │ ├── HP_sum.py │ │ │ ├── Sum_of_HP.cpp │ │ │ ├── Sum_of_HP.cs │ │ │ └── hpSum.js │ │ ├── Sum_of_N/ │ │ │ ├── Sum_of_n.c │ │ │ ├── sumOfNNumbers.sh │ │ │ ├── sum_of_n_natural_no.cpp │ │ │ ├── sum_of_n_natural_numbers.go │ │ │ ├── sumn.py │ │ │ ├── sumofNnaturalnums.cs │ │ │ └── sumofNnaturalnums.py │ │ ├── Sum_of_N2/ │ │ │ ├── SumOf_n^2.C++ │ │ │ ├── Sum_Of_n^2.py │ │ │ ├── Sum_of_n^2.swift │ │ │ ├── square_sum.cs │ │ │ ├── sumOfNSquare.js │ │ │ ├── sumOfn_squared.py │ │ │ └── sumofnsqaure.php │ │ └── Sum_of_N3/ │ │ ├── Sum of n3.cpp │ │ ├── sum of n^3.cpp │ │ └── sumofncube.php │ └── Statistics/ │ ├── Compound_Interest/ │ │ ├── Compound_Interest.c │ │ ├── Compound_Interest.cpp │ │ ├── Compound_Interest.cs │ │ ├── Compound_Interest.html │ │ ├── Compound_Interest.java │ │ ├── Compound_Interest.js │ │ ├── Compound_Interest.py │ │ ├── Compound_Interest.rb │ │ └── Compound_Interest.ts │ ├── Confidence_Interval/ │ │ ├── Confidence_Interval.cpp │ │ ├── Confidence_Inverval.c │ │ ├── README.md │ │ ├── confidenceInterval.js │ │ └── confidence_interval.py │ ├── Exponential_Smoothing/ │ │ ├── Exponential_Smoothing.cpp │ │ ├── Exponential_Smoothing.java │ │ ├── Exponential_Smoothing.rb │ │ └── README.md │ ├── K-means_Clustering/ │ │ └── K-means_Clustering.py │ ├── Logistic_Function/ │ │ └── README.md │ ├── Mean/ │ │ ├── mean.cpp │ │ ├── mean.java │ │ ├── mean.py │ │ ├── meanOfGivenNumbers.c │ │ ├── meanOfGivenNumbers.cs │ │ └── meanOfGivenNumbers.js │ ├── Median/ │ │ ├── Median.c │ │ ├── Median.java │ │ ├── Median.js │ │ ├── Median.py │ │ ├── README.md │ │ └── meadian.cpp │ ├── Mode/ │ │ ├── Mode.java │ │ ├── README.md │ │ ├── mode.c │ │ ├── mode.cpp │ │ ├── mode.js │ │ ├── mode.php │ │ └── mode.py │ ├── README.md │ └── Standard_Deviation/ │ ├── README.md │ ├── Standard_Deviation.c │ ├── Standard_Deviation.cpp │ ├── Standard_Deviation.js │ ├── Standard_Deviation.py │ └── Standard_Deviation.swift ├── README.md ├── STL/ │ ├── Array/ │ │ └── Array.cpp │ ├── Map/ │ │ ├── MultiMap/ │ │ │ └── multimap.cpp │ │ ├── Unodered-Map/ │ │ │ └── unorderedmap.cpp │ │ └── map.cpp │ ├── Queue/ │ │ ├── Deque/ │ │ │ ├── README.md │ │ │ └── deque.cpp │ │ ├── PriorityQueue/ │ │ │ └── priority_queue.cpp │ │ └── Queue.cpp │ ├── README.md │ ├── Set/ │ │ ├── Unodered-Set/ │ │ │ └── UnorderedSet.cpp │ │ └── set.cpp │ ├── Stack/ │ │ └── stack.cpp │ └── Vector/ │ └── Vector.cpp └── _config.yml