gitextract_vzijow3k/ ├── .gitattributes ├── .github/ │ ├── CODE_OF_CONDUCT.md │ ├── CONTRIBUTING.md │ ├── CONTRIBUTORS.md │ ├── ISSUE_TEMPLATE.md │ └── PULL_REQUEST_TEMPLATE.md ├── .gitignore ├── .gitmodules ├── .travis.yml ├── LICENSE ├── README.md ├── code/ │ ├── algorithm_applications/ │ │ └── src/ │ │ ├── Cichelli's Perfect Hashing Alogorithm/ │ │ │ ├── Hashing.java │ │ │ ├── Key.java │ │ │ └── files/ │ │ │ ├── kywrdsOdd.txt │ │ │ └── tstOdd.txt │ │ ├── Strassens algorithm/ │ │ │ └── strassens algorithm.cpp │ │ ├── binary_search/ │ │ │ ├── ceil_of_element/ │ │ │ │ └── ceil_of_element_in_sorted_array.cpp │ │ │ ├── distributing_candies/ │ │ │ │ └── CandyDistribution.java │ │ │ ├── first_and_last_position_in_sorted_array/ │ │ │ │ └── firstAndLastPosInSortedArray.cpp │ │ │ └── floor_of_element/ │ │ │ └── floor_of_element_in_sorted_array.cpp │ │ ├── bubble_sort/ │ │ │ └── bubble_sort_implementation.cpp │ │ └── merge_arrays/ │ │ └── merge_two_arrays.c │ ├── artificial_intelligence/ │ │ ├── src/ │ │ │ ├── Inception_Pre-trained_Model/ │ │ │ │ ├── Inception_model.md │ │ │ │ └── README.md │ │ │ ├── VGG-11/ │ │ │ │ ├── README.md │ │ │ │ └── vgg11.md │ │ │ ├── Vaccum_Cleaner/ │ │ │ │ ├── VC.md │ │ │ │ └── Vaccum_cleaner (1).ipynb │ │ │ ├── a_star/ │ │ │ │ └── a_star.py │ │ │ ├── artificial_neural_network/ │ │ │ │ ├── ann.py │ │ │ │ └── dataset.csv │ │ │ ├── autoenncoder/ │ │ │ │ ├── Convolutional_Autoencoder.ipynb │ │ │ │ └── autoencoder.ipynb │ │ │ ├── bayesian_belief_network/ │ │ │ │ └── Bayesian-Belief-Network.ipynb │ │ │ ├── bernoulli_naive_bayes/ │ │ │ │ ├── README.md │ │ │ │ └── bernoulli.py │ │ │ ├── chatbot/ │ │ │ │ ├── Chatbot.ipynb │ │ │ │ ├── README.md │ │ │ │ └── intents.json │ │ │ ├── convolutional_neural_network/ │ │ │ │ ├── cnn.ipynb │ │ │ │ ├── cnn_adversarial_examples.ipynb │ │ │ │ ├── test.csv │ │ │ │ └── train.csv │ │ │ ├── dbscan_clustering/ │ │ │ │ ├── dbscan.py │ │ │ │ └── readme.md │ │ │ ├── decision_tree/ │ │ │ │ ├── Decision_Tree_Regression.ipynb │ │ │ │ ├── Position_Salaries.csv │ │ │ │ ├── data_banknote_authentication.csv │ │ │ │ ├── decision_tree.py │ │ │ │ └── decision_trees_information_gain.py │ │ │ ├── deep_q_networks/ │ │ │ │ └── deep-q-networks.ipynb │ │ │ ├── factorization_machines/ │ │ │ │ ├── README.md │ │ │ │ └── matrix_factorization.py │ │ │ ├── gaussian_mixture_model/ │ │ │ │ └── README.md │ │ │ ├── gaussian_naive_bayes/ │ │ │ │ ├── gaussian_naive_bayes.py │ │ │ │ ├── gaussian_naive_bayes_moons.py │ │ │ │ └── iris1.csv │ │ │ ├── generative_adversarial_networks/ │ │ │ │ ├── CGAN.ipynb │ │ │ │ ├── CycleGAN.ipynb │ │ │ │ └── DCGAN.ipynb │ │ │ ├── getting_started_with_ml/ │ │ │ │ └── README.md │ │ │ ├── gradient_boosting_trees/ │ │ │ │ └── README.md │ │ │ ├── hierachical_clustering/ │ │ │ │ ├── README.md │ │ │ │ ├── hierachical_clustering/ │ │ │ │ │ └── hierarchical_clustering.ipynb │ │ │ │ └── hierachical_clustering.cpp │ │ │ ├── image_processing/ │ │ │ │ ├── Cell-Segmentation/ │ │ │ │ │ ├── Cell_Segmentation_.ipynb │ │ │ │ │ ├── README.md │ │ │ │ │ └── img/ │ │ │ │ │ └── blogdiagram.drawio │ │ │ │ ├── README.md │ │ │ │ ├── canny/ │ │ │ │ │ ├── canny.cpp │ │ │ │ │ ├── canny.h │ │ │ │ │ └── main.cpp │ │ │ │ ├── connected_component_labeling/ │ │ │ │ │ └── Connected-Component-Labeling.ipynb │ │ │ │ ├── contrast_enhancement/ │ │ │ │ │ ├── CLAHE.ipynb │ │ │ │ │ ├── Histogram-Equalization.ipynb │ │ │ │ │ └── Min-Max-Contrast-Stretching.ipynb │ │ │ │ ├── erode_dilate/ │ │ │ │ │ └── main.cpp │ │ │ │ ├── houghtransform/ │ │ │ │ │ └── main.cpp │ │ │ │ ├── image_stitching/ │ │ │ │ │ ├── a.out │ │ │ │ │ └── imagestitching.cpp │ │ │ │ ├── install_opencv.sh │ │ │ │ ├── prewittfilter/ │ │ │ │ │ └── prewitt.cpp │ │ │ │ └── sobelfilter/ │ │ │ │ └── sobel.cpp │ │ │ ├── isodata_clustering/ │ │ │ │ ├── isodata.py │ │ │ │ └── readme.md │ │ │ ├── k_means/ │ │ │ │ ├── README.md │ │ │ │ ├── k-means.c │ │ │ │ ├── k_means.cpp │ │ │ │ ├── k_means.py │ │ │ │ └── k_means.swift │ │ │ ├── k_nearest_neighbours/ │ │ │ │ ├── KNN.c │ │ │ │ ├── iris.data │ │ │ │ ├── k_nearest_neighbours.cpp │ │ │ │ └── k_nearest_neighbours.py │ │ │ ├── lasso_regression/ │ │ │ │ └── lasso_regression.ipynb │ │ │ ├── linear_regression/ │ │ │ │ ├── README.md │ │ │ │ ├── Salary_Data.csv │ │ │ │ ├── linear_regression/ │ │ │ │ │ └── linear_regression.js │ │ │ │ ├── linear_regression.java │ │ │ │ ├── linear_regression.js │ │ │ │ ├── linear_regression.py │ │ │ │ ├── linear_regression.swift │ │ │ │ ├── linear_regression_scikit_learn.ipynb │ │ │ │ └── linear_regression_scikit_learn.py │ │ │ ├── logistic_regression/ │ │ │ │ ├── README.md │ │ │ │ └── logistic_regression.py │ │ │ ├── minimax/ │ │ │ │ ├── README.md │ │ │ │ └── minimax.py │ │ │ ├── missionaries_and_cannibals.py │ │ │ ├── naive_bayes/ │ │ │ │ ├── README.md │ │ │ │ ├── iris1.csv │ │ │ │ ├── naive_bayes.cpp │ │ │ │ ├── naive_bayes.py │ │ │ │ └── naive_bayes.swift │ │ │ ├── named_entity_recognition/ │ │ │ │ ├── NER.ipynb │ │ │ │ ├── README.md │ │ │ │ └── ner_dataset.csv │ │ │ ├── nearest_sequence_memory/ │ │ │ │ └── nsm_matlab/ │ │ │ │ ├── main.m │ │ │ │ ├── nsm_agent.m │ │ │ │ └── simulator.m │ │ │ ├── neural_network/ │ │ │ │ ├── keras_nn.py │ │ │ │ └── neural_network.py │ │ │ ├── neural_style_transfer/ │ │ │ │ └── neural_style_transfer.ipynb │ │ │ ├── number_recogniser/ │ │ │ │ └── python/ │ │ │ │ ├── driver.py │ │ │ │ ├── mnist.npz │ │ │ │ └── nn.py │ │ │ ├── particle_swarm_optimization/ │ │ │ │ ├── gbestPSO/ │ │ │ │ │ ├── Gbest2D.py │ │ │ │ │ └── Gbest3D.py │ │ │ │ └── lbestPSO/ │ │ │ │ ├── LBest3D.py │ │ │ │ └── Lbest2D.py │ │ │ ├── perceptron/ │ │ │ │ └── perceptron.py │ │ │ ├── principal_component_analysis/ │ │ │ │ ├── README.md │ │ │ │ └── pca.py │ │ │ ├── q_learning/ │ │ │ │ ├── README.md │ │ │ │ ├── q_learning.ipynb │ │ │ │ └── q_learning.js │ │ │ ├── random_forests/ │ │ │ │ ├── Position_Salaries.csv │ │ │ │ ├── README.md │ │ │ │ └── Random_Forest_Regression_Model.ipynb │ │ │ ├── residual_convolutional_neural_network/ │ │ │ │ ├── .gitignore │ │ │ │ ├── logs/ │ │ │ │ │ └── events.out.tfevents.1594761798.POSITRON.2995.0 │ │ │ │ └── main.py │ │ │ ├── restricted_boltzmann_machine/ │ │ │ │ ├── README.md │ │ │ │ ├── rbm.ipynb │ │ │ │ ├── test.csv │ │ │ │ └── train.csv │ │ │ ├── sat/ │ │ │ │ └── togasat.cpp │ │ │ ├── shufflenet_v1/ │ │ │ │ ├── README.md │ │ │ │ └── ShuffleNet_Implementation.ipynb │ │ │ ├── skull_stripping/ │ │ │ │ ├── data.py │ │ │ │ └── model.py │ │ │ ├── support_vector_machine/ │ │ │ │ ├── README.md │ │ │ │ ├── support_vector_machine.cpp │ │ │ │ ├── svm.c │ │ │ │ └── svm.py │ │ │ ├── t_distributed_stochastic_neighbor_embedding/ │ │ │ │ └── README.md │ │ │ ├── tsp/ │ │ │ │ ├── algo.md │ │ │ │ ├── euc_100 │ │ │ │ ├── euc_250 │ │ │ │ ├── euc_500 │ │ │ │ ├── makefile │ │ │ │ ├── noneuc_100 │ │ │ │ ├── noneuc_250 │ │ │ │ ├── noneuc_500 │ │ │ │ └── salesman.cpp │ │ │ ├── tsp.c │ │ │ └── yolo_v1/ │ │ │ ├── README.md │ │ │ └── yolo-v1-implementation.ipynb │ │ └── test/ │ │ └── README.md │ ├── backtracking/ │ │ ├── src/ │ │ │ ├── Min_Max/ │ │ │ │ ├── README.md │ │ │ │ ├── alphabetaprune.cpp │ │ │ │ └── aphabetapruning.java │ │ │ ├── README.md │ │ │ ├── algorithm_x/ │ │ │ │ ├── README.md │ │ │ │ └── algorithm_x.cpp │ │ │ ├── crossword_puzzle/ │ │ │ │ ├── crossword_puzzle.cpp │ │ │ │ ├── crossword_puzzle.java │ │ │ │ └── crossword_puzzle.js │ │ │ ├── generate_parentheses/ │ │ │ │ └── generate_parentheses.cpp │ │ │ ├── knight_tour/ │ │ │ │ ├── README.md │ │ │ │ ├── knight_tour.c │ │ │ │ ├── knight_tour.cpp │ │ │ │ ├── knight_tour.go │ │ │ │ ├── knight_tour.java │ │ │ │ ├── knight_tour.py │ │ │ │ ├── knight_tour.rs │ │ │ │ └── knight_tour_withoutbt.c │ │ │ ├── kth_grammar/ │ │ │ │ └── kth-Grammar.cpp │ │ │ ├── m_coloring_problem/ │ │ │ │ └── m_coloring_problem.py │ │ │ ├── n_queen/ │ │ │ │ ├── README.md │ │ │ │ ├── n_queen.c │ │ │ │ ├── n_queen.go │ │ │ │ ├── n_queen.hs │ │ │ │ ├── n_queen.java │ │ │ │ ├── n_queen.py │ │ │ │ ├── n_queen_backtracking.cpp │ │ │ │ ├── n_queen_backtracking.rs │ │ │ │ ├── n_queen_bit.go │ │ │ │ ├── n_queen_bitimp.cpp │ │ │ │ ├── n_queen_bitset.cpp │ │ │ │ └── nqueen_bitmask.c │ │ │ ├── number_of_ways_in_maze/ │ │ │ │ ├── README.md │ │ │ │ ├── number_of_ways_in_maze.c │ │ │ │ ├── number_of_ways_in_maze.cpp │ │ │ │ ├── number_of_ways_in_maze.go │ │ │ │ ├── number_of_ways_in_maze.java │ │ │ │ └── number_of_ways_in_maze.rs │ │ │ ├── partitions_of_number/ │ │ │ │ ├── README.md │ │ │ │ ├── partitions_of_number.cpp │ │ │ │ ├── partitions_of_number.go │ │ │ │ └── partitions_of_number.rs │ │ │ ├── partitions_of_set/ │ │ │ │ ├── README.md │ │ │ │ ├── partitions_of_set.cpp │ │ │ │ └── partitions_of_set.go │ │ │ ├── permutations_of_string/ │ │ │ │ ├── README.md │ │ │ │ ├── permutations_of_string.c │ │ │ │ ├── permutations_of_string.go │ │ │ │ ├── permutations_of_string.kt │ │ │ │ ├── permutations_of_string.py │ │ │ │ ├── permutations_of_string_itertools.py │ │ │ │ └── permutations_of_string_stl.cpp │ │ │ ├── power_set/ │ │ │ │ ├── power_set.c │ │ │ │ ├── power_set.go │ │ │ │ └── power_set.java │ │ │ ├── rat_in_a_maze/ │ │ │ │ ├── README.md │ │ │ │ ├── rat_in_a_maze.cpp │ │ │ │ └── rat_in_a_maze.py │ │ │ ├── subset_sum/ │ │ │ │ ├── README.md │ │ │ │ ├── subset_sum.c │ │ │ │ ├── subset_sum.cpp │ │ │ │ ├── subset_sum.go │ │ │ │ ├── subset_sum.java │ │ │ │ ├── subset_sum.py │ │ │ │ └── subset_sum_duplicates.py │ │ │ └── sudoku_solve/ │ │ │ ├── README.md │ │ │ ├── sudoku_solve.c │ │ │ ├── sudoku_solve.cpp │ │ │ ├── sudoku_solve.py │ │ │ ├── sudoku_solve.rs │ │ │ ├── sudoku_solveNxN.cpp │ │ │ └── sudoku_solver.java │ │ └── test/ │ │ └── README.md │ ├── bit_manipulation/ │ │ ├── src/ │ │ │ ├── Find the element that appears once/ │ │ │ │ └── Find_the_element_that_appears_once.cpp │ │ │ ├── README.md │ │ │ ├── addition_using_bits/ │ │ │ │ ├── addition_using_bits.c │ │ │ │ ├── addition_using_bits.cpp │ │ │ │ ├── addition_using_bits.cs │ │ │ │ ├── addition_using_bits.java │ │ │ │ ├── addition_using_bits.js │ │ │ │ └── addition_using_bits.py │ │ │ ├── bit_division/ │ │ │ │ ├── README.md │ │ │ │ ├── bit_division.c │ │ │ │ ├── bit_division.cpp │ │ │ │ ├── bit_division.go │ │ │ │ ├── bit_division.java │ │ │ │ ├── bit_division.js │ │ │ │ └── bit_division.py │ │ │ ├── byte_swapper/ │ │ │ │ └── byte_swapper.java │ │ │ ├── clear_bits_from_msb/ │ │ │ │ ├── clear_bits_from_msb.c │ │ │ │ ├── clear_bits_from_msb.cpp │ │ │ │ ├── clear_bits_from_msb.java │ │ │ │ └── clear_bits_from_msb.py │ │ │ ├── convert_number_binary/ │ │ │ │ ├── README.md │ │ │ │ ├── binary_to_integer.py │ │ │ │ ├── convert_number_binary.c │ │ │ │ ├── convert_number_binary.cpp │ │ │ │ ├── convert_number_binary.hs │ │ │ │ ├── convert_number_binary.java │ │ │ │ ├── convert_number_binary.js │ │ │ │ ├── convert_number_binary.php │ │ │ │ └── convert_number_binary.py │ │ │ ├── count_set_bits/ │ │ │ │ ├── README.md │ │ │ │ ├── brian_kernighan_algo/ │ │ │ │ │ └── brian_kernighan_algorithm.cpp │ │ │ │ ├── count_set_bits.c │ │ │ │ ├── count_set_bits.cpp │ │ │ │ ├── count_set_bits.cs │ │ │ │ ├── count_set_bits.java │ │ │ │ ├── count_set_bits.js │ │ │ │ ├── count_set_bits.py │ │ │ │ └── count_set_bits_lookup_table.cpp │ │ │ ├── first_set_bit/ │ │ │ │ └── first_set_bit.cpp │ │ │ ├── flip_bits/ │ │ │ │ ├── README.md │ │ │ │ ├── flipbits.java │ │ │ │ ├── flippingbits.c │ │ │ │ ├── flippingbits.cpp │ │ │ │ └── flippingbits.py │ │ │ ├── hamming_distance/ │ │ │ │ ├── README.md │ │ │ │ ├── hamming_distance.c │ │ │ │ ├── hamming_distance.cpp │ │ │ │ ├── hamming_distance.go │ │ │ │ ├── hamming_distance.java │ │ │ │ ├── hamming_distance.py │ │ │ │ └── hamming_distance2.py │ │ │ ├── invert_bit/ │ │ │ │ ├── invert_bit.c │ │ │ │ ├── invert_bit.cpp │ │ │ │ ├── invert_bit.js │ │ │ │ ├── invert_bit.py │ │ │ │ └── invert_bit.rs │ │ │ ├── lonely_integer/ │ │ │ │ ├── README.md │ │ │ │ ├── lonely_integer.c │ │ │ │ ├── lonely_integer.cpp │ │ │ │ ├── lonely_integer.go │ │ │ │ ├── lonely_integer.java │ │ │ │ ├── lonely_integer.js │ │ │ │ ├── lonely_integer.py │ │ │ │ └── lonely_integer.rs │ │ │ ├── magic_number/ │ │ │ │ ├── README.md │ │ │ │ ├── magic_number.c │ │ │ │ ├── magic_number.cpp │ │ │ │ ├── magic_number.java │ │ │ │ └── magic_number.py │ │ │ ├── maximum_xor_value/ │ │ │ │ ├── README.md │ │ │ │ └── maximum_xor_value.cpp │ │ │ ├── multiply_by_2/ │ │ │ │ ├── README.md │ │ │ │ └── multiply_by_2.cpp │ │ │ ├── power_of_2/ │ │ │ │ ├── power_of_2.c │ │ │ │ ├── power_of_2.cpp │ │ │ │ ├── power_of_2.cs │ │ │ │ ├── power_of_2.go │ │ │ │ ├── power_of_2.java │ │ │ │ ├── power_of_2.jl │ │ │ │ ├── power_of_2.js │ │ │ │ ├── power_of_2.php │ │ │ │ ├── power_of_2.py │ │ │ │ └── power_of_2.rs │ │ │ ├── power_of_4/ │ │ │ │ ├── Main.java │ │ │ │ └── power_of_4.cpp │ │ │ ├── set_ith_bit/ │ │ │ │ ├── set_ith_bit.cpp │ │ │ │ └── set_ith_bit.py │ │ │ ├── subset_generation/ │ │ │ │ ├── README.md │ │ │ │ ├── subset_generator_using_bit.cpp │ │ │ │ ├── subset_mask_generator.cpp │ │ │ │ └── subset_sum.cpp │ │ │ ├── sum_binary_numbers/ │ │ │ │ ├── README.md │ │ │ │ ├── sum_binary_numbers.c │ │ │ │ └── sum_binary_numbers.cpp │ │ │ ├── sum_equals_xor/ │ │ │ │ ├── README.md │ │ │ │ ├── sum_equals_xor.c │ │ │ │ ├── sum_equals_xor.cpp │ │ │ │ └── sum_equals_xor.py │ │ │ ├── thrice_unique_number/ │ │ │ │ ├── README.md │ │ │ │ ├── thrice_unique_number.cpp │ │ │ │ ├── thrice_unique_number.java │ │ │ │ ├── thrice_unique_number.js │ │ │ │ └── thrice_unique_number.py │ │ │ ├── twice_unique_number/ │ │ │ │ ├── README.md │ │ │ │ ├── twice_unique_number.c │ │ │ │ └── twice_unique_number.cpp │ │ │ └── xor_swap/ │ │ │ ├── README.md │ │ │ ├── xor_swap.c │ │ │ ├── xor_swap.cpp │ │ │ ├── xor_swap.go │ │ │ ├── xor_swap.js │ │ │ └── xor_swap.py │ │ └── test/ │ │ ├── README.md │ │ └── addition_using_bits_test.cpp │ ├── blockchain/ │ │ ├── Application.java │ │ ├── Block.java │ │ ├── UtilityClass.java │ │ └── explainBlockchain.md │ ├── cellular_automaton/ │ │ ├── src/ │ │ │ ├── brians_brain/ │ │ │ │ └── README.md │ │ │ ├── conways_game_of_life/ │ │ │ │ ├── README.md │ │ │ │ ├── conway.java │ │ │ │ ├── conways_game_of_life.rb │ │ │ │ ├── game_of_life_c_sdl.c │ │ │ │ ├── gameoflife.hs │ │ │ │ ├── life.c │ │ │ │ ├── life.cpp │ │ │ │ ├── life.go │ │ │ │ ├── life.py │ │ │ │ └── life.rb │ │ │ ├── elementary_cellular_automata/ │ │ │ │ ├── README.md │ │ │ │ └── elementarycellularautomaton.java │ │ │ ├── genetic_algorithm/ │ │ │ │ ├── genetic.cpp │ │ │ │ ├── genetic_algorithm.go │ │ │ │ ├── genetic_algorithm.java │ │ │ │ ├── genetic_algorithm.js │ │ │ │ ├── genetic_algorithm.py │ │ │ │ └── genetic_algorithm2.py │ │ │ ├── langtons_ant/ │ │ │ │ ├── README.md │ │ │ │ ├── langtons_ant.cpp │ │ │ │ ├── langtons_ant.html │ │ │ │ ├── langtons_ant.java │ │ │ │ └── langtons_ant.py │ │ │ ├── nobili_cellular_automata/ │ │ │ │ └── README.md │ │ │ └── von_neumann_cellular_automata/ │ │ │ ├── README.md │ │ │ └── von_neumann_cellular_automata.c │ │ └── test/ │ │ └── README.md │ ├── compression/ │ │ ├── src/ │ │ │ ├── README.md │ │ │ ├── lossless_compression/ │ │ │ │ ├── README.md │ │ │ │ ├── huffman/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── huffman.cpp │ │ │ │ └── lempel_ziv_welch/ │ │ │ │ ├── README.md │ │ │ │ ├── lzw.cpp │ │ │ │ └── lzw.py │ │ │ └── lossy_compression/ │ │ │ └── README.md │ │ └── test/ │ │ └── lossless_compression/ │ │ └── huffman/ │ │ └── test_huffman.cpp │ ├── computational_geometry/ │ │ ├── src/ │ │ │ ├── 2d_line_intersection/ │ │ │ │ ├── 2d_line_intersection.c │ │ │ │ ├── 2d_line_intersection.cpp │ │ │ │ ├── 2d_line_intersection.cs │ │ │ │ ├── 2d_line_intersection.hs │ │ │ │ ├── 2d_line_intersection.java │ │ │ │ ├── 2d_line_intersection.js │ │ │ │ ├── 2d_line_intersection.py │ │ │ │ ├── 2d_line_intersection.rb │ │ │ │ ├── README.md │ │ │ │ ├── line_determinant_method.cpp │ │ │ │ └── line_elemination_method.cpp │ │ │ ├── 2d_separating_axis_test/ │ │ │ │ └── 2d_separating_axis_test.cpp │ │ │ ├── README.md │ │ │ ├── area_of_polygon/ │ │ │ │ ├── area_of_polygon.c │ │ │ │ ├── area_of_polygon.cpp │ │ │ │ ├── area_of_polygon.java │ │ │ │ └── area_of_polygon.py │ │ │ ├── area_of_triangle/ │ │ │ │ ├── area_of_triangle.c │ │ │ │ ├── area_of_triangle.cpp │ │ │ │ ├── area_of_triangle.go │ │ │ │ ├── area_of_triangle.java │ │ │ │ ├── area_of_triangle.js │ │ │ │ ├── area_of_triangle.py │ │ │ │ ├── area_of_triangle.rs │ │ │ │ └── area_of_triangle_herons_formula.cpp │ │ │ ├── axis_aligned_bounding_box_collision/ │ │ │ │ ├── axis_aligned_bounding_box_collision.cpp │ │ │ │ └── axis_aligned_bounding_box_collision.go │ │ │ ├── bresenham_circle/ │ │ │ │ ├── bresenham_circle.cpp │ │ │ │ └── graphics.h │ │ │ ├── bresenham_line/ │ │ │ │ ├── bresenham_line.cpp │ │ │ │ ├── bresenham_line.java │ │ │ │ ├── bresenham_line.py │ │ │ │ └── bresenham_line2.py │ │ │ ├── chans_algorithm/ │ │ │ │ └── chans_algorithm.cpp │ │ │ ├── cohen_sutherland_lineclip/ │ │ │ │ ├── README.md │ │ │ │ ├── cohen_sutherland_lineclip.c │ │ │ │ └── cohen_sutherland_lineclip.cpp │ │ │ ├── dda_line/ │ │ │ │ └── dda_line.cpp │ │ │ ├── distance_between_points/ │ │ │ │ ├── README.md │ │ │ │ ├── distance_between_points.c │ │ │ │ ├── distance_between_points.cpp │ │ │ │ ├── distance_between_points.go │ │ │ │ ├── distance_between_points.java │ │ │ │ ├── distance_between_points.js │ │ │ │ ├── distance_between_points.py │ │ │ │ └── distance_between_points.rs │ │ │ ├── graham_scan/ │ │ │ │ ├── graham_scan.cpp │ │ │ │ ├── graham_scan.java │ │ │ │ ├── graham_scan.py │ │ │ │ └── graham_scan2.cpp │ │ │ ├── halfplane_intersection/ │ │ │ │ └── halfplane_intersection.cpp │ │ │ ├── jarvis_march/ │ │ │ │ ├── README.md │ │ │ │ ├── jarvis_march.cpp │ │ │ │ ├── jarvis_march.py │ │ │ │ └── jarvis_march2.cpp │ │ │ ├── liang_barsky_algo/ │ │ │ │ ├── liang_barsky_algo.c │ │ │ │ └── liang_barsky_algo.cpp │ │ │ ├── mandelbrot_fractal/ │ │ │ │ └── mandelbrot_fractal.py │ │ │ ├── quick_hull/ │ │ │ │ ├── README.md │ │ │ │ ├── quick_hull.cpp │ │ │ │ ├── quick_hull.hs │ │ │ │ ├── quick_hull.java │ │ │ │ ├── quick_hull2.cpp │ │ │ │ ├── test_data.csv │ │ │ │ └── test_data_soln.txt │ │ │ ├── sphere_tetrahedron_intersection/ │ │ │ │ ├── luvector.hpp │ │ │ │ └── sphere_tetrahedron_intersection.cpp │ │ │ └── sutherland_hodgeman_clipping/ │ │ │ ├── README.md │ │ │ ├── sutherland_hodgeman_clipping.c │ │ │ └── sutherland_hodgeman_clipping.cpp │ │ └── test/ │ │ └── README.md │ ├── computer_graphics/ │ │ └── src/ │ │ ├── README.md │ │ ├── Transformation/ │ │ │ ├── 2D Transformation/ │ │ │ │ ├── README.md │ │ │ │ ├── Scaling/ │ │ │ │ │ └── Scaling.C │ │ │ │ └── Translation/ │ │ │ │ └── Translation.c │ │ │ └── README.md │ │ ├── circle_drawing_algorithm/ │ │ │ ├── bresenham's_circle_drawing_algorithm/ │ │ │ │ └── bresenham's_circle_drawing_algorithm.c │ │ │ └── mid_point_algorithm/ │ │ │ └── mid_point_algorithm.c │ │ ├── diamond_square/ │ │ │ ├── diamond_square.py │ │ │ └── diamondsquare.java │ │ └── line_drawing_alrogrithm/ │ │ ├── Bresenham's Line Drawing Algrorithm/ │ │ │ └── BDA.c │ │ └── dda/ │ │ └── dda.c │ ├── cryptography/ │ │ ├── src/ │ │ │ ├── README.md │ │ │ ├── aes_128/ │ │ │ │ ├── aes_128.cpp │ │ │ │ ├── aes_128.py │ │ │ │ └── aes_csharp/ │ │ │ │ ├── README.md │ │ │ │ ├── aescipher.cs │ │ │ │ ├── aesconsts.cs │ │ │ │ ├── aesdecipher.cs │ │ │ │ ├── aeskeygen.cs │ │ │ │ ├── example/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── streamcipher.cs │ │ │ │ │ └── streamcipherexception.cs │ │ │ │ └── helpers.cs │ │ │ ├── affine_cipher/ │ │ │ │ ├── affine.cpp │ │ │ │ ├── affine.htm │ │ │ │ ├── affine.java │ │ │ │ ├── affine.py │ │ │ │ ├── affine_cipher.py │ │ │ │ └── affinekotlin.kt │ │ │ ├── atbash_cipher/ │ │ │ │ ├── README.md │ │ │ │ ├── atbash_cipher.cpp │ │ │ │ ├── atbash_cipher.java │ │ │ │ └── atbash_cipher.py │ │ │ ├── autokey_cipher/ │ │ │ │ ├── README.md │ │ │ │ ├── autokey.py │ │ │ │ ├── autokey_cipher.c │ │ │ │ ├── autokey_cipher.cpp │ │ │ │ └── autokey_cipher.java │ │ │ ├── baconian_cipher/ │ │ │ │ ├── README.md │ │ │ │ ├── baconian_cipher.c │ │ │ │ ├── baconian_cipher.cpp │ │ │ │ ├── baconian_cipher.exs │ │ │ │ ├── baconian_cipher.java │ │ │ │ ├── baconian_cipher.js │ │ │ │ ├── baconian_cipher.php │ │ │ │ ├── baconian_cipher.py │ │ │ │ └── baconian_cipher.rb │ │ │ ├── caesar_cipher/ │ │ │ │ ├── README.md │ │ │ │ ├── caesar_cipher.c │ │ │ │ ├── caesar_cipher.cpp │ │ │ │ ├── caesar_cipher.cs │ │ │ │ ├── caesar_cipher.go │ │ │ │ ├── caesar_cipher.hs │ │ │ │ ├── caesar_cipher.java │ │ │ │ ├── caesar_cipher.js │ │ │ │ ├── caesar_cipher.php │ │ │ │ ├── caesar_cipher.py │ │ │ │ ├── caesar_cipher.rb │ │ │ │ ├── decryption.cpp │ │ │ │ └── encryption.cpp │ │ │ ├── columnar_transposition_cipher/ │ │ │ │ └── columnar_transposition_cipher.cpp │ │ │ ├── des_cipher/ │ │ │ │ └── des_java/ │ │ │ │ ├── .gitignore │ │ │ │ ├── DES.java │ │ │ │ ├── Main.java │ │ │ │ ├── README.MD │ │ │ │ └── files/ │ │ │ │ ├── cipher.txt │ │ │ │ ├── key.txt │ │ │ │ └── msg.txt │ │ │ ├── elgamal/ │ │ │ │ ├── README.md │ │ │ │ └── elgamal.py │ │ │ ├── hill_cipher/ │ │ │ │ └── hill_cipher.py │ │ │ ├── huffman_encoding/ │ │ │ │ ├── README.md │ │ │ │ ├── huffman.java │ │ │ │ ├── huffman.py │ │ │ │ └── huffman_encoding.c │ │ │ ├── monoalphabetic_cipher/ │ │ │ │ ├── monoalphabetic.py │ │ │ │ └── monoalphabeticCipher.py │ │ │ ├── morse_cipher/ │ │ │ │ ├── README.md │ │ │ │ ├── morse_code.java │ │ │ │ ├── morse_code.sh │ │ │ │ ├── morse_code_generator.bf │ │ │ │ ├── morse_code_generator.c │ │ │ │ ├── morse_code_generator.cpp │ │ │ │ ├── morse_code_generator.rb │ │ │ │ ├── morse_code_translator.cpp │ │ │ │ ├── morse_code_translator.exs │ │ │ │ ├── morse_code_translator.js │ │ │ │ ├── morse_code_translator.lua │ │ │ │ ├── morse_code_translator.php │ │ │ │ ├── morse_code_translator.py │ │ │ │ └── morse_code_translator.ts │ │ │ ├── password_generator/ │ │ │ │ └── strongpasswordgenerator.py │ │ │ ├── playfair_cipher/ │ │ │ │ └── playfair_cipher.c │ │ │ ├── polybius_cipher/ │ │ │ │ └── polybius_cipher.py │ │ │ ├── porta_cipher/ │ │ │ │ └── porta_cipher.py │ │ │ ├── rail_fence_cipher/ │ │ │ │ ├── rail_fence_cipher.cpp │ │ │ │ ├── rail_fence_cipher.py │ │ │ │ └── rail_fence_cipher.rb │ │ │ ├── rot13_cipher/ │ │ │ │ ├── README.md │ │ │ │ ├── rot13_cipher.c │ │ │ │ ├── rot13_cipher.cpp │ │ │ │ ├── rot13_cipher.java │ │ │ │ ├── rot13_cipher.js │ │ │ │ ├── rot13_cipher.py │ │ │ │ ├── rot13_cipher.rb │ │ │ │ ├── rot13_cipher.sh │ │ │ │ ├── rot13_cipher2.cpp │ │ │ │ ├── rot13_cipher2.js │ │ │ │ └── rotn_cipher.exs │ │ │ ├── rsa/ │ │ │ │ ├── rsa.c │ │ │ │ ├── rsa.cs │ │ │ │ ├── rsa.java │ │ │ │ ├── rsa.py │ │ │ │ └── rsa_input.in │ │ │ ├── rsa_digital_signature/ │ │ │ │ └── rsa_digital_signature.ipynb │ │ │ ├── runningkey_cipher/ │ │ │ │ ├── README.md │ │ │ │ └── runningkey_cipher.py │ │ │ ├── sha/ │ │ │ │ └── sha_256/ │ │ │ │ └── sha_256.py │ │ │ ├── simple_des/ │ │ │ │ └── sdes.py │ │ │ ├── vernam_cipher/ │ │ │ │ └── vernam_cipher.py │ │ │ └── vigenere_cipher/ │ │ │ ├── README.md │ │ │ ├── vigenere_cipher.c │ │ │ ├── vigenere_cipher.cpp │ │ │ ├── vigenere_cipher.go │ │ │ ├── vigenere_cipher.hs │ │ │ ├── vigenere_cipher.java │ │ │ ├── vigenere_cipher.jl │ │ │ ├── vigenere_cipher.js │ │ │ ├── vigenere_cipher.php │ │ │ ├── vigenere_cipher.py │ │ │ └── vigenere_cipher.rb │ │ └── test/ │ │ ├── README.md │ │ └── baconian_cipher/ │ │ └── baconian_test.cpp │ ├── data_structures/ │ │ ├── src/ │ │ │ ├── 2d_array/ │ │ │ │ ├── SpiralMatrix.cpp │ │ │ │ ├── rotate2darray.java │ │ │ │ ├── rotate_matrix.cpp │ │ │ │ └── set_matrix_zero.cpp │ │ │ ├── 3d_array/ │ │ │ │ └── ThreeDArray.java │ │ │ ├── CircularLinkedList/ │ │ │ │ ├── circularLinkedList.cpp │ │ │ │ └── src_java/ │ │ │ │ └── circularlinkedlist.java │ │ │ ├── DoubleLinkedList/ │ │ │ │ ├── Doubly linked list.py │ │ │ │ ├── lru_cache_with_dll/ │ │ │ │ │ └── src_go/ │ │ │ │ │ └── main.go │ │ │ │ ├── src_c++/ │ │ │ │ │ └── Doubly_LL.cpp │ │ │ │ ├── src_cpp/ │ │ │ │ │ └── doublylinkedlist.cpp │ │ │ │ └── src_java/ │ │ │ │ ├── DoubleLinkedLists.java │ │ │ │ ├── DoubleLinkedListsMain.java │ │ │ │ └── Node.java │ │ │ ├── Linked_List/ │ │ │ │ ├── Add_one_to_LL.cpp │ │ │ │ ├── Count_nodes_of_Linked_List.cpp │ │ │ │ ├── Intersection_of_two_sorted_lists.cpp │ │ │ │ ├── Remove_duplicates_in_unsorted_linked_list.cpp │ │ │ │ ├── add_two_numbers_represented_by_linked_lists.cpp │ │ │ │ ├── creating_linked_list.cpp │ │ │ │ ├── deleting_a_node.cpp │ │ │ │ ├── inserting_a_node.cpp │ │ │ │ ├── linked_list_palindrome.cpp │ │ │ │ ├── pairwise_swap_on_linked_list.cpp │ │ │ │ ├── remove_duplicate_element_from_sorted_linked_list.cpp │ │ │ │ ├── reverse_linked_list_in_k_groups.cpp │ │ │ │ ├── reversing_linkedlist.cpp │ │ │ │ ├── sort_a_linked_list.cpp │ │ │ │ ├── swap_nodes_in_pairs.cpp │ │ │ │ └── traverse_a_linked_list.cpp │ │ │ ├── README.md │ │ │ ├── bag/ │ │ │ │ ├── bag.cpp │ │ │ │ ├── bag.java │ │ │ │ ├── bag.js │ │ │ │ └── bag.py │ │ │ ├── binary_heap/ │ │ │ │ ├── binary_heap.cpp │ │ │ │ ├── binary_heap.dart │ │ │ │ └── binary_heap.py │ │ │ ├── disjoint_set/ │ │ │ │ ├── DisjointSet(DS).cpp │ │ │ │ ├── DisjointSet_DS.py │ │ │ │ └── README.md │ │ │ ├── graph/ │ │ │ │ └── graph.py │ │ │ ├── hashs/ │ │ │ │ ├── bloom_filter/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── bloom_filter.c │ │ │ │ │ ├── bloom_filter.cpp │ │ │ │ │ ├── bloom_filter.go │ │ │ │ │ ├── bloom_filter.java │ │ │ │ │ ├── bloom_filter.js │ │ │ │ │ ├── bloom_filter.py │ │ │ │ │ ├── bloom_filter.scala │ │ │ │ │ └── bloom_filter.swift │ │ │ │ └── hash_table/ │ │ │ │ ├── README.md │ │ │ │ ├── double_hashing.c │ │ │ │ ├── hash_table.c │ │ │ │ ├── hash_table.cpp │ │ │ │ ├── hash_table.cs │ │ │ │ ├── hash_table.go │ │ │ │ ├── hash_table.java │ │ │ │ ├── hash_table.js │ │ │ │ ├── hash_table.py │ │ │ │ ├── hash_table.rs │ │ │ │ └── hash_table.swift │ │ │ ├── list/ │ │ │ │ ├── Queue_using_Linked_list/ │ │ │ │ │ └── Queue_using_Linked_List.c │ │ │ │ ├── README.md │ │ │ │ ├── circular_linked_list/ │ │ │ │ │ ├── circular_linked_list.c │ │ │ │ │ ├── circular_linked_list.cpp │ │ │ │ │ ├── circular_linked_list.java │ │ │ │ │ ├── circular_linked_list.py │ │ │ │ │ └── operations/ │ │ │ │ │ ├── FloydAlgo_circular_ll.cpp │ │ │ │ │ ├── has_loop.py │ │ │ │ │ ├── is_circular.py │ │ │ │ │ └── is_circular_linked_list.cpp │ │ │ │ ├── doubly_linked_list/ │ │ │ │ │ ├── c/ │ │ │ │ │ │ ├── doubly_linked_list.c │ │ │ │ │ │ └── doubly_linked_list.h │ │ │ │ │ ├── doubly_linked_list.cpp │ │ │ │ │ ├── doubly_linked_list.go │ │ │ │ │ ├── doubly_linked_list.java │ │ │ │ │ ├── doubly_linked_list.js │ │ │ │ │ ├── doubly_linked_list.py │ │ │ │ │ ├── doubly_linked_list.swift │ │ │ │ │ └── menu_interface/ │ │ │ │ │ ├── dlink.h │ │ │ │ │ └── doubly_link.c │ │ │ │ ├── merge_two_sorted_lists/ │ │ │ │ │ └── Merging_two_sorted.cpp │ │ │ │ ├── singly_linked_list/ │ │ │ │ │ ├── menu_interface/ │ │ │ │ │ │ ├── link.h │ │ │ │ │ │ └── singly_list.c │ │ │ │ │ ├── operations/ │ │ │ │ │ │ ├── delete/ │ │ │ │ │ │ │ ├── delete_node_with_key.java │ │ │ │ │ │ │ ├── delete_node_without_head_linked_list.cpp │ │ │ │ │ │ │ └── delete_nth_node.c │ │ │ │ │ │ ├── detect_cycle/ │ │ │ │ │ │ │ ├── detect_cycle.cpp │ │ │ │ │ │ │ └── detect_cycle_hashmap.py │ │ │ │ │ │ ├── find/ │ │ │ │ │ │ │ ├── find.c │ │ │ │ │ │ │ ├── find.java │ │ │ │ │ │ │ └── find.py │ │ │ │ │ │ ├── insertion/ │ │ │ │ │ │ │ ├── insertion_at_end.py │ │ │ │ │ │ │ ├── insertion_at_front.py │ │ │ │ │ │ │ └── insertion_at_nth_node.py │ │ │ │ │ │ ├── merge_sorted/ │ │ │ │ │ │ │ └── merge_sorted.cpp │ │ │ │ │ │ ├── nth_node_linked_list/ │ │ │ │ │ │ │ ├── nth_node_linked_list.c │ │ │ │ │ │ │ └── nth_node_linked_list.cpp │ │ │ │ │ │ ├── print_reverse/ │ │ │ │ │ │ │ ├── print_reverse.py │ │ │ │ │ │ │ └── print_reverse.scala │ │ │ │ │ │ ├── push/ │ │ │ │ │ │ │ └── push.cpp │ │ │ │ │ │ ├── reverse/ │ │ │ │ │ │ │ ├── reverse.c │ │ │ │ │ │ │ ├── reverse.cpp │ │ │ │ │ │ │ ├── reverse_iteration.cpp │ │ │ │ │ │ │ ├── reverse_recursion.cpp │ │ │ │ │ │ │ └── reverse_recursion2.cpp │ │ │ │ │ │ ├── rotate/ │ │ │ │ │ │ │ └── rotate.cpp │ │ │ │ │ │ ├── rotate_a_linked_list_by_k_nodes/ │ │ │ │ │ │ │ └── rotate_a_linked_list_by_k_nodes.cpp │ │ │ │ │ │ ├── sort/ │ │ │ │ │ │ │ └── bubble_sort.cpp │ │ │ │ │ │ └── unclassified/ │ │ │ │ │ │ ├── linked_list.java │ │ │ │ │ │ ├── linked_list_example.java │ │ │ │ │ │ ├── linked_list_operations.cpp │ │ │ │ │ │ ├── union_intersection_in_list.c │ │ │ │ │ │ └── union_intersection_in_list.textclipping │ │ │ │ │ ├── singly_linked_list.c │ │ │ │ │ ├── singly_linked_list.cpp │ │ │ │ │ ├── singly_linked_list.cs │ │ │ │ │ ├── singly_linked_list.go │ │ │ │ │ ├── singly_linked_list.h │ │ │ │ │ ├── singly_linked_list.java │ │ │ │ │ ├── singly_linked_list.js │ │ │ │ │ ├── singly_linked_list.py │ │ │ │ │ ├── singly_linked_list.rb │ │ │ │ │ ├── singly_linked_list.swift │ │ │ │ │ ├── singly_linked_list_menu_driven.c │ │ │ │ │ ├── singly_linked_list_with_3_nodes.java │ │ │ │ │ └── singly_linked_list_with_classes.cpp │ │ │ │ ├── skip_list/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── skip_list.c │ │ │ │ │ ├── skip_list.cpp │ │ │ │ │ ├── skip_list.java │ │ │ │ │ ├── skip_list.rb │ │ │ │ │ ├── skip_list.scala │ │ │ │ │ └── skip_list.swift │ │ │ │ ├── stack_using_linked_list/ │ │ │ │ │ └── stack_using_linked_list.c │ │ │ │ └── xor_linked_list/ │ │ │ │ ├── README.md │ │ │ │ └── xor_linked_list.cpp │ │ │ ├── maxHeap/ │ │ │ │ ├── maxHeap.cpp │ │ │ │ ├── maxHeap.h │ │ │ │ ├── maxHeap.java │ │ │ │ └── maxheap.py │ │ │ ├── maxSubArray(KadaneAlgorithm)/ │ │ │ │ ├── KadaneAlgorithm.cpp │ │ │ │ ├── KadaneAlgorithm.java │ │ │ │ └── Kadane_algorithm.py │ │ │ ├── minHeap/ │ │ │ │ └── minHeap.py │ │ │ ├── minqueue/ │ │ │ │ └── minqueue.cpp │ │ │ ├── other/ │ │ │ │ ├── README.md │ │ │ │ └── ways_to_swap.cpp │ │ │ ├── prefix_sum_array/ │ │ │ │ ├── prefix_sum_array.py │ │ │ │ └── prefix_sum_subarray.cpp │ │ │ ├── queue/ │ │ │ │ ├── README.md │ │ │ │ ├── circular_buffer/ │ │ │ │ │ ├── circular_buffer.cpp │ │ │ │ │ └── circular_buffer.py │ │ │ │ ├── double_ended_queue/ │ │ │ │ │ ├── deque_library_function.cpp │ │ │ │ │ ├── double_ended_queue.c │ │ │ │ │ ├── double_ended_queue.cpp │ │ │ │ │ └── double_ended_queue.py │ │ │ │ ├── queue/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── queue.c │ │ │ │ │ ├── queue.cpp │ │ │ │ │ ├── queue.cs │ │ │ │ │ ├── queue.exs │ │ │ │ │ ├── queue.go │ │ │ │ │ ├── queue.java │ │ │ │ │ ├── queue.js │ │ │ │ │ ├── queue.py │ │ │ │ │ ├── queue.rb │ │ │ │ │ ├── queue.swift │ │ │ │ │ └── queue_vector.cpp │ │ │ │ ├── queue_stream/ │ │ │ │ │ └── queue_stream.cs │ │ │ │ ├── queue_using_linked_list/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── queue_using_linked_list.c │ │ │ │ │ ├── queue_using_linked_list.cpp │ │ │ │ │ ├── queue_using_linked_list.java │ │ │ │ │ ├── queue_using_linked_list.py │ │ │ │ │ └── queue_using_linked_list.rb │ │ │ │ ├── queue_using_stack/ │ │ │ │ │ ├── queue_using_stack.c │ │ │ │ │ ├── queue_using_stack.cpp │ │ │ │ │ ├── queue_using_stack.java │ │ │ │ │ ├── queue_using_stack.py │ │ │ │ │ └── queue_using_stack.sh │ │ │ │ └── reverse_queue/ │ │ │ │ ├── reverse_queue.cpp │ │ │ │ ├── reverse_queue.go │ │ │ │ ├── reverse_queue.java │ │ │ │ ├── reverse_queue.py │ │ │ │ └── reverse_queue.swift │ │ │ ├── sparse_table/ │ │ │ │ └── sparse_table.cpp │ │ │ ├── stack/ │ │ │ │ ├── Quick_sort_usingSack/ │ │ │ │ │ └── quick_sort.cpp │ │ │ │ ├── README.md │ │ │ │ ├── abstract_stack/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── cpp/ │ │ │ │ │ │ ├── array_stack/ │ │ │ │ │ │ │ ├── array_stack.cpp │ │ │ │ │ │ │ └── array_stack.h │ │ │ │ │ │ ├── array_stack.java │ │ │ │ │ │ └── is_stack.h │ │ │ │ │ └── is_stack.h │ │ │ │ ├── balanced_expression/ │ │ │ │ │ ├── balanced_expression.c │ │ │ │ │ ├── balanced_expression.cpp │ │ │ │ │ ├── balanced_expression.java │ │ │ │ │ └── balanced_expression.py │ │ │ │ ├── infix_to_postfix/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── infix_to_postfix.c │ │ │ │ │ ├── infix_to_postfix.cpp │ │ │ │ │ ├── infix_to_postfix.java │ │ │ │ │ ├── infix_to_postfix.py │ │ │ │ │ └── infix_to_postfix2.cpp │ │ │ │ ├── infix_to_prefix/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── infix_to_prefix.cpp │ │ │ │ │ └── infix_to_prefix.java │ │ │ │ ├── postfix_evaluation/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── postfix_evaluation.c │ │ │ │ │ ├── postfix_evaluation.cpp │ │ │ │ │ ├── postfix_evaluation.java │ │ │ │ │ ├── postfix_evaluation.py │ │ │ │ │ └── postfix_evaluation.sh │ │ │ │ ├── postfix_to_prefix/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── postfix_to_prefix.cpp │ │ │ │ ├── prefix_to_postfix/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── prefix_to_postfix.py │ │ │ │ ├── reverse_array_using_stack/ │ │ │ │ │ └── reverse_array_using_stack.cpp │ │ │ │ ├── reverse_stack/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── reverse_stack.c │ │ │ │ │ ├── reverse_stack.cs │ │ │ │ │ ├── reverse_stack.go │ │ │ │ │ ├── reverse_stack.java │ │ │ │ │ ├── reverse_stack.py │ │ │ │ │ ├── reverse_stack.swift │ │ │ │ │ └── reverse_stack_without_extra_space.cpp │ │ │ │ ├── sort_stack/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── sort_stack.c │ │ │ │ │ ├── sort_stack.cpp │ │ │ │ │ └── sort_stack.py │ │ │ │ ├── stack/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── stack.c │ │ │ │ │ ├── stack.cpp │ │ │ │ │ ├── stack.cs │ │ │ │ │ ├── stack.erl │ │ │ │ │ ├── stack.ex │ │ │ │ │ ├── stack.go │ │ │ │ │ ├── stack.java │ │ │ │ │ ├── stack.js │ │ │ │ │ ├── stack.php │ │ │ │ │ ├── stack.py │ │ │ │ │ ├── stack.rb │ │ │ │ │ ├── stack.rs │ │ │ │ │ ├── stack.swift │ │ │ │ │ ├── stack_in_dart.dart │ │ │ │ │ ├── stack_using_array.py │ │ │ │ │ └── stack_using_linked_list.py │ │ │ │ └── stack_using_queue/ │ │ │ │ ├── stack_using_queue.cpp │ │ │ │ └── stack_using_queue.py │ │ │ └── tree/ │ │ │ ├── b_tree/ │ │ │ │ ├── b_tree/ │ │ │ │ │ ├── b_tree.cpp │ │ │ │ │ ├── b_tree.py │ │ │ │ │ ├── b_tree.swift │ │ │ │ │ └── b_tree_c/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── btree.c │ │ │ │ │ ├── btree.h │ │ │ │ │ └── main.c │ │ │ │ └── two_three_tree/ │ │ │ │ └── twothreetree.scala │ │ │ ├── binary_tree/ │ │ │ │ ├── aa_tree/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── aa_tree.cpp │ │ │ │ ├── avl_tree/ │ │ │ │ │ ├── avl_tree.c │ │ │ │ │ ├── avl_tree.cpp │ │ │ │ │ ├── avl_tree.java │ │ │ │ │ ├── avl_tree.py.py │ │ │ │ │ └── avl_tree.swift │ │ │ │ ├── binary_search_tree/ │ │ │ │ │ ├── BST_Operations.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── binary_tree/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── Subtree_sum/ │ │ │ │ │ │ └── subtreesum_recursive.cpp │ │ │ │ │ ├── balance_binary_tree/ │ │ │ │ │ │ ├── BST.py │ │ │ │ │ │ └── balance_bst_dsw.cpp │ │ │ │ │ ├── convert_to_doubly_linked_list/ │ │ │ │ │ │ └── convert_to_doubly_linked_list.cpp │ │ │ │ │ ├── count_universal_subtree/ │ │ │ │ │ │ └── count_universal_subtrees.cpp │ │ │ │ │ ├── diameter/ │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── diameter.c │ │ │ │ │ │ ├── diameter.cpp │ │ │ │ │ │ ├── diameter.hs │ │ │ │ │ │ ├── diameter.java │ │ │ │ │ │ ├── diameter.py │ │ │ │ │ │ ├── diameter2.c │ │ │ │ │ │ └── diameter2.cpp │ │ │ │ │ ├── is_balance/ │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ └── is_balance.java │ │ │ │ │ ├── is_binary_tree/ │ │ │ │ │ │ └── is_binary_tree.cpp │ │ │ │ │ ├── is_same/ │ │ │ │ │ │ └── is_same.cpp │ │ │ │ │ ├── make_binary_tree/ │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── from_inorder_and_postorder/ │ │ │ │ │ │ │ ├── make_tree_from_inorder_and_postorder.c │ │ │ │ │ │ │ └── make_tree_from_inorder_and_postorder.cpp │ │ │ │ │ │ └── from_inorder_and_preorder/ │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── make_tree_from_inorder_and_preorder.c │ │ │ │ │ │ ├── make_tree_from_inorder_and_preorder.cpp │ │ │ │ │ │ └── make_tree_from_inorder_and_preorder.java │ │ │ │ │ ├── make_mirror_tree/ │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── make_mirror_tree.c │ │ │ │ │ │ ├── make_mirror_tree.cpp │ │ │ │ │ │ └── make_mirror_tree.py │ │ │ │ │ ├── maximum_height/ │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── maximum_height.cpp │ │ │ │ │ │ ├── maximum_height.java │ │ │ │ │ │ ├── maximum_height.py │ │ │ │ │ │ └── maximum_height2.cpp │ │ │ │ │ ├── minimum_height/ │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── minimum_height.c │ │ │ │ │ │ ├── minimum_height.cpp │ │ │ │ │ │ ├── minimum_height.java │ │ │ │ │ │ └── minimum_height.py │ │ │ │ │ ├── node/ │ │ │ │ │ │ └── node.cpp │ │ │ │ │ ├── path_sum/ │ │ │ │ │ │ ├── path_sum.cpp │ │ │ │ │ │ ├── path_sum.hpp │ │ │ │ │ │ └── sum_left/ │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── left_sum.py │ │ │ │ │ │ └── sum_left.c │ │ │ │ │ ├── serializer/ │ │ │ │ │ │ └── serializer.cpp │ │ │ │ │ ├── traversal/ │ │ │ │ │ │ ├── inorder/ │ │ │ │ │ │ │ └── right_threaded/ │ │ │ │ │ │ │ └── right_threaded.cpp │ │ │ │ │ │ ├── preorder/ │ │ │ │ │ │ │ ├── left_view/ │ │ │ │ │ │ │ │ └── left_view.java │ │ │ │ │ │ │ └── right_view/ │ │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ │ ├── right_view.cpp │ │ │ │ │ │ │ ├── right_view.py │ │ │ │ │ │ │ └── right_view2.cpp │ │ │ │ │ │ └── zigzag/ │ │ │ │ │ │ └── zigzag.cpp │ │ │ │ │ └── tree/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── bottom_view_binary_tree/ │ │ │ │ │ │ ├── bottom_view_tree.cpp │ │ │ │ │ │ └── bottom_view_tree.java │ │ │ │ │ ├── tree.c │ │ │ │ │ ├── tree.cpp │ │ │ │ │ ├── tree.go │ │ │ │ │ ├── tree.java │ │ │ │ │ ├── tree.js │ │ │ │ │ ├── tree.py │ │ │ │ │ ├── tree.rb │ │ │ │ │ ├── tree.swift │ │ │ │ │ ├── tree2.java │ │ │ │ │ └── tree2.swift │ │ │ │ ├── inorder_threaded_binary_search_tree/ │ │ │ │ │ └── TBT_all_operations.c │ │ │ │ ├── rope/ │ │ │ │ │ └── rope.py │ │ │ │ └── treap/ │ │ │ │ ├── persistent_treap.kt │ │ │ │ ├── treap.cpp │ │ │ │ ├── treap.java │ │ │ │ ├── treap.scala │ │ │ │ └── treap.swift │ │ │ ├── heap/ │ │ │ │ ├── README.md │ │ │ │ ├── binomial_heap/ │ │ │ │ │ ├── binomial_heap.c │ │ │ │ │ ├── binomial_heap.cpp │ │ │ │ │ └── binomial_heap.scala │ │ │ │ ├── max_heap/ │ │ │ │ │ ├── max_heap.c │ │ │ │ │ ├── max_heap.cpp │ │ │ │ │ ├── max_heap.go │ │ │ │ │ ├── max_heap.java │ │ │ │ │ └── max_heap.py │ │ │ │ ├── min_heap/ │ │ │ │ │ ├── min_heap.c │ │ │ │ │ ├── min_heap.cpp │ │ │ │ │ ├── min_heap.java │ │ │ │ │ ├── min_heap.js │ │ │ │ │ ├── min_heap.py │ │ │ │ │ ├── min_heap.rb │ │ │ │ │ └── min_heap.swift │ │ │ │ ├── pairing_heap/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── pairing_heap.fs │ │ │ │ │ └── pairing_heap.sml │ │ │ │ ├── priority_queue/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── leftist_tree/ │ │ │ │ │ │ └── leftist_priority_queue.cpp │ │ │ │ │ ├── priority_queue.js │ │ │ │ │ └── priority_queue.py │ │ │ │ └── soft_heap/ │ │ │ │ └── soft_heap.cpp │ │ │ ├── multiway_tree/ │ │ │ │ ├── fenwick_tree/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── fenwick_tree.c │ │ │ │ │ ├── fenwick_tree.cpp │ │ │ │ │ ├── fenwick_tree.go │ │ │ │ │ ├── fenwick_tree.java │ │ │ │ │ ├── fenwick_tree.pl │ │ │ │ │ ├── fenwick_tree.py │ │ │ │ │ └── fenwick_tree_inversion_count.cpp │ │ │ │ ├── red_black_tree/ │ │ │ │ │ ├── red_black_tree.c │ │ │ │ │ ├── red_black_tree.cpp │ │ │ │ │ ├── red_black_tree.h │ │ │ │ │ ├── red_black_tree.java │ │ │ │ │ ├── red_black_tree.rb │ │ │ │ │ ├── red_black_tree.scala │ │ │ │ │ └── red_black_tree.test.cpp │ │ │ │ ├── splay_tree/ │ │ │ │ │ ├── readme.md │ │ │ │ │ ├── splay_tree.cpp │ │ │ │ │ ├── splay_tree.go │ │ │ │ │ ├── splay_tree.java │ │ │ │ │ ├── splay_tree.kt │ │ │ │ │ └── splay_tree.scala │ │ │ │ ├── union_find/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── union_find.c │ │ │ │ │ ├── union_find.cpp │ │ │ │ │ ├── union_find.go │ │ │ │ │ ├── union_find.java │ │ │ │ │ ├── union_find.js │ │ │ │ │ ├── union_find.py │ │ │ │ │ ├── union_find.scala │ │ │ │ │ └── union_find_dynamic.cpp │ │ │ │ └── van_emde_boas_tree/ │ │ │ │ └── van_emde_boas.cpp │ │ │ ├── segment_tree/ │ │ │ │ ├── LazySegmentTree.cpp │ │ │ │ ├── generic_segment_tree.cpp │ │ │ │ ├── segment_tree.c │ │ │ │ ├── segment_tree.java │ │ │ │ ├── segment_tree_optimized.cpp │ │ │ │ └── segment_tree_rmq.adb │ │ │ ├── space_partitioning_tree/ │ │ │ │ ├── interval_tree/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── interval_tree.cpp │ │ │ │ │ └── interval_tree.java │ │ │ │ ├── kd_tree/ │ │ │ │ │ ├── kd_tree.cpp │ │ │ │ │ └── kd_tree.java │ │ │ │ ├── oc_tree/ │ │ │ │ │ └── oc_tree.py │ │ │ │ ├── quad_tree/ │ │ │ │ │ ├── Python_Implementation_Visualization/ │ │ │ │ │ │ ├── QuadTree.py │ │ │ │ │ │ └── Visualizer.py │ │ │ │ │ └── quad_tree.swift │ │ │ │ └── segment_tree/ │ │ │ │ ├── README.md │ │ │ │ ├── lazy_segment_tree.java │ │ │ │ ├── persistent_segment_tree_sum.cpp │ │ │ │ ├── segment_tree.java │ │ │ │ ├── segment_tree.scala │ │ │ │ ├── segment_tree_kth_statistics_on_segment.cpp │ │ │ │ ├── segment_tree_lazy_propagation.cpp │ │ │ │ ├── segment_tree_rmq.adb │ │ │ │ ├── segment_tree_rmq.cpp │ │ │ │ ├── segment_tree_rmq.go │ │ │ │ ├── segment_tree_rmq.py │ │ │ │ ├── segment_tree_rmq_with_update.cpp │ │ │ │ ├── segment_tree_sum.cpp │ │ │ │ ├── segment_tree_sum.go │ │ │ │ ├── segment_tree_sum.py │ │ │ │ └── segment_tree_sum.rb │ │ │ ├── tree/ │ │ │ │ ├── suffix_array/ │ │ │ │ │ └── suffix_array.cpp │ │ │ │ └── trie/ │ │ │ │ ├── README.md │ │ │ │ ├── trie.c │ │ │ │ ├── trie.cpp │ │ │ │ ├── trie.cs │ │ │ │ ├── trie.go │ │ │ │ ├── trie.java │ │ │ │ ├── trie.js │ │ │ │ ├── trie.py │ │ │ │ ├── trie.rb │ │ │ │ ├── trie.scala │ │ │ │ └── trie.swift │ │ │ └── van_emde_boas_tree/ │ │ │ └── van_emde_boas_tree.cpp │ │ └── test/ │ │ ├── README.md │ │ ├── bag/ │ │ │ └── test_bag.cpp │ │ ├── list/ │ │ │ └── test_list.cpp │ │ └── tree/ │ │ ├── binary_tree/ │ │ │ └── binary_tree/ │ │ │ ├── diameter/ │ │ │ │ └── test_diameter.cpp │ │ │ ├── is_same/ │ │ │ │ └── test_is_same.cpp │ │ │ └── path_sum/ │ │ │ ├── test_path_sum_for_sum_of_part_paths.cpp │ │ │ ├── test_path_sum_for_sum_of_whole_paths.cpp │ │ │ └── test_path_sum_for_whole_paths.cpp │ │ ├── multiway_tree/ │ │ │ ├── red_black_tree/ │ │ │ │ └── test_red_black.c │ │ │ └── union_find/ │ │ │ └── test_union_find.cpp │ │ └── segment_tree/ │ │ └── test_generic_segment_tree.cpp │ ├── design_pattern/ │ │ ├── src/ │ │ │ ├── OOP_patterns/ │ │ │ │ ├── README.md │ │ │ │ ├── __init__.py │ │ │ │ ├── adapter/ │ │ │ │ │ ├── adaptor.java │ │ │ │ │ ├── civilian.java │ │ │ │ │ ├── movement.java │ │ │ │ │ └── soldiers/ │ │ │ │ │ ├── adaptee.java │ │ │ │ │ ├── general.java │ │ │ │ │ ├── order.java │ │ │ │ │ └── soldier.java │ │ │ │ ├── builder/ │ │ │ │ │ ├── builder/ │ │ │ │ │ │ ├── nationality.java │ │ │ │ │ │ ├── person.java │ │ │ │ │ │ └── personbuilder.java │ │ │ │ │ └── main.java │ │ │ │ ├── decorator/ │ │ │ │ │ └── decorator.ts │ │ │ │ ├── facade/ │ │ │ │ │ ├── daily/ │ │ │ │ │ │ └── tasks/ │ │ │ │ │ │ ├── dailyroutinefacade.java │ │ │ │ │ │ ├── evening/ │ │ │ │ │ │ │ └── routine/ │ │ │ │ │ │ │ ├── eat.java │ │ │ │ │ │ │ ├── eveningroutinefacade.java │ │ │ │ │ │ │ ├── takeashower.java │ │ │ │ │ │ │ ├── watchyoutubevideos.java │ │ │ │ │ │ │ └── writecode.java │ │ │ │ │ │ ├── gym/ │ │ │ │ │ │ │ ├── benchpress.java │ │ │ │ │ │ │ ├── deadlift.java │ │ │ │ │ │ │ ├── gymfacade.java │ │ │ │ │ │ │ └── squat.java │ │ │ │ │ │ ├── job/ │ │ │ │ │ │ │ ├── develop.java │ │ │ │ │ │ │ ├── eatatwork.java │ │ │ │ │ │ │ ├── jobfacade.java │ │ │ │ │ │ │ ├── leave.java │ │ │ │ │ │ │ ├── playfifa.java │ │ │ │ │ │ │ └── watchyoutubevideos.java │ │ │ │ │ │ └── morning/ │ │ │ │ │ │ └── routine/ │ │ │ │ │ │ ├── dress.java │ │ │ │ │ │ ├── eat.java │ │ │ │ │ │ ├── leave.java │ │ │ │ │ │ ├── morningroutinefacade.java │ │ │ │ │ │ └── wakeup.java │ │ │ │ │ ├── facade │ │ │ │ │ └── main.java │ │ │ │ ├── factory/ │ │ │ │ │ ├── gifts/ │ │ │ │ │ │ ├── booze.java │ │ │ │ │ │ ├── car.java │ │ │ │ │ │ ├── gift.java │ │ │ │ │ │ ├── nothing.java │ │ │ │ │ │ └── toy.java │ │ │ │ │ ├── gifttype.java │ │ │ │ │ └── roulette.java │ │ │ │ ├── observer_java/ │ │ │ │ │ ├── demo.java │ │ │ │ │ ├── main.java │ │ │ │ │ └── observer/ │ │ │ │ │ ├── network/ │ │ │ │ │ │ ├── artist.java │ │ │ │ │ │ └── fan.java │ │ │ │ │ ├── observer.java │ │ │ │ │ └── subject.java │ │ │ │ ├── observer_pattern/ │ │ │ │ │ ├── __init__.py │ │ │ │ │ ├── observer_pattern.cpp │ │ │ │ │ ├── observer_pattern.py │ │ │ │ │ └── observer_pattern.rs │ │ │ │ ├── proxy/ │ │ │ │ │ ├── demo/ │ │ │ │ │ │ └── demo.java │ │ │ │ │ ├── main.java │ │ │ │ │ ├── protection/ │ │ │ │ │ │ └── proxy/ │ │ │ │ │ │ ├── registeredusers.java │ │ │ │ │ │ ├── user.java │ │ │ │ │ │ ├── userproxy.java │ │ │ │ │ │ └── validuser.java │ │ │ │ │ └── virtual/ │ │ │ │ │ └── proxy/ │ │ │ │ │ ├── demo.java │ │ │ │ │ ├── ultrahdvideo.java │ │ │ │ │ ├── video.java │ │ │ │ │ └── videoproxy.java │ │ │ │ └── singleton_pattern/ │ │ │ │ ├── singleton_pattern.cpp │ │ │ │ ├── singleton_pattern.java │ │ │ │ ├── singleton_pattern.php │ │ │ │ └── singleton_pattern.py │ │ │ ├── __init__.py │ │ │ ├── builder_pattern/ │ │ │ │ └── builder.cs │ │ │ ├── functional_patterns/ │ │ │ │ ├── README.md │ │ │ │ └── functional_patterns/ │ │ │ │ └── scala/ │ │ │ │ ├── build.sbt │ │ │ │ ├── project/ │ │ │ │ │ └── build.properties │ │ │ │ └── src/ │ │ │ │ └── main/ │ │ │ │ └── scala/ │ │ │ │ ├── arrows/ │ │ │ │ │ └── arrow/ │ │ │ │ │ └── arrow.scala │ │ │ │ ├── functors/ │ │ │ │ │ ├── applicative/ │ │ │ │ │ │ └── functor/ │ │ │ │ │ │ └── applicativefunctor.scala │ │ │ │ │ ├── bifunctor/ │ │ │ │ │ │ └── bifunctor.scala │ │ │ │ │ ├── contravariant/ │ │ │ │ │ │ └── contravariant.scala │ │ │ │ │ ├── functor/ │ │ │ │ │ │ └── functor.scala │ │ │ │ │ ├── multifunctor/ │ │ │ │ │ │ └── multifunctor.scala │ │ │ │ │ └── profunctor/ │ │ │ │ │ └── profunctor.scala │ │ │ │ ├── main.scala │ │ │ │ └── monads/ │ │ │ │ ├── comonad/ │ │ │ │ │ └── comonad.scala │ │ │ │ ├── costate/ │ │ │ │ │ └── monad/ │ │ │ │ │ └── costatemonad.scala │ │ │ │ ├── free/ │ │ │ │ │ └── monad/ │ │ │ │ │ └── freemonad.scala │ │ │ │ ├── gonad/ │ │ │ │ │ └── gonad.scala │ │ │ │ ├── io/ │ │ │ │ │ └── monad/ │ │ │ │ │ └── iomonad.scala │ │ │ │ ├── monad/ │ │ │ │ │ └── monad.scala │ │ │ │ └── state/ │ │ │ │ └── monad/ │ │ │ │ └── statemonad.scala │ │ │ ├── iterator_pattern/ │ │ │ │ ├── class.java │ │ │ │ ├── classiterator.java │ │ │ │ ├── iterator.java │ │ │ │ ├── main.java │ │ │ │ └── student.java │ │ │ ├── policy_based_design/ │ │ │ │ ├── policy_design.cpp │ │ │ │ └── readme.md │ │ │ └── singleton_pattern/ │ │ │ ├── singleton_pattern.cs │ │ │ └── singleton_pattern.js │ │ └── test/ │ │ ├── README.md │ │ ├── __init__.py │ │ └── test_observer.py │ ├── divide_conquer/ │ │ ├── src/ │ │ │ ├── README.md │ │ │ ├── closest_pair_of_points/ │ │ │ │ ├── closest_pair.cpp │ │ │ │ └── closest_pair.py │ │ │ ├── factorial/ │ │ │ │ ├── factorial.cpp │ │ │ │ └── factorial.py │ │ │ ├── inversion_count/ │ │ │ │ ├── README.md │ │ │ │ ├── count_inversions.c │ │ │ │ ├── inversion_count.cpp │ │ │ │ ├── inversion_count.java │ │ │ │ ├── inversion_count.js │ │ │ │ └── inversion_count.py │ │ │ ├── karatsuba_multiplication/ │ │ │ │ ├── karatsuba_multiplication.py │ │ │ │ ├── karatsubamultiply.cpp │ │ │ │ └── multiply.java │ │ │ ├── maximum_contiguous_subsequence_sum/ │ │ │ │ └── maximum_contiguous_subsequence_sum.c │ │ │ ├── merge_sort_using_divide_and_conquer/ │ │ │ │ ├── README.md │ │ │ │ ├── inversions.c │ │ │ │ ├── merge_sort_using_divide_and_conquer.cpp │ │ │ │ └── merge_sort_using_divide_and_conquer.java │ │ │ ├── power_of_a_number/ │ │ │ │ ├── power_of_a_number.cpp │ │ │ │ └── power_of_a_number.py │ │ │ ├── quick_hull/ │ │ │ │ └── quick_hull.cpp │ │ │ ├── quick_sort/ │ │ │ │ ├── Quick_Sort.cs │ │ │ │ ├── README.md │ │ │ │ ├── quick_sort.c │ │ │ │ ├── quick_sort.cpp │ │ │ │ ├── quick_sort.hs │ │ │ │ ├── quick_sort.py │ │ │ │ ├── quick_sort.rs │ │ │ │ ├── quick_sort.swift │ │ │ │ ├── quick_sort2.cpp │ │ │ │ └── quicksort.java │ │ │ ├── search_in_a_rotated_array/ │ │ │ │ └── search_in_a_rotated_array.cpp │ │ │ ├── strassen_matrix_multiplication/ │ │ │ │ ├── main.cpp │ │ │ │ └── strassen.py │ │ │ ├── tournament_method_to_find_min_max/ │ │ │ │ └── tournament_method_to_find_min_max.c │ │ │ ├── warnock_algorithm/ │ │ │ │ └── warnock_algorithm.pde │ │ │ └── x_power_y/ │ │ │ └── x_power_y.c │ │ └── test/ │ │ └── README.md │ ├── dynamic_programming/ │ │ ├── src/ │ │ │ ├── Climbing Stairs/ │ │ │ │ └── solution.cpp │ │ │ ├── Count_Subsequence_Having_Product_Less_Than_K/ │ │ │ │ └── Solution.cpp │ │ │ ├── README.md │ │ │ ├── array_median/ │ │ │ │ ├── array_median.c │ │ │ │ ├── array_median.cpp │ │ │ │ ├── array_median.exs │ │ │ │ ├── array_median.java │ │ │ │ ├── array_median.php │ │ │ │ ├── array_median.py │ │ │ │ ├── array_median.rb │ │ │ │ └── array_median.rs │ │ │ ├── assembly_line_scheduling/ │ │ │ │ └── assembly_line_scheduling.cpp │ │ │ ├── best_time_to_sell_stock_II/ │ │ │ │ └── best_time_to_sell_stock_II.cpp │ │ │ ├── binomial_coefficient/ │ │ │ │ ├── README.md │ │ │ │ ├── binomial_coefficient.c │ │ │ │ ├── binomial_coefficient.cpp │ │ │ │ ├── binomial_coefficient.ex │ │ │ │ ├── binomial_coefficient.java │ │ │ │ ├── binomial_coefficient.js │ │ │ │ └── binomial_coefficient.py │ │ │ ├── bitmask_dp/ │ │ │ │ ├── README.md │ │ │ │ └── bitmask_dp_prob#1.cpp │ │ │ ├── boolean_parenthesization/ │ │ │ │ ├── README.md │ │ │ │ ├── boolean_parenthesization.c │ │ │ │ ├── boolean_parenthesization.cpp │ │ │ │ ├── boolean_parenthesization.java │ │ │ │ ├── boolean_parenthesization.py │ │ │ │ └── boolean_parenthesization.swift │ │ │ ├── box_stacking/ │ │ │ │ ├── README.md │ │ │ │ ├── box_stacking.cpp │ │ │ │ ├── box_stacking.java │ │ │ │ └── box_stacking.py │ │ │ ├── catalan/ │ │ │ │ └── catalan_number.go │ │ │ ├── coin_change/ │ │ │ │ ├── README.md │ │ │ │ ├── coin_change.java │ │ │ │ ├── coin_change.py │ │ │ │ ├── coinchange.c │ │ │ │ ├── coinchange.cpp │ │ │ │ ├── coinchange.go │ │ │ │ └── mincoinchange.cpp │ │ │ ├── die_simulation/ │ │ │ │ ├── README.md │ │ │ │ └── die_simulation.cpp │ │ │ ├── digit_dp/ │ │ │ │ ├── DigitDP.java │ │ │ │ └── digit_dp.cpp │ │ │ ├── edit_distance/ │ │ │ │ ├── README.md │ │ │ │ ├── edit_distance.c │ │ │ │ ├── edit_distance.cpp │ │ │ │ ├── edit_distance.go │ │ │ │ ├── edit_distance.hs │ │ │ │ ├── edit_distance.java │ │ │ │ ├── edit_distance.php │ │ │ │ ├── edit_distance.py │ │ │ │ ├── edit_distance.rs │ │ │ │ ├── edit_distance_backtracking.cpp │ │ │ │ └── edit_distance_hirschberg.cpp │ │ │ ├── egg_dropping_puzzle/ │ │ │ │ ├── README.md │ │ │ │ ├── egg_dropping_puzzle.c │ │ │ │ ├── egg_dropping_puzzle.cpp │ │ │ │ ├── egg_dropping_puzzle.cs │ │ │ │ ├── egg_dropping_puzzle.hs │ │ │ │ ├── egg_dropping_puzzle.py │ │ │ │ └── eggdroppingpuzzle.java │ │ │ ├── factorial/ │ │ │ │ ├── factorial.c │ │ │ │ ├── factorial.cpp │ │ │ │ ├── factorial.exs │ │ │ │ ├── factorial.go │ │ │ │ ├── factorial.java │ │ │ │ ├── factorial.js │ │ │ │ ├── factorial.md │ │ │ │ ├── factorial.py │ │ │ │ ├── factorial.rs │ │ │ │ └── factorial.scala │ │ │ ├── fibonacci/ │ │ │ │ ├── fibonacci.c │ │ │ │ ├── fibonacci.cpp │ │ │ │ ├── fibonacci.exs │ │ │ │ ├── fibonacci.go │ │ │ │ ├── fibonacci.java │ │ │ │ ├── fibonacci.js │ │ │ │ ├── fibonacci.md │ │ │ │ └── fibonacci.py │ │ │ ├── friends_pairing/ │ │ │ │ ├── friends_pairing.c │ │ │ │ ├── friends_pairing.cpp │ │ │ │ └── friends_pairing.py │ │ │ ├── house_robber/ │ │ │ │ ├── HouseRobber.cpp │ │ │ │ ├── HouseRobber.java │ │ │ │ ├── HouseRobber.js │ │ │ │ └── README.md │ │ │ ├── knapsack/ │ │ │ │ ├── Knapsack_DP_all3tech.cpp │ │ │ │ ├── README.md │ │ │ │ ├── knapsack.c │ │ │ │ ├── knapsack.cpp │ │ │ │ ├── knapsack.go │ │ │ │ ├── knapsack.java │ │ │ │ ├── knapsack.js │ │ │ │ └── knapsack.py │ │ │ ├── largest_sum_contiguous_subarray/ │ │ │ │ ├── README.md │ │ │ │ ├── largest_sum_contiguous_subarray.c │ │ │ │ ├── largest_sum_contiguous_subarray.cpp │ │ │ │ ├── largest_sum_contiguous_subarray.go │ │ │ │ ├── largest_sum_contiguous_subarray.hs │ │ │ │ ├── largest_sum_contiguous_subarray.java │ │ │ │ └── largest_sum_contiguous_subarray.py │ │ │ ├── longest_bitonic_sequence/ │ │ │ │ ├── README.md │ │ │ │ ├── longest_bitonic_sequence.c │ │ │ │ ├── longest_bitonic_sequence.js │ │ │ │ ├── longest_bitonic_sequence.py │ │ │ │ ├── longestbitonicseq.cpp │ │ │ │ └── longestbitonicsequence.java │ │ │ ├── longest_common_increasing_subsequence/ │ │ │ │ └── longest_common_increasing_subsequence.cpp │ │ │ ├── longest_common_subsequence/ │ │ │ │ ├── Printing_longest_common_subsequence.cpp │ │ │ │ ├── README.md │ │ │ │ ├── longest_common_subsequence.c │ │ │ │ ├── longest_common_subsequence.cpp │ │ │ │ ├── longest_common_subsequence.cs │ │ │ │ ├── longest_common_subsequence.go │ │ │ │ ├── longest_common_subsequence.java │ │ │ │ ├── longest_common_subsequence.php │ │ │ │ ├── longest_common_subsequence.py │ │ │ │ └── longest_common_subsequence_rec.java │ │ │ ├── longest_common_subsequence_substring/ │ │ │ │ └── longest_common_subsequence_substring_problem.cpp │ │ │ ├── longest_common_substring/ │ │ │ │ ├── Longest_Common_Substring.java │ │ │ │ ├── Longest_Common_Substring.py │ │ │ │ ├── Longest_Common_Substring_rename.cpp │ │ │ │ └── longest_common_substring_2.cpp │ │ │ ├── longest_increasing_subsequence/ │ │ │ │ ├── README.md │ │ │ │ ├── longest_increasing_subsequence.c │ │ │ │ ├── longest_increasing_subsequence.cpp │ │ │ │ ├── longest_increasing_subsequence.go │ │ │ │ ├── longest_increasing_subsequence.java │ │ │ │ ├── longest_increasing_subsequence.js │ │ │ │ ├── longest_increasing_subsequence.py │ │ │ │ └── longest_increasing_subsequence_using_segment_tree.cpp │ │ │ ├── longest_independent_set/ │ │ │ │ └── README.md │ │ │ ├── longest_palindromic_sequence/ │ │ │ │ ├── README.md │ │ │ │ ├── longest_palindromic_sequence.c │ │ │ │ ├── longest_palindromic_sequence.cpp │ │ │ │ ├── longest_palindromic_sequence.js │ │ │ │ └── longest_palindromic_sequence.py │ │ │ ├── longest_palindromic_substring/ │ │ │ │ ├── README.md │ │ │ │ ├── longest_palindromic_substring.cpp │ │ │ │ └── longest_palindromic_substring.py │ │ │ ├── longest_repeating_subsequence/ │ │ │ │ └── longest_repeating_subsequence.cpp │ │ │ ├── matrix_chain_multiplication/ │ │ │ │ ├── README.md │ │ │ │ ├── matrix_chain_multiplication.c │ │ │ │ ├── matrix_chain_multiplication.cpp │ │ │ │ ├── matrix_chain_multiplication.py │ │ │ │ └── matrixchainmultiplication.java │ │ │ ├── maximum_product_subarray/ │ │ │ │ └── maximum_product_subarray.cpp │ │ │ ├── maximum_subarray_sum/ │ │ │ │ └── maximum_subarray_sum.cpp │ │ │ ├── maximum_sum_increasing_subsequence/ │ │ │ │ ├── README.md │ │ │ │ ├── maximum_sum_increasing_subsequence.c │ │ │ │ └── maximum_sum_increasing_subsequence.cpp │ │ │ ├── maximum_sum_sub_matrix/ │ │ │ │ ├── maximum_sum_sub_matrix.cpp │ │ │ │ └── maximum_sum_sub_matrix.java │ │ │ ├── maximum_weight_independent_set_of_path_graph/ │ │ │ │ └── maximum_weight_independent_set_of_path_graph.cpp │ │ │ ├── min_cost_path/ │ │ │ │ ├── README.md │ │ │ │ ├── min_cost_path.c │ │ │ │ ├── min_cost_path.cpp │ │ │ │ ├── min_cost_path.java │ │ │ │ └── min_cost_path.py │ │ │ ├── min_rests_skipped_to_reach_on_time/ │ │ │ │ ├── Minimum Skips to Arrive at Meeting On Time.go │ │ │ │ ├── Minimum Skips to Arrive at Meeting On Time.java │ │ │ │ ├── Minimum Skips to Arrive at Meeting On Time.py │ │ │ │ ├── README.md │ │ │ │ └── min_skips.cpp │ │ │ ├── minimum_cost_polygon_triangulation/ │ │ │ │ └── README.md │ │ │ ├── minimum_insertion_palindrome/ │ │ │ │ └── minimum_insertions_palindrome_using_lcs.cpp │ │ │ ├── newman_conway/ │ │ │ │ └── newman_conway_dp.cpp │ │ │ ├── no_consec_ones/ │ │ │ │ ├── README.md │ │ │ │ ├── no_consec_1.cpp │ │ │ │ └── no_consec_ones.py │ │ │ ├── number_of_dice_rolls_with_target_sum/ │ │ │ │ └── NumberOfDiceRollsWithTargetSum.java │ │ │ ├── number_of_substring_divisible_by_8_but_not_3/ │ │ │ │ ├── README.md │ │ │ │ └── number_of_substrings.cpp │ │ │ ├── numeric_keypad_problem/ │ │ │ │ └── numeric_keypad_problem.cpp │ │ │ ├── optimal_binary_search_tree/ │ │ │ │ └── optimal_bst.py │ │ │ ├── palindrome_partition/ │ │ │ │ ├── README.md │ │ │ │ ├── palindrome_partition.cpp │ │ │ │ └── palindrome_partition.js │ │ │ ├── rod_cutting/ │ │ │ │ ├── README.md │ │ │ │ ├── rod_cutting.c │ │ │ │ ├── rod_cutting.cpp │ │ │ │ ├── rod_cutting.go │ │ │ │ ├── rod_cutting.hs │ │ │ │ └── rod_cutting.py │ │ │ ├── shortest_common_supersequence/ │ │ │ │ ├── README.md │ │ │ │ ├── scs.java │ │ │ │ ├── shortest_common_supersequence.cpp │ │ │ │ └── shortest_common_supersequence.py │ │ │ ├── subset_sum/ │ │ │ │ ├── README.md │ │ │ │ ├── subset_sum.cpp │ │ │ │ ├── subset_sum.go │ │ │ │ ├── subset_sum.java │ │ │ │ └── subset_sum.py │ │ │ ├── tiling_problem/ │ │ │ │ ├── README.md │ │ │ │ ├── tiling_problem.c │ │ │ │ ├── tiling_problem.cpp │ │ │ │ └── tiling_problem.py │ │ │ ├── trapping_rain_water/ │ │ │ │ ├── rainwater_trapping.cpp │ │ │ │ ├── trapping_rain_water.cpp │ │ │ │ ├── trapping_rain_water.java │ │ │ │ └── trapping_rain_water.py │ │ │ ├── unique_paths/ │ │ │ │ └── unique_paths.cpp │ │ │ ├── weighted_job_scheduling/ │ │ │ │ ├── README.md │ │ │ │ ├── weighted_job_scheduling.cpp │ │ │ │ └── weighted_job_scheduling.py │ │ │ └── wildcard_matching/ │ │ │ ├── wildcard.cpp │ │ │ └── wildcard.md │ │ └── test/ │ │ ├── README.md │ │ ├── longest_repeating_subsequence/ │ │ │ └── longest_repeating_subsequence_test.cpp │ │ └── subset_sum/ │ │ └── test_subset_sum.cpp │ ├── filters/ │ │ └── src/ │ │ ├── gaussian_filter/ │ │ │ └── gaussian_filter.py │ │ └── median_filter/ │ │ └── median_filter.py │ ├── game_theory/ │ │ └── src/ │ │ ├── expectimax/ │ │ │ └── expectimax.py │ │ ├── game_of_nim_next_best_move/ │ │ │ └── game_of_nim_next_best_move.py │ │ ├── game_of_nim_win_loss_prediction/ │ │ │ └── game_of_nim_win_loss_prediction.py │ │ ├── grundy_numbers_kayle/ │ │ │ └── grundy_numbers_kayle.py │ │ └── minimax/ │ │ └── minimax.py │ ├── git/ │ │ ├── undo-changes.md │ │ └── viewhist.md │ ├── graph_algorithms/ │ │ ├── src/ │ │ │ ├── Number-of-Islands-using-DFS.cpp │ │ │ ├── README.md │ │ │ ├── adjacency_lists_graph_representation/ │ │ │ │ └── adjacency_lists_in_c/ │ │ │ │ ├── README.MD │ │ │ │ ├── lgraph_stack.c │ │ │ │ ├── lgraph_stack.h │ │ │ │ ├── lgraph_struct.c │ │ │ │ ├── lgraph_struct.h │ │ │ │ └── main.c │ │ │ ├── astar_algorithm/ │ │ │ │ └── astar_algorithm.js │ │ │ ├── bellman_ford_algorithm/ │ │ │ │ ├── README.md │ │ │ │ ├── bellman_ford_algorithm.c │ │ │ │ ├── bellman_ford_algorithm.cpp │ │ │ │ ├── bellman_ford_algorithm.js │ │ │ │ ├── bellman_ford_algorithm.php │ │ │ │ ├── bellman_ford_algorithm.py │ │ │ │ ├── bellman_ford_algorithm_adjacency_list.java │ │ │ │ └── bellman_ford_algorithm_edge_list.java │ │ │ ├── biconnected_components/ │ │ │ │ ├── README.md │ │ │ │ ├── biconnected_components.cpp │ │ │ │ ├── biconnected_components.java │ │ │ │ └── biconnected_components.py │ │ │ ├── bipartite_check/ │ │ │ │ ├── bipartite_check.cpp │ │ │ │ └── bipartite_check.java │ │ │ ├── bipartite_checking/ │ │ │ │ ├── README.md │ │ │ │ ├── bipartite_checking.cpp │ │ │ │ ├── bipartite_checking.java │ │ │ │ ├── bipartite_checking2.cpp │ │ │ │ └── bipartite_checking_adjacency_list.java │ │ │ ├── boruvka_minimum_spanning_tree/ │ │ │ │ ├── README.md │ │ │ │ └── boruvka_minimum_spanning_tree.cpp │ │ │ ├── breadth_first_search/ │ │ │ │ ├── README.md │ │ │ │ ├── breadth_first_search.c │ │ │ │ ├── breadth_first_search.cpp │ │ │ │ ├── breadth_first_search.java │ │ │ │ ├── breadth_first_search.py │ │ │ │ ├── breadth_first_search.rb │ │ │ │ └── breadth_first_search.swift │ │ │ ├── bridge_tree/ │ │ │ │ └── bridge_tree.cpp │ │ │ ├── bridges_in_graph/ │ │ │ │ ├── Count_bridges.py │ │ │ │ ├── README.md │ │ │ │ └── bridges.cpp │ │ │ ├── bron_kerbosch_algorithm/ │ │ │ │ └── bron_kerbosch_algorithm.java │ │ │ ├── centroid_decomposition/ │ │ │ │ ├── centroid_decomposition.cpp │ │ │ │ └── centroid_decomposition.java │ │ │ ├── channel_assignment/ │ │ │ │ └── README.md │ │ │ ├── connected_components/ │ │ │ │ └── connected_components.c │ │ │ ├── count_of_ways_n/ │ │ │ │ └── count_of_ways_n.cpp │ │ │ ├── cut_vertices/ │ │ │ │ ├── README.md │ │ │ │ └── cut_vertices.cpp │ │ │ ├── cycle_directed_graph/ │ │ │ │ ├── README.md │ │ │ │ ├── cycle_directed_graph.c │ │ │ │ ├── cycle_directed_graph.cpp │ │ │ │ ├── cycle_directed_graph.py │ │ │ │ └── cycle_directed_graph_detection.c │ │ │ ├── cycle_undirected_graph/ │ │ │ │ ├── README.md │ │ │ │ ├── cycle_undirected_graph.cpp │ │ │ │ ├── cycle_undirected_graph.py │ │ │ │ ├── cycle_undirected_graph_check.java │ │ │ │ └── cycle_undirected_graph_union_find.cpp │ │ │ ├── data_structures/ │ │ │ │ ├── README.md │ │ │ │ ├── adjacency_list.cpp │ │ │ │ ├── adjacency_list.py │ │ │ │ ├── adjacency_matrix.cpp │ │ │ │ ├── adjacency_matrix.py │ │ │ │ └── adjacency_matrix_c/ │ │ │ │ ├── main.c │ │ │ │ ├── mgraph_struct.c │ │ │ │ └── mgraph_struct.h │ │ │ ├── depth_first_search/ │ │ │ │ ├── README.md │ │ │ │ ├── depth_first_search.c │ │ │ │ ├── depth_first_search.cpp │ │ │ │ ├── depth_first_search.cs │ │ │ │ ├── depth_first_search.go │ │ │ │ ├── depth_first_search.java │ │ │ │ ├── depth_first_search.kt │ │ │ │ ├── depth_first_search.py │ │ │ │ └── depth_first_search.rb │ │ │ ├── dijkstra_shortest_path/ │ │ │ │ ├── README.md │ │ │ │ ├── dijkstra_shortest_path.c │ │ │ │ ├── dijkstra_shortest_path.cpp │ │ │ │ ├── dijkstra_shortest_path.java │ │ │ │ ├── dijkstra_shortest_path.js │ │ │ │ ├── dijkstra_shortest_path.py │ │ │ │ ├── dijkstra_shortest_path_efficient.py │ │ │ │ └── dijkstra_shortest_path_gnu_fast.cpp │ │ │ ├── dinic_maximum_flow/ │ │ │ │ └── dinic_maximum_flow.cpp │ │ │ ├── eulerian_path/ │ │ │ │ ├── README.md │ │ │ │ ├── eulerian_path.java │ │ │ │ └── eulerian_path.py │ │ │ ├── fleury_algorithm_euler_path/ │ │ │ │ └── README.md │ │ │ ├── floyd_warshall_algorithm/ │ │ │ │ ├── README.md │ │ │ │ ├── floyd_warshall.go │ │ │ │ ├── floyd_warshall_algorithm.c │ │ │ │ ├── floyd_warshall_algorithm.cpp │ │ │ │ ├── floyd_warshall_algorithm.java │ │ │ │ └── floyd_warshall_algorithm.py │ │ │ ├── ford_fulkerson_maximum_flow/ │ │ │ │ ├── README.md │ │ │ │ ├── ford_fulkerson_maximum_flow.cpp │ │ │ │ ├── ford_fulkerson_maximum_flow_using_bfs.cpp │ │ │ │ ├── ford_fulkerson_maximum_flow_using_bfs.java │ │ │ │ └── ford_fulkerson_maximum_flow_using_bfs.py │ │ │ ├── graph_coloring/ │ │ │ │ ├── README.md │ │ │ │ ├── graph_coloring.cpp │ │ │ │ ├── graph_coloring.java │ │ │ │ └── graph_coloring_greedy.py │ │ │ ├── hamiltonian_cycle/ │ │ │ │ ├── README.md │ │ │ │ ├── hamiltonian_cycle.java │ │ │ │ └── hamiltonian_cycle.py │ │ │ ├── hamiltonian_path/ │ │ │ │ └── hamiltonian_path.cpp │ │ │ ├── hopcroft_karp_algorithm/ │ │ │ │ └── README.md │ │ │ ├── johnson_algorithm_shortest_path/ │ │ │ │ ├── README.md │ │ │ │ └── johnson_algorithm_shortest_path.py │ │ │ ├── karger_minimum_cut/ │ │ │ │ ├── README.md │ │ │ │ └── karger_minimum_cut.java │ │ │ ├── kruskal_minimum_spanning_tree/ │ │ │ │ ├── README.md │ │ │ │ ├── kruskal_minimum_spanning_tree.c │ │ │ │ ├── kruskal_minimum_spanning_tree.cpp │ │ │ │ ├── kruskal_minimum_spanning_tree.java │ │ │ │ └── kruskal_minimum_spanning_tree.py │ │ │ ├── kuhn_maximum_matching/ │ │ │ │ └── kuhn_maximum_matching.cpp │ │ │ ├── kuhn_munkres_algorithm/ │ │ │ │ └── kuhn_munkres_algorithm.cpp │ │ │ ├── left_view_binary_tree/ │ │ │ │ ├── left_view_binary_tree.cpp │ │ │ │ ├── left_view_binary_tree.java │ │ │ │ └── left_view_binary_tree.py │ │ │ ├── longest_path_directed_acyclic_graph/ │ │ │ │ ├── README.md │ │ │ │ └── longest_path_directed_acyclic_graph.cpp │ │ │ ├── lowest_common_ancestor/ │ │ │ │ └── lowest_common_ancestor.cpp │ │ │ ├── matrix_transformation/ │ │ │ │ └── matrix_transformation.swift │ │ │ ├── maximum_bipartite_matching/ │ │ │ │ ├── README.md │ │ │ │ └── maximum_bipartite_matching.py │ │ │ ├── maximum_edge_disjoint_paths/ │ │ │ │ └── README.md │ │ │ ├── minimum_s_t_cut/ │ │ │ │ └── README.md │ │ │ ├── negative_cycle_finding/ │ │ │ │ └── negativeCycleFinding.cpp │ │ │ ├── postorder_from_inorder_and_preorder/ │ │ │ │ └── postorder_from_inorder_and_preorder.cpp │ │ │ ├── prim_minimum_spanning_tree/ │ │ │ │ ├── README.md │ │ │ │ ├── prim_minimum_spanning_tree.c │ │ │ │ ├── prim_minimum_spanning_tree.cpp │ │ │ │ └── prim_minimum_spanning_tree.py │ │ │ ├── push_relabel/ │ │ │ │ └── push_relabel.cpp │ │ │ ├── redundant-connection/ │ │ │ │ └── redundant_connection.cpp │ │ │ ├── shortest_path_k_edges/ │ │ │ │ └── README.md │ │ │ ├── steiner_tree/ │ │ │ │ └── steiner_tree.java │ │ │ ├── strongly_connected_components/ │ │ │ │ ├── README.md │ │ │ │ ├── strongly_connected_components.cpp │ │ │ │ └── strongly_connected_components.py │ │ │ ├── tarjan_algorithm_strongly_connected_components/ │ │ │ │ ├── README.md │ │ │ │ └── tarjan_algorithm_strongly_connected_components.c │ │ │ ├── topological_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── kahn_algo_unique_toposort.cpp │ │ │ │ ├── kahn_algorithm_basic.cpp │ │ │ │ ├── print_all_topological_sorts.cpp │ │ │ │ ├── topological_sort.c │ │ │ │ ├── topological_sort.cpp │ │ │ │ ├── topological_sort.hs │ │ │ │ ├── topological_sort.js │ │ │ │ ├── topological_sort.py │ │ │ │ ├── topological_sort_adjacency_list.java │ │ │ │ ├── topological_sort_adjacency_list2.java │ │ │ │ ├── topological_sort_adjacency_matrix.java │ │ │ │ └── topological_sort_adjacency_matrix2.java │ │ │ ├── transitive_closure_graph/ │ │ │ │ ├── README.md │ │ │ │ ├── transitive_closure_graph.cpp │ │ │ │ ├── transitive_closure_graph.py │ │ │ │ ├── transitive_closure_graph_floyd_warshall.cpp │ │ │ │ ├── transitive_closure_graph_powering.cpp │ │ │ │ └── transitive_closure_graph_powering_improved.cpp │ │ │ ├── travelling_sales_man_dp/ │ │ │ │ ├── README.md │ │ │ │ └── travelling_salesman_dp.cpp │ │ │ ├── travelling_salesman_branch&bound/ │ │ │ │ └── tsp_branch_bound.cpp │ │ │ ├── travelling_salesman_mst/ │ │ │ │ ├── README.md │ │ │ │ ├── travelling_salesman.c │ │ │ │ ├── travelling_salesman.cpp │ │ │ │ └── travelling_salesman.py │ │ │ └── vertex_cover/ │ │ │ └── README.md │ │ └── test/ │ │ ├── README.md │ │ ├── floyd_warshall_graph/ │ │ │ └── floyd_warshal_test.go │ │ ├── matrix_transformation/ │ │ │ └── test_matrix_transformation.swift │ │ └── push_relabel/ │ │ └── test_push_relabel.cpp │ ├── greedy_algorithms/ │ │ ├── src/ │ │ │ ├── README.md │ │ │ ├── SplitArrayLargestSum/ │ │ │ │ ├── README.md │ │ │ │ └── SplitArrayLargestSum.cpp │ │ │ ├── activity_selection/ │ │ │ │ ├── README.md │ │ │ │ ├── activity_selection.c │ │ │ │ ├── activity_selection.cpp │ │ │ │ ├── activity_selection.java │ │ │ │ └── activity_selection.py │ │ │ ├── dials_algorithm/ │ │ │ │ └── dials_algorithm.cpp │ │ │ ├── dijkstra_shortest_path/ │ │ │ │ ├── README.md │ │ │ │ ├── dijkstra_shortest_path.c │ │ │ │ ├── dijkstra_shortest_path.cpp │ │ │ │ ├── dijkstra_shortest_path.java │ │ │ │ └── dijkstra_shortest_path.py │ │ │ ├── egyptian_fraction/ │ │ │ │ ├── egyptian_fraction.c │ │ │ │ ├── egyptian_fraction.cpp │ │ │ │ ├── egyptian_fraction.php │ │ │ │ └── egyptian_fraction.py │ │ │ ├── fractional_knapsack/ │ │ │ │ ├── README.md │ │ │ │ ├── fractional_knapsack.c │ │ │ │ ├── fractional_knapsack.cpp │ │ │ │ ├── fractional_knapsack.cs │ │ │ │ ├── fractional_knapsack.go │ │ │ │ ├── fractional_knapsack.java │ │ │ │ └── fractional_knapsack.py │ │ │ ├── hillclimber/ │ │ │ │ └── hillclimber.java │ │ │ ├── huffman_coding/ │ │ │ │ ├── README.md │ │ │ │ ├── huffman_GreedyAlgo.java │ │ │ │ ├── huffman_coding.c │ │ │ │ ├── huffman_coding.cpp │ │ │ │ └── huffman_coding.py │ │ │ ├── job_sequencing/ │ │ │ │ ├── README.md │ │ │ │ ├── job_sequencing.cpp │ │ │ │ ├── job_sequencing.java │ │ │ │ └── job_sequencing.py │ │ │ ├── k_centers/ │ │ │ │ ├── README.md │ │ │ │ └── k_centers.py │ │ │ ├── kruskal_minimum_spanning_tree/ │ │ │ │ ├── README.md │ │ │ │ ├── kruskal.c │ │ │ │ ├── kruskal.cpp │ │ │ │ ├── kruskal.py │ │ │ │ └── kruskal_using_adjacency_matrix.c │ │ │ ├── min_lateness/ │ │ │ │ ├── README.md │ │ │ │ └── min_lateness.cpp │ │ │ ├── min_operation_to_make_gcd_k/ │ │ │ │ ├── README.md │ │ │ │ └── min_operation.cpp │ │ │ ├── minimum_coins/ │ │ │ │ ├── README.md │ │ │ │ ├── minimum_coins.c │ │ │ │ ├── minimum_coins.cpp │ │ │ │ ├── minimum_coins.go │ │ │ │ ├── minimum_coins.js │ │ │ │ ├── minimum_coins.py │ │ │ │ ├── minimumcoins.hs │ │ │ │ └── minimumcoins.java │ │ │ ├── prim_minimum_spanning_tree/ │ │ │ │ ├── README.md │ │ │ │ ├── prim_minimum_spanning_tree.c │ │ │ │ ├── prim_minimum_spanning_tree.cpp │ │ │ │ ├── prim_minimum_spanning_tree.hs │ │ │ │ └── prim_minimum_spanning_tree.py │ │ │ ├── warshall/ │ │ │ │ └── warshalls.c │ │ │ └── water_connection/ │ │ │ └── water_connection_algorithm.cpp │ │ └── test/ │ │ ├── README.md │ │ └── kruskal_minimum_spanning_tree/ │ │ └── test_kruskal.cpp │ ├── html/ │ │ ├── README.md │ │ ├── bootstrap/ │ │ │ ├── Readme.MD │ │ │ └── tables.html │ │ └── css/ │ │ ├── Hover/ │ │ │ └── src/ │ │ │ └── Hover_effect.html │ │ ├── Layout/ │ │ │ └── normalflow.html │ │ ├── Margin/ │ │ │ ├── README.md │ │ │ └── src/ │ │ │ ├── Auto_keyword.html │ │ │ ├── Individual.html │ │ │ ├── Inherit_keyword.html │ │ │ ├── Margin.html │ │ │ ├── Margin_collapse.html │ │ │ ├── Margin_length.html │ │ │ ├── Margin_value_percentage.html │ │ │ ├── Shorthand_1.html │ │ │ ├── Shorthand_2.html │ │ │ ├── Shorthand_3.html │ │ │ └── Shorthand_4.html │ │ ├── Padding/ │ │ │ ├── README.md │ │ │ └── src/ │ │ │ ├── BoxModel.html │ │ │ ├── Individual_sides.html │ │ │ ├── Inherit.html │ │ │ ├── Length.html │ │ │ ├── Padding.html │ │ │ ├── Percentage.html │ │ │ ├── Shorthand_1.html │ │ │ ├── Shorthand_2.html │ │ │ ├── Shorthand_3.html │ │ │ ├── Shorthand_4.html │ │ │ └── code.html │ │ ├── Position/ │ │ │ ├── README.md │ │ │ └── src/ │ │ │ ├── Absolute_no_ancestor.html │ │ │ ├── Absoulte_ancestor.html │ │ │ ├── Fixed.html │ │ │ ├── Position.html │ │ │ ├── Relative.html │ │ │ └── Static.html │ │ ├── README.md │ │ ├── Z_index/ │ │ │ ├── README.md │ │ │ └── src/ │ │ │ ├── inherit.html │ │ │ ├── initial.html │ │ │ └── z_index.html │ │ └── border/ │ │ ├── README.md │ │ └── src/ │ │ ├── Border_color.html │ │ ├── Border_style.html │ │ ├── Border_width.html │ │ ├── Individual_border.html │ │ ├── Rounded_Border.html │ │ └── Shorthand_property.html │ ├── languages/ │ │ ├── Java/ │ │ │ ├── 2d-array-list-java.java │ │ │ ├── 2d-array.java │ │ │ ├── Handlingexceptions/ │ │ │ │ └── Handlingexp.java │ │ │ ├── Kadane_algo.java │ │ │ ├── README_Kadane_Algo.md │ │ │ ├── README_bubble-sort.md │ │ │ ├── README_reduce_TL.md │ │ │ ├── Readme.md │ │ │ ├── Reduce_Time_complexity.java │ │ │ ├── String/ │ │ │ │ ├── Readme.md │ │ │ │ └── StringClass.java │ │ │ ├── bubble-sort.java │ │ │ ├── readme-2DArray.md │ │ │ └── this_reference/ │ │ │ ├── Readme.md │ │ │ └── this.java │ │ ├── c/ │ │ │ ├── README.md │ │ │ ├── delete_array/ │ │ │ │ ├── README.md │ │ │ │ └── del.c │ │ │ ├── dynamic_memory_allocation/ │ │ │ │ ├── README.md │ │ │ │ └── example.c │ │ │ ├── linear_search/ │ │ │ │ ├── linear_search.c │ │ │ │ ├── linear_search_duplicates.c │ │ │ │ ├── linear_search_duplicates_linked_list.c │ │ │ │ └── linear_search_linked_list.c │ │ │ ├── loop/ │ │ │ │ ├── While.c │ │ │ │ ├── break.c │ │ │ │ ├── continue.c │ │ │ │ ├── do-while.c │ │ │ │ ├── for.c │ │ │ │ └── switch-case.c │ │ │ └── rock_paper_scissor/ │ │ │ └── rock_game.c │ │ ├── c#/ │ │ │ ├── BasicDataTypes.cs │ │ │ ├── ForLoop.cs │ │ │ └── IfElseIfElse.cs │ │ ├── cpp/ │ │ │ ├── begin_and_end/ │ │ │ │ ├── README.md │ │ │ │ └── begin_and_end.cpp │ │ │ ├── binary_search/ │ │ │ │ ├── README.md │ │ │ │ └── binary_search_implementation.cpp │ │ │ ├── calculator/ │ │ │ │ └── simpleCalculator.cpp │ │ │ ├── delete_vs_free/ │ │ │ │ ├── README.md │ │ │ │ └── free_vs_delete.cpp │ │ │ ├── detect_cycle_undirected_graph_using_degrees_of_nodes/ │ │ │ │ ├── README.md │ │ │ │ └── detect_cycle_graph_using_degree.cpp │ │ │ ├── double_to_string/ │ │ │ │ ├── README.md │ │ │ │ └── double_to_str.cpp │ │ │ ├── initializing_multimap/ │ │ │ │ ├── README.md │ │ │ │ └── multimap.cpp │ │ │ ├── largest-element-in-an-array/ │ │ │ │ ├── Largest_element.cpp │ │ │ │ └── README.md │ │ │ ├── linear_search/ │ │ │ │ ├── Linear Search In A LinkedList With Duplicates.cpp │ │ │ │ ├── Linear Search In Array.cpp │ │ │ │ ├── Linear Search In Duplicate Array.cpp │ │ │ │ ├── README.md │ │ │ │ └── Search In Linked List.cpp │ │ │ ├── loop/ │ │ │ │ └── continue.cpp │ │ │ ├── reverse_linked_list/ │ │ │ │ ├── README.md │ │ │ │ ├── reverse_linked_list_2pointers.cpp │ │ │ │ └── reverse_linked_list_3pointers.cpp │ │ │ ├── sort_vector/ │ │ │ │ └── sorting_vector.cpp │ │ │ ├── spiral_matrix/ │ │ │ │ └── spiral_matrix.cpp │ │ │ ├── uint8_t/ │ │ │ │ ├── README.md │ │ │ │ └── int8_t_test.cpp │ │ │ ├── vector-to-map.cpp │ │ │ └── vector_to_map/ │ │ │ └── readme.md │ │ ├── dart/ │ │ │ ├── 01.data_types.dart │ │ │ ├── 02.condition.dart │ │ │ ├── 03.loop.dart │ │ │ ├── 04.data_structure.dart │ │ │ └── README.md │ │ └── python/ │ │ ├── 2d-array-numpy/ │ │ │ ├── 2d-array-numpy.py │ │ │ └── README.md │ │ ├── Image Encryption Decryption/ │ │ │ ├── README.md │ │ │ └── image_encryption_decryption.py │ │ ├── counter_objects/ │ │ │ ├── README.md │ │ │ └── counter_obj.py │ │ ├── rock_paper_scissors/ │ │ │ └── rock_paper_scissor.py │ │ ├── static-class-variable/ │ │ │ ├── Readme.md │ │ │ └── StaticClassVariable.py │ │ ├── stock_data/ │ │ │ └── Stock_data.py │ │ ├── tuple/ │ │ │ ├── README.md │ │ │ └── example.py │ │ ├── validate-parentheses/ │ │ │ ├── README.md │ │ │ └── validate-parentheses.py │ │ └── web_programming/ │ │ ├── README.md │ │ ├── __init__.py │ │ ├── co2_emission.py │ │ ├── covid_stats_via_xpath.py │ │ ├── crawl_google_results.py │ │ ├── current_stock_price.py │ │ ├── current_weather.py │ │ ├── daily_horoscope.py │ │ ├── emails_from_url.py │ │ ├── fetch_bbc_news.py │ │ ├── fetch_github_info.py │ │ ├── fetch_jobs.py │ │ ├── get_imdb_top_250_movies_csv.py │ │ ├── get_imdbtop.py │ │ ├── instagram_crawler.py │ │ ├── recaptcha_verification.py │ │ ├── slack_message.py │ │ └── world_covid19_stats.py │ ├── mathematical_algorithms/ │ │ ├── mathematical_algorithms/ │ │ │ ├── Solve_Pi/ │ │ │ │ ├── README.md │ │ │ │ └── Solve_Pi.py │ │ │ ├── Solve_Sum_2PositiveIntegers/ │ │ │ │ ├── README.md │ │ │ │ └── Sum_2largeNumbers.py │ │ │ ├── Solve_x_y/ │ │ │ │ ├── FindX_Y.py │ │ │ │ └── README.md │ │ │ ├── automorphic_number.c │ │ │ └── factorial/ │ │ │ └── factorial.pl │ │ ├── src/ │ │ │ ├── 2sum/ │ │ │ │ ├── 2sum.c │ │ │ │ ├── 2sum.cpp │ │ │ │ ├── 2sum.go │ │ │ │ ├── 2sum.java │ │ │ │ ├── 2sum.js │ │ │ │ ├── 2sum.py │ │ │ │ ├── 2sum.rb │ │ │ │ └── 2sum.rs │ │ │ ├── Binary_GCD_Algorithm/ │ │ │ │ ├── Binary_GCD_Iterative.cpp │ │ │ │ ├── Binary_GCD_Recursive.cpp │ │ │ │ ├── Binary_GCD_Recursive.py │ │ │ │ └── README.md │ │ │ ├── README.md │ │ │ ├── add_polynomials/ │ │ │ │ ├── README.md │ │ │ │ ├── add_polynomials.c │ │ │ │ ├── add_polynomials.cpp │ │ │ │ └── add_polynomials.go │ │ │ ├── amicable_numbers/ │ │ │ │ ├── amicable_numbers.c │ │ │ │ ├── amicable_numbers.cpp │ │ │ │ ├── amicable_numbers.cs │ │ │ │ ├── amicable_numbers.go │ │ │ │ ├── amicable_numbers.java │ │ │ │ ├── amicable_numbers.js │ │ │ │ ├── amicable_numbers.py │ │ │ │ ├── amicable_numbers.rb │ │ │ │ └── amicable_numbers.rs │ │ │ ├── armstrong_num_range/ │ │ │ │ ├── README.md │ │ │ │ ├── amstrong_num_range.c │ │ │ │ └── amstrong_num_range.py │ │ │ ├── armstrong_numbers/ │ │ │ │ ├── README.md │ │ │ │ ├── armstrong_number.php │ │ │ │ ├── armstrong_numbers.c │ │ │ │ ├── armstrong_numbers.cpp │ │ │ │ ├── armstrong_numbers.cs │ │ │ │ ├── armstrong_numbers.go │ │ │ │ ├── armstrong_numbers.java │ │ │ │ ├── armstrong_numbers.js │ │ │ │ ├── armstrong_numbers.py │ │ │ │ └── armstrong_numbers.rb │ │ │ ├── automorphic_numbers/ │ │ │ │ ├── README.md │ │ │ │ ├── automorphic_numbers.c │ │ │ │ ├── automorphic_numbers.cpp │ │ │ │ ├── automorphic_numbers.cs │ │ │ │ ├── automorphic_numbers.go │ │ │ │ ├── automorphic_numbers.hs │ │ │ │ ├── automorphic_numbers.java │ │ │ │ ├── automorphic_numbers.js │ │ │ │ ├── automorphic_numbers.php │ │ │ │ ├── automorphic_numbers.py │ │ │ │ ├── automorphic_numbers.rb │ │ │ │ └── automorphic_numbers.swift │ │ │ ├── average_stream_numbers/ │ │ │ │ ├── README.md │ │ │ │ ├── average_stream_numbers.c │ │ │ │ ├── average_stream_numbers.cpp │ │ │ │ ├── average_stream_numbers.go │ │ │ │ ├── average_stream_numbers.js │ │ │ │ └── average_stream_numbers.py │ │ │ ├── babylonian_method/ │ │ │ │ ├── README.md │ │ │ │ ├── babylonian_method.c │ │ │ │ ├── babylonian_method.cpp │ │ │ │ ├── babylonian_method.go │ │ │ │ ├── babylonian_method.java │ │ │ │ ├── babylonian_method.js │ │ │ │ └── babylonian_method.py │ │ │ ├── binary_to_decimal/ │ │ │ │ ├── Conversion_from_Binary_to_Decimal.cpp │ │ │ │ └── Conversion_from_Binary_to_Decimal.py │ │ │ ├── binomial_coefficient/ │ │ │ │ ├── README.md │ │ │ │ ├── binomial_coefficient.c │ │ │ │ ├── binomial_coefficient.cpp │ │ │ │ ├── binomial_coefficient.go │ │ │ │ ├── binomial_coefficient.java │ │ │ │ └── binomial_coefficient.py │ │ │ ├── catalan_number/ │ │ │ │ ├── README.md │ │ │ │ ├── catalan_number.c │ │ │ │ ├── catalan_number.java │ │ │ │ ├── catalan_number.js │ │ │ │ ├── catalan_number.py │ │ │ │ ├── catalan_number.rb │ │ │ │ ├── catalan_number.scala │ │ │ │ ├── catalan_number2.py │ │ │ │ ├── catalan_number_dynamic.cpp │ │ │ │ └── catalan_number_recursive.cpp │ │ │ ├── check_good_array_GCD_problem/ │ │ │ │ ├── GCD_related_problems.py │ │ │ │ └── readme.md │ │ │ ├── check_is_square/ │ │ │ │ ├── check_is_square.c │ │ │ │ ├── check_is_square.cpp │ │ │ │ ├── check_is_square.cs │ │ │ │ ├── check_is_square.go │ │ │ │ ├── check_is_square.java │ │ │ │ ├── check_is_square.js │ │ │ │ ├── check_is_square.kt │ │ │ │ ├── check_is_square.php │ │ │ │ ├── check_is_square.py │ │ │ │ ├── check_is_square.rs │ │ │ │ ├── check_is_square.ruby │ │ │ │ ├── check_is_square.scala │ │ │ │ ├── check_is_square.swift │ │ │ │ └── check_is_square_alternative.py │ │ │ ├── collatz_conjecture_sequence/ │ │ │ │ └── collatz_conjecture_sequence.c │ │ │ ├── convolution/ │ │ │ │ └── convolution.cpp │ │ │ ├── coprime_numbers/ │ │ │ │ ├── README.md │ │ │ │ ├── coprime_numbers.c │ │ │ │ ├── coprime_numbers.cpp │ │ │ │ ├── coprime_numbers.cs │ │ │ │ ├── coprime_numbers.go │ │ │ │ ├── coprime_numbers.java │ │ │ │ ├── coprime_numbers.js │ │ │ │ ├── coprime_numbers.py │ │ │ │ ├── coprime_numbers.rb │ │ │ │ └── coprime_numbers.rs │ │ │ ├── count_digits/ │ │ │ │ ├── count_digits.c │ │ │ │ ├── count_digits.cpp │ │ │ │ ├── count_digits.cs │ │ │ │ ├── count_digits.go │ │ │ │ ├── count_digits.hs │ │ │ │ ├── count_digits.java │ │ │ │ ├── count_digits.js │ │ │ │ ├── count_digits.py │ │ │ │ ├── count_digits.swift │ │ │ │ └── counts_digits.rb │ │ │ ├── count_trailing_zeroes/ │ │ │ │ ├── count_trailing_zeroes.c │ │ │ │ ├── count_trailing_zeroes.scala │ │ │ │ ├── count_trailing_zeroes_factorial.cpp │ │ │ │ ├── count_trailing_zeroes_factorial.java │ │ │ │ ├── count_trailing_zeroes_factorial.js │ │ │ │ └── count_trailing_zeroes_factorial.py │ │ │ ├── decoding_of_string/ │ │ │ │ └── README.md │ │ │ ├── delannoy_number/ │ │ │ │ ├── README.md │ │ │ │ ├── delannoy_number.c │ │ │ │ ├── delannoy_number.cpp │ │ │ │ └── delannoy_number.py │ │ │ ├── derangements/ │ │ │ │ └── derangements.c │ │ │ ├── dfa_division/ │ │ │ │ └── README.md │ │ │ ├── diophantine/ │ │ │ │ └── diophantine.cpp │ │ │ ├── divided_differences/ │ │ │ │ ├── README.md │ │ │ │ ├── divided_differences.java │ │ │ │ └── divided_differences.py │ │ │ ├── euler_totient/ │ │ │ │ ├── README.md │ │ │ │ ├── euler_totient.c │ │ │ │ ├── euler_totient.cpp │ │ │ │ ├── euler_totient.java │ │ │ │ ├── euler_totient.py │ │ │ │ ├── euler_totient_sieve.cpp │ │ │ │ └── euler_totient_sieve.py │ │ │ ├── exponentiation_power/ │ │ │ │ ├── README.md │ │ │ │ ├── exponentiation_by_squaring/ │ │ │ │ │ ├── exponentiation_by_squaring.c │ │ │ │ │ ├── exponentiation_by_squaring.cpp │ │ │ │ │ ├── exponentiation_by_squaring.go │ │ │ │ │ └── exponentiation_by_squaring.py │ │ │ │ ├── exponentiation_power.c │ │ │ │ ├── exponentiation_power.cpp │ │ │ │ ├── exponentiation_power.java │ │ │ │ └── modulo_exponentation_power.cpp │ │ │ ├── factorial/ │ │ │ │ ├── factorial.c │ │ │ │ ├── factorial.clj │ │ │ │ ├── factorial.erl │ │ │ │ ├── factorial.ex │ │ │ │ ├── factorial.go │ │ │ │ ├── factorial.hs │ │ │ │ ├── factorial.java │ │ │ │ ├── factorial.kt │ │ │ │ ├── factorial.php │ │ │ │ ├── factorial.rb │ │ │ │ ├── factorial.rs │ │ │ │ ├── factorial.scala │ │ │ │ ├── factorial.swift │ │ │ │ ├── factorial_hrw.py │ │ │ │ ├── factorial_iteration.c │ │ │ │ ├── factorial_iteration.cs │ │ │ │ ├── factorial_iteration.js │ │ │ │ ├── factorial_iteration.py │ │ │ │ ├── factorial_recursion.c │ │ │ │ ├── factorial_recursion.cpp │ │ │ │ ├── factorial_recursion.cs │ │ │ │ ├── factorial_recursion.js │ │ │ │ └── factorial_recursion.py │ │ │ ├── fast_fourier_transform/ │ │ │ │ ├── fast_fourier_transform.c │ │ │ │ └── fast_fourier_transform.java │ │ │ ├── fast_inverse_sqrt/ │ │ │ │ ├── fast_inverse_sqrt.cpp │ │ │ │ └── fast_inverse_sqrt.py │ │ │ ├── fermats_little_theorem/ │ │ │ │ ├── fermats_little_theorem.cpp │ │ │ │ ├── fermats_little_theorem.java │ │ │ │ └── fermats_little_theorem.py │ │ │ ├── fibonacci_number/ │ │ │ │ ├── README.md │ │ │ │ ├── fast_fibonacci.c │ │ │ │ ├── fibonacci_for_big_numbers.cpp │ │ │ │ ├── fibonacci_lucas.py │ │ │ │ ├── fibonacci_matrix_exponentiation.cpp │ │ │ │ ├── fibonacci_matrix_multiplication.py │ │ │ │ ├── fibonacci_memorized.swift │ │ │ │ ├── fibonacci_number.c │ │ │ │ ├── fibonacci_number.clj │ │ │ │ ├── fibonacci_number.cpp │ │ │ │ ├── fibonacci_number.cs │ │ │ │ ├── fibonacci_number.erl │ │ │ │ ├── fibonacci_number.ex │ │ │ │ ├── fibonacci_number.go │ │ │ │ ├── fibonacci_number.hs │ │ │ │ ├── fibonacci_number.java │ │ │ │ ├── fibonacci_number.js │ │ │ │ ├── fibonacci_number.kt │ │ │ │ ├── fibonacci_number.php │ │ │ │ ├── fibonacci_number.py │ │ │ │ ├── fibonacci_number.rb │ │ │ │ ├── fibonacci_number.rs │ │ │ │ ├── fibonacci_number.scala │ │ │ │ └── fibonacci_number.swift │ │ │ ├── fractals/ │ │ │ │ ├── julia_miim.cpp │ │ │ │ └── simple_julia.cpp │ │ │ ├── gaussian_elimination/ │ │ │ │ ├── gaussian_elimination.cpp │ │ │ │ ├── gaussian_elimination.java │ │ │ │ └── scala/ │ │ │ │ ├── build.sbt │ │ │ │ ├── project/ │ │ │ │ │ └── build.properties │ │ │ │ └── src/ │ │ │ │ └── main/ │ │ │ │ └── scala/ │ │ │ │ ├── gaussian/ │ │ │ │ │ └── elimination/ │ │ │ │ │ ├── gaussianelimination.scala │ │ │ │ │ ├── matrixtype.scala │ │ │ │ │ └── solution.scala │ │ │ │ ├── main.scala │ │ │ │ └── structures/ │ │ │ │ ├── epsilon.scala │ │ │ │ ├── matrix.scala │ │ │ │ └── regularmatrix.scala │ │ │ ├── gcd_and_lcm/ │ │ │ │ ├── README.md │ │ │ │ ├── gcd_and_lcm.c │ │ │ │ ├── gcd_and_lcm.cpp │ │ │ │ ├── gcd_and_lcm.cs │ │ │ │ ├── gcd_and_lcm.erl │ │ │ │ ├── gcd_and_lcm.ex │ │ │ │ ├── gcd_and_lcm.go │ │ │ │ ├── gcd_and_lcm.java │ │ │ │ ├── gcd_and_lcm.js │ │ │ │ ├── gcd_and_lcm.php │ │ │ │ ├── gcd_and_lcm.py │ │ │ │ ├── gcd_and_lcm.scala │ │ │ │ └── gcd_and_lcm_best_approach.cpp │ │ │ ├── greatest_digit_in_number/ │ │ │ │ ├── greatest_digit_in_number.c │ │ │ │ ├── greatest_digit_in_number.cpp │ │ │ │ ├── greatest_digit_in_number.cs │ │ │ │ ├── greatest_digit_in_number.hs │ │ │ │ ├── greatest_digit_in_number.java │ │ │ │ ├── greatest_digit_in_number.js │ │ │ │ ├── greatest_digit_in_number.php │ │ │ │ ├── greatest_digit_in_number.py │ │ │ │ └── greatest_digit_in_number.rb │ │ │ ├── hill_climbing/ │ │ │ │ ├── hill_climbing.java │ │ │ │ └── hill_climbing.py │ │ │ ├── horner_polynomial_evaluation/ │ │ │ │ ├── README.md │ │ │ │ ├── horner_polynomial_evaluation.cpp │ │ │ │ └── horner_polynomial_evaluation.java │ │ │ ├── integer_conversion/ │ │ │ │ ├── decimal_to_any_base.js │ │ │ │ ├── decimal_to_any_base.py │ │ │ │ ├── decimal_to_any_base.rs │ │ │ │ ├── decimal_to_bin.cpp │ │ │ │ ├── decimal_to_hex.cpp │ │ │ │ ├── decimal_to_int.go │ │ │ │ └── decimal_to_oct.cpp │ │ │ ├── integer_to_roman/ │ │ │ │ ├── integer_to_roman.cpp │ │ │ │ ├── integer_to_roman.js │ │ │ │ └── integer_to_roman.py │ │ │ ├── jacobi_method/ │ │ │ │ ├── README.md │ │ │ │ └── jacobi_method.java │ │ │ ├── karatsuba_multiplication/ │ │ │ │ ├── karatsuba_multiplication.cpp │ │ │ │ └── karatsuba_multiplication.java │ │ │ ├── largrange_polynomial/ │ │ │ │ ├── README.md │ │ │ │ └── lagrange_polynomial.java │ │ │ ├── lexicographic_string_rank/ │ │ │ │ ├── README.md │ │ │ │ ├── lexicographic_string_rank.c │ │ │ │ ├── lexicographic_string_rank.cpp │ │ │ │ ├── lexicographic_string_rank.java │ │ │ │ └── lexicographic_string_rank.py │ │ │ ├── log_of_factorial/ │ │ │ │ ├── log_of_factorial.c │ │ │ │ ├── log_of_factorial.cpp │ │ │ │ ├── log_of_factorial.java │ │ │ │ └── log_of_factorial.py │ │ │ ├── lorenz_attractor/ │ │ │ │ ├── Lorenz Attractor.py │ │ │ │ └── lorenz_attractor.py │ │ │ ├── lucas_theorem/ │ │ │ │ └── lucas_theorem.cpp │ │ │ ├── lucky_number/ │ │ │ │ ├── README.md │ │ │ │ ├── lucky_number.c │ │ │ │ └── lucky_number.java │ │ │ ├── magic_square/ │ │ │ │ ├── README.md │ │ │ │ └── magic_square.py │ │ │ ├── matrix_row_reduction/ │ │ │ │ └── matrix_row_reduction.cpp │ │ │ ├── maximum_perimeter_triangle/ │ │ │ │ └── PerimeterTriangle.java │ │ │ ├── minimum_operations_elements_equal/ │ │ │ │ └── EqualizeEveryone.java │ │ │ ├── modular_inverse/ │ │ │ │ ├── modular_inverse.cpp │ │ │ │ ├── modular_inverse.java │ │ │ │ ├── modular_inverse.py │ │ │ │ └── modular_inverse.rb │ │ │ ├── multiply_polynomial/ │ │ │ │ ├── README.md │ │ │ │ └── multiply_polynomial.cpp │ │ │ ├── newman_conway/ │ │ │ │ ├── README.md │ │ │ │ ├── newman_conway_recursion.cpp │ │ │ │ ├── newman_conway_sequence.c │ │ │ │ └── newman_conway_sequence.cpp │ │ │ ├── newton_polynomial/ │ │ │ │ ├── README.md │ │ │ │ └── newton_polynomial.java │ │ │ ├── newton_raphson_method/ │ │ │ │ ├── README.md │ │ │ │ ├── newton_raphson.c │ │ │ │ ├── newton_raphson.cpp │ │ │ │ └── newton_raphson.php │ │ │ ├── next_larger_number/ │ │ │ │ ├── next_larger_number.cpp │ │ │ │ ├── next_larger_number.java │ │ │ │ ├── next_larger_number.php │ │ │ │ └── next_larger_number.py │ │ │ ├── pandigital_number/ │ │ │ │ ├── README.md │ │ │ │ ├── pandigital_number.c │ │ │ │ └── pandigital_number.rb │ │ │ ├── pascal_triangle/ │ │ │ │ ├── README.md │ │ │ │ ├── pascal_triangle.c │ │ │ │ ├── pascal_triangle.cpp │ │ │ │ ├── pascal_triangle.exs │ │ │ │ ├── pascal_triangle.go │ │ │ │ ├── pascal_triangle.java │ │ │ │ └── pascal_triangle.py │ │ │ ├── perfect_number/ │ │ │ │ ├── .gitignore │ │ │ │ ├── README.md │ │ │ │ ├── perfect_number.c │ │ │ │ ├── perfect_number.cpp │ │ │ │ ├── perfect_number.hs │ │ │ │ ├── perfect_number.java │ │ │ │ ├── perfect_number.js │ │ │ │ ├── perfect_number.php │ │ │ │ ├── perfect_number.py │ │ │ │ ├── perfect_number.rb │ │ │ │ ├── perfect_number.rs │ │ │ │ └── perfect_number_list.cpp │ │ │ ├── permutation_lexicographic_order/ │ │ │ │ ├── README.md │ │ │ │ └── permutation_lexicographic_order.cpp │ │ │ ├── poisson_sample/ │ │ │ │ └── poisson_sample.py │ │ │ ├── power/ │ │ │ │ ├── method1_power_recursion_with_even_odd_optimization.cpp │ │ │ │ └── method2_power_recursion_with_even_odd_optimization.cpp │ │ │ ├── primality_tests/ │ │ │ │ ├── fermat_primality_test/ │ │ │ │ │ ├── fermat_primality_test.c │ │ │ │ │ └── fermat_primality_test.py │ │ │ │ ├── miller_rabin_primality_test/ │ │ │ │ │ ├── miller_rabin_primality_test.cpp │ │ │ │ │ ├── miller_rabin_primality_test.java │ │ │ │ │ └── miller_rabin_primality_test.py │ │ │ │ └── solovay_strassen_primality_test/ │ │ │ │ └── solovay_strassen_primality_test.cpp │ │ │ ├── prime_factors/ │ │ │ │ ├── prime_factors.c │ │ │ │ ├── prime_factors.cpp │ │ │ │ ├── prime_factors.go │ │ │ │ ├── prime_factors.java │ │ │ │ ├── prime_factors.py │ │ │ │ ├── sum_of_prime_factors.c │ │ │ │ └── sum_of_primes.cpp │ │ │ ├── prime_numbers_of_n/ │ │ │ │ ├── README.md │ │ │ │ ├── prime_numbers_of_n.c │ │ │ │ ├── prime_numbers_of_n.cpp │ │ │ │ ├── prime_numbers_of_n.js │ │ │ │ └── prime_numbers_of_n.py │ │ │ ├── pythagorean_triplet/ │ │ │ │ ├── pythagorean_triplet.cpp │ │ │ │ └── pythagorean_triplet.py │ │ │ ├── replace_0_with_5/ │ │ │ │ ├── 0_to_5_efficent.cpp │ │ │ │ ├── replace_0_with_5.c │ │ │ │ ├── replace_0_with_5.cpp │ │ │ │ ├── replace_0_with_5.cs │ │ │ │ ├── replace_0_with_5.go │ │ │ │ ├── replace_0_with_5.java │ │ │ │ ├── replace_0_with_5.js │ │ │ │ └── replace_0_with_5.py │ │ │ ├── reverse_factorial/ │ │ │ │ ├── README.md │ │ │ │ ├── reverse_factorial.c │ │ │ │ ├── reverse_factorial.go │ │ │ │ ├── reverse_factorial.java │ │ │ │ ├── reverse_factorial.js │ │ │ │ ├── reverse_factorial.py │ │ │ │ └── reverse_factorial.rb │ │ │ ├── reverse_number/ │ │ │ │ ├── reverse_a_number.c │ │ │ │ ├── reverse_number.c │ │ │ │ ├── reverse_number.cpp │ │ │ │ ├── reverse_number.cs │ │ │ │ ├── reverse_number.go │ │ │ │ ├── reverse_number.hs │ │ │ │ ├── reverse_number.java │ │ │ │ ├── reverse_number.js │ │ │ │ ├── reverse_number.php │ │ │ │ ├── reverse_number.py │ │ │ │ ├── reverse_number.rb │ │ │ │ ├── reverse_number.swift │ │ │ │ ├── reverse_number_iterative.c │ │ │ │ └── reverse_number_recursion.java │ │ │ ├── russian_peasant_multiplication/ │ │ │ │ ├── README.md │ │ │ │ ├── russian_peasant_multiplication.c │ │ │ │ ├── russian_peasant_multiplication.cpp │ │ │ │ ├── russian_peasant_multiplication.cs │ │ │ │ ├── russian_peasant_multiplication.go │ │ │ │ ├── russian_peasant_multiplication.js │ │ │ │ ├── russian_peasant_multiplication.php │ │ │ │ ├── russian_peasant_multiplication.py │ │ │ │ └── russian_peasant_multiplication.rs │ │ │ ├── segmented_sieve_of_eratosthenes/ │ │ │ │ └── segmented_sieve_of_eratosthenes.cpp │ │ │ ├── shuffle_array/ │ │ │ │ ├── README.md │ │ │ │ ├── shuffle_array.c │ │ │ │ ├── shuffle_array.cpp │ │ │ │ ├── shuffle_array.js │ │ │ │ └── shuffle_array.rb │ │ │ ├── sieve_of_atkin/ │ │ │ │ ├── sieve_of_atkin.c │ │ │ │ ├── sieve_of_atkin.cpp │ │ │ │ ├── sieve_of_atkin.java │ │ │ │ └── sieve_of_atkin.py │ │ │ ├── sieve_of_eratosthenes/ │ │ │ │ ├── README.md │ │ │ │ ├── sieve_of_eratosthenes.c │ │ │ │ ├── sieve_of_eratosthenes.cpp │ │ │ │ ├── sieve_of_eratosthenes.cs │ │ │ │ ├── sieve_of_eratosthenes.go │ │ │ │ ├── sieve_of_eratosthenes.hs │ │ │ │ ├── sieve_of_eratosthenes.java │ │ │ │ ├── sieve_of_eratosthenes.js │ │ │ │ ├── sieve_of_eratosthenes.php │ │ │ │ ├── sieve_of_eratosthenes.py │ │ │ │ ├── sieve_of_eratosthenes_compact.cpp │ │ │ │ └── sieve_of_eratosthenes_linear.cpp │ │ │ ├── simpsons_rule/ │ │ │ │ ├── simpsons_rule.cpp │ │ │ │ └── simpsons_rule.py │ │ │ ├── smallest_digit_in_number/ │ │ │ │ ├── smallest_digit_in_number.c │ │ │ │ ├── smallest_digit_in_number.cpp │ │ │ │ ├── smallest_digit_in_number.cs │ │ │ │ ├── smallest_digit_in_number.hs │ │ │ │ ├── smallest_digit_in_number.java │ │ │ │ ├── smallest_digit_in_number.js │ │ │ │ ├── smallest_digit_in_number.php │ │ │ │ ├── smallest_digit_in_number.py │ │ │ │ └── smallest_digit_in_number.rb │ │ │ ├── spiral_matrix/ │ │ │ │ ├── recursive_spiral_matrix.cpp │ │ │ │ └── spiral_matrix_clockwise_cycle.cpp │ │ │ ├── square_free_number/ │ │ │ │ ├── square_free_number.c │ │ │ │ ├── square_free_number.cpp │ │ │ │ ├── square_free_number.py │ │ │ │ └── squarefreenumber.java │ │ │ ├── std/ │ │ │ │ ├── std.c │ │ │ │ ├── std.cpp │ │ │ │ ├── std.go │ │ │ │ ├── std.js │ │ │ │ └── std.py │ │ │ ├── steepest_descent/ │ │ │ │ └── steepest_descent.cpp │ │ │ ├── sum_of_digits/ │ │ │ │ ├── sum_of_digits.c │ │ │ │ ├── sum_of_digits.cpp │ │ │ │ ├── sum_of_digits.cs │ │ │ │ ├── sum_of_digits.ex │ │ │ │ ├── sum_of_digits.go │ │ │ │ ├── sum_of_digits.java │ │ │ │ ├── sum_of_digits.js │ │ │ │ ├── sum_of_digits.php │ │ │ │ ├── sum_of_digits.py │ │ │ │ ├── sum_of_digits.rb │ │ │ │ ├── sum_of_digits.rs │ │ │ │ ├── sum_of_digits.swift │ │ │ │ └── sum_of_digits_with_recursion.c │ │ │ ├── taxicab_numbers/ │ │ │ │ ├── taxicab_numbers.java │ │ │ │ └── taxicab_numbers.py │ │ │ ├── tower_of_hanoi/ │ │ │ │ ├── README.md │ │ │ │ ├── tower_of_hanoi.c │ │ │ │ ├── tower_of_hanoi.cpp │ │ │ │ ├── tower_of_hanoi.go │ │ │ │ ├── tower_of_hanoi.hs │ │ │ │ ├── tower_of_hanoi.java │ │ │ │ ├── tower_of_hanoi.js │ │ │ │ ├── tower_of_hanoi.ml │ │ │ │ ├── tower_of_hanoi.py │ │ │ │ ├── tower_of_hanoi.rs │ │ │ │ ├── tower_of_hanoi.scala │ │ │ │ ├── tower_of_hanoi_binary_solution.c │ │ │ │ └── tower_of_hanoi_iterative.c │ │ │ ├── tribonacci_numbers/ │ │ │ │ ├── tribonacci_numbers.c │ │ │ │ ├── tribonacci_numbers.cpp │ │ │ │ ├── tribonacci_numbers.go │ │ │ │ ├── tribonacci_numbers.java │ │ │ │ ├── tribonacci_numbers.js │ │ │ │ ├── tribonacci_numbers.py │ │ │ │ ├── tribonacci_numbers.rs │ │ │ │ └── tribonnaci.java │ │ │ └── tridiagonal_matrix/ │ │ │ ├── README.md │ │ │ └── tridiagonal_matrix.java │ │ └── test/ │ │ ├── README.md │ │ └── test_exponentiation_by_squaring.c │ ├── networking/ │ │ ├── src/ │ │ │ ├── README.md │ │ │ ├── determine_endianess/ │ │ │ │ ├── determine_endianess.c │ │ │ │ └── determine_endianess.sh │ │ │ ├── packetsniffer/ │ │ │ │ ├── README.md │ │ │ │ └── packetsniffer.py │ │ │ └── validate_ip/ │ │ │ ├── README.md │ │ │ ├── ValidateIp.java │ │ │ ├── ipv4_check.go │ │ │ ├── is_valid_ip.php │ │ │ ├── validate_connection_ipv4.py │ │ │ ├── validate_ip/ │ │ │ │ ├── validate_ipv4.c │ │ │ │ └── validate_ipv6.c │ │ │ ├── validate_ip.c │ │ │ ├── validate_ip.cc │ │ │ ├── validate_ip.rb │ │ │ ├── validate_ip.sh │ │ │ ├── validate_ipv4.js │ │ │ ├── validate_ipv4.py │ │ │ └── validate_ipv6.py │ │ └── test/ │ │ └── README.md │ ├── numerical_analysis/ │ │ ├── adam_bashforth/ │ │ │ └── src/ │ │ │ └── adam_bashforth.py │ │ ├── bisection/ │ │ │ └── src/ │ │ │ └── Bisection Method.cpp │ │ ├── false_position/ │ │ │ └── src/ │ │ │ └── False Position.cpp │ │ ├── gauss_jacobi/ │ │ │ └── src/ │ │ │ └── Gauss Jacobi.cpp │ │ ├── gauss_seidal/ │ │ │ └── src/ │ │ │ └── Gauss Seidal.cpp │ │ ├── integral/ │ │ │ └── src/ │ │ │ ├── integral_rectangle.c │ │ │ ├── integral_rectangle.cpp │ │ │ ├── integral_rectangle.java │ │ │ ├── integral_rectangle.py │ │ │ ├── integral_trapezoid.c │ │ │ ├── integral_trapezoid.cpp │ │ │ ├── integral_trapezoid.java │ │ │ └── integral_trapezoid.py │ │ ├── iteration/ │ │ │ └── src/ │ │ │ └── Iteration Method.cpp │ │ ├── monte_carlo/ │ │ │ └── src/ │ │ │ ├── integral_monte_carlo.cpp │ │ │ ├── integral_montecarlo.c │ │ │ ├── integral_montecarlo.py │ │ │ ├── pi_monte_carlo.cpp │ │ │ ├── pi_montecarlo.c │ │ │ └── pi_montecarlo.py │ │ ├── newton_rapson/ │ │ │ └── src/ │ │ │ └── Newton Rapson Method.cpp │ │ ├── polynomial_interpolations/ │ │ │ └── src/ │ │ │ ├── lagrange_interpolation.py │ │ │ └── nevilles_method.py │ │ └── runge_kutt/ │ │ └── src/ │ │ ├── rk4.c │ │ ├── rk4.cpp │ │ └── rk4.py │ ├── online_challenges/ │ │ ├── src/ │ │ │ ├── README.md │ │ │ ├── codechef/ │ │ │ │ ├── AMSGAME1/ │ │ │ │ │ ├── AMSGAME1.c │ │ │ │ │ └── README.md │ │ │ │ ├── BACREP/ │ │ │ │ │ ├── BACREP.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── BRKBKS/ │ │ │ │ │ ├── Brkbks.java │ │ │ │ │ └── README.md │ │ │ │ ├── CARVANS/ │ │ │ │ │ ├── CARVANS.c │ │ │ │ │ └── README.md │ │ │ │ ├── CASH/ │ │ │ │ │ ├── HardCash.java │ │ │ │ │ ├── README.md │ │ │ │ │ └── hard_cash.cpp │ │ │ │ ├── CHDIGER/ │ │ │ │ │ ├── CHDIGER.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── CHEALG/ │ │ │ │ │ ├── CHEALG.java │ │ │ │ │ └── README.md │ │ │ │ ├── CHEFING/ │ │ │ │ │ ├── CHEFING.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── CHFING/ │ │ │ │ │ ├── CHFING.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── CHNUM/ │ │ │ │ │ ├── CHNUM.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── CLEANUP/ │ │ │ │ │ ├── CLEANUP.c │ │ │ │ │ └── README.md │ │ │ │ ├── CNOTE/ │ │ │ │ │ ├── CNOTE.c │ │ │ │ │ └── README.md │ │ │ │ ├── COINS/ │ │ │ │ │ ├── COINS.py │ │ │ │ │ ├── README.md │ │ │ │ │ └── coins.cpp │ │ │ │ ├── CONFLIP/ │ │ │ │ │ ├── CONFLIP.c │ │ │ │ │ └── README.md │ │ │ │ ├── COVID19/ │ │ │ │ │ ├── COVID19.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── DIVIDING/ │ │ │ │ │ ├── DIVIDING.c │ │ │ │ │ └── README.md │ │ │ │ ├── EGGFREE/ │ │ │ │ │ ├── EGGFREE.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── EID2/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── eid2.cpp │ │ │ │ ├── ERROR/ │ │ │ │ │ ├── ERROR.c │ │ │ │ │ └── README.md │ │ │ │ ├── FCTRL/ │ │ │ │ │ ├── Factorial.c │ │ │ │ │ └── README.md │ │ │ │ ├── GCD2/ │ │ │ │ │ ├── GCD2.c │ │ │ │ │ └── README.md │ │ │ │ ├── GDOG/ │ │ │ │ │ ├── GDOG.c │ │ │ │ │ └── README.md │ │ │ │ ├── GUESSNUM/ │ │ │ │ │ ├── Guessnum.java │ │ │ │ │ └── README.md │ │ │ │ ├── Greedy Puppy/ │ │ │ │ │ ├── Greedy_Pupy.c │ │ │ │ │ └── README.md │ │ │ │ ├── HILLJUMP/ │ │ │ │ │ ├── HILLJUMP.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── HORSES/ │ │ │ │ │ ├── HORSES.c │ │ │ │ │ └── README.md │ │ │ │ ├── J7/ │ │ │ │ │ ├── J7.c │ │ │ │ │ └── README.md │ │ │ │ ├── JAIN/ │ │ │ │ │ ├── JAIN.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── JOHNY/ │ │ │ │ │ ├── JOHNY.c │ │ │ │ │ ├── JOHNY.cpp │ │ │ │ │ ├── JOHNY.py │ │ │ │ │ └── README.md │ │ │ │ ├── LAZERTST/ │ │ │ │ │ ├── LAZERTST.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── LEPERMUT/ │ │ │ │ │ ├── LEPERMUT.c │ │ │ │ │ └── README.md │ │ │ │ ├── MARBLES/ │ │ │ │ │ ├── MARBLES.c │ │ │ │ │ ├── MARBLES.py │ │ │ │ │ └── README.md │ │ │ │ ├── MARCHA1/ │ │ │ │ │ ├── MARCHA1.c │ │ │ │ │ └── README.md │ │ │ │ ├── MATCHES/ │ │ │ │ │ ├── Mathces.cpp │ │ │ │ │ ├── README.md │ │ │ │ │ └── matches.c │ │ │ │ ├── MAXDIFF/ │ │ │ │ │ ├── MAXDIFF.c │ │ │ │ │ └── README.md │ │ │ │ ├── MEETUP/ │ │ │ │ │ ├── MEETUP.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── MNMX/ │ │ │ │ │ ├── MNMX.c │ │ │ │ │ └── README.md │ │ │ │ ├── NBONACCI/ │ │ │ │ │ ├── NBONACCI.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── NEWSCH/ │ │ │ │ │ ├── NEWSCH.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── NUKES/ │ │ │ │ │ ├── NUKES.c │ │ │ │ │ └── README.md │ │ │ │ ├── NUMGAME2/ │ │ │ │ │ ├── NUMGAME2.c │ │ │ │ │ └── README.md │ │ │ │ ├── OJUMPS/ │ │ │ │ │ ├── OJUMPS.c │ │ │ │ │ └── README.md │ │ │ │ ├── P-BATTLE/ │ │ │ │ │ └── PBATTLE.cpp │ │ │ │ ├── PRIME1/ │ │ │ │ │ ├── PRIME1.c │ │ │ │ │ └── README.md │ │ │ │ ├── README.md │ │ │ │ ├── RESQ/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── RESQ.c │ │ │ │ ├── RIGHTRI/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── RIGHTRI.c │ │ │ │ ├── RRCOPY/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── RRCOPY.c │ │ │ │ ├── SALARY/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── SALARY.c │ │ │ │ ├── SLAB/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── SLAB.cpp │ │ │ │ │ └── Slab.java │ │ │ │ ├── SNUG_FIT/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── snug_fit.cpp │ │ │ │ ├── SPCANDY/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── SPCANDY.c │ │ │ │ ├── STFOOD/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── Stfood.java │ │ │ │ ├── STONES/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── STONES.c │ │ │ │ ├── STRWN/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── STRWN.cpp │ │ │ │ ├── STUPMACH/ │ │ │ │ │ └── Stupmach.java │ │ │ │ ├── TACHSTCK/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── TACHSTCK.c │ │ │ │ ├── TOTR/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── TOTR.c │ │ │ │ └── VOTERS/ │ │ │ │ ├── README.md │ │ │ │ └── VOTERS.c │ │ │ ├── hackerrank/ │ │ │ │ ├── 2d_array_ds/ │ │ │ │ │ └── 2d_array_ds.java │ │ │ │ ├── 3D_aurface_area/ │ │ │ │ │ ├── 3D_surface_area.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── Counting_Valleys/ │ │ │ │ │ ├── Counting_Valleys.cpp │ │ │ │ │ └── README.md │ │ │ │ ├── Electronics_Shop/ │ │ │ │ │ ├── Electronics_Shop.cpp │ │ │ │ │ └── Electronics_Shop.java │ │ │ │ ├── almost_sorted/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── almost_sorted.cpp │ │ │ │ ├── alternating_characters/ │ │ │ │ │ ├── Alternating.py │ │ │ │ │ └── README.md │ │ │ │ ├── array_manipulation/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── array_manipulation.cpp │ │ │ │ ├── bigger_is_greater/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── bigger_is_greater.cpp │ │ │ │ ├── dynamic_array/ │ │ │ │ │ └── dynamic_array.java │ │ │ │ ├── encryption/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── encryption.cpp │ │ │ │ ├── jumping_on_the_clouds/ │ │ │ │ │ ├── Readme.md │ │ │ │ │ └── Solution.java │ │ │ │ ├── lonely_integer/ │ │ │ │ │ └── lonely_integer.cpp │ │ │ │ └── the_maximum_subarray/ │ │ │ │ ├── README.md │ │ │ │ └── the_maximum_subarray.cpp │ │ │ ├── leetcode/ │ │ │ │ ├── Arranging_coins/ │ │ │ │ │ └── arranging_coins.cpp │ │ │ │ ├── Find_Minimum_in_Rotated_Sorted_Array/ │ │ │ │ │ └── FindMinimumInRotatedSortedArray.java │ │ │ │ ├── README.md │ │ │ │ ├── Sqrt(x)/ │ │ │ │ │ └── Sqrt(x).cpp │ │ │ │ ├── decode_string/ │ │ │ │ │ └── encryption_string.py │ │ │ │ ├── longest_substring_without_repetition/ │ │ │ │ │ └── longest_substring_without_repetition.cpp │ │ │ │ ├── max_distance_to_closest_person/ │ │ │ │ │ └── Solution.py │ │ │ │ ├── maximum_subarray/ │ │ │ │ │ └── maximumsubarray.cpp │ │ │ │ ├── median_of_two_sorted_arrays/ │ │ │ │ │ └── median_of_two_sorted_arrays.cpp │ │ │ │ ├── minimum_number_of_days_to_make_m_bouquets/ │ │ │ │ │ └── minimum_number_of_days_to_make_m_bouquets.cpp │ │ │ │ ├── remove_duplicates_from_sorted_list_ii/ │ │ │ │ │ └── remove_duplicates_from_sorted_list_ii.cpp │ │ │ │ ├── symmetric_tree/ │ │ │ │ │ └── symmetric_tree.cpp │ │ │ │ └── two_sum/ │ │ │ │ └── two_sum.cpp │ │ │ ├── project_euler/ │ │ │ │ ├── README.md │ │ │ │ ├── documentation_guide.md │ │ │ │ ├── problem_001/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_001.c │ │ │ │ │ ├── problem_001.cpp │ │ │ │ │ ├── problem_001.java │ │ │ │ │ ├── problem_001.js │ │ │ │ │ ├── problem_001.py │ │ │ │ │ └── problem_001.rs │ │ │ │ ├── problem_002/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_002.c │ │ │ │ │ ├── problem_002.cpp │ │ │ │ │ ├── problem_002.java │ │ │ │ │ ├── problem_002.js │ │ │ │ │ └── problem_002.py │ │ │ │ ├── problem_003/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_003.c │ │ │ │ │ ├── problem_003.cpp │ │ │ │ │ ├── problem_003.java │ │ │ │ │ ├── problem_003.js │ │ │ │ │ └── problem_003.py │ │ │ │ ├── problem_004/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_004.cpp │ │ │ │ │ ├── problem_004.java │ │ │ │ │ └── problem_004.py │ │ │ │ ├── problem_005/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_005.c │ │ │ │ │ ├── problem_005.cpp │ │ │ │ │ ├── problem_005.java │ │ │ │ │ └── problem_005.py │ │ │ │ ├── problem_006/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_006.cpp │ │ │ │ │ ├── problem_006.java │ │ │ │ │ └── problem_006.py │ │ │ │ ├── problem_007/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_007.cpp │ │ │ │ │ ├── problem_007.js │ │ │ │ │ └── problem_007.py │ │ │ │ ├── problem_008/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_008.java │ │ │ │ │ └── problem_008.py │ │ │ │ ├── problem_009/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_009.cpp │ │ │ │ │ ├── problem_009.java │ │ │ │ │ └── problem_009.py │ │ │ │ ├── problem_010/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_010.cpp │ │ │ │ │ ├── problem_010.java │ │ │ │ │ └── problem_010.py │ │ │ │ ├── problem_011/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_011.cpp │ │ │ │ ├── problem_012/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_012.cpp │ │ │ │ │ └── problem_012.py │ │ │ │ ├── problem_013/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_013.py │ │ │ │ ├── problem_014/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_014.cpp │ │ │ │ │ └── problem_014.py │ │ │ │ ├── problem_016/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_016.py │ │ │ │ ├── problem_017/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_017.cpp │ │ │ │ ├── problem_018/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_018.py │ │ │ │ ├── problem_019/ │ │ │ │ │ └── problem_019.java │ │ │ │ ├── problem_020/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_020.java │ │ │ │ │ └── problem_020.py │ │ │ │ ├── problem_021/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_021.cpp │ │ │ │ ├── problem_022/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_022.py │ │ │ │ ├── problem_023/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_023.cpp │ │ │ │ ├── problem_024/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_024.py │ │ │ │ ├── problem_025/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_025.cpp │ │ │ │ │ └── problem_025.py │ │ │ │ ├── problem_026/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_026.cpp │ │ │ │ ├── problem_027/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_027.cpp │ │ │ │ ├── problem_028/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_028.cpp │ │ │ │ │ └── problem_028.py │ │ │ │ ├── problem_034/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_034.cpp │ │ │ │ ├── problem_036/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── problem_036.cpp │ │ │ │ │ └── problem_036.py │ │ │ │ ├── problem_037/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_037.cpp │ │ │ │ ├── problem_040/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_040.py │ │ │ │ ├── problem_067/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── problem_067.py │ │ │ │ └── problem_102/ │ │ │ │ ├── README.md │ │ │ │ ├── problem_102.cpp │ │ │ │ └── triangles.txt │ │ │ └── rosalind/ │ │ │ ├── README.md │ │ │ └── complement_dna_strand/ │ │ │ ├── complement_dna.rs │ │ │ └── complement_dna_strand.exs │ │ └── test/ │ │ └── README.md │ ├── operating_system/ │ │ ├── src/ │ │ │ ├── README.md │ │ │ ├── concurrency/ │ │ │ │ ├── dining_philosophers/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── dining_philosophers.c │ │ │ │ ├── monitors/ │ │ │ │ │ └── monitors_system_v/ │ │ │ │ │ ├── main.c │ │ │ │ │ ├── monitors.c │ │ │ │ │ └── monitors.h │ │ │ │ ├── peterson_algorithm_for_mutual_exclusion/ │ │ │ │ │ └── peterson_algorithm_in_c/ │ │ │ │ │ ├── mythreads.h │ │ │ │ │ └── peterson_algo_mutual_exclusion_in_c.c │ │ │ │ ├── producer_consumer/ │ │ │ │ │ └── producer_consumer.cpp │ │ │ │ └── readers_writers/ │ │ │ │ └── readers_writers.cpp │ │ │ ├── deadlocks/ │ │ │ │ └── bankers_algorithm/ │ │ │ │ ├── README.md │ │ │ │ └── banker_safety.cpp │ │ │ ├── memory_management/ │ │ │ │ ├── least_recently_used/ │ │ │ │ │ ├── lru.c │ │ │ │ │ └── lru.cpp │ │ │ │ ├── memory_mapping/ │ │ │ │ │ └── mapping.c │ │ │ │ └── partitioned_allocation/ │ │ │ │ ├── best_fit.cpp │ │ │ │ ├── first_fit.cpp │ │ │ │ ├── next_fit.cpp │ │ │ │ └── worst_fit.cpp │ │ │ ├── processCreation/ │ │ │ │ ├── Processes.c │ │ │ │ ├── README.md │ │ │ │ └── vfork.c │ │ │ ├── scheduling/ │ │ │ │ ├── first_come_first_serve/ │ │ │ │ │ ├── fcfs.cpp │ │ │ │ │ ├── fcfs.cs │ │ │ │ │ ├── fcfs.java │ │ │ │ │ ├── fcfs.py │ │ │ │ │ └── fcfs.rs │ │ │ │ ├── guaranteed_scheduler/ │ │ │ │ │ └── guaranteed_scheduling.c │ │ │ │ ├── job_sequencing/ │ │ │ │ │ └── job_sequencing.cpp │ │ │ │ ├── multi_level_feedback_queue_scheduling/ │ │ │ │ │ └── mlfq.ts │ │ │ │ ├── priority_scheduling/ │ │ │ │ │ ├── priority_scheduling_non_preemptive.c │ │ │ │ │ └── priority_scheduling_preemptive.c │ │ │ │ ├── round_robin_scheduling/ │ │ │ │ │ ├── round_robin_c/ │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── queue.c │ │ │ │ │ │ ├── queue.h │ │ │ │ │ │ └── round_robin.c │ │ │ │ │ ├── round_robin_scheduling.cpp │ │ │ │ │ └── round_robin_scheduling.java │ │ │ │ ├── shortest_job_first/ │ │ │ │ │ ├── SJF.ASM │ │ │ │ │ └── sjf.cpp │ │ │ │ ├── shortest_seek_time_first/ │ │ │ │ │ ├── shortest_seek_time_first.c │ │ │ │ │ └── shortest_seek_time_first.cpp │ │ │ │ └── smallest_remaining_time_first/ │ │ │ │ └── srtf.c │ │ │ └── shell/ │ │ │ ├── README.md │ │ │ └── c/ │ │ │ ├── README.md │ │ │ ├── makefile │ │ │ └── shell.c │ │ └── test/ │ │ └── README.md │ ├── quantum_algorithms/ │ │ ├── grovers_algorithm/ │ │ │ ├── P1_grover_plot.py │ │ │ └── README.md │ │ └── shors_algorithm/ │ │ ├── P1_shor_primefactorization.py │ │ └── README.md │ ├── randomized_algorithms/ │ │ ├── src/ │ │ │ ├── README.md │ │ │ ├── birthday_paradox/ │ │ │ │ └── birthday_paradox.py │ │ │ ├── karger_minimum_cut_algorithm/ │ │ │ │ ├── README.md │ │ │ │ └── karger_minimum_cut_algorithm.cpp │ │ │ ├── kth_smallest_element_algorithm/ │ │ │ │ ├── README.md │ │ │ │ ├── kth_smallest_element.java │ │ │ │ ├── kth_smallest_element_algorithm.c │ │ │ │ └── kth_smallest_element_algorithm.cpp │ │ │ ├── random_from_stream/ │ │ │ │ └── random_number_selection_from_a_stream.cpp │ │ │ ├── random_node_linkedlist/ │ │ │ │ └── README.md │ │ │ ├── randomized_quick_sort/ │ │ │ │ ├── randomized_quicksort.c │ │ │ │ └── randomized_quicksort.cpp │ │ │ ├── reservoir_sampling/ │ │ │ │ ├── README.md │ │ │ │ ├── reservoir_sampling.cpp │ │ │ │ └── reservoir_sampling.rs │ │ │ └── shuffle_an_array/ │ │ │ ├── README.md │ │ │ ├── shuffle_an_array.cpp │ │ │ ├── shuffle_an_array.java │ │ │ ├── shuffle_an_array.js │ │ │ ├── shuffle_an_array.php │ │ │ ├── shuffle_an_array.py │ │ │ ├── shuffle_an_array.rb │ │ │ ├── shuffle_an_array.rs │ │ │ └── shuffle_library.rb │ │ └── test/ │ │ └── README.md │ ├── search/ │ │ ├── src/ │ │ │ ├── README.md │ │ │ ├── binary_search/ │ │ │ │ ├── BinarySearch.asm │ │ │ │ ├── README.md │ │ │ │ ├── binary_search.c │ │ │ │ ├── binary_search.cpp │ │ │ │ ├── binary_search.cs │ │ │ │ ├── binary_search.ex │ │ │ │ ├── binary_search.go │ │ │ │ ├── binary_search.hs │ │ │ │ ├── binary_search.java │ │ │ │ ├── binary_search.js │ │ │ │ ├── binary_search.kt │ │ │ │ ├── binary_search.php │ │ │ │ ├── binary_search.py │ │ │ │ ├── binary_search.rb │ │ │ │ ├── binary_search.rkt │ │ │ │ ├── binary_search.rs │ │ │ │ ├── binary_search.scala │ │ │ │ ├── binary_search.sh │ │ │ │ ├── binary_search.swift │ │ │ │ ├── binary_search_2.cpp │ │ │ │ └── binarysearchrecursion.cpp │ │ │ ├── exponential_search/ │ │ │ │ ├── README.md │ │ │ │ ├── exponential_search.c │ │ │ │ ├── exponential_search.cpp │ │ │ │ ├── exponential_search.cs │ │ │ │ ├── exponential_search.go │ │ │ │ ├── exponential_search.java │ │ │ │ ├── exponential_search.js │ │ │ │ ├── exponential_search.php │ │ │ │ ├── exponential_search.py │ │ │ │ ├── exponential_search.rb │ │ │ │ ├── exponential_search.rs │ │ │ │ └── exponential_search2.cpp │ │ │ ├── fibonacci_search/ │ │ │ │ ├── fibonacci_search.c │ │ │ │ ├── fibonacci_search.cpp │ │ │ │ ├── fibonacci_search.java │ │ │ │ ├── fibonacci_search.js │ │ │ │ ├── fibonacci_search.py │ │ │ │ └── fibonacci_search.swift │ │ │ ├── fuzzy_search/ │ │ │ │ ├── fuzzy_search.js │ │ │ │ └── fuzzy_search.php │ │ │ ├── interpolation_search/ │ │ │ │ ├── README.md │ │ │ │ ├── interpolation_search.c │ │ │ │ ├── interpolation_search.cpp │ │ │ │ ├── interpolation_search.go │ │ │ │ ├── interpolation_search.java │ │ │ │ ├── interpolation_search.js │ │ │ │ ├── interpolation_search.php │ │ │ │ └── interpolation_search.py │ │ │ ├── jump_search/ │ │ │ │ ├── README.md │ │ │ │ ├── jump_search.c │ │ │ │ ├── jump_search.cpp │ │ │ │ ├── jump_search.go │ │ │ │ ├── jump_search.java │ │ │ │ ├── jump_search.js │ │ │ │ ├── jump_search.php │ │ │ │ ├── jump_search.py │ │ │ │ ├── jump_search.rs │ │ │ │ └── jump_search.swift │ │ │ ├── linear_search/ │ │ │ │ ├── LINEAR_SEARCH.ASM │ │ │ │ ├── README.md │ │ │ │ ├── linear_search.c │ │ │ │ ├── linear_search.clj │ │ │ │ ├── linear_search.cpp │ │ │ │ ├── linear_search.cs │ │ │ │ ├── linear_search.go │ │ │ │ ├── linear_search.hs │ │ │ │ ├── linear_search.java │ │ │ │ ├── linear_search.js │ │ │ │ ├── linear_search.kt │ │ │ │ ├── linear_search.ml │ │ │ │ ├── linear_search.nim │ │ │ │ ├── linear_search.php │ │ │ │ ├── linear_search.py │ │ │ │ ├── linear_search.rb │ │ │ │ ├── linear_search.re │ │ │ │ ├── linear_search.rs │ │ │ │ ├── linear_search.scala │ │ │ │ ├── linear_search.swift │ │ │ │ └── sentinellinearsearch.cpp │ │ │ └── ternary_search/ │ │ │ ├── README.md │ │ │ ├── ternary_search.c │ │ │ ├── ternary_search.cpp │ │ │ ├── ternary_search.go │ │ │ ├── ternary_search.java │ │ │ ├── ternary_search.js │ │ │ ├── ternary_search.kt │ │ │ ├── ternary_search.php │ │ │ ├── ternary_search.py │ │ │ └── ternary_search.rs │ │ └── test/ │ │ ├── README.md │ │ ├── test_search.cpp │ │ └── test_search.py │ ├── selection_algorithms/ │ │ ├── src/ │ │ │ ├── README.md │ │ │ ├── median_of_medians/ │ │ │ │ ├── median_of_medians.c │ │ │ │ ├── median_of_medians.hs │ │ │ │ └── median_of_medians.py │ │ │ ├── quick_select.java │ │ │ ├── quick_select.kt │ │ │ ├── quick_select.swift │ │ │ ├── quickselect.cpp │ │ │ ├── quickselect.go │ │ │ ├── quickselect.py │ │ │ └── quickselect_stl.cpp │ │ └── test/ │ │ └── README.md │ ├── shell_script/ │ │ ├── Looping/ │ │ │ ├── README.md │ │ │ ├── for_loop/ │ │ │ │ ├── for_break.sh │ │ │ │ ├── for_continue.sh │ │ │ │ ├── for_ctype.sh │ │ │ │ ├── for_increment.sh │ │ │ │ ├── for_infinite.sh │ │ │ │ ├── for_items.sh │ │ │ │ ├── for_jump.sh │ │ │ │ ├── for_seq.sh │ │ │ │ └── forloop_tuple.sh │ │ │ └── while_loop/ │ │ │ ├── while_basics.sh │ │ │ └── while_infinite.sh │ │ ├── README.md │ │ ├── basic_scripts/ │ │ │ ├── README.md │ │ │ └── src/ │ │ │ ├── HelloWorld.sh │ │ │ ├── arithmetic.sh │ │ │ ├── commandlineargument.sh │ │ │ ├── deletevar.sh │ │ │ ├── inout.sh │ │ │ ├── readvar.sh │ │ │ ├── specialvar.sh │ │ │ └── variable.sh │ │ ├── control_structures/ │ │ │ ├── README.md │ │ │ └── src/ │ │ │ ├── if_elif_else.sh │ │ │ ├── if_else.sh │ │ │ └── switch_case.sh │ │ ├── deleting_old_archives.sh │ │ ├── functions/ │ │ │ ├── README.md │ │ │ └── src/ │ │ │ ├── func_parameters.sh │ │ │ ├── function.sh │ │ │ ├── multicall.sh │ │ │ ├── multiplefunctioncall.sh │ │ │ ├── nestedfunction.sh │ │ │ ├── return_code.sh │ │ │ └── scope.sh │ │ └── make_and_makefile/ │ │ ├── Makefile │ │ ├── README.md │ │ ├── add.c │ │ ├── divide.c │ │ ├── main.c │ │ ├── multiply.c │ │ ├── mycalculator │ │ ├── mymath.h │ │ └── subtract.c │ ├── sorting/ │ │ ├── src/ │ │ │ ├── Frequency_Sort/ │ │ │ │ └── Frequency_Sort.py │ │ │ ├── README.md │ │ │ ├── Wave_Sort/ │ │ │ │ └── Wave_Sort.py │ │ │ ├── bead_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── bead_sort.c │ │ │ │ ├── bead_sort.cpp │ │ │ │ ├── bead_sort.cs │ │ │ │ ├── bead_sort.java │ │ │ │ ├── bead_sort.js │ │ │ │ ├── bead_sort.m │ │ │ │ ├── bead_sort.php │ │ │ │ ├── bead_sort.py │ │ │ │ ├── bead_sort.swift │ │ │ │ └── bead_sort_numpy.py │ │ │ ├── bogo_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── bogo_or_permutation_sort.py │ │ │ │ ├── bogo_sort.c │ │ │ │ ├── bogo_sort.cpp │ │ │ │ ├── bogo_sort.fs │ │ │ │ ├── bogo_sort.go │ │ │ │ ├── bogo_sort.java │ │ │ │ ├── bogo_sort.js │ │ │ │ ├── bogo_sort.m │ │ │ │ ├── bogo_sort.pl │ │ │ │ ├── bogo_sort.py │ │ │ │ ├── bogo_sort.rb │ │ │ │ └── bogo_sort.swift │ │ │ ├── bubble_sort/ │ │ │ │ ├── BubbleSort.asm │ │ │ │ ├── README.md │ │ │ │ ├── bubble_sort.c │ │ │ │ ├── bubble_sort.cpp │ │ │ │ ├── bubble_sort.cs │ │ │ │ ├── bubble_sort.dart │ │ │ │ ├── bubble_sort.elm │ │ │ │ ├── bubble_sort.exs │ │ │ │ ├── bubble_sort.f │ │ │ │ ├── bubble_sort.go │ │ │ │ ├── bubble_sort.hs │ │ │ │ ├── bubble_sort.java │ │ │ │ ├── bubble_sort.jl │ │ │ │ ├── bubble_sort.js │ │ │ │ ├── bubble_sort.kt │ │ │ │ ├── bubble_sort.m │ │ │ │ ├── bubble_sort.php │ │ │ │ ├── bubble_sort.py │ │ │ │ ├── bubble_sort.rb │ │ │ │ ├── bubble_sort.rs │ │ │ │ ├── bubble_sort.sh │ │ │ │ ├── bubble_sort.sml │ │ │ │ ├── bubble_sort.swift │ │ │ │ ├── bubble_sort.ts │ │ │ │ ├── bubble_sort_efficient.cpp │ │ │ │ ├── bubble_sort_extension.swift │ │ │ │ ├── bubble_sort_linked_list.cpp │ │ │ │ └── bubble_sort_recursive.cpp │ │ │ ├── bucket_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── bucket_sort.c │ │ │ │ ├── bucket_sort.cpp │ │ │ │ ├── bucket_sort.cs │ │ │ │ ├── bucket_sort.go │ │ │ │ ├── bucket_sort.hs │ │ │ │ ├── bucket_sort.java │ │ │ │ ├── bucket_sort.js │ │ │ │ ├── bucket_sort.m │ │ │ │ ├── bucket_sort.php │ │ │ │ ├── bucket_sort.py │ │ │ │ ├── bucket_sort.rb │ │ │ │ ├── bucket_sort.swift │ │ │ │ └── bucket_sorting.cpp │ │ │ ├── circle_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── circle_sort.c │ │ │ │ ├── circle_sort.cpp │ │ │ │ ├── circle_sort.cs │ │ │ │ ├── circle_sort.java │ │ │ │ ├── circle_sort.js │ │ │ │ ├── circle_sort.m │ │ │ │ ├── circle_sort.py │ │ │ │ └── circle_sort.swift │ │ │ ├── cocktail_sort/ │ │ │ │ ├── cocktail_sort.c │ │ │ │ ├── cocktail_sort.java │ │ │ │ └── cocktail_sort.py │ │ │ ├── comb_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── comb_sort.c │ │ │ │ ├── comb_sort.cpp │ │ │ │ ├── comb_sort.go │ │ │ │ ├── comb_sort.java │ │ │ │ ├── comb_sort.js │ │ │ │ ├── comb_sort.m │ │ │ │ ├── comb_sort.py │ │ │ │ └── comb_sort.swift │ │ │ ├── counting_sort/ │ │ │ │ ├── Counting_sort.php │ │ │ │ ├── README.md │ │ │ │ ├── counting_sort.c │ │ │ │ ├── counting_sort.cpp │ │ │ │ ├── counting_sort.cs │ │ │ │ ├── counting_sort.go │ │ │ │ ├── counting_sort.java │ │ │ │ ├── counting_sort.js │ │ │ │ ├── counting_sort.m │ │ │ │ ├── counting_sort.py │ │ │ │ └── counting_sort.swift │ │ │ ├── cycle_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── cycle_sort.c │ │ │ │ ├── cycle_sort.cpp │ │ │ │ ├── cycle_sort.cs │ │ │ │ ├── cycle_sort.go │ │ │ │ ├── cycle_sort.java │ │ │ │ ├── cycle_sort.js │ │ │ │ ├── cycle_sort.m │ │ │ │ ├── cycle_sort.py │ │ │ │ └── cycle_sort.swift │ │ │ ├── flash_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── flash_sort.c │ │ │ │ ├── flash_sort.js │ │ │ │ ├── flash_sort.m │ │ │ │ └── flash_sort.swift │ │ │ ├── gnome_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── gnome_sort.c │ │ │ │ ├── gnome_sort.cpp │ │ │ │ ├── gnome_sort.go │ │ │ │ ├── gnome_sort.java │ │ │ │ ├── gnome_sort.js │ │ │ │ ├── gnome_sort.m │ │ │ │ ├── gnome_sort.py │ │ │ │ └── gnome_sort.swift │ │ │ ├── heap_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── heap_sort.c │ │ │ │ ├── heap_sort.cpp │ │ │ │ ├── heap_sort.cs │ │ │ │ ├── heap_sort.go │ │ │ │ ├── heap_sort.java │ │ │ │ ├── heap_sort.js │ │ │ │ ├── heap_sort.m │ │ │ │ ├── heap_sort.py │ │ │ │ ├── heap_sort.rb │ │ │ │ ├── heap_sort.rs │ │ │ │ ├── heap_sort.sc │ │ │ │ ├── heap_sort.swift │ │ │ │ └── heapsort.go │ │ │ ├── insertion_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── insertion_sort.c │ │ │ │ ├── insertion_sort.cpp │ │ │ │ ├── insertion_sort.cs │ │ │ │ ├── insertion_sort.dart │ │ │ │ ├── insertion_sort.go │ │ │ │ ├── insertion_sort.hs │ │ │ │ ├── insertion_sort.java │ │ │ │ ├── insertion_sort.js │ │ │ │ ├── insertion_sort.kt │ │ │ │ ├── insertion_sort.m │ │ │ │ ├── insertion_sort.ml │ │ │ │ ├── insertion_sort.php │ │ │ │ ├── insertion_sort.py │ │ │ │ ├── insertion_sort.rb │ │ │ │ ├── insertion_sort.re │ │ │ │ ├── insertion_sort.rs │ │ │ │ ├── insertion_sort.sh │ │ │ │ ├── insertion_sort.swift │ │ │ │ └── insertion_sort_extension.swift │ │ │ ├── intro_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── intro_sort.cpp │ │ │ │ ├── intro_sort.m │ │ │ │ └── intro_sort.swift │ │ │ ├── median_sort/ │ │ │ │ ├── median_sort.cpp │ │ │ │ ├── median_sort.cs │ │ │ │ ├── median_sort.m │ │ │ │ ├── median_sort.py │ │ │ │ ├── median_sort.swift │ │ │ │ └── median_sort_fast.cpp │ │ │ ├── merge_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── merge_sort.c │ │ │ │ ├── merge_sort.cpp │ │ │ │ ├── merge_sort.cs │ │ │ │ ├── merge_sort.fs │ │ │ │ ├── merge_sort.go │ │ │ │ ├── merge_sort.hs │ │ │ │ ├── merge_sort.java │ │ │ │ ├── merge_sort.js │ │ │ │ ├── merge_sort.kt │ │ │ │ ├── merge_sort.m │ │ │ │ ├── merge_sort.php │ │ │ │ ├── merge_sort.pl │ │ │ │ ├── merge_sort.py │ │ │ │ ├── merge_sort.rb │ │ │ │ ├── merge_sort.rs │ │ │ │ ├── merge_sort.scala │ │ │ │ ├── merge_sort.sh │ │ │ │ ├── merge_sort.swift │ │ │ │ ├── merge_sort.ts │ │ │ │ ├── merge_sort_extension.swift │ │ │ │ ├── merge_sort_linked_list.c │ │ │ │ └── merge_sort_linked_list.cpp │ │ │ ├── pancake_sort/ │ │ │ │ └── pancake_sort.cpp │ │ │ ├── pigeonhole_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── pigeonhole_sort.c │ │ │ │ ├── pigeonhole_sort.cpp │ │ │ │ ├── pigeonhole_sort.cs │ │ │ │ ├── pigeonhole_sort.go │ │ │ │ ├── pigeonhole_sort.java │ │ │ │ ├── pigeonhole_sort.js │ │ │ │ ├── pigeonhole_sort.m │ │ │ │ ├── pigeonhole_sort.php │ │ │ │ ├── pigeonhole_sort.py │ │ │ │ ├── pigeonhole_sort.swift │ │ │ │ └── pigeonholesort.scala │ │ │ ├── postmans_sort/ │ │ │ │ ├── postmans_sort.c │ │ │ │ └── postmans_sort.cpp │ │ │ ├── quick_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── dutch_national_flag.cpp │ │ │ │ ├── quick_sort.c │ │ │ │ ├── quick_sort.cpp │ │ │ │ ├── quick_sort.cs │ │ │ │ ├── quick_sort.elm │ │ │ │ ├── quick_sort.go │ │ │ │ ├── quick_sort.hs │ │ │ │ ├── quick_sort.java │ │ │ │ ├── quick_sort.js │ │ │ │ ├── quick_sort.lua │ │ │ │ ├── quick_sort.m │ │ │ │ ├── quick_sort.ml │ │ │ │ ├── quick_sort.py │ │ │ │ ├── quick_sort.rb │ │ │ │ ├── quick_sort.rs │ │ │ │ ├── quick_sort.scala │ │ │ │ ├── quick_sort.sh │ │ │ │ ├── quick_sort.swift │ │ │ │ ├── quick_sort.ts │ │ │ │ ├── quick_sort_extension.swift │ │ │ │ ├── quick_sort_in_place.scala │ │ │ │ ├── quick_sort_median_of_medians.c │ │ │ │ └── quick_sort_three_way.cpp │ │ │ ├── radix_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── radix_sort.c │ │ │ │ ├── radix_sort.cpp │ │ │ │ ├── radix_sort.go │ │ │ │ ├── radix_sort.hs │ │ │ │ ├── radix_sort.java │ │ │ │ ├── radix_sort.js │ │ │ │ ├── radix_sort.py │ │ │ │ ├── radix_sort.rs │ │ │ │ └── radix_sort.sh │ │ │ ├── selection_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── SELCTION_SORT.ASM │ │ │ │ ├── selection_sort.c │ │ │ │ ├── selection_sort.cpp │ │ │ │ ├── selection_sort.cs │ │ │ │ ├── selection_sort.go │ │ │ │ ├── selection_sort.hs │ │ │ │ ├── selection_sort.java │ │ │ │ ├── selection_sort.js │ │ │ │ ├── selection_sort.kt │ │ │ │ ├── selection_sort.m │ │ │ │ ├── selection_sort.php │ │ │ │ ├── selection_sort.py │ │ │ │ ├── selection_sort.rb │ │ │ │ ├── selection_sort.rs │ │ │ │ ├── selection_sort.sh │ │ │ │ ├── selection_sort.swift │ │ │ │ ├── selection_sort.vb │ │ │ │ └── selection_sort_extension.swift │ │ │ ├── shaker_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── shaker_sort.c │ │ │ │ ├── shaker_sort.cpp │ │ │ │ ├── shaker_sort.cs │ │ │ │ ├── shaker_sort.go │ │ │ │ ├── shaker_sort.java │ │ │ │ ├── shaker_sort.js │ │ │ │ ├── shaker_sort.m │ │ │ │ ├── shaker_sort.php │ │ │ │ ├── shaker_sort.py │ │ │ │ ├── shaker_sort.rs │ │ │ │ └── shaker_sort.swift │ │ │ ├── shell_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── shell_sort.c │ │ │ │ ├── shell_sort.cpp │ │ │ │ ├── shell_sort.go │ │ │ │ ├── shell_sort.java │ │ │ │ ├── shell_sort.js │ │ │ │ ├── shell_sort.kt │ │ │ │ ├── shell_sort.m │ │ │ │ ├── shell_sort.py │ │ │ │ ├── shell_sort.swift │ │ │ │ └── shellsort.go │ │ │ ├── sleep_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── sleep_sort.c │ │ │ │ ├── sleep_sort.cpp │ │ │ │ ├── sleep_sort.cs │ │ │ │ ├── sleep_sort.go │ │ │ │ ├── sleep_sort.java │ │ │ │ ├── sleep_sort.jl │ │ │ │ ├── sleep_sort.js │ │ │ │ ├── sleep_sort.m │ │ │ │ ├── sleep_sort.php │ │ │ │ ├── sleep_sort.py │ │ │ │ ├── sleep_sort.rb │ │ │ │ ├── sleep_sort.scala │ │ │ │ ├── sleep_sort.sh │ │ │ │ └── sleep_sort.swift │ │ │ ├── slow_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── slow_sort.cpp │ │ │ │ └── slow_sort.java │ │ │ ├── stooge_sort/ │ │ │ │ ├── README.md │ │ │ │ ├── stooge_sort.c │ │ │ │ ├── stooge_sort.cpp │ │ │ │ ├── stooge_sort.go │ │ │ │ ├── stooge_sort.java │ │ │ │ ├── stooge_sort.js │ │ │ │ └── stooge_sort.py │ │ │ ├── topological_sort/ │ │ │ │ ├── readme.md │ │ │ │ ├── topological_sort.c │ │ │ │ ├── topological_sort.cpp │ │ │ │ ├── topological_sort.java │ │ │ │ └── topological_sort.py │ │ │ └── tree_sort/ │ │ │ ├── README.md │ │ │ ├── tree_sort.c │ │ │ ├── tree_sort.cpp │ │ │ ├── tree_sort.go │ │ │ ├── tree_sort.java │ │ │ ├── tree_sort.js │ │ │ ├── tree_sort.php │ │ │ └── tree_sort.py │ │ └── test/ │ │ ├── README.md │ │ ├── test_sort.cpp │ │ ├── test_sort.py │ │ └── test_sort.swift │ ├── square_root_decomposition/ │ │ ├── src/ │ │ │ ├── README.md │ │ │ └── mos_algorithm/ │ │ │ ├── mos_algorithm.cpp │ │ │ └── sqrtdecomposition.py │ │ └── test/ │ │ └── README.md │ ├── string_algorithms/ │ │ ├── src/ │ │ │ ├── Longest_common_subsequence/ │ │ │ │ └── longest_common_subsequence.c │ │ │ ├── README.md │ │ │ ├── aho_corasick_algorithm/ │ │ │ │ ├── README.md │ │ │ │ ├── aho_corasick_algorithm.cpp │ │ │ │ ├── aho_corasick_algorithm.java │ │ │ │ └── aho_corasick_algorithm2.cpp │ │ │ ├── anagram_search/ │ │ │ │ ├── README.md │ │ │ │ ├── anagram.scala │ │ │ │ ├── anagram_search.c │ │ │ │ ├── anagram_search.cpp │ │ │ │ ├── anagram_search.cs │ │ │ │ ├── anagram_search.go │ │ │ │ ├── anagram_search.java │ │ │ │ ├── anagram_search.js │ │ │ │ ├── anagram_search.py │ │ │ │ ├── anagram_search.rb │ │ │ │ └── anagram_search.swift │ │ │ ├── arithmetic_on_large_numbers/ │ │ │ │ ├── string_addition.cpp │ │ │ │ ├── string_factorial.cpp │ │ │ │ ├── string_multiplication.cpp │ │ │ │ └── string_subtract.cpp │ │ │ ├── boyer_moore_algorithm/ │ │ │ │ ├── README.md │ │ │ │ ├── boyer_moore_algorithm.c │ │ │ │ ├── boyer_moore_algorithm.cpp │ │ │ │ └── boyer_moore_algorithm2.c │ │ │ ├── finite_automata/ │ │ │ │ ├── README.md │ │ │ │ ├── c/ │ │ │ │ │ ├── c/ │ │ │ │ │ │ └── makefile │ │ │ │ │ ├── dfa.c │ │ │ │ │ ├── dfa.h │ │ │ │ │ ├── main.c │ │ │ │ │ ├── types.c │ │ │ │ │ └── types.h │ │ │ │ ├── searchstringusingdfa.java │ │ │ │ └── searchstringusingdfa.rs │ │ │ ├── kasai_algorithm/ │ │ │ │ ├── README.md │ │ │ │ └── kasai_algorithm.cpp │ │ │ ├── kmp_algorithm/ │ │ │ │ ├── README.md │ │ │ │ ├── kmp.java │ │ │ │ ├── kmp.py │ │ │ │ └── kmp_algorithm.cpp │ │ │ ├── levenshtein_distance/ │ │ │ │ ├── README.md │ │ │ │ └── levenshteindistance.java │ │ │ ├── lexicographically_largest_palindrome_subsequence/ │ │ │ │ └── Lexicographyically_largest_palindrome_subsequence.cpp │ │ │ ├── lipogram_checker/ │ │ │ │ ├── lipogram_checker.cpp │ │ │ │ ├── lipogram_checker.cs │ │ │ │ ├── lipogram_checker.js │ │ │ │ └── lipogram_checker.py │ │ │ ├── longest_palindromic_substring/ │ │ │ │ ├── longest_palindromic_substring.cpp │ │ │ │ ├── longest_palindromic_substring.js │ │ │ │ └── longest_palindromic_substring.py │ │ │ ├── manachar_algorithm/ │ │ │ │ ├── manachar_longest_palindromic_subs.cpp │ │ │ │ └── manachar_longest_palindromic_subs.py │ │ │ ├── morse_code/ │ │ │ │ ├── morsecode.cpp │ │ │ │ ├── morsecode.go │ │ │ │ ├── morsecode.js │ │ │ │ ├── morsecode.php │ │ │ │ └── morsecode.py │ │ │ ├── naive_pattern_search/ │ │ │ │ ├── README.md │ │ │ │ ├── naive_pattern_search.cpp │ │ │ │ └── naive_pattern_search.py │ │ │ ├── palindrome_checker/ │ │ │ │ ├── palindrome.c │ │ │ │ ├── palindrome.clj │ │ │ │ ├── palindrome.cpp │ │ │ │ ├── palindrome.cr │ │ │ │ ├── palindrome.cs │ │ │ │ ├── palindrome.erl │ │ │ │ ├── palindrome.ex │ │ │ │ ├── palindrome.go │ │ │ │ ├── palindrome.hs │ │ │ │ ├── palindrome.java │ │ │ │ ├── palindrome.js │ │ │ │ ├── palindrome.kt │ │ │ │ ├── palindrome.lua │ │ │ │ ├── palindrome.php │ │ │ │ ├── palindrome.purs │ │ │ │ ├── palindrome.py │ │ │ │ ├── palindrome.rb │ │ │ │ ├── palindrome.rs │ │ │ │ ├── palindrome.sh │ │ │ │ ├── palindrome.swift │ │ │ │ └── palindrome.ts │ │ │ ├── palindrome_substring/ │ │ │ │ └── palindrome_substring.c │ │ │ ├── pangram_checker/ │ │ │ │ ├── README.md │ │ │ │ ├── pangram.cpp │ │ │ │ ├── pangram.java │ │ │ │ ├── pangram.rb │ │ │ │ ├── pangram_checker.c │ │ │ │ ├── pangram_checker.go │ │ │ │ ├── pangram_checker.js │ │ │ │ ├── pangram_checker.m │ │ │ │ ├── pangram_checker.php │ │ │ │ ├── pangram_checker.py │ │ │ │ ├── pangram_checker.swift │ │ │ │ └── pangram_checker.ts │ │ │ ├── password_strength_checker/ │ │ │ │ ├── README.md │ │ │ │ ├── pw_checker.cpp │ │ │ │ ├── pw_checker.cs │ │ │ │ ├── pw_checker.java │ │ │ │ ├── pw_checker.js │ │ │ │ └── pw_checker.py │ │ │ ├── rabin_karp_algorithm/ │ │ │ │ ├── README.md │ │ │ │ ├── rabinKarp.cpp │ │ │ │ ├── rabin_karp.c │ │ │ │ ├── rabin_karp.java │ │ │ │ └── rabin_karp.py │ │ │ ├── remove_dups/ │ │ │ │ ├── remove_dumps.py │ │ │ │ ├── remove_dups.c │ │ │ │ ├── remove_dups.cpp │ │ │ │ ├── remove_dups.js │ │ │ │ └── remove_dups.rs │ │ │ ├── reverse_word_string/ │ │ │ │ ├── reverse_word_string.cpp │ │ │ │ ├── reverse_word_string.js │ │ │ │ ├── reverse_word_string.py │ │ │ │ └── reverse_word_string.rs │ │ │ ├── string_matching/ │ │ │ │ └── NaiveStringmatching.py │ │ │ ├── suffix_array/ │ │ │ │ ├── README.md │ │ │ │ └── suffix_array.java │ │ │ ├── sum_of_numbers_string/ │ │ │ │ └── sum_of_numbers_string.py │ │ │ ├── trie_pattern_search/ │ │ │ │ ├── README.md │ │ │ │ └── trie_pattern_search.cpp │ │ │ └── z_algorithm/ │ │ │ ├── README.md │ │ │ ├── z_algorithm.cpp │ │ │ ├── z_algorithm.py │ │ │ └── z_algorithm_z_array.cpp │ │ └── test/ │ │ ├── README.md │ │ └── test_naive_pattern_search.cpp │ ├── theory_of_computation/ │ │ └── src/ │ │ ├── deterministic_finite_automaton/ │ │ │ ├── dfa.cpp │ │ │ ├── dfa.hh │ │ │ └── dfa.py │ │ ├── non_deterministic_finite_automata_to_finite_automata/ │ │ │ └── ndfa_to_dfa.cpp │ │ └── nondeterministic_finite_atomaton/ │ │ ├── nfa.cpp │ │ └── nfa.py │ └── unclassified/ │ ├── src/ │ │ ├── README.md │ │ ├── add_1_to_no_represented_as_array_of_digit/ │ │ │ └── add_1_to_no_represented_as_array_of_digit.py │ │ ├── add_one_to_number/ │ │ │ └── add_one_to_number.cpp │ │ ├── array_to_set/ │ │ │ └── arraytoset_iterator.cpp │ │ ├── autobiographical_numbers/ │ │ │ ├── README.md │ │ │ └── autobiographical_numbers.cpp │ │ ├── average/ │ │ │ ├── average.c │ │ │ ├── average.cpp │ │ │ ├── average.cs │ │ │ ├── average.erl │ │ │ ├── average.es6.js │ │ │ ├── average.ex │ │ │ ├── average.go │ │ │ ├── average.java │ │ │ ├── average.js │ │ │ ├── average.nims │ │ │ ├── average.php │ │ │ ├── average.py │ │ │ ├── average.rb │ │ │ ├── average.rs │ │ │ ├── average.scala │ │ │ ├── average.sh │ │ │ ├── average.swift │ │ │ └── readme.md │ │ ├── biggest_of_n_numbers/ │ │ │ ├── biggest_of_n.js │ │ │ ├── biggest_of_n_numbers.c │ │ │ ├── biggest_of_n_numbers.cpp │ │ │ ├── biggest_of_n_numbers.cs │ │ │ ├── biggest_of_n_numbers.java │ │ │ ├── biggest_of_n_numbers.nims │ │ │ ├── biggest_of_n_numbers.py │ │ │ ├── biggest_of_n_numbers2.cpp │ │ │ └── readme.md │ │ ├── biggest_suffix/ │ │ │ ├── biggest_suffix.c │ │ │ ├── biggest_suffix.js │ │ │ └── readme.md │ │ ├── fifteen_puzzle/ │ │ │ ├── fifteen.c │ │ │ ├── log.txt │ │ │ ├── makefile │ │ │ └── readme.md │ │ ├── flutter_res/ │ │ │ └── README.md │ │ ├── jaccard_similarity/ │ │ │ ├── README.md │ │ │ ├── jaccard.c │ │ │ ├── jaccard.java │ │ │ ├── jaccard.js │ │ │ ├── jaccard.nims │ │ │ └── jaccard.py │ │ ├── josephus_problem/ │ │ │ ├── README.md │ │ │ ├── josephus.c │ │ │ ├── josephus.cpp │ │ │ ├── josephus.go │ │ │ ├── josephus.js │ │ │ └── josephus.py │ │ ├── krishnamurthy_number/ │ │ │ ├── README.md │ │ │ └── krishnamurthyNumber.py │ │ ├── lapindrom_checker/ │ │ │ ├── README.md │ │ │ ├── lapindrome_checker.cpp │ │ │ └── lapindrome_checker.py │ │ ├── leap_year/ │ │ │ ├── leap_year.c │ │ │ ├── leap_year.cpp │ │ │ ├── leap_year.cs │ │ │ ├── leap_year.go │ │ │ ├── leap_year.java │ │ │ ├── leap_year.nim │ │ │ ├── leap_year.py │ │ │ ├── leap_year.rs │ │ │ ├── leap_years.js │ │ │ └── readme.txt │ │ ├── magic_square/ │ │ │ ├── magic_square.c │ │ │ ├── magic_square.php │ │ │ ├── magic_square.py │ │ │ └── magic_square.swift │ │ ├── majority_element/ │ │ │ ├── majority_element.cpp │ │ │ └── majority_element_randomized.cpp │ │ ├── maximum_subarray_sum/ │ │ │ └── maximum_subarray_sum.cpp │ │ ├── median_of_two_sorted_arrays/ │ │ │ └── median_of_two_sorted_arrays.c │ │ ├── median_two_sortedArrayOfDifferentLength/ │ │ │ └── medianOfTwoSortedArrayOfDifferentLength.cpp │ │ ├── merge_arrays/ │ │ │ └── merge_arrays.cpp │ │ ├── minimum_subarray_size_with_degree/ │ │ │ └── minsubarraysizewithdegree.cpp │ │ ├── move_zeroes_to_end/ │ │ │ ├── move_zeroes_to_end.cpp │ │ │ └── move_zeroes_to_end.py │ │ ├── no_operator_addition/ │ │ │ └── addition.c │ │ ├── optimized_fibonacci/ │ │ │ └── optimized_fibonacci.cpp │ │ ├── paint_fill/ │ │ │ └── paint_fill.cpp │ │ ├── palindrome/ │ │ │ └── palindrome_check/ │ │ │ ├── palindrome.nim │ │ │ ├── palindrome.py │ │ │ ├── palindrome_check.c │ │ │ ├── palindrome_check.cpp │ │ │ ├── palindrome_check.cs │ │ │ ├── palindrome_check.java │ │ │ ├── palindrome_check.js │ │ │ └── palindrome_check.rb │ │ ├── range_sum_of_BST/ │ │ │ └── range_sum_of_bst.java │ │ ├── segregate_even_odd/ │ │ │ ├── segregate_even_odd.cpp │ │ │ └── segregate_even_odd.py │ │ ├── segregate_positive_negative/ │ │ │ └── segregate_positive_negative.cpp │ │ ├── smallest_number_to_the_left/ │ │ │ └── smallest.cpp │ │ ├── spiral_print/ │ │ │ ├── README.md │ │ │ ├── spiral_print.c │ │ │ ├── spiral_print.cpp │ │ │ ├── spiral_print.go │ │ │ ├── spiral_print.java │ │ │ └── spiral_print.py │ │ ├── split_list/ │ │ │ ├── split_array.js │ │ │ └── split_list.py │ │ ├── sum_numbers_string/ │ │ │ └── sum_numbers_string.cpp │ │ ├── tokenizer/ │ │ │ └── tokenizer.cpp │ │ ├── unique_number/ │ │ │ ├── unique_num_stl.cpp │ │ │ ├── unique_number.cpp │ │ │ ├── unique_number.java │ │ │ └── unique_number.py │ │ ├── unique_numbers/ │ │ │ └── unique_numbers.py │ │ └── utilities/ │ │ ├── convert2mp3.sh │ │ └── download_link.sh │ └── test/ │ ├── README.md │ ├── palindrome/ │ │ └── palindrome_check/ │ │ ├── README.md │ │ └── test_palindrome_check.cpp │ └── spiral_printing/ │ └── test_spiral_print.cpp ├── generate_dependencies.make ├── guides/ │ ├── README.md │ ├── coding_style/ │ │ ├── README.md │ │ ├── c/ │ │ │ └── README.md │ │ ├── c#/ │ │ │ ├── README.md │ │ │ └── tryCatch.md │ │ ├── c++/ │ │ │ ├── README.md │ │ │ └── uncrustify_tests/ │ │ │ ├── input/ │ │ │ │ └── space001.cpp │ │ │ ├── output/ │ │ │ │ └── space001.cpp │ │ │ └── test.sh │ │ ├── elixir/ │ │ │ └── README.md │ │ ├── f#/ │ │ │ └── README.md │ │ ├── go/ │ │ │ └── README.md │ │ ├── java/ │ │ │ └── README.md │ │ ├── javascript/ │ │ │ └── README.md │ │ ├── kotlin/ │ │ │ └── README.md │ │ ├── lisp/ │ │ │ └── README.md │ │ ├── ml/ │ │ │ └── README.md │ │ ├── pascal/ │ │ │ └── README.md │ │ ├── perl/ │ │ │ └── style.md │ │ ├── php/ │ │ │ └── README.md │ │ ├── python/ │ │ │ └── README.md │ │ ├── ruby/ │ │ │ └── README.md │ │ ├── rust/ │ │ │ └── README.md │ │ ├── swift/ │ │ │ └── README.md │ │ └── typescript/ │ │ └── README.md │ ├── documentation_guide.md │ └── installation_guides/ │ ├── README.md │ ├── c/ │ │ ├── README.md │ │ ├── linux/ │ │ │ └── README.md │ │ ├── mac/ │ │ │ └── README.md │ │ └── windows/ │ │ └── README.md │ ├── c++/ │ │ ├── README.md │ │ ├── linux/ │ │ │ └── README.md │ │ ├── mac/ │ │ │ └── README.md │ │ └── windows/ │ │ └── README.md │ ├── elixir/ │ │ ├── README.md │ │ ├── linux/ │ │ │ └── README.md │ │ ├── mac/ │ │ │ └── README.md │ │ └── windows/ │ │ └── README.md │ ├── go/ │ │ ├── README.md │ │ ├── linux/ │ │ │ └── README.md │ │ ├── mac/ │ │ │ └── README.md │ │ └── windows/ │ │ └── README.md │ ├── java/ │ │ ├── README.md │ │ ├── linux/ │ │ │ └── README.md │ │ ├── mac/ │ │ │ └── README.md │ │ └── windows/ │ │ └── README.md │ ├── javascript/ │ │ ├── README.md │ │ ├── linux/ │ │ │ └── README.md │ │ ├── mac/ │ │ │ └── README.md │ │ └── windows/ │ │ └── README.md │ ├── kotlin/ │ │ ├── README.md │ │ ├── linux/ │ │ │ └── README.md │ │ ├── mac/ │ │ │ └── README.md │ │ └── windows/ │ │ └── README.md │ ├── pascal/ │ │ ├── README.md │ │ ├── linux/ │ │ │ └── README.md │ │ ├── mac/ │ │ │ └── README.md │ │ └── windows/ │ │ └── README.md │ ├── python/ │ │ ├── README.md │ │ ├── linux/ │ │ │ └── README.md │ │ ├── mac/ │ │ │ └── README.md │ │ └── windows/ │ │ └── README.md │ ├── python_pip/ │ │ └── linux/ │ │ └── README.md │ ├── ruby/ │ │ ├── README.md │ │ ├── linux/ │ │ │ └── README.md │ │ ├── mac/ │ │ │ └── README.md │ │ └── windows/ │ │ └── README.md │ ├── rust/ │ │ ├── README.md │ │ ├── linux/ │ │ │ └── README.md │ │ ├── mac/ │ │ │ └── README.md │ │ └── windows/ │ │ └── README.md │ └── swift/ │ ├── README.md │ ├── linux/ │ │ └── README.md │ ├── mac/ │ │ └── README.md │ └── windows/ │ └── README.md ├── makefile ├── scripts/ │ ├── README.md │ ├── STATS.md │ ├── STATS.txt │ ├── build_cpp.sh │ ├── cpp_coding_style_checker.sh │ ├── filename_formatter.sh │ ├── global-metadata.py │ ├── global_metadata.json │ ├── javascript_code_style_checker.sh │ ├── metadata/ │ │ └── code/ │ │ ├── artificial_intelligence/ │ │ │ └── src/ │ │ │ ├── a_star/ │ │ │ │ └── data.json │ │ │ ├── artificial_neural_network/ │ │ │ │ └── data.json │ │ │ ├── autoenncoder/ │ │ │ │ └── data.json │ │ │ ├── convolutional_neural_network/ │ │ │ │ └── data.json │ │ │ ├── dbscan_clustering/ │ │ │ │ └── data.json │ │ │ ├── decision_tree/ │ │ │ │ └── data.json │ │ │ ├── factorization_machines/ │ │ │ │ └── data.json │ │ │ ├── gaussian_mixture_model/ │ │ │ │ └── data.json │ │ │ ├── gaussian_naive_bayes/ │ │ │ │ └── data.json │ │ │ ├── gradient_boosting_trees/ │ │ │ │ └── data.json │ │ │ ├── hierachical_clustering/ │ │ │ │ └── hierachical_clustering/ │ │ │ │ └── data.json │ │ │ ├── image_processing/ │ │ │ │ ├── canny/ │ │ │ │ │ └── data.json │ │ │ │ ├── data.json │ │ │ │ ├── erode_dilate/ │ │ │ │ │ └── data.json │ │ │ │ ├── houghtransform/ │ │ │ │ │ └── data.json │ │ │ │ ├── image_stitching/ │ │ │ │ │ └── data.json │ │ │ │ ├── prewittfilter/ │ │ │ │ │ └── data.json │ │ │ │ └── sobelfilter/ │ │ │ │ └── data.json │ │ │ ├── isodata_clustering/ │ │ │ │ └── data.json │ │ │ ├── k_means/ │ │ │ │ └── data.json │ │ │ ├── k_nearest_neighbours/ │ │ │ │ └── data.json │ │ │ ├── linear_regression/ │ │ │ │ └── linear_regression/ │ │ │ │ └── data.json │ │ │ ├── logistic_regression/ │ │ │ │ └── data.json │ │ │ ├── minimax/ │ │ │ │ └── data.json │ │ │ ├── naive_bayes/ │ │ │ │ └── data.json │ │ │ ├── nearest_sequence_memory/ │ │ │ │ └── nsm_matlab/ │ │ │ │ └── data.json │ │ │ ├── neural_network/ │ │ │ │ └── data.json │ │ │ ├── neural_style_transfer/ │ │ │ │ └── data.json │ │ │ ├── particle_swarm_optimization/ │ │ │ │ ├── gbestPSO/ │ │ │ │ │ └── data.json │ │ │ │ └── lbestPSO/ │ │ │ │ └── data.json │ │ │ ├── perceptron/ │ │ │ │ └── data.json │ │ │ ├── principal_component_analysis/ │ │ │ │ └── data.json │ │ │ ├── q_learning/ │ │ │ │ └── data.json │ │ │ ├── random_forests/ │ │ │ │ └── data.json │ │ │ ├── restricted_boltzmann_machine/ │ │ │ │ └── data.json │ │ │ ├── sat/ │ │ │ │ └── data.json │ │ │ ├── support_vector_machine/ │ │ │ │ └── data.json │ │ │ ├── t_distributed_stochastic_neighbor_embedding/ │ │ │ │ └── data.json │ │ │ └── tsp/ │ │ │ └── data.json │ │ ├── backtracking/ │ │ │ └── src/ │ │ │ ├── algorithm_x/ │ │ │ │ └── data.json │ │ │ ├── crossword_puzzle/ │ │ │ │ └── data.json │ │ │ ├── knight_tour/ │ │ │ │ └── data.json │ │ │ ├── m_coloring_problem/ │ │ │ │ └── data.json │ │ │ ├── n_queen/ │ │ │ │ └── data.json │ │ │ ├── number_of_ways_in_maze/ │ │ │ │ └── data.json │ │ │ ├── partitions_of_number/ │ │ │ │ └── data.json │ │ │ ├── partitions_of_set/ │ │ │ │ └── data.json │ │ │ ├── permutations_of_string/ │ │ │ │ └── data.json │ │ │ ├── powerset/ │ │ │ │ └── data.json │ │ │ ├── rat_in_a_maze/ │ │ │ │ └── data.json │ │ │ ├── subset_sum/ │ │ │ │ └── data.json │ │ │ └── sudoku_solve/ │ │ │ └── data.json │ │ ├── bit_manipulation/ │ │ │ └── src/ │ │ │ ├── addition_using_bits/ │ │ │ │ └── data.json │ │ │ ├── bit_division/ │ │ │ │ └── data.json │ │ │ ├── byte_swapper/ │ │ │ │ └── data.json │ │ │ ├── convert_number_binary/ │ │ │ │ └── data.json │ │ │ ├── count_set_bits/ │ │ │ │ └── data.json │ │ │ ├── flip_bits/ │ │ │ │ └── data.json │ │ │ ├── hamming_distance/ │ │ │ │ └── data.json │ │ │ ├── invert_bit/ │ │ │ │ └── data.json │ │ │ ├── lonely_integer/ │ │ │ │ └── data.json │ │ │ ├── magic_number/ │ │ │ │ └── data.json │ │ │ ├── maximum_xor_value/ │ │ │ │ └── data.json │ │ │ ├── power_of_2/ │ │ │ │ └── data.json │ │ │ ├── subset_generation/ │ │ │ │ └── data.json │ │ │ ├── sum_binary_numbers/ │ │ │ │ └── data.json │ │ │ ├── sum_equals_xor/ │ │ │ │ └── data.json │ │ │ ├── thrice_unique_number/ │ │ │ │ └── data.json │ │ │ ├── twice_unique_number/ │ │ │ │ └── data.json │ │ │ └── xor_swap/ │ │ │ └── data.json │ │ ├── cellular_automaton/ │ │ │ └── src/ │ │ │ ├── brians_brain/ │ │ │ │ └── data.json │ │ │ ├── conways_game_of_life/ │ │ │ │ └── data.json │ │ │ ├── elementary_cellular_automata/ │ │ │ │ └── data.json │ │ │ ├── genetic_algorithm/ │ │ │ │ └── data.json │ │ │ ├── langtons_ant/ │ │ │ │ └── data.json │ │ │ ├── nobili_cellular_automata/ │ │ │ │ └── data.json │ │ │ └── von_neumann_cellular_automata/ │ │ │ └── data.json │ │ ├── compression/ │ │ │ └── src/ │ │ │ ├── lossless_compression/ │ │ │ │ ├── data.json │ │ │ │ ├── huffman/ │ │ │ │ │ └── data.json │ │ │ │ └── lempel_ziv_welch/ │ │ │ │ └── data.json │ │ │ └── lossy_compression/ │ │ │ └── data.json │ │ ├── computational_geometry/ │ │ │ └── src/ │ │ │ ├── 2d_line_intersection/ │ │ │ │ └── data.json │ │ │ ├── 2d_separating_axis_test/ │ │ │ │ └── data.json │ │ │ ├── area_of_polygon/ │ │ │ │ └── data.json │ │ │ ├── area_of_triangle/ │ │ │ │ └── data.json │ │ │ ├── axis_aligned_bounding_box_collision/ │ │ │ │ └── data.json │ │ │ ├── bresenham_circle/ │ │ │ │ └── data.json │ │ │ ├── bresenham_line/ │ │ │ │ └── data.json │ │ │ ├── chans_algorithm/ │ │ │ │ └── data.json │ │ │ ├── cohen_sutherland_lineclip/ │ │ │ │ └── data.json │ │ │ ├── dda_line/ │ │ │ │ └── data.json │ │ │ ├── distance_between_points/ │ │ │ │ └── data.json │ │ │ ├── graham_scan/ │ │ │ │ └── data.json │ │ │ ├── halfplane_intersection/ │ │ │ │ └── data.json │ │ │ ├── jarvis_march/ │ │ │ │ └── data.json │ │ │ ├── quickhull/ │ │ │ │ └── data.json │ │ │ ├── sphere_tetrahedron_intersection/ │ │ │ │ └── data.json │ │ │ └── sutherland_hodgeman_clipping/ │ │ │ └── data.json │ │ ├── computer_graphics/ │ │ │ └── src/ │ │ │ └── diamond_square/ │ │ │ └── data.json │ │ ├── cryptography/ │ │ │ └── src/ │ │ │ ├── aes_128/ │ │ │ │ ├── aes_csharp/ │ │ │ │ │ ├── data.json │ │ │ │ │ └── example/ │ │ │ │ │ └── data.json │ │ │ │ └── data.json │ │ │ ├── affine_cipher/ │ │ │ │ └── data.json │ │ │ ├── atbash_cipher/ │ │ │ │ └── data.json │ │ │ ├── autokey_cipher/ │ │ │ │ └── data.json │ │ │ ├── baconian_cipher/ │ │ │ │ └── data.json │ │ │ ├── caesar_cipher/ │ │ │ │ └── data.json │ │ │ ├── columnar_transposition_cipher/ │ │ │ │ └── data.json │ │ │ ├── huffman_encoding/ │ │ │ │ └── data.json │ │ │ ├── morse_cipher/ │ │ │ │ └── data.json │ │ │ ├── polybius_cipher/ │ │ │ │ └── data.json │ │ │ ├── porta_cipher/ │ │ │ │ └── data.json │ │ │ ├── rail_fence_cipher/ │ │ │ │ └── data.json │ │ │ ├── rot13_cipher/ │ │ │ │ └── data.json │ │ │ ├── rsa/ │ │ │ │ └── data.json │ │ │ ├── rsa_digital_signature/ │ │ │ │ └── data.json │ │ │ ├── runningkey_cipher/ │ │ │ │ └── data.json │ │ │ ├── sha/ │ │ │ │ └── sha_256/ │ │ │ │ └── data.json │ │ │ └── vigenere_cipher/ │ │ │ └── data.json │ │ ├── data_structures/ │ │ │ └── src/ │ │ │ ├── bag/ │ │ │ │ └── data.json │ │ │ ├── binary_heap/ │ │ │ │ └── data.json │ │ │ ├── hashs/ │ │ │ │ ├── bloom_filter/ │ │ │ │ │ └── data.json │ │ │ │ └── hash_table/ │ │ │ │ └── data.json │ │ │ ├── linked_list/ │ │ │ │ └── data.json │ │ │ ├── list/ │ │ │ │ ├── circular_linked_list/ │ │ │ │ │ ├── data.json │ │ │ │ │ └── operations/ │ │ │ │ │ └── data.json │ │ │ │ ├── data.json │ │ │ │ ├── doubly_linked_list/ │ │ │ │ │ ├── c/ │ │ │ │ │ │ └── data.json │ │ │ │ │ └── data.json │ │ │ │ ├── singly_linked_list/ │ │ │ │ │ ├── data.json │ │ │ │ │ ├── menu_interface/ │ │ │ │ │ │ └── data.json │ │ │ │ │ └── operations/ │ │ │ │ │ ├── delete/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── detect_cycle/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── find/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── insertion/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── merge_sorted/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── n_th_node_linked_list/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── print_reverse/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── push/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── reverse/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── rotate/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── sort/ │ │ │ │ │ │ └── data.json │ │ │ │ │ └── unclassified/ │ │ │ │ │ └── data.json │ │ │ │ ├── skip_list/ │ │ │ │ │ └── data.json │ │ │ │ └── xor_linked_list/ │ │ │ │ └── data.json │ │ │ ├── other/ │ │ │ │ └── data.json │ │ │ ├── queue/ │ │ │ │ ├── circular_buffer/ │ │ │ │ │ └── data.json │ │ │ │ ├── double_ended_queue/ │ │ │ │ │ └── data.json │ │ │ │ ├── queue/ │ │ │ │ │ └── data.json │ │ │ │ ├── queue_stream/ │ │ │ │ │ └── data.json │ │ │ │ ├── queue_using_linked_list/ │ │ │ │ │ └── data.json │ │ │ │ ├── queue_using_stack/ │ │ │ │ │ └── data.json │ │ │ │ └── reverse_queue/ │ │ │ │ └── data.json │ │ │ ├── stack/ │ │ │ │ ├── abstract_stack/ │ │ │ │ │ ├── cpp/ │ │ │ │ │ │ ├── arraystack/ │ │ │ │ │ │ │ └── data.json │ │ │ │ │ │ └── data.json │ │ │ │ │ └── data.json │ │ │ │ ├── balanced_expression/ │ │ │ │ │ └── data.json │ │ │ │ ├── infix_to_postfix/ │ │ │ │ │ └── data.json │ │ │ │ ├── postfix_evaluation/ │ │ │ │ │ └── data.json │ │ │ │ ├── prefix_to_postfix/ │ │ │ │ │ └── data.json │ │ │ │ ├── reverse_stack/ │ │ │ │ │ └── data.json │ │ │ │ ├── sort_stack/ │ │ │ │ │ └── data.json │ │ │ │ └── stack/ │ │ │ │ └── data.json │ │ │ └── tree/ │ │ │ ├── b_tree/ │ │ │ │ ├── b_tree/ │ │ │ │ │ ├── b_tree_c/ │ │ │ │ │ │ └── data.json │ │ │ │ │ └── data.json │ │ │ │ └── two_three_tree/ │ │ │ │ └── data.json │ │ │ ├── binary_tree/ │ │ │ │ ├── aa_tree/ │ │ │ │ │ └── data.json │ │ │ │ ├── avl_tree/ │ │ │ │ │ └── data.json │ │ │ │ ├── binary_tree/ │ │ │ │ │ ├── convert_to_doubly_linked_list/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── data.json │ │ │ │ │ ├── diameter/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── is_balance/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── is_binary_tree/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── is_same/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── make_binary_tree/ │ │ │ │ │ │ ├── data.json │ │ │ │ │ │ ├── from_inorder_and_postorder/ │ │ │ │ │ │ │ └── data.json │ │ │ │ │ │ └── from_inorder_and_preorder/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── make_mirror_tree/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── maximum_height/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── minimum_height/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── node/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── path_sum/ │ │ │ │ │ │ ├── data.json │ │ │ │ │ │ └── sum_left/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── serializer/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── traversal/ │ │ │ │ │ │ ├── inorder/ │ │ │ │ │ │ │ └── right_threaded/ │ │ │ │ │ │ │ └── data.json │ │ │ │ │ │ ├── preorder/ │ │ │ │ │ │ │ ├── left_view/ │ │ │ │ │ │ │ │ └── data.json │ │ │ │ │ │ │ └── right_view/ │ │ │ │ │ │ │ └── data.json │ │ │ │ │ │ └── zigzag/ │ │ │ │ │ │ └── data.json │ │ │ │ │ └── tree/ │ │ │ │ │ ├── bottom_view_binary_tree/ │ │ │ │ │ │ └── data.json │ │ │ │ │ └── data.json │ │ │ │ ├── rope/ │ │ │ │ │ └── data.json │ │ │ │ └── treap/ │ │ │ │ └── data.json │ │ │ ├── heap/ │ │ │ │ ├── binomial_heap/ │ │ │ │ │ └── data.json │ │ │ │ ├── data.json │ │ │ │ ├── max_heap/ │ │ │ │ │ └── data.json │ │ │ │ ├── min_heap/ │ │ │ │ │ └── data.json │ │ │ │ ├── pairing_heap/ │ │ │ │ │ └── data.json │ │ │ │ ├── priority_queue/ │ │ │ │ │ ├── data.json │ │ │ │ │ └── leftist_tree/ │ │ │ │ │ └── data.json │ │ │ │ └── soft_heap/ │ │ │ │ └── data.json │ │ │ ├── multiway_tree/ │ │ │ │ ├── fenwick_tree/ │ │ │ │ │ └── data.json │ │ │ │ ├── red_black_tree/ │ │ │ │ │ └── data.json │ │ │ │ ├── splay_tree/ │ │ │ │ │ └── data.json │ │ │ │ ├── union_find/ │ │ │ │ │ └── data.json │ │ │ │ └── van_emde_boas_tree/ │ │ │ │ └── data.json │ │ │ ├── space_partitioning_tree/ │ │ │ │ ├── interval_tree/ │ │ │ │ │ └── data.json │ │ │ │ ├── kd_tree/ │ │ │ │ │ └── data.json │ │ │ │ ├── quad_tree/ │ │ │ │ │ └── data.json │ │ │ │ └── segment_tree/ │ │ │ │ └── data.json │ │ │ └── tree/ │ │ │ ├── suffix_array/ │ │ │ │ └── data.json │ │ │ └── trie/ │ │ │ └── data.json │ │ ├── design_pattern/ │ │ │ └── src/ │ │ │ ├── OOP_patterns/ │ │ │ │ ├── adapter/ │ │ │ │ │ ├── data.json │ │ │ │ │ └── soldiers/ │ │ │ │ │ └── data.json │ │ │ │ ├── builder/ │ │ │ │ │ └── builder/ │ │ │ │ │ └── data.json │ │ │ │ ├── facade/ │ │ │ │ │ ├── daily/ │ │ │ │ │ │ └── tasks/ │ │ │ │ │ │ ├── data.json │ │ │ │ │ │ ├── evening/ │ │ │ │ │ │ │ └── routine/ │ │ │ │ │ │ │ └── data.json │ │ │ │ │ │ ├── gym/ │ │ │ │ │ │ │ └── data.json │ │ │ │ │ │ └── job/ │ │ │ │ │ │ └── data.json │ │ │ │ │ └── data.json │ │ │ │ ├── factory/ │ │ │ │ │ ├── data.json │ │ │ │ │ └── gifts/ │ │ │ │ │ └── data.json │ │ │ │ ├── observer_java/ │ │ │ │ │ ├── data.json │ │ │ │ │ └── observer/ │ │ │ │ │ ├── data.json │ │ │ │ │ └── network/ │ │ │ │ │ └── data.json │ │ │ │ ├── observer_pattern/ │ │ │ │ │ └── data.json │ │ │ │ ├── proxy/ │ │ │ │ │ ├── demo/ │ │ │ │ │ │ └── data.json │ │ │ │ │ └── protection/ │ │ │ │ │ └── proxy/ │ │ │ │ │ └── data.json │ │ │ │ └── singleton_pattern/ │ │ │ │ └── data.json │ │ │ ├── builder_pattern/ │ │ │ │ └── data.json │ │ │ ├── functional_patterns/ │ │ │ │ ├── data.json │ │ │ │ └── functional_patterns/ │ │ │ │ └── scala/ │ │ │ │ └── src/ │ │ │ │ └── main/ │ │ │ │ └── scala/ │ │ │ │ ├── arrows/ │ │ │ │ │ └── arrow/ │ │ │ │ │ └── data.json │ │ │ │ ├── functors/ │ │ │ │ │ ├── applicative/ │ │ │ │ │ │ └── functor/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── bifunctor/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── contravariant/ │ │ │ │ │ │ └── data.json │ │ │ │ │ ├── multifunctor/ │ │ │ │ │ │ └── data.json │ │ │ │ │ └── profunctor/ │ │ │ │ │ └── data.json │ │ │ │ └── monads/ │ │ │ │ ├── comonad/ │ │ │ │ │ └── data.json │ │ │ │ ├── free/ │ │ │ │ │ └── monad/ │ │ │ │ │ └── data.json │ │ │ │ └── gonad/ │ │ │ │ └── data.json │ │ │ ├── iterator_pattern/ │ │ │ │ └── data.json │ │ │ └── policy_based_design/ │ │ │ └── data.json │ │ ├── divide_conquer/ │ │ │ └── src/ │ │ │ ├── closest_pair_of_points/ │ │ │ │ └── data.json │ │ │ ├── factorial/ │ │ │ │ └── data.json │ │ │ ├── inversion_count/ │ │ │ │ └── data.json │ │ │ ├── karatsuba_multiplication/ │ │ │ │ └── data.json │ │ │ ├── maximum_contiguous_subsequence_sum/ │ │ │ │ └── data.json │ │ │ ├── merge_sort_using_divide_and_conquer/ │ │ │ │ └── data.json │ │ │ ├── strassen_matrix_multiplication/ │ │ │ │ └── data.json │ │ │ ├── tournament_method_to_find_min_max/ │ │ │ │ └── data.json │ │ │ ├── warnock_algorithm/ │ │ │ │ └── data.json │ │ │ └── x_power_y/ │ │ │ └── data.json │ │ ├── dynamic_programming/ │ │ │ └── src/ │ │ │ ├── array_median/ │ │ │ │ └── data.json │ │ │ ├── boolean_parenthesization/ │ │ │ │ └── data.json │ │ │ ├── box_stacking/ │ │ │ │ └── data.json │ │ │ ├── coin_change/ │ │ │ │ └── data.json │ │ │ ├── digit_dp/ │ │ │ │ └── data.json │ │ │ ├── edit_distance/ │ │ │ │ └── data.json │ │ │ ├── egg_dropping_puzzle/ │ │ │ │ └── data.json │ │ │ ├── fibonacci/ │ │ │ │ └── data.json │ │ │ ├── house_robber/ │ │ │ │ └── data.json │ │ │ ├── knapsack/ │ │ │ │ └── data.json │ │ │ ├── largest_sum_contiguous_subarray/ │ │ │ │ └── data.json │ │ │ ├── longest_bitonic_sequence/ │ │ │ │ └── data.json │ │ │ ├── longest_common_increasing_subsequence/ │ │ │ │ └── data.json │ │ │ ├── longest_common_subsequence/ │ │ │ │ └── data.json │ │ │ ├── longest_common_substring/ │ │ │ │ └── data.json │ │ │ ├── longest_increasing_subsequence/ │ │ │ │ └── data.json │ │ │ ├── longest_independent_set/ │ │ │ │ └── data.json │ │ │ ├── longest_palindromic_sequence/ │ │ │ │ └── data.json │ │ │ ├── longest_repeating_subsequence/ │ │ │ │ └── data.json │ │ │ ├── matrix_chain_multiplication/ │ │ │ │ └── data.json │ │ │ ├── maximum_sum_increasing_subsequence/ │ │ │ │ └── data.json │ │ │ ├── maximum_sum_sub_matrix/ │ │ │ │ └── data.json │ │ │ ├── maximum_weight_independent_set_of_path_graph/ │ │ │ │ └── data.json │ │ │ ├── min_cost_path/ │ │ │ │ └── data.json │ │ │ ├── minimum_cost_polygon_triangulation/ │ │ │ │ └── data.json │ │ │ ├── minimum_insertion_palindrome/ │ │ │ │ └── data.json │ │ │ ├── no_consec_ones/ │ │ │ │ └── data.json │ │ │ ├── numeric_keypad_problem/ │ │ │ │ └── data.json │ │ │ ├── optimal_binary_search_tree/ │ │ │ │ └── data.json │ │ │ ├── palindrome_partition/ │ │ │ │ └── data.json │ │ │ ├── rod_cutting/ │ │ │ │ └── data.json │ │ │ ├── shortest_common_supersequence/ │ │ │ │ └── data.json │ │ │ ├── tiling_problem/ │ │ │ │ └── data.json │ │ │ └── weighted_job_scheduling/ │ │ │ └── data.json │ │ ├── filters/ │ │ │ └── src/ │ │ │ ├── gaussian_filter/ │ │ │ │ └── data.json │ │ │ └── median_filter/ │ │ │ └── data.json │ │ ├── game_theory/ │ │ │ └── src/ │ │ │ ├── game_of_nim_next_best_move/ │ │ │ │ └── data.json │ │ │ ├── game_of_nim_win_loss_prediction/ │ │ │ │ └── data.json │ │ │ └── grundy_numbers_kayle/ │ │ │ └── data.json │ │ ├── graph_algorithms/ │ │ │ └── src/ │ │ │ ├── adjacency_lists_graph_representation/ │ │ │ │ └── adjacency_lists_in_c/ │ │ │ │ └── data.json │ │ │ ├── astar_algorithm/ │ │ │ │ └── data.json │ │ │ ├── bellman_ford_algorithm/ │ │ │ │ └── data.json │ │ │ ├── biconnected_components/ │ │ │ │ └── data.json │ │ │ ├── bipartite_check/ │ │ │ │ └── data.json │ │ │ ├── bipartite_checking/ │ │ │ │ └── data.json │ │ │ ├── boruvka_minimum_spanning_tree/ │ │ │ │ └── data.json │ │ │ ├── breadth_first_search/ │ │ │ │ └── data.json │ │ │ ├── bridge_tree/ │ │ │ │ └── data.json │ │ │ ├── bridges_in_graph/ │ │ │ │ └── data.json │ │ │ ├── bron_kerbosch_algorithm/ │ │ │ │ └── data.json │ │ │ ├── centroid_decomposition/ │ │ │ │ └── data.json │ │ │ ├── channel_assignment/ │ │ │ │ └── data.json │ │ │ ├── connected_components/ │ │ │ │ └── data.json │ │ │ ├── count_of_ways_n/ │ │ │ │ └── data.json │ │ │ ├── cut_vertices/ │ │ │ │ └── data.json │ │ │ ├── cycle_directed_graph/ │ │ │ │ └── data.json │ │ │ ├── cycle_undirected_graph/ │ │ │ │ └── data.json │ │ │ ├── data_structures/ │ │ │ │ ├── adjacency_matrix_c/ │ │ │ │ │ └── data.json │ │ │ │ └── data.json │ │ │ ├── depth_first_search/ │ │ │ │ └── data.json │ │ │ ├── dinic_maximum_flow/ │ │ │ │ └── data.json │ │ │ ├── eulerian_path/ │ │ │ │ └── data.json │ │ │ ├── fleury_algorithm_euler_path/ │ │ │ │ └── data.json │ │ │ ├── floyd_warshall_algorithm/ │ │ │ │ └── data.json │ │ │ ├── ford_fulkerson_maximum_flow/ │ │ │ │ └── data.json │ │ │ ├── graph_coloring/ │ │ │ │ └── data.json │ │ │ ├── hamiltonian_cycle/ │ │ │ │ └── data.json │ │ │ ├── hamiltonian_path/ │ │ │ │ └── data.json │ │ │ ├── hopcroft_karp_algorithm/ │ │ │ │ └── data.json │ │ │ ├── johnson_algorithm_shortest_path/ │ │ │ │ └── data.json │ │ │ ├── karger_minimum_cut/ │ │ │ │ └── data.json │ │ │ ├── kuhn_maximum_matching/ │ │ │ │ └── data.json │ │ │ ├── kuhn_munkres_algorithm/ │ │ │ │ └── data.json │ │ │ ├── left_view_binary_tree/ │ │ │ │ └── data.json │ │ │ ├── longest_path_directed_acyclic_graph/ │ │ │ │ └── data.json │ │ │ ├── matrix_transformation/ │ │ │ │ └── data.json │ │ │ ├── maximum_bipartite_matching/ │ │ │ │ └── data.json │ │ │ ├── maximum_edge_disjoint_paths/ │ │ │ │ └── data.json │ │ │ ├── minimum_s_t_cut/ │ │ │ │ └── data.json │ │ │ ├── postorder_from_inorder_and_preorder/ │ │ │ │ └── data.json │ │ │ ├── push_relabel/ │ │ │ │ └── data.json │ │ │ ├── shortest_path_k_edges/ │ │ │ │ └── data.json │ │ │ ├── steiner_tree/ │ │ │ │ └── data.json │ │ │ ├── strongly_connected_components/ │ │ │ │ └── data.json │ │ │ ├── tarjan_algorithm_strongly_connected_components/ │ │ │ │ └── data.json │ │ │ ├── transitive_closure_graph/ │ │ │ │ └── data.json │ │ │ ├── travelling_salesman_mst/ │ │ │ │ └── data.json │ │ │ └── vertex_cover/ │ │ │ └── data.json │ │ ├── greedy_algorithms/ │ │ │ └── src/ │ │ │ ├── activity_selection/ │ │ │ │ └── data.json │ │ │ ├── dijkstra_shortest_path/ │ │ │ │ └── data.json │ │ │ ├── egyptian_fraction/ │ │ │ │ └── data.json │ │ │ ├── fractional_knapsack/ │ │ │ │ └── data.json │ │ │ ├── hillclimber/ │ │ │ │ └── data.json │ │ │ ├── huffman_coding/ │ │ │ │ └── data.json │ │ │ ├── job_sequencing/ │ │ │ │ └── data.json │ │ │ ├── k_centers/ │ │ │ │ └── data.json │ │ │ ├── kruskal_minimum_spanning_tree/ │ │ │ │ └── data.json │ │ │ ├── minimum_coins/ │ │ │ │ └── data.json │ │ │ ├── prim_minimum_spanning_tree/ │ │ │ │ └── data.json │ │ │ └── warshall/ │ │ │ └── data.json │ │ ├── languages/ │ │ │ └── c/ │ │ │ └── dynamic_memory_allocation/ │ │ │ └── data.json │ │ ├── mathematical_algorithms/ │ │ │ └── src/ │ │ │ ├── 2sum/ │ │ │ │ └── data.json │ │ │ ├── add_polynomials/ │ │ │ │ └── data.json │ │ │ ├── amicable_numbers/ │ │ │ │ └── data.json │ │ │ ├── armstrong_numbers/ │ │ │ │ └── data.json │ │ │ ├── automorphic_numbers/ │ │ │ │ └── data.json │ │ │ ├── average_stream_numbers/ │ │ │ │ └── data.json │ │ │ ├── babylonian_method/ │ │ │ │ └── data.json │ │ │ ├── binomial_coefficient/ │ │ │ │ └── data.json │ │ │ ├── catalan_number/ │ │ │ │ └── data.json │ │ │ ├── check_is_square/ │ │ │ │ └── data.json │ │ │ ├── collatz_conjecture_sequence/ │ │ │ │ └── data.json │ │ │ ├── convolution/ │ │ │ │ └── data.json │ │ │ ├── coprime_numbers/ │ │ │ │ └── data.json │ │ │ ├── count_digits/ │ │ │ │ └── data.json │ │ │ ├── count_trailing_zeroes/ │ │ │ │ └── data.json │ │ │ ├── decoding_of_string/ │ │ │ │ └── data.json │ │ │ ├── delannoy_number/ │ │ │ │ └── data.json │ │ │ ├── derangements/ │ │ │ │ └── data.json │ │ │ ├── dfa_division/ │ │ │ │ └── data.json │ │ │ ├── diophantine/ │ │ │ │ └── data.json │ │ │ ├── divided_differences/ │ │ │ │ └── data.json │ │ │ ├── euler_totient/ │ │ │ │ └── data.json │ │ │ ├── exponentiation_power/ │ │ │ │ ├── data.json │ │ │ │ └── exponentiation_by_squaring/ │ │ │ │ └── data.json │ │ │ ├── fast_fourier_transform/ │ │ │ │ └── data.json │ │ │ ├── fast_inverse_sqrt/ │ │ │ │ └── data.json │ │ │ ├── fermats_little_theorem/ │ │ │ │ └── data.json │ │ │ ├── fibonacci_number/ │ │ │ │ └── data.json │ │ │ ├── fractals/ │ │ │ │ └── data.json │ │ │ ├── gaussian_elimination/ │ │ │ │ ├── data.json │ │ │ │ └── scala/ │ │ │ │ └── src/ │ │ │ │ └── main/ │ │ │ │ └── scala/ │ │ │ │ ├── data.json │ │ │ │ ├── gaussian/ │ │ │ │ │ └── elimination/ │ │ │ │ │ └── data.json │ │ │ │ └── structures/ │ │ │ │ └── data.json │ │ │ ├── gcd_and_lcm/ │ │ │ │ └── data.json │ │ │ ├── greatest_digit_in_number/ │ │ │ │ └── data.json │ │ │ ├── hill_climbing/ │ │ │ │ └── data.json │ │ │ ├── horner_polynomial_evaluation/ │ │ │ │ └── data.json │ │ │ ├── integer_conversion/ │ │ │ │ └── data.json │ │ │ ├── integer_to_roman/ │ │ │ │ └── data.json │ │ │ ├── jacobi_method/ │ │ │ │ └── data.json │ │ │ ├── largrange_polynomial/ │ │ │ │ └── data.json │ │ │ ├── lexicographic_string_rank/ │ │ │ │ └── data.json │ │ │ ├── log_of_factorial/ │ │ │ │ └── data.json │ │ │ ├── lucas_theorem/ │ │ │ │ └── data.json │ │ │ ├── lucky_number/ │ │ │ │ └── data.json │ │ │ ├── modular_inverse/ │ │ │ │ └── data.json │ │ │ ├── multiply_polynomial/ │ │ │ │ └── data.json │ │ │ ├── newman_conway/ │ │ │ │ └── data.json │ │ │ ├── newton_polynomial/ │ │ │ │ └── data.json │ │ │ ├── newton_raphson_method/ │ │ │ │ └── data.json │ │ │ ├── next_larger_number/ │ │ │ │ └── data.json │ │ │ ├── pandigital_number/ │ │ │ │ └── data.json │ │ │ ├── pascal_triangle/ │ │ │ │ └── data.json │ │ │ ├── perfect_number/ │ │ │ │ └── data.json │ │ │ ├── permutation_lexicographic_order/ │ │ │ │ └── data.json │ │ │ ├── poisson_sample/ │ │ │ │ └── data.json │ │ │ ├── primality_tests/ │ │ │ │ ├── fermat_primality_test/ │ │ │ │ │ └── data.json │ │ │ │ ├── miller_rabin_primality_test/ │ │ │ │ │ └── data.json │ │ │ │ └── solovay_strassen_primality_test/ │ │ │ │ └── data.json │ │ │ ├── prime_factors/ │ │ │ │ └── data.json │ │ │ ├── prime_numbers_of_n/ │ │ │ │ └── data.json │ │ │ ├── pythagorean_triplet/ │ │ │ │ └── data.json │ │ │ ├── replace_0_with_5/ │ │ │ │ └── data.json │ │ │ ├── reverse_factorial/ │ │ │ │ └── data.json │ │ │ ├── reverse_number/ │ │ │ │ └── data.json │ │ │ ├── russian_peasant_multiplication/ │ │ │ │ └── data.json │ │ │ ├── segmented_sieve_of_eratosthenes/ │ │ │ │ └── data.json │ │ │ ├── shuffle_array/ │ │ │ │ └── data.json │ │ │ ├── sieve_of_atkin/ │ │ │ │ └── data.json │ │ │ ├── sieve_of_eratosthenes/ │ │ │ │ └── data.json │ │ │ ├── simpsons_rule/ │ │ │ │ └── data.json │ │ │ ├── smallest_digit_in_number/ │ │ │ │ └── data.json │ │ │ ├── square_free_number/ │ │ │ │ └── data.json │ │ │ ├── std/ │ │ │ │ └── data.json │ │ │ ├── steepest_descent/ │ │ │ │ └── data.json │ │ │ ├── sum_of_digits/ │ │ │ │ └── data.json │ │ │ ├── taxicab_numbers/ │ │ │ │ └── data.json │ │ │ ├── tower_of_hanoi/ │ │ │ │ └── data.json │ │ │ ├── tribonacci_numbers/ │ │ │ │ └── data.json │ │ │ └── tridiagonal_matrix/ │ │ │ └── data.json │ │ ├── networking/ │ │ │ └── src/ │ │ │ ├── determine_endianess/ │ │ │ │ └── data.json │ │ │ ├── packetsniffer/ │ │ │ │ └── data.json │ │ │ └── validate_ip/ │ │ │ └── validate_ip/ │ │ │ └── data.json │ │ ├── online_challenges/ │ │ │ └── src/ │ │ │ ├── codechef/ │ │ │ │ ├── CHDIGER/ │ │ │ │ │ └── data.json │ │ │ │ ├── CHNUM/ │ │ │ │ │ └── data.json │ │ │ │ ├── JAIN/ │ │ │ │ │ └── data.json │ │ │ │ ├── NBONACCI/ │ │ │ │ │ └── data.json │ │ │ │ └── data.json │ │ │ ├── hackerrank/ │ │ │ │ ├── 3D_aurface_area/ │ │ │ │ │ └── data.json │ │ │ │ ├── almost_sorted/ │ │ │ │ │ └── data.json │ │ │ │ ├── array_manipulation/ │ │ │ │ │ └── data.json │ │ │ │ ├── bigger_is_greater/ │ │ │ │ │ └── data.json │ │ │ │ ├── encryption/ │ │ │ │ │ └── data.json │ │ │ │ └── the_maximum_subarray/ │ │ │ │ └── data.json │ │ │ ├── project_euler/ │ │ │ │ ├── data.json │ │ │ │ ├── problem_001/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_002/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_003/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_004/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_005/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_006/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_007/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_008/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_009/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_010/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_012/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_013/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_014/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_016/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_018/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_019/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_020/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_021/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_022/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_024/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_025/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_026/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_028/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_034/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_036/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_037/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_040/ │ │ │ │ │ └── data.json │ │ │ │ ├── problem_067/ │ │ │ │ │ └── data.json │ │ │ │ └── problem_102/ │ │ │ │ └── data.json │ │ │ └── rosalind/ │ │ │ ├── complement_dna_strand/ │ │ │ │ └── data.json │ │ │ └── data.json │ │ ├── operating_system/ │ │ │ └── src/ │ │ │ ├── concurrency/ │ │ │ │ ├── dining_philosophers/ │ │ │ │ │ └── data.json │ │ │ │ ├── monitors/ │ │ │ │ │ └── monitors_system_v/ │ │ │ │ │ └── data.json │ │ │ │ ├── peterson_algorithm_for_mutual_exclusion/ │ │ │ │ │ └── peterson_algorithm_in_c/ │ │ │ │ │ └── data.json │ │ │ │ ├── producer_consumer/ │ │ │ │ │ └── data.json │ │ │ │ └── readers_writers/ │ │ │ │ └── data.json │ │ │ ├── deadlocks/ │ │ │ │ └── bankers_algorithm/ │ │ │ │ └── data.json │ │ │ ├── memory_management/ │ │ │ │ ├── least_recently_used/ │ │ │ │ │ └── data.json │ │ │ │ └── memory_mapping/ │ │ │ │ └── data.json │ │ │ ├── processCreation/ │ │ │ │ └── data.json │ │ │ ├── scheduling/ │ │ │ │ ├── first_come_first_serve/ │ │ │ │ │ └── data.json │ │ │ │ ├── multi_level_feedback_queue_scheduling/ │ │ │ │ │ └── data.json │ │ │ │ ├── round_robin_scheduling/ │ │ │ │ │ ├── data.json │ │ │ │ │ └── round_robin_c/ │ │ │ │ │ └── data.json │ │ │ │ ├── shortest_seek_time_first/ │ │ │ │ │ └── data.json │ │ │ │ └── smallest_remaining_time_first/ │ │ │ │ └── data.json │ │ │ └── shell/ │ │ │ └── data.json │ │ ├── randomized_algorithms/ │ │ │ └── src/ │ │ │ ├── birthday_paradox/ │ │ │ │ └── data.json │ │ │ ├── karger_minimum_cut_algorithm/ │ │ │ │ └── data.json │ │ │ ├── kth_smallest_element_algorithm/ │ │ │ │ └── data.json │ │ │ ├── random_from_stream/ │ │ │ │ └── data.json │ │ │ ├── random_node_linkedlist/ │ │ │ │ └── data.json │ │ │ ├── randomized_quick_sort/ │ │ │ │ └── data.json │ │ │ ├── reservoir_sampling/ │ │ │ │ └── data.json │ │ │ └── shuffle_an_array/ │ │ │ └── data.json │ │ ├── search/ │ │ │ └── src/ │ │ │ ├── binary_search/ │ │ │ │ └── data.json │ │ │ ├── exponential_search/ │ │ │ │ └── data.json │ │ │ ├── fibonacci_search/ │ │ │ │ └── data.json │ │ │ ├── fuzzy_search/ │ │ │ │ └── data.json │ │ │ ├── interpolation_search/ │ │ │ │ └── data.json │ │ │ ├── jump_search/ │ │ │ │ └── data.json │ │ │ ├── linear_search/ │ │ │ │ └── data.json │ │ │ └── ternary_search/ │ │ │ └── data.json │ │ ├── selection_algorithms/ │ │ │ └── src/ │ │ │ └── median_of_medians/ │ │ │ └── data.json │ │ ├── sorting/ │ │ │ ├── circle_sort/ │ │ │ │ └── data.json │ │ │ └── src/ │ │ │ ├── bead_sort/ │ │ │ │ └── data.json │ │ │ ├── bogo_sort/ │ │ │ │ └── data.json │ │ │ ├── bubble_sort/ │ │ │ │ └── data.json │ │ │ ├── bucket_sort/ │ │ │ │ └── data.json │ │ │ ├── comb_sort/ │ │ │ │ └── data.json │ │ │ ├── counting_sort/ │ │ │ │ └── data.json │ │ │ ├── cycle_sort/ │ │ │ │ └── data.json │ │ │ ├── data.json │ │ │ ├── flash_sort/ │ │ │ │ └── data.json │ │ │ ├── gnome_sort/ │ │ │ │ └── data.json │ │ │ ├── heap_sort/ │ │ │ │ └── data.json │ │ │ ├── insertion_sort/ │ │ │ │ └── data.json │ │ │ ├── intro_sort/ │ │ │ │ └── data.json │ │ │ ├── median_sort/ │ │ │ │ └── data.json │ │ │ ├── merge_sort/ │ │ │ │ └── data.json │ │ │ ├── pigeonhole_sort/ │ │ │ │ └── data.json │ │ │ ├── quick_sort/ │ │ │ │ └── data.json │ │ │ ├── radix_sort/ │ │ │ │ └── data.json │ │ │ ├── selection_sort/ │ │ │ │ └── data.json │ │ │ ├── shaker_sort/ │ │ │ │ └── data.json │ │ │ ├── shell_sort/ │ │ │ │ └── data.json │ │ │ ├── sleep_sort/ │ │ │ │ └── data.json │ │ │ ├── stooge_sort/ │ │ │ │ └── data.json │ │ │ ├── topological_sort/ │ │ │ │ └── data.json │ │ │ └── tree_sort/ │ │ │ └── data.json │ │ ├── square_root_decomposition/ │ │ │ └── src/ │ │ │ └── mos_algorithm/ │ │ │ └── data.json │ │ ├── string_algorithms/ │ │ │ └── src/ │ │ │ ├── aho_corasick_algorithm/ │ │ │ │ └── data.json │ │ │ ├── anagram_search/ │ │ │ │ └── data.json │ │ │ ├── arithmetic_on_large_numbers/ │ │ │ │ └── data.json │ │ │ ├── boyer_moore_algorithm/ │ │ │ │ └── data.json │ │ │ ├── finite_automata/ │ │ │ │ └── data.json │ │ │ ├── kasai_algorithm/ │ │ │ │ └── data.json │ │ │ ├── kmp_algorithm/ │ │ │ │ └── data.json │ │ │ ├── levenshtein_distance/ │ │ │ │ └── data.json │ │ │ ├── lipogram_checker/ │ │ │ │ └── data.json │ │ │ ├── longest_palindromic_substring/ │ │ │ │ └── data.json │ │ │ ├── manachar_algorithm/ │ │ │ │ └── data.json │ │ │ ├── morse_code/ │ │ │ │ └── data.json │ │ │ ├── naive_pattern_search/ │ │ │ │ └── data.json │ │ │ ├── palindrome_checker/ │ │ │ │ └── data.json │ │ │ ├── palindrome_substring/ │ │ │ │ └── data.json │ │ │ ├── pangram_checker/ │ │ │ │ └── data.json │ │ │ ├── password_strength_checker/ │ │ │ │ └── data.json │ │ │ ├── rabin_karp_algorithm/ │ │ │ │ └── data.json │ │ │ ├── remove_dups/ │ │ │ │ └── data.json │ │ │ ├── trie_pattern_search/ │ │ │ │ └── data.json │ │ │ └── z_algorithm/ │ │ │ └── data.json │ │ ├── theory_of_computation/ │ │ │ └── src/ │ │ │ ├── deterministic_finite_automaton/ │ │ │ │ └── data.json │ │ │ └── nondeterministic_finite_atomaton/ │ │ │ └── data.json │ │ ├── unclassified/ │ │ │ └── src/ │ │ │ ├── average/ │ │ │ │ └── data.json │ │ │ ├── biggest_of_n_numbers/ │ │ │ │ └── data.json │ │ │ ├── biggest_suffix/ │ │ │ │ └── data.json │ │ │ ├── fifteen_puzzle/ │ │ │ │ └── data.json │ │ │ ├── flutter_res/ │ │ │ │ └── data.json │ │ │ ├── jaccard_similarity/ │ │ │ │ └── data.json │ │ │ ├── josephus_problem/ │ │ │ │ └── data.json │ │ │ ├── lapindrom_checker/ │ │ │ │ └── data.json │ │ │ ├── leap_year/ │ │ │ │ └── data.json │ │ │ ├── magic_square/ │ │ │ │ └── data.json │ │ │ ├── majority_element/ │ │ │ │ └── data.json │ │ │ ├── minimum_subarray_size_with_degree/ │ │ │ │ └── data.json │ │ │ ├── no_operator_addition/ │ │ │ │ └── data.json │ │ │ ├── optimized_fibonacci/ │ │ │ │ └── data.json │ │ │ ├── paint_fill/ │ │ │ │ └── data.json │ │ │ ├── smallest_number_to_the_left/ │ │ │ │ └── data.json │ │ │ ├── spiral_print/ │ │ │ │ └── data.json │ │ │ ├── split_list/ │ │ │ │ └── data.json │ │ │ ├── tokenizer/ │ │ │ │ └── data.json │ │ │ ├── unique_number/ │ │ │ │ └── data.json │ │ │ └── utilities/ │ │ │ └── data.json │ │ └── utility/ │ │ └── src/ │ │ └── palindrome/ │ │ └── palindrome_check/ │ │ └── data.json │ ├── metadata-generator.py │ ├── python_code_style_checker.sh │ └── stats.py ├── test/ │ └── c++/ │ ├── README.md │ ├── catch.hpp │ ├── catch_pch.cpp │ └── test_sample.cpp ├── testing.make └── third_party/ ├── namanager_settings.json └── uncrustify.cfg