gitextract_w21wx358/ ├── .github/ │ └── workflows/ │ └── push-ci.yml ├── .gitignore ├── .nvmrc ├── .prettierrc ├── .vscode/ │ └── settings.json ├── FUNDING.yml ├── LICENSE ├── README.md ├── big-o.md ├── coding_interviews/ │ ├── README.md │ ├── algoexpert/ │ │ ├── README.md │ │ ├── array-of-products/ │ │ │ ├── array-of-products-optimized.js │ │ │ └── array-of-products.js │ │ ├── best-seat/ │ │ │ └── best-seat.js │ │ ├── binary-search/ │ │ │ └── binary-search.js │ │ ├── branch-sums/ │ │ │ ├── branch-sums-without-recreating-sums.js │ │ │ └── branch-sums.js │ │ ├── bst-construction/ │ │ │ └── bst-construction.js │ │ ├── bst-traversal/ │ │ │ └── bst-traversal.js │ │ ├── bubble-sort/ │ │ │ └── bubble-sort.js │ │ ├── caesar-cipher-encryptor/ │ │ │ └── caesar-cipher-encryptor.js │ │ ├── class-photos/ │ │ │ └── class-photos.js │ │ ├── common-characters/ │ │ │ └── common-characters.js │ │ ├── depth-first-search/ │ │ │ ├── depth-first-search-cleaner.js │ │ │ └── depth-first-search.js │ │ ├── evaluate-expression-tree/ │ │ │ ├── evaluate-expression-tree-cleaner.js │ │ │ ├── evaluate-expression-tree-with-trunc.js │ │ │ └── evaluate-expression-tree.js │ │ ├── find-closest-value-in-bst/ │ │ │ ├── find-closest-value-in-bst-optimized-cleaner.js │ │ │ ├── find-closest-value-in-bst-optimized.js │ │ │ └── find-closest-value-in-bst.js │ │ ├── find-three-largest-numbers/ │ │ │ └── find-three-largest-numbers.js │ │ ├── first-duplicate-value/ │ │ │ ├── first-duplicate-value-optimized.js │ │ │ └── first-duplicate-value.js │ │ ├── first-non-repeating-character/ │ │ │ └── first-non-repeating-character.js │ │ ├── generate-document/ │ │ │ └── generate-document.js │ │ ├── insertion-sort/ │ │ │ └── insertion-sort.js │ │ ├── longest-peak/ │ │ │ └── longest-peak.js │ │ ├── majority-element/ │ │ │ └── majority-element.js │ │ ├── merge-overlapping-intervals/ │ │ │ └── merge-overlapping-intervals.js │ │ ├── middle-node/ │ │ │ ├── middle-node-slow-fast.js │ │ │ └── middle-node.js │ │ ├── minimum-waiting-time/ │ │ │ └── minimum-waiting-time.js │ │ ├── missing-numbers/ │ │ │ └── missing-numbers.js │ │ ├── monotonic-array/ │ │ │ ├── monotonic-array-optimization-1.js │ │ │ ├── monotonic-array-optimization-2.js │ │ │ └── monotonic-array.js │ │ ├── move-element-to-end/ │ │ │ └── move-element-to-end.js │ │ ├── node-depths/ │ │ │ └── node-depths.js │ │ ├── non-constructible-change/ │ │ │ └── non-constructible-change.js │ │ ├── nth-fibonacci/ │ │ │ ├── nth-fibonacci-memo-no-space.js │ │ │ ├── nth-fibonacci-memo.js │ │ │ └── nth-fibonacci.js │ │ ├── optimal-freelancing/ │ │ │ ├── optimal-freelancing-sorting.js │ │ │ └── optimal-freelancing.js │ │ ├── palindrome-check/ │ │ │ └── palindrome-check.js │ │ ├── product-sum/ │ │ │ ├── product-sum-timer-later.js │ │ │ └── product-sum.js │ │ ├── remove-duplicates-from-linked-list/ │ │ │ └── remove-duplicates-from-linked-list.js │ │ ├── remove-islands/ │ │ │ ├── remove-islands-optimized.js │ │ │ └── remove-islands.js │ │ ├── run-length-encoding/ │ │ │ ├── run-length-encoding copy.js │ │ │ ├── run-length-encoding-cleaner.js │ │ │ └── run-length-encoding.js │ │ ├── semordnilap/ │ │ │ └── semordnilap.js │ │ ├── smallest-difference/ │ │ │ └── smallest-difference.js │ │ ├── sorted-squared-array/ │ │ │ ├── sorted-squared-array-insert-position.js │ │ │ ├── sorted-squared-array-two-pointers.js │ │ │ └── sorted-squared-array.js │ │ ├── spiral-traverse/ │ │ │ └── spiral-traverse.js │ │ ├── tandem-bicycle/ │ │ │ ├── tandem-bicycle-cleaner.js │ │ │ └── tandem-bicycle.js │ │ ├── three-number-sum/ │ │ │ └── three-number-sum.js │ │ ├── tournament-winner/ │ │ │ ├── tournament-winner-optimized.js │ │ │ └── tournament-winner.js │ │ ├── transpose-matrix/ │ │ │ └── transpose-matrix.js │ │ ├── two-number-sum/ │ │ │ ├── two-number-sum-optimized.js │ │ │ ├── two-number-sum-two-pointers.js │ │ │ └── two-number-sum.js │ │ ├── validate-bst/ │ │ │ └── validate-bst.js │ │ ├── validate-subsequence/ │ │ │ ├── validate-subsequence-two-pointers.js │ │ │ └── validate-subsequence.js │ │ └── zero-sum-subarray/ │ │ ├── zero-sum-subarray-optimized.js │ │ └── zero-sum-subarray.js │ ├── algorithms_in_python/ │ │ ├── queue/ │ │ │ └── R-6.7.py │ │ └── stack/ │ │ ├── R-6.1.py │ │ ├── R-6.3.py │ │ ├── R-6.4.py │ │ └── R-6.5.py │ ├── blind75/ │ │ └── README.md │ ├── coding_interview_questions/ │ │ ├── common_elements.py │ │ ├── decode-string/ │ │ │ ├── decode-string.js │ │ │ └── tests/ │ │ │ └── decode-string.test.js │ │ ├── mine_swipper.py │ │ ├── most_frequently_occurring.py │ │ ├── non_repeating.py │ │ ├── nth_element_from_the_end.py │ │ ├── one_away_strings.py │ │ ├── optimized_common_elements.py │ │ ├── rotation_array.py │ │ └── two-crystal-balls/ │ │ ├── index.js │ │ └── tests/ │ │ └── index.test.js │ ├── cracking-the-coding-interview/ │ │ ├── README.md │ │ ├── big_o/ │ │ │ ├── aditional1.py │ │ │ ├── aditional2.py │ │ │ ├── aditional3.py │ │ │ ├── aditional4.py │ │ │ ├── aditional5.py │ │ │ ├── aditional6.py │ │ │ ├── example1.py │ │ │ ├── example10.py │ │ │ ├── example11.py │ │ │ ├── example12.py │ │ │ ├── example13.py │ │ │ ├── example14.py │ │ │ ├── example15.py │ │ │ ├── example16.py │ │ │ ├── example2.py │ │ │ ├── example3.py │ │ │ ├── example4.py │ │ │ ├── example5.py │ │ │ ├── example6.py │ │ │ ├── example7.py │ │ │ └── example9.py │ │ └── chapter-001/ │ │ ├── check-permutation/ │ │ │ ├── check-permutation.js │ │ │ └── check-permutation.test.js │ │ ├── cpp/ │ │ │ └── remove_specified_character.cpp │ │ ├── is-unique/ │ │ │ ├── is-unique.js │ │ │ └── is-unique.test.js │ │ ├── one-away/ │ │ │ ├── one-away.js │ │ │ └── one-away.test.js │ │ ├── palindrome-permutation/ │ │ │ ├── palindrome-permutation.js │ │ │ └── palindrome-permutation.test.js │ │ ├── python/ │ │ │ ├── 001.01.py │ │ │ ├── 001.02.py │ │ │ ├── 001.03.py │ │ │ ├── 001.04.py │ │ │ ├── 001.05.py │ │ │ ├── 001.06.py │ │ │ ├── 001.07.py │ │ │ ├── bottlenecks.py │ │ │ └── is_unique.py │ │ ├── string-compression/ │ │ │ └── string-compression.js │ │ └── urlify/ │ │ ├── urlify.js │ │ └── urlify.test.js │ ├── daily_code_problems/ │ │ ├── 001.py │ │ ├── 002.py │ │ ├── 003.py │ │ ├── 004.py │ │ ├── 005.py │ │ ├── 006.py │ │ ├── 007.py │ │ └── README.md │ ├── elements_of_programming_interview/ │ │ ├── array.py │ │ ├── base_conversion.py │ │ ├── buy_and_sell_stock_once.py │ │ ├── can_reach_end.py │ │ ├── delete_duplicates_from_a_sorted_array.py │ │ ├── interconvert_string_and_integer.py │ │ ├── longest_subarray_length_with_same_integers.py │ │ ├── multiply_two_arbitrary_precision_integers.py │ │ └── spreadsheet_column_encoding.py │ ├── hackerrank_interview_prep_kit/ │ │ ├── hash_tables/ │ │ │ ├── count_triplets.py │ │ │ ├── ransom_note.py │ │ │ ├── sherlock_and_anagrams.py │ │ │ └── two_strings.py │ │ └── warmup/ │ │ ├── counting_valleys.py │ │ ├── jumping_on_the_clouds.py │ │ ├── repeated_string.py │ │ └── sales_by_match.py │ ├── interviews/ │ │ ├── fair/ │ │ │ ├── decrementBinaryNumber.js │ │ │ ├── diceTotalScore.js │ │ │ ├── isSubmatrixFull.js │ │ │ └── sortChessSubsquares.js │ │ ├── google/ │ │ │ └── printSequence/ │ │ │ └── printSequence.js │ │ ├── mercari/ │ │ │ ├── cumulativeSum.js │ │ │ ├── findMaxMin.js │ │ │ ├── findSumPairs.js │ │ │ ├── multipleDupesArray.js │ │ │ ├── products.js │ │ │ ├── removeDupes.js │ │ │ └── retries.js │ │ ├── meta/ │ │ │ ├── compareLettersInArray/ │ │ │ │ └── compareLettersInArray.js │ │ │ └── flatten/ │ │ │ ├── flatten.js │ │ │ └── flatten2.js │ │ ├── quintoandar/ │ │ │ ├── quinto1.py │ │ │ ├── quinto2.py │ │ │ ├── quinto3.py │ │ │ └── regions.js │ │ ├── smartnews/ │ │ │ ├── countries.js │ │ │ ├── emiter.js │ │ │ └── getTriplets.js │ │ └── uber/ │ │ ├── longest-words.js │ │ ├── maxFrequency.js │ │ ├── permutations.js │ │ └── tests/ │ │ └── maxFrequency.test.js │ ├── javascript/ │ │ ├── array/ │ │ │ ├── binary-search.js │ │ │ ├── slice.js │ │ │ └── subarrays.js │ │ ├── hashmap/ │ │ │ ├── iteration.js │ │ │ └── object.js │ │ ├── queue/ │ │ │ └── queue.js │ │ ├── stack/ │ │ │ └── stack.js │ │ ├── string/ │ │ │ ├── alphabet.js │ │ │ ├── charCode.js │ │ │ ├── isString.js │ │ │ ├── methods.js │ │ │ └── sort.js │ │ └── tree/ │ │ ├── inorder.js │ │ ├── postorder.js │ │ └── preorder.js │ ├── leetcode/ │ │ ├── easy/ │ │ │ ├── a-number-after-a-double-reversal/ │ │ │ │ ├── a-number-after-a-double-reversal.js │ │ │ │ └── tests/ │ │ │ │ └── a-number-after-a-double-reversal.test.js │ │ │ ├── add-digits/ │ │ │ │ └── add-digits.js │ │ │ ├── add-two-integers/ │ │ │ │ └── index.js │ │ │ ├── alternating-digit-sum/ │ │ │ │ └── alternating-digit-sum.js │ │ │ ├── apply-operations-to-an-array/ │ │ │ │ └── apply-operations-to-an-array.js │ │ │ ├── arithmetic_progression/ │ │ │ │ └── arithmetic_progression.py │ │ │ ├── array_partition.py │ │ │ ├── average-of-levels-in-binary-tree/ │ │ │ │ └── average-of-levels-in-binary-tree.js │ │ │ ├── average-salary-excluding-the-minimum-and-maximum-salary/ │ │ │ │ └── average-salary-excluding-the-minimum-and-maximum-salary.js │ │ │ ├── average-value-of-even-numbers-that-are-divisible-by-three/ │ │ │ │ └── average-value-of-even-numbers-that-are-divisible-by-three.js │ │ │ ├── backspace-string-compare/ │ │ │ │ ├── index.js │ │ │ │ └── tests/ │ │ │ │ └── index.test.js │ │ │ ├── baseball-game/ │ │ │ │ └── baseball-game.js │ │ │ ├── best-poker-hand/ │ │ │ │ └── best-poker-hand.js │ │ │ ├── best-time-to-buy-and-sell-stock/ │ │ │ │ ├── best-time-to-buy-and-sell-stock-tle.js │ │ │ │ └── best-time-to-buy-and-sell-stock.js │ │ │ ├── binary-number-with-alternating-bits/ │ │ │ │ └── binary-number-with-alternating-bits.js │ │ │ ├── binary-search/ │ │ │ │ └── binary-search.js │ │ │ ├── binary-tree-inorder-traversal/ │ │ │ │ └── binary-tree-inorder-traversal.js │ │ │ ├── binary-tree-paths/ │ │ │ │ └── binary-tree-paths.js │ │ │ ├── binary-tree-postorder-traversal/ │ │ │ │ └── binary-tree-postorder-traversal.js │ │ │ ├── binary-tree-preorder-traversal/ │ │ │ │ └── binary-tree-preorder-traversal.js │ │ │ ├── binary-tree-tilt/ │ │ │ │ ├── binary-tree-tilt-optimized.js │ │ │ │ └── binary-tree-tilt.js │ │ │ ├── binary_in_linked_list/ │ │ │ │ └── binary_in_linked_list.py │ │ │ ├── build_an_array_with_stack_operations/ │ │ │ │ └── build_an_array_with_stack_operations.py │ │ │ ├── build_array_from_permutation/ │ │ │ │ └── build_array_from_permutation.js │ │ │ ├── buy-two-chocolates/ │ │ │ │ ├── buy-two-chocolates-on.js │ │ │ │ ├── buy-two-chocolates-sort.js │ │ │ │ └── buy-two-chocolates.js │ │ │ ├── calculate-amount-paid-in-taxes/ │ │ │ │ └── calculate-amount-paid-in-taxes.js │ │ │ ├── calculate-delayed-arrival-time/ │ │ │ │ └── calculate-delayed-arrival-time.js │ │ │ ├── calculate-digit-sum-of-a-string/ │ │ │ │ └── calculate-digit-sum-of-a-string.js │ │ │ ├── calculate-money-in-leetcode-bank/ │ │ │ │ └── calculate-money-in-leetcode-bank.js │ │ │ ├── can-place-flowers/ │ │ │ │ └── can-place-flowers.js │ │ │ ├── capitalize-the-title/ │ │ │ │ └── capitalize-the-title.js │ │ │ ├── cells-in-a-range-on-an-excel-sheet/ │ │ │ │ ├── cells-in-a-range-on-an-excel-sheet.js │ │ │ │ └── tests/ │ │ │ │ └── cells-in-a-range-on-an-excel-sheet.test.js │ │ │ ├── check-array-formation-through-concatenation/ │ │ │ │ └── check-array-formation-through-concatenation.js │ │ │ ├── check-distances-between-same-letters/ │ │ │ │ └── check-distances-between-same-letters.js │ │ │ ├── check-if-a-string-is-an-acronym-of-words/ │ │ │ │ └── check-if-a-string-is-an-acronym-of-words.js │ │ │ ├── check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence/ │ │ │ │ └── check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence.js │ │ │ ├── check-if-all-as-appears-before-all-bs/ │ │ │ │ └── check-if-all-as-appears-before-all-bs.js │ │ │ ├── check-if-matrix-is-x-matrix/ │ │ │ │ └── check-if-matrix-is-x-matrix.js │ │ │ ├── check-if-number-has-equal-digit-count-and-digit-value/ │ │ │ │ └── check-if-number-has-equal-digit-count-and-digit-value.js │ │ │ ├── check-if-numbers-are-ascending-in-a-sentence/ │ │ │ │ └── check-if-numbers-are-ascending-in-a-sentence.js │ │ │ ├── check-if-the-sentence-is-pangram/ │ │ │ │ └── check-if-the-sentence-is-pangram.py │ │ │ ├── check-whether-two-strings-are-almost-equivalent/ │ │ │ │ └── check-whether-two-strings-are-almost-equivalent.js │ │ │ ├── check_if_all_characters_have_equal_number_of_occurrences/ │ │ │ │ └── check_if_all_characters_have_equal_number_of_occurrences.js │ │ │ ├── check_if_two_string_arrays_are_equivalent/ │ │ │ │ └── check_if_two_string_arrays_are_equivalent.py │ │ │ ├── circular-sentence/ │ │ │ │ └── circular-sentence.js │ │ │ ├── climbing-stairs/ │ │ │ │ └── climbing-stairs.js │ │ │ ├── climbing_stairs.py │ │ │ ├── concatenation_of_array/ │ │ │ │ └── concatenation_of_array.js │ │ │ ├── consecutive-characters/ │ │ │ │ └── consecutive-characters.js │ │ │ ├── construct-string-from-binary-tree/ │ │ │ │ └── construct-string-from-binary-tree.js │ │ │ ├── contains-duplicate/ │ │ │ │ ├── contains-duplicate-hashmap.js │ │ │ │ ├── contains-duplicate.js │ │ │ │ └── contains-duplicate.py │ │ │ ├── convert-sorted-array-to-binary-search-tree/ │ │ │ │ └── convert-sorted-array-to-binary-search-tree.js │ │ │ ├── convert-the-temperature/ │ │ │ │ └── convert-the-temperature.js │ │ │ ├── count-asterisks/ │ │ │ │ └── count-asterisks.js │ │ │ ├── count-common-words-with-one-occurrence/ │ │ │ │ └── count-common-words-with-one-occurrence.js │ │ │ ├── count-complete-tree-nodes/ │ │ │ │ └── count-complete-tree-nodes.js │ │ │ ├── count-equal-and-divisible-pairs-in-an-array/ │ │ │ │ ├── count-equal-and-divisible-pairs-in-an-array-2.js │ │ │ │ ├── count-equal-and-divisible-pairs-in-an-array.js │ │ │ │ └── tests/ │ │ │ │ ├── count-equal-and-divisible-pairs-in-an-array-2.test.js │ │ │ │ └── count-equal-and-divisible-pairs-in-an-array.test.js │ │ │ ├── count-good-triplets/ │ │ │ │ └── count-good-triplets.py │ │ │ ├── count-integers-with-even-digit-sum/ │ │ │ │ └── count-integers-with-even-digit-sum.js │ │ │ ├── count-k-difference/ │ │ │ │ └── count-k-difference.js │ │ │ ├── count-largest-group/ │ │ │ │ └── count-largest-group.js │ │ │ ├── count-operations-to-obtain-zero/ │ │ │ │ ├── count-operations-to-obtain-zero.js │ │ │ │ └── tests/ │ │ │ │ └── count-operations-to-obtain-zero.test.js │ │ │ ├── count-pairs-of-similar-strings/ │ │ │ │ └── count-pairs-of-similar-strings.js │ │ │ ├── count-pairs-whose-sum-is-less-than-target/ │ │ │ │ ├── count-pairs-whose-sum-is-less-than-target-two-pointers.js │ │ │ │ └── count-pairs-whose-sum-is-less-than-target.js │ │ │ ├── count-prefixes-of-a-given-string/ │ │ │ │ └── count-prefixes-of-a-given-string.js │ │ │ ├── count-square-sum-triples/ │ │ │ │ └── count-square-sum-triples.js │ │ │ ├── count-symmetric-integers/ │ │ │ │ └── count-symmetric-integers.js │ │ │ ├── count-the-digits-that-divide-a-number/ │ │ │ │ └── count-the-digits-that-divide-a-number.js │ │ │ ├── count-the-number-of-vowel-strings-in-range/ │ │ │ │ └── count-the-number-of-vowel-strings-in-range.js │ │ │ ├── count-vowel-substrings-of-a-string/ │ │ │ │ └── count-vowel-substrings-of-a-string.js │ │ │ ├── count_good_rectangles/ │ │ │ │ └── count_good_rectangles.py │ │ │ ├── count_matches/ │ │ │ │ └── count_matches.py │ │ │ ├── count_of_matches_in_tournament/ │ │ │ │ └── count_of_matches_in_tournament.py │ │ │ ├── count_students/ │ │ │ │ └── count_students.py │ │ │ ├── count_the_number_of_consistent_strings/ │ │ │ │ └── count_the_number_of_consistent_strings.py │ │ │ ├── counting-bits/ │ │ │ │ └── counting-bits.js │ │ │ ├── counting-words-with-a-given-prefix/ │ │ │ │ ├── counting-words-with-a-given-prefix.js │ │ │ │ └── tests/ │ │ │ │ └── counting-words-with-a-given-prefix.test.js │ │ │ ├── crawler-log-folder/ │ │ │ │ └── crawler-log-folder.js │ │ │ ├── create_target_array/ │ │ │ │ └── create_target_array.py │ │ │ ├── decode-the-message/ │ │ │ │ ├── decode-the-message.js │ │ │ │ └── tests/ │ │ │ │ └── decode-the-message.test.js │ │ │ ├── decode_xored_array/ │ │ │ │ └── decode_xored_array.py │ │ │ ├── decompressed_encoded_list/ │ │ │ │ └── decompressed_encoded_list.py │ │ │ ├── decrypt_string/ │ │ │ │ └── decrypt_string.py │ │ │ ├── defanging_an_ip_address/ │ │ │ │ └── defanging_an_ip_address.py │ │ │ ├── defuse-the-bomb/ │ │ │ │ └── defuse-the-bomb.js │ │ │ ├── delete-greatest-value-in-each-row/ │ │ │ │ └── delete-greatest-value-in-each-row.js │ │ │ ├── delete_columns_to_make_sorted/ │ │ │ │ └── delete_columns_to_make_sorted.py │ │ │ ├── design-an-ordered-stream/ │ │ │ │ └── design-an-ordered-stream.js │ │ │ ├── design-hashmap/ │ │ │ │ └── design-hashmap.js │ │ │ ├── design-hashset/ │ │ │ │ └── design-hashset.js │ │ │ ├── design_parking_system/ │ │ │ │ └── design_parking_system.py │ │ │ ├── destination_city/ │ │ │ │ └── destination_city.py │ │ │ ├── detect-capital/ │ │ │ │ └── detect-capital.js │ │ │ ├── determine-if-string-halves-are-alike/ │ │ │ │ └── determine-if-string-halves-are-alike.js │ │ │ ├── determine_color_of_a_chessboard_square/ │ │ │ │ └── determine_color_of_a_chessboard_square.py │ │ │ ├── di_string_match/ │ │ │ │ └── di_string_match.py │ │ │ ├── difference-between-element-sum-and-digit-sum-of-an-array/ │ │ │ │ └── difference-between-element-sum-and-digit-sum-of-an-array.js │ │ │ ├── discount_price/ │ │ │ │ └── discount_price.py │ │ │ ├── distribute-candies-among-children-i/ │ │ │ │ ├── distribute-candies-among-children-i.js │ │ │ │ └── distribute-candies-among-children-ii.js │ │ │ ├── distribute-candies-to-people/ │ │ │ │ └── distribute-candies-to-people.js │ │ │ ├── divide-a-string-into-groups-of-size-k/ │ │ │ │ └── divide-a-string-into-groups-of-size-k.js │ │ │ ├── divide-array-into-equal-pairs/ │ │ │ │ ├── divide-array-into-equal-pairs.js │ │ │ │ └── tests/ │ │ │ │ └── divide-array-into-equal-pairs.test.js │ │ │ ├── divisible-and-non-divisible-sums-difference/ │ │ │ │ └── divisible-and-non-divisible-sums-difference.js │ │ │ ├── divisor-game/ │ │ │ │ └── divisor-game.js │ │ │ ├── equal_reversed_arrays/ │ │ │ │ └── equal_reversed_arrays.py │ │ │ ├── evaluate-boolean-binary-tree/ │ │ │ │ └── evaluate-boolean-binary-tree.js │ │ │ ├── even_digits/ │ │ │ │ └── even_digits.py │ │ │ ├── excel-sheet-column-number/ │ │ │ │ └── excel-sheet-column-number.js │ │ │ ├── fair-candy-swap/ │ │ │ │ ├── fair-candy-swap-optimized.js │ │ │ │ └── fair-candy-swap.js │ │ │ ├── faulty-keyboard/ │ │ │ │ └── faulty-keyboard.js │ │ │ ├── fibonacci_number/ │ │ │ │ └── fibonacci_number.py │ │ │ ├── final-value-after-operations/ │ │ │ │ └── final-value-after-operations.js │ │ │ ├── find-all-k-distant-indices-in-an-array/ │ │ │ │ └── find-all-k-distant-indices-in-an-array.js │ │ │ ├── find-all-numbers-disappeared-in-an-array/ │ │ │ │ └── find-all-numbers-disappeared-in-an-array.js │ │ │ ├── find-center-of-star-graph/ │ │ │ │ └── find-center-of-star-graph.js │ │ │ ├── find-champion-i/ │ │ │ │ ├── find-champion-i-no-map.js │ │ │ │ └── find-champion-i.js │ │ │ ├── find-first-palindromic-string-in-the-array/ │ │ │ │ ├── find-first-palindromic-string-in-the-array.js │ │ │ │ └── tests/ │ │ │ │ └── find-first-palindromic-string-in-the-array.test.js │ │ │ ├── find-greatest-common-divisor-of-array/ │ │ │ │ └── find-greatest-common-divisor-of-array.js │ │ │ ├── find-indices-with-index-and-value-difference-i/ │ │ │ │ └── find-indices-with-index-and-value-difference-i.js │ │ │ ├── find-lucky-integer-in-an-array/ │ │ │ │ └── find-lucky-integer-in-an-array.js │ │ │ ├── find-maximum-number-of-string-pairs/ │ │ │ │ └── find-maximum-number-of-string-pairs.js │ │ │ ├── find-nearest-point-that-has-the-same-x-or-y-coordinate/ │ │ │ │ └── find-nearest-point-that-has-the-same-x-or-y-coordinate.js │ │ │ ├── find-subarrays-with-equal-sum/ │ │ │ │ └── find-subarrays-with-equal-sum.js │ │ │ ├── find-target-indices-after-sorting-array/ │ │ │ │ ├── find-target-indices-after-sorting-array.js │ │ │ │ └── tests/ │ │ │ │ └── find-target-indices-after-sorting-array.test.js │ │ │ ├── find-the-array-concatenation-value/ │ │ │ │ └── find-the-array-concatenation-value.js │ │ │ ├── find-the-difference/ │ │ │ │ └── find-the-difference.js │ │ │ ├── find-the-difference-of-two-arrays/ │ │ │ │ └── find-the-difference-of-two-arrays.js │ │ │ ├── find-the-distance-value-between-two-arrays/ │ │ │ │ └── find-the-distance-value-between-two-arrays.js │ │ │ ├── find-the-distinct-difference-array/ │ │ │ │ ├── find-the-distinct-difference-array.js │ │ │ │ └── optimized-find-the-distinct-difference-array.js │ │ │ ├── find-the-maximum-achievable-number/ │ │ │ │ └── find-the-maximum-achievable-number.js │ │ │ ├── find-the-middle-index-in-array/ │ │ │ │ └── find-the-middle-index-in-array.js │ │ │ ├── find-the-pivot-integer/ │ │ │ │ └── find-the-pivot-integer.js │ │ │ ├── find-the-width-of-columns-of-a-grid/ │ │ │ │ └── find-the-width-of-columns-of-a-grid.js │ │ │ ├── find-words-containing-character/ │ │ │ │ └── find-words-containing-character.js │ │ │ ├── find-words-that-can-be-formed-by-characters/ │ │ │ │ └── find-words-that-can-be-formed-by-characters.js │ │ │ ├── find_common_characters/ │ │ │ │ └── find_common_characters.py │ │ │ ├── find_the_highest_altitude/ │ │ │ │ └── find_the_highest_altitude.py │ │ │ ├── first-bad-version/ │ │ │ │ ├── first-bad-version-binary-search.js │ │ │ │ └── first-bad-version.js │ │ │ ├── first-letter-to-appear-twice/ │ │ │ │ └── first-letter-to-appear-twice.js │ │ │ ├── first-unique-character-in-a-string/ │ │ │ │ └── first-unique-character-in-a-string.js │ │ │ ├── first_bad_version/ │ │ │ │ └── first_bad_version.py │ │ │ ├── fizz-buzz/ │ │ │ │ └── fizz-buzz.js │ │ │ ├── flipping_an_image.py │ │ │ ├── flood-fill/ │ │ │ │ ├── flood-fill-without-visited.js │ │ │ │ └── flood-fill.js │ │ │ ├── furthest-point-from-origin/ │ │ │ │ └── furthest-point-from-origin.js │ │ │ ├── generate_the_string/ │ │ │ │ └── generate_the_string.py │ │ │ ├── goal_parser_interpretation/ │ │ │ │ └── goal_parser_interpretation.py │ │ │ ├── greatest-english-letter-in-upper-and-lower-case/ │ │ │ │ └── greatest-english-letter-in-upper-and-lower-case.js │ │ │ ├── greatest_candies/ │ │ │ │ └── greatest_candies.py │ │ │ ├── guess-number-higher-or-lower/ │ │ │ │ └── guess-number-higher-or-lower.js │ │ │ ├── halves_are_alike/ │ │ │ │ └── halves_are_alike.py │ │ │ ├── hamming_distance/ │ │ │ │ └── hamming_distance.py │ │ │ ├── height_checker/ │ │ │ │ └── height_checker.py │ │ │ ├── implement-queue-using-stacks/ │ │ │ │ └── implement-queue-using-stacks.js │ │ │ ├── implement-stack-using-queues/ │ │ │ │ └── implement-stack-using-queues.js │ │ │ ├── increasing_decreasing_string/ │ │ │ │ └── incresing_decreasin_string.py │ │ │ ├── increasing_order_search_tree/ │ │ │ │ └── increasing_order_search_tree.py │ │ │ ├── intersection-of-multiple-arrays/ │ │ │ │ └── intersection-of-multiple-arrays.js │ │ │ ├── intersection-of-two-arrays-ii/ │ │ │ │ └── intersection-of-two-arrays-ii.js │ │ │ ├── intersection_of_two_arrays/ │ │ │ │ └── intersection_of_two_arrays.py │ │ │ ├── intersection_of_two_arrays_ii/ │ │ │ │ └── intersection_of_two_arrays.py │ │ │ ├── invert-binary-tree/ │ │ │ │ └── invert-binary-tree.js │ │ │ ├── is-subsequence/ │ │ │ │ └── is-subsequence.js │ │ │ ├── is_palindrome.py │ │ │ ├── is_sum_equal/ │ │ │ │ └── is_sum_equal.py │ │ │ ├── island-perimeter/ │ │ │ │ └── island-perimeter.js │ │ │ ├── jewels_and_stones.py │ │ │ ├── judge_route_circle.py │ │ │ ├── judge_route_circle_one_line.py │ │ │ ├── k-items-with-the-maximum-sum/ │ │ │ │ ├── k-items-with-the-maximum-sum-second.js │ │ │ │ └── k-items-with-the-maximum-sum.js │ │ │ ├── keep-multiplying-found-values-by-two/ │ │ │ │ └── keep-multiplying-found-values-by-two.js │ │ │ ├── keyboard-row/ │ │ │ │ └── keyboard-row.js │ │ │ ├── kth-distinct-string-in-an-array/ │ │ │ │ └── kth-distinct-string-in-an-array.js │ │ │ ├── largest-local-values-in-a-matrix/ │ │ │ │ └── largest-local-values-in-a-matrix.js │ │ │ ├── largest-number-after-digit-swaps-by-parity/ │ │ │ │ └── largest-number-after-digit-swaps-by-parity.js │ │ │ ├── largest-positive-integer-that-exists-with-its-negative/ │ │ │ │ └── largest-positive-integer-that-exists-with-its-negative.js │ │ │ ├── last-stone-weight/ │ │ │ │ ├── last-stone-weight.js │ │ │ │ └── tests/ │ │ │ │ └── last-stone-weight.test.js │ │ │ ├── last-visited-integers/ │ │ │ │ └── last-visited-integers.js │ │ │ ├── leaf-similar-trees/ │ │ │ │ └── leaf-similar-trees.js │ │ │ ├── left-and-right-sum-differences/ │ │ │ │ └── left-and-right-sum-differences.js │ │ │ ├── length-of-last-word/ │ │ │ │ └── length-of-last-word.js │ │ │ ├── lexicographically-smallest-palindrome/ │ │ │ │ └── lexicographically-smallest-palindrome.js │ │ │ ├── linked-list-cycle/ │ │ │ │ └── linked-list-cycle.js │ │ │ ├── longer-contiguous-segments-of-ones-than-zeros/ │ │ │ │ └── longer-contiguous-segments-of-ones-than-zeros.js │ │ │ ├── longest-nice-substring/ │ │ │ │ └── longest-nice-substring.js │ │ │ ├── longest-subsequence-with-limited-sum/ │ │ │ │ └── longest-subsequence-with-limited-sum.js │ │ │ ├── longest_palindrome.py │ │ │ ├── lowest-common-ancestor-of-a-binary-search-tree/ │ │ │ │ └── lowest-common-ancestor-of-a-binary-search-tree.js │ │ │ ├── lucky_numbers_in_a_matrix/ │ │ │ │ └── lucky_numbers_in_a_matrix.py │ │ │ ├── majority-element/ │ │ │ │ └── majority-element.js │ │ │ ├── make-array-zero-by-subtracting-equal-amounts/ │ │ │ │ └── make-array-zero-by-subtracting-equal-amounts.js │ │ │ ├── make-the-string-great/ │ │ │ │ └── make-the-string-great.js │ │ │ ├── matrix-cells-in-distance-order/ │ │ │ │ └── matrix-cells-in-distance-order.js │ │ │ ├── matrix_diagonal_sum/ │ │ │ │ └── matrix_diagonal_sum.py │ │ │ ├── matrix_negative_numbers/ │ │ │ │ └── matrix_negative_numbers.py │ │ │ ├── max-consecutive-ones/ │ │ │ │ └── max-consecutive-ones.js │ │ │ ├── maximum-69-number/ │ │ │ │ └── maximum-69-number.js │ │ │ ├── maximum-ascending-subarray-sum/ │ │ │ │ └── maximum-ascending-subarray-sum.js │ │ │ ├── maximum-count-of-positive-integer-and-negative-integer/ │ │ │ │ └── maximum-count-of-positive-integer-and-negative-integer.js │ │ │ ├── maximum-depth-of-binary-tree/ │ │ │ │ ├── maximum-depth-of-binary-tree-2.js │ │ │ │ └── maximum-depth-of-binary-tree.js │ │ │ ├── maximum-depth-of-n-ary-tree/ │ │ │ │ └── maximum-depth-of-n-ary-tree.js │ │ │ ├── maximum-number-of-balloons/ │ │ │ │ └── maximum-number-of-balloons.js │ │ │ ├── maximum-number-of-pairs-in-array/ │ │ │ │ └── maximum-number-of-pairs-in-array.js │ │ │ ├── maximum-odd-binary-number/ │ │ │ │ └── maximum-odd-binary-number.js │ │ │ ├── maximum-subarray/ │ │ │ │ └── maximum-subarray.js │ │ │ ├── maximum-sum-with-exactly-k-elements/ │ │ │ │ └── maximum-sum-with-exactly-k-elements.js │ │ │ ├── maximum-units-on-a-truck/ │ │ │ │ └── maximum-units-on-a-truck.py │ │ │ ├── maximum-value-of-a-string-in-an-array/ │ │ │ │ └── maximum-value-of-a-string-in-an-array.js │ │ │ ├── maximum_nesting_depth_of_the_parentheses/ │ │ │ │ └── maximum_nesting_depth_of_the_parentheses.py │ │ │ ├── maximum_number_of_balls_in_a_box/ │ │ │ │ └── maximum_number_of_balls_in_a_box.py │ │ │ ├── maximum_number_of_words_you_can_type/ │ │ │ │ └── maximum_number_of_words_you_can_type.js │ │ │ ├── maximum_population/ │ │ │ │ └── maximum_population.py │ │ │ ├── maximum_product/ │ │ │ │ └── maximum_product.py │ │ │ ├── maximum_product_difference_between_two_pairs/ │ │ │ │ └── maximum_product_difference_between_two_pairs.js │ │ │ ├── mean-of-array-after-removing-some-elements/ │ │ │ │ └── mean-of-array-after-removing-some-elements.js │ │ │ ├── merge-nodes-in-between-zeros/ │ │ │ │ ├── merge-nodes-in-between-zeros.js │ │ │ │ └── tests/ │ │ │ │ └── merge-nodes-in-between-zeros.test.js │ │ │ ├── merge-similar-items/ │ │ │ │ └── merge-similar-items.js │ │ │ ├── merge-sorted-array/ │ │ │ │ └── merge-sorted-array.js │ │ │ ├── merge-two-2d-arrays-by-summing-values/ │ │ │ │ └── merge-two-2d-arrays-by-summing-values.js │ │ │ ├── merge-two-binary-trees/ │ │ │ │ └── merge-two-binary-trees.js │ │ │ ├── merge-two-sorted-lists/ │ │ │ │ ├── merge-two-sorted-lists.js │ │ │ │ └── tests/ │ │ │ │ └── merge-two-sorted-lists.test.js │ │ │ ├── merge_strings_alternately/ │ │ │ │ └── merge_strings_alternately.py │ │ │ ├── merge_trees.py │ │ │ ├── merge_two_lists.py │ │ │ ├── middle-of-the-linked-list/ │ │ │ │ ├── middle-of-the-linked-list-fast-slow.js │ │ │ │ └── middle-of-the-linked-list.js │ │ │ ├── min-max-game/ │ │ │ │ └── min-max-game.js │ │ │ ├── minimize-string-length/ │ │ │ │ └── minimize-string-length.js │ │ │ ├── minimum-absolute-difference/ │ │ │ │ └── minimum-absolute-difference.js │ │ │ ├── minimum-absolute-difference-in-bst/ │ │ │ │ └── minimum-absolute-difference-in-bst.js │ │ │ ├── minimum-bit-flips-to-convert-number/ │ │ │ │ ├── minimum-bit-flips-to-convert-number.js │ │ │ │ └── tests/ │ │ │ │ └── minimum-bit-flips-to-convert-number.test.js │ │ │ ├── minimum-cost-to-move-chips-to-the-same-position/ │ │ │ │ └── minimum-cost-to-move-chips-to-the-same-position.js │ │ │ ├── minimum-depth-of-binary-tree/ │ │ │ │ └── minimum-depth-of-binary-tree.js │ │ │ ├── minimum-distance-between-bst-nodes/ │ │ │ │ └── minimum-distance-between-bst-nodes.js │ │ │ ├── minimum-number-game/ │ │ │ │ └── minimum-number-game.js │ │ │ ├── minimum-number-of-moves-to-seat-everyone/ │ │ │ │ ├── minimum-number-of-moves-to-seat-everyone.js │ │ │ │ └── tests/ │ │ │ │ └── minimum-number-of-moves-to-seat-everyone.test.js │ │ │ ├── minimum-number-of-operations-to-convert-time/ │ │ │ │ └── minimum-number-of-operations-to-convert-time.js │ │ │ ├── minimum-string-length-after-removing-substrings/ │ │ │ │ └── minimum-string-length-after-removing-substrings.js │ │ │ ├── minimum-subsequence-in-non-increasing-order/ │ │ │ │ └── minimum-subsequence-in-non-increasing-order.js │ │ │ ├── minimum-sum/ │ │ │ │ └── minimum-sum.js │ │ │ ├── minimum-sum-of-mountain-triplets-i/ │ │ │ │ └── minimum-sum-of-mountain-triplets-i.js │ │ │ ├── minimum-time-to-type-word-using-special-typewriter/ │ │ │ │ └── minimum-time-to-type-word-using-special-typewriter.js │ │ │ ├── minimum-value-to-get-positive-step-by-step-sum/ │ │ │ │ └── minimum-value-to-get-positive-step-by-step-sum.js │ │ │ ├── minimum_operations_to_make_the_array_increasing/ │ │ │ │ └── minimum_operations_to_make_the_array_increasing.py │ │ │ ├── missing-number/ │ │ │ │ └── missing-number.js │ │ │ ├── monotonic-array/ │ │ │ │ └── monotonic-array.js │ │ │ ├── most-words-found/ │ │ │ │ └── most-words-found.js │ │ │ ├── move-zeroes/ │ │ │ │ ├── move-zeroes-in-place.js │ │ │ │ └── move-zeroes.js │ │ │ ├── n_ary_tree_postorder_traversal/ │ │ │ │ └── n_ary_tree_postorder_traversal.py │ │ │ ├── n_ary_tree_preorder_traversal/ │ │ │ │ └── n_ary_tree_preorder_traversal.py │ │ │ ├── n_repeated_element_in_size_2n_array/ │ │ │ │ └── n_repeated_element_in_size_2n_array.py │ │ │ ├── neither-minimum-nor-maximum/ │ │ │ │ ├── neither-minimum-nor-maximum-on.js │ │ │ │ └── neither-minimum-nor-maximum.js │ │ │ ├── next-greater-element-i/ │ │ │ │ ├── next-greater-element-i-optimized.js │ │ │ │ ├── next-greater-element-i.js │ │ │ │ └── tests/ │ │ │ │ ├── next-greater-element-i-optimized.test.js │ │ │ │ └── next-greater-element-i.test.js │ │ │ ├── num_unique_emails/ │ │ │ │ └── num_unique_emails.py │ │ │ ├── number-of-1-bits/ │ │ │ │ └── number-of-1-bits.js │ │ │ ├── number-of-arithmetic-triplets/ │ │ │ │ └── number-of-arithmetic-triplets.js │ │ │ ├── number-of-common-factors/ │ │ │ │ └── number-of-common-factors.js │ │ │ ├── number-of-employees-who-met-the-target/ │ │ │ │ └── number-of-employees-who-met-the-target.js │ │ │ ├── number-of-even-and-odd-bits/ │ │ │ │ └── number-of-even-and-odd-bits.js │ │ │ ├── number-of-lines-to-write-string/ │ │ │ │ └── number-of-lines-to-write-string.js │ │ │ ├── number-of-senior-citizens/ │ │ │ │ ├── number-of-senior-citizens.js │ │ │ │ └── one-liner-number-of-senior-citizens.js │ │ │ ├── number-of-strings-that-appear-as-substrings-in-word/ │ │ │ │ └── number-of-strings-that-appear-as-substrings-in-word.js │ │ │ ├── number-of-unequal-triplets-in-array/ │ │ │ │ └── number-of-unequal-triplets-in-array.js │ │ │ ├── number_complement.py │ │ │ ├── number_of_good_pairs/ │ │ │ │ └── number_of_good_pairs.py │ │ │ ├── number_of_recent_calls/ │ │ │ │ └── number_of_recent_calls.py │ │ │ ├── number_of_students/ │ │ │ │ └── number_of_students.py │ │ │ ├── odd-string-difference/ │ │ │ │ └── odd-string-difference.js │ │ │ ├── odd_in_matrix/ │ │ │ │ └── odd_in_matrix.py │ │ │ ├── partition_labels.py │ │ │ ├── pascals-triangle/ │ │ │ │ └── pascals-triangle.js │ │ │ ├── path-sum/ │ │ │ │ └── path-sum.js │ │ │ ├── peak_index_mountain.py │ │ │ ├── percentage-of-letter-in-string/ │ │ │ │ └── percentage-of-letter-in-string.js │ │ │ ├── plus_one/ │ │ │ │ ├── plus_one.js │ │ │ │ └── plus_one.py │ │ │ ├── points-that-intersect-with-cars/ │ │ │ │ └── points-that-intersect-with-cars.js │ │ │ ├── power-of-two/ │ │ │ │ └── power-of-two.js │ │ │ ├── prime-number-of-set-bits-in-binary-representation/ │ │ │ │ └── prime-number-of-set-bits-in-binary-representation.js │ │ │ ├── projection-area-of-3d-shapes/ │ │ │ │ └── projection-area-of-3d-shapes.js │ │ │ ├── range_sum_of_bst/ │ │ │ │ └── range_sum_of_bst.py │ │ │ ├── rank-transform-of-an-array/ │ │ │ │ ├── rank-transform-of-an-array-less-memory.js │ │ │ │ └── rank-transform-of-an-array.js │ │ │ ├── ransom-note/ │ │ │ │ └── ransom-note.js │ │ │ ├── ransom_note/ │ │ │ │ └── ransom_note.py │ │ │ ├── reduce_zero/ │ │ │ │ └── reduce_zero.py │ │ │ ├── reformat-date/ │ │ │ │ └── reformat-date.js │ │ │ ├── reformat-phone-number/ │ │ │ │ └── reformat-phone-number.js │ │ │ ├── relative-ranks/ │ │ │ │ └── relative-ranks.js │ │ │ ├── relative-sort-array/ │ │ │ │ └── relative-sort-array.js │ │ │ ├── remove-duplicates-from-sorted-list/ │ │ │ │ └── remove-duplicates-from-sorted-list.js │ │ │ ├── remove-linked-list-elements/ │ │ │ │ └── remove-linked-list-elements.js │ │ │ ├── remove-outermost-parentheses/ │ │ │ │ ├── remove-outermost-parentheses.js │ │ │ │ └── tests/ │ │ │ │ └── remove-outermost-parentheses.test.js │ │ │ ├── remove-palindromic-subsequences/ │ │ │ │ └── remove-palindromic-subsequences.js │ │ │ ├── remove-trailing-zeros-from-a-string/ │ │ │ │ └── remove-trailing-zeros-from-a-string.js │ │ │ ├── remove_duplicates/ │ │ │ │ └── remove_duplicates.py │ │ │ ├── remove_duplicates.py │ │ │ ├── remove_duplicates_from_list.py │ │ │ ├── remove_element.py │ │ │ ├── replace_digits/ │ │ │ │ └── replace_digits.py │ │ │ ├── replace_elements/ │ │ │ │ └── replace_elements.py │ │ │ ├── reshape-the-matrix/ │ │ │ │ └── reshape-the-matrix.js │ │ │ ├── reverse-linked-list/ │ │ │ │ └── reverse-linked-list.js │ │ │ ├── reverse-only-letters/ │ │ │ │ └── reverse-only-letters.js │ │ │ ├── reverse-prefix-of-word/ │ │ │ │ ├── reverse-prefix-of-word.js │ │ │ │ └── tests/ │ │ │ │ └── reverse-prefix-of-word.test.js │ │ │ ├── reverse-string/ │ │ │ │ ├── reverse-string-in-place.js │ │ │ │ └── reverse-string.js │ │ │ ├── reverse-vowels-of-a-string/ │ │ │ │ └── reverse-vowels-of-a-string.js │ │ │ ├── reverse-words-in-a-string-iii/ │ │ │ │ └── reverse-words-in-a-string-iii.js │ │ │ ├── reverse_integer.py │ │ │ ├── reverse_string.py │ │ │ ├── reverse_vowels.py │ │ │ ├── reverse_words_string.py │ │ │ ├── rings-and-rods/ │ │ │ │ ├── rings-and-rods.js │ │ │ │ └── tests/ │ │ │ │ └── rings-and-rods.test.js │ │ │ ├── root-equals-sum-of-children/ │ │ │ │ └── index.js │ │ │ ├── row-with-maximum-ones/ │ │ │ │ └── row-with-maximum-ones.js │ │ │ ├── running_array_sum/ │ │ │ │ └── running_array_sum.py │ │ │ ├── same-tree/ │ │ │ │ └── same-tree.js │ │ │ ├── same_tree.py │ │ │ ├── search-in-a-binary-search-tree/ │ │ │ │ └── search-in-a-binary-search-tree.js │ │ │ ├── search-insert-position/ │ │ │ │ ├── search-insert-position-new.js │ │ │ │ └── search-insert-position.js │ │ │ ├── search_in_a_binary_search_tree/ │ │ │ │ └── search_in_a_binary_search_tree.py │ │ │ ├── second-largest-digit-in-a-string/ │ │ │ │ └── second-largest-digit-in-a-string.js │ │ │ ├── self_dividing_numbers.py │ │ │ ├── semi-ordered-permutation/ │ │ │ │ └── semi-ordered-permutation.js │ │ │ ├── separate-the-digits-in-an-array/ │ │ │ │ └── separate-the-digits-in-an-array.js │ │ │ ├── shortest_to_char/ │ │ │ │ └── shortest_to_char.py │ │ │ ├── shuffle_string/ │ │ │ │ └── shuffle_string.py │ │ │ ├── shuffle_the_array/ │ │ │ │ └── shuffle_the_array.py │ │ │ ├── sign_of_the_product_of_an_array/ │ │ │ │ └── sign_of_the_product_of_an_array.py │ │ │ ├── single-number/ │ │ │ │ └── single-number.js │ │ │ ├── single_number/ │ │ │ │ └── single_number.py │ │ │ ├── slowest-key/ │ │ │ │ └── slowest-key.js │ │ │ ├── smallest-even-multiple/ │ │ │ │ └── smallest-even-multiple.js │ │ │ ├── smallest-index-with-equal-value/ │ │ │ │ └── smallest-index-with-equal-value.js │ │ │ ├── smallest-range-i/ │ │ │ │ ├── optimized-smallest-range-i.js │ │ │ │ ├── smallest-range-i.js │ │ │ │ └── smallest-range-iI.js │ │ │ ├── smallest_numbers/ │ │ │ │ └── smallest_numbers.py │ │ │ ├── sort-array-by-increasing-frequency/ │ │ │ │ └── sort-array-by-increasing-frequency.js │ │ │ ├── sort-array-by-parity/ │ │ │ │ ├── sort-array-by-parity-two-loops.js │ │ │ │ └── sort-array-by-parity.js │ │ │ ├── sort-array-by-parity-ii/ │ │ │ │ ├── sort-array-by-parity-ii.js │ │ │ │ └── tests/ │ │ │ │ └── sort-array-by-parity-ii.test.js │ │ │ ├── sort-even-and-odd-indices-independently/ │ │ │ │ └── sort-even-and-odd-indices-independently.js │ │ │ ├── sort-integers-by-the-number-of-1-bits/ │ │ │ │ └── sort-integers-by-the-number-of-1-bits.js │ │ │ ├── sort-the-people/ │ │ │ │ └── sort-the-people.js │ │ │ ├── sort_array_by_parity/ │ │ │ │ └── sort_array_by_parity.py │ │ │ ├── sort_sentence/ │ │ │ │ └── sort_sentence.py │ │ │ ├── special-positions-in-a-binary-matrix/ │ │ │ │ ├── special-positions-in-a-binary-matrix-cache.js │ │ │ │ └── special-positions-in-a-binary-matrix.js │ │ │ ├── split-strings-by-separator/ │ │ │ │ └── split-strings-by-separator.js │ │ │ ├── split-with-minimum-sum/ │ │ │ │ └── split-with-minimum-sum.js │ │ │ ├── split_string_in_balanced_strings/ │ │ │ │ └── split_string_in_balanced_strings.py │ │ │ ├── squares-of-a-sorted-array/ │ │ │ │ ├── squares-of-a-sorted-array-on.js │ │ │ │ └── squares-of-a-sorted-array.js │ │ │ ├── squares_of_a_sorted_array/ │ │ │ │ └── squares_of_a_sorted_array.py │ │ │ ├── str_str/ │ │ │ │ └── str_str.py │ │ │ ├── string-matching-in-an-array/ │ │ │ │ └── string-matching-in-an-array.js │ │ │ ├── subarrays-distinct-element-sum-of-squares-i/ │ │ │ │ └── subarrays-distinct-element-sum-of-squares-i.js │ │ │ ├── subdomain_visit_count.py │ │ │ ├── substrings-of-size-three-with-distinct-characters/ │ │ │ │ └── substrings-of-size-three-with-distinct-characters.js │ │ │ ├── subtract_product_and_sum/ │ │ │ │ └── subtract_product_and_sum.py │ │ │ ├── subtree-of-another-tree/ │ │ │ │ └── subtree-of-another-tree.js │ │ │ ├── sum-multiples/ │ │ │ │ └── sum-multiples.js │ │ │ ├── sum-of-all-subset-xor-totals/ │ │ │ │ └── sum-of-all-subset-xor-totals.js │ │ │ ├── sum-of-digits-in-base-k/ │ │ │ │ └── sum-of-digits-in-base-k.js │ │ │ ├── sum-of-digits-of-string-after-convert/ │ │ │ │ └── sum-of-digits-of-string-after-convert.js │ │ │ ├── sum-of-left-leaves/ │ │ │ │ └── sum-of-left-leaves.js │ │ │ ├── sum-of-squares-of-special-elements/ │ │ │ │ └── sum-of-squares-of-special-elements.js │ │ │ ├── sum-of-values-at-indices-with-k-set-bits/ │ │ │ │ └── sum-of-values-at-indices-with-k-set-bits.js │ │ │ ├── sum_leaf_binary_numbers/ │ │ │ │ └── sum_leaf_binary_numbers.py │ │ │ ├── sum_of_all_odd_length_subarrays/ │ │ │ │ └── sum_of_all_odd_length_subarrays.py │ │ │ ├── sum_of_unique_elements/ │ │ │ │ └── sum_of_unique_elements.py │ │ │ ├── sum_zero/ │ │ │ │ └── sum_zero.py │ │ │ ├── symmetric-tree/ │ │ │ │ └── symmetric-tree.js │ │ │ ├── take-gifts-from-the-richest-pile/ │ │ │ │ └── take-gifts-from-the-richest-pile.js │ │ │ ├── three-consecutive-odds/ │ │ │ │ └── three-consecutive-odds.js │ │ │ ├── time-needed-to-buy-tickets/ │ │ │ │ └── time-needed-to-buy-tickets.js │ │ │ ├── to_lower_case/ │ │ │ │ └── to_lower_case.py │ │ │ ├── toeplitz-matrix/ │ │ │ │ └── toeplitz-matrix.js │ │ │ ├── transpose-matrix/ │ │ │ │ └── transpose-matrix.js │ │ │ ├── truncate_sentence/ │ │ │ │ └── truncate_sentence.py │ │ │ ├── two-furthest-houses-with-different-colors/ │ │ │ │ └── two-furthest-houses-with-different-colors.js │ │ │ ├── two-out-of-three/ │ │ │ │ └── two-out-of-three.js │ │ │ ├── two-sum/ │ │ │ │ └── two-sum.js │ │ │ ├── two-sum-iv-input-is-a-bst/ │ │ │ │ └── two-sum-iv-input-is-a-bst.js │ │ │ ├── two_sum.py │ │ │ ├── uncommon-words-from-two-sentences/ │ │ │ │ └── uncommon-words-from-two-sentences.js │ │ │ ├── unique-number-of-occurrences/ │ │ │ │ └── unique-number-of-occurrences.js │ │ │ ├── unique_morse_code_words.py │ │ │ ├── unique_number_of_occurrences/ │ │ │ │ └── unique_number_of_occurrences.py │ │ │ ├── univalued-binary-tree/ │ │ │ │ └── univalued-binary-tree.js │ │ │ ├── valid-anagram/ │ │ │ │ └── valid-anagram.js │ │ │ ├── valid-palindrome/ │ │ │ │ ├── valid-palindrome-2.js │ │ │ │ ├── valid-palindrome.js │ │ │ │ └── valid_palindrome.py │ │ │ ├── valid-parentheses/ │ │ │ │ └── valid-parentheses.js │ │ │ ├── water-bottles/ │ │ │ │ └── water-bottles.js │ │ │ ├── weakest_rows/ │ │ │ │ └── weakest_rows.py │ │ │ └── xor-operation-in-an-array/ │ │ │ └── xor-operation-in-an-array.js │ │ └── medium/ │ │ ├── 3sum/ │ │ │ └── 3sum-tle.js │ │ ├── add_two_numbers/ │ │ │ └── add_two_numbers.py │ │ ├── all_elements_in_two_binary_search_trees/ │ │ │ └── all_elements_in_two_binary_search_trees.py │ │ ├── arithmetic-subarrays/ │ │ │ └── arithmetic-subarrays.py │ │ ├── balance-a-binary-search-tree/ │ │ │ └── balance-a-binary-search-tree.js │ │ ├── binary-tree-inorder-traversal/ │ │ │ └── binary-tree-inorder-traversal.py │ │ ├── binary-tree-level-order-traversal/ │ │ │ └── binary-tree-level-order-traversal.js │ │ ├── bst_from_pre_order_traversal/ │ │ │ └── bst_from_pre_order_traversal.py │ │ ├── bst_to_greatest/ │ │ │ └── bst_to_greatest.py │ │ ├── clone-graph/ │ │ │ └── clone-graph.js │ │ ├── cloned_binary_tree/ │ │ │ └── cloned_binary_tree.py │ │ ├── count-nodes-equal-to-average-of-subtree/ │ │ │ └── count-nodes-equal-to-average-of-subtree.js │ │ ├── count-number-of-distinct-integers-after-reverse-operations/ │ │ │ ├── count-number-of-distinct-integers-after-reverse-operations-numbers.js │ │ │ └── count-number-of-distinct-integers-after-reverse-operations.js │ │ ├── count-sorted-vowel-strings/ │ │ │ └── count-sorted-vowel-strings.js │ │ ├── count-sub-islands/ │ │ │ ├── count-sub-islands-tle.js │ │ │ └── count-sub-islands.js │ │ ├── count_points/ │ │ │ └── count_points.py │ │ ├── counter_number_of_teams/ │ │ │ └── counter_number_of_teams.py │ │ ├── deck_revealed_increasing/ │ │ │ └── deck_revealed_increasing.py │ │ ├── decode-string/ │ │ │ ├── decode-string.js │ │ │ └── tests/ │ │ │ └── decode-string.test.js │ │ ├── deepest_leaves_sum/ │ │ │ └── deepest_leaves_sum.py │ │ ├── delete-node-in-a-linked-list/ │ │ │ ├── better-delete-node-in-a-linked-list.js │ │ │ └── delete-node-in-a-linked-list.js │ │ ├── design-a-stack-with-increment-operation/ │ │ │ ├── design-a-stack-with-increment-operation.js │ │ │ └── tests/ │ │ │ └── design-a-stack-with-increment-operation.test.js │ │ ├── design-add-and-search-words-data-structure/ │ │ │ └── design-add-and-search-words-data-structure.js │ │ ├── difference-between-ones-and-zeros-in-row-and-column/ │ │ │ └── difference-between-ones-and-zeros-in-row-and-column.js │ │ ├── encode_and_decode_tinyurl/ │ │ │ └── encode_and_decode_tinyurl.py │ │ ├── execution-of-all-suffix-instructions-staying-in-a-grid/ │ │ │ └── execution-of-all-suffix-instructions-staying-in-a-grid.js │ │ ├── find-the-original-array-of-prefix-xor/ │ │ │ ├── README.md │ │ │ └── find-the-original-array-of-prefix-xor.js │ │ ├── find-the-winner-of-the-circular-game/ │ │ │ ├── find-the-winner-of-the-circular-game.js │ │ │ └── queue-find-the-winner-of-the-circular-game.js │ │ ├── find-triangular-sum-of-an-array/ │ │ │ ├── find-triangular-sum-of-an-array.js │ │ │ └── tests/ │ │ │ └── find-triangular-sum-of-an-array.test.js │ │ ├── find-valid-matrix-given-row-and-column-sums/ │ │ │ └── find-valid-matrix-given-row-and-column-sums.js │ │ ├── find_and_replace_pattern/ │ │ │ └── find_and_replace_pattern.py │ │ ├── finding_pairs_with_a_certain_sum/ │ │ │ └── finding_pairs_with_a_certain_sum.py │ │ ├── finding_the_users_active_minutes/ │ │ │ └── finding_the_users_active_minutes.py │ │ ├── fraction_to_decimal/ │ │ │ └── fraction_to_decimal.py │ │ ├── group-anagrams/ │ │ │ └── group-anagrams.js │ │ ├── group_the_people/ │ │ │ └── group_the_people.py │ │ ├── insert-greatest-common-divisors-in-linked-list/ │ │ │ └── insert-greatest-common-divisors-in-linked-list.js │ │ ├── insert-into-a-binary-search-tree/ │ │ │ └── insert-into-a-binary-search-tree.js │ │ ├── insert_bst/ │ │ │ └── insert_bst.py │ │ ├── keep_city_skyline/ │ │ │ └── keep_city_skyline.py │ │ ├── kth-smallest-element-in-a-bst/ │ │ │ ├── kth-smallest-element-in-a-bst-1.js │ │ │ ├── kth-smallest-element-in-a-bst-2.js │ │ │ └── kth-smallest-element-in-a-bst.js │ │ ├── letter_tile_possibilities/ │ │ │ └── letter_tile_possibilities.py │ │ ├── longest-substring-without-repeating-characters/ │ │ │ └── longest-substring-without-repeating-characters.js │ │ ├── max-area-of-island/ │ │ │ └── max-area-of-island.js │ │ ├── max_coins/ │ │ │ └── max_coins.py │ │ ├── maximum-sum-of-an-hourglass/ │ │ │ └── maximum-sum-of-an-hourglass.js │ │ ├── maximum_binary_tree/ │ │ │ └── maximum_binary_tree.py │ │ ├── median_tree/ │ │ │ └── median_tree.py │ │ ├── merge-nodes-in-between-zeros/ │ │ │ ├── merge-nodes-in-between-zeros.js │ │ │ └── tests/ │ │ │ └── merge-nodes-in-between-zeros.test.js │ │ ├── min-cost-climbing-stairs/ │ │ │ └── min-cost-climbing-stairs.js │ │ ├── min_operations/ │ │ │ └── min_operations.py │ │ ├── min_pair_sum/ │ │ │ └── min_pair_sum.py │ │ ├── min_partitions/ │ │ │ └── min_partitions.py │ │ ├── minimum-add-to-make-parentheses-valid/ │ │ │ └── minimum-add-to-make-parentheses-valid.js │ │ ├── minimum-amount-of-time-to-collect-garbage/ │ │ │ └── minimum-amount-of-time-to-collect-garbage.js │ │ ├── minimum-cost-of-buying-candies-with-discount/ │ │ │ └── minimum-cost-of-buying-candies-with-discount.js │ │ ├── minimum-number-of-steps-to-make-two-strings-anagram/ │ │ │ ├── README.md │ │ │ └── minimum-number-of-steps-to-make-two-strings-anagram.js │ │ ├── minimum_number_of_operations_to_move_all_balls_to_each_box/ │ │ │ └── minimum_number_of_operations_to_move_all_balls_to_each_box.py │ │ ├── number-of-closed-islands/ │ │ │ └── number-of-closed-islands.js │ │ ├── number-of-enclaves/ │ │ │ └── number-of-enclaves.js │ │ ├── number-of-islands/ │ │ │ └── number-of-islands.js │ │ ├── number-of-laser-beams-in-a-bank/ │ │ │ ├── number-of-laser-beams-in-a-bank.js │ │ │ └── tests/ │ │ │ └── number-of-laser-beams-in-a-bank.test.js │ │ ├── optimal-partition-of-string/ │ │ │ ├── optimal-partition-of-string.js │ │ │ └── optimized-optimal-partition-of-string.js │ │ ├── pair-sum/ │ │ │ ├── pair-sum.js │ │ │ └── tests/ │ │ │ └── pair-sum.test.js │ │ ├── partition-array-according-to-given-pivot/ │ │ │ ├── partition-array-according-to-given-pivot.js │ │ │ └── tests/ │ │ │ └── partition-array-according-to-given-pivot.test.js │ │ ├── permutation-in-string/ │ │ │ ├── permutation-in-string-sliding-window.js │ │ │ └── permutation-in-string.js │ │ ├── populating-next-right-pointers-in-each-node/ │ │ │ ├── populating-next-right-pointers-in-each-node-simpler.js │ │ │ └── populating-next-right-pointers-in-each-node.js │ │ ├── process_queries/ │ │ │ └── process_queries.py │ │ ├── product-of-array-except-self/ │ │ │ └── product-of-array-except-self.js │ │ ├── rearrange-array-elements-by-sign/ │ │ │ ├── rearrange-array-elements-by-sign.js │ │ │ └── tests/ │ │ │ └── rearrange-array-elements-by-sign.test.js │ │ ├── reduce_array_size_to_the_half/ │ │ │ └── reduce_array_size_to_the_half.py │ │ ├── remove-nth-node-from-end-of-list/ │ │ │ ├── remove-nth-node-from-end-of-list-fast-slow.js │ │ │ └── remove-nth-node-from-end-of-list.js │ │ ├── rotate-array/ │ │ │ ├── rotate-array-optimized.js │ │ │ └── rotate-array.js │ │ ├── rotate-image/ │ │ │ └── rotate-image.js │ │ ├── search-a-2d-matrix/ │ │ │ ├── search-a-2d-matrix.js │ │ │ └── search-a-2d-matrix.py │ │ ├── search-a-2d-matrix-ii/ │ │ │ └── search-a-2d-matrix-ii.py │ │ ├── set-matrix-zeroes/ │ │ │ └── set-matrix-zeroes.js │ │ ├── sort-the-students-by-their-kth-score/ │ │ │ └── sort-the-students-by-their-kth-score.js │ │ ├── sort_the_matrix_diagonally/ │ │ │ └── sort_the_matrix_diagonally.py │ │ ├── string-compression/ │ │ │ ├── string-compression-copy.js │ │ │ └── string-compression.js │ │ ├── subrectangle_queries/ │ │ │ └── subrectangle_queries.py │ │ ├── sum_of_nodes/ │ │ │ └── sum_of_nodes.py │ │ ├── two-sum-ii-input-array-is-sorted/ │ │ │ ├── two-sum-ii-input-array-is-sorted-2.js │ │ │ └── two-sum-ii-input-array-is-sorted.js │ │ ├── valid-sudoku/ │ │ │ └── valid-sudoku.js │ │ ├── validate-binary-search-tree/ │ │ │ ├── validate-binary-search-tree-2.js │ │ │ ├── validate-binary-search-tree-almost-right.js │ │ │ └── validate-binary-search-tree.js │ │ └── watering-plants/ │ │ ├── tests/ │ │ │ └── watering-plants.test.js │ │ └── watering-plants.js │ ├── python/ │ │ └── string.py │ └── top-problems/ │ ├── are-anagrams.js │ ├── first-and-last-index.js │ ├── kth-largest.js │ ├── min-sliding-window.js │ └── tests/ │ ├── are-anagrams.test.js │ ├── first-and-last-index.test.js │ └── kth-largest.test.js ├── college/ │ ├── graph/ │ │ └── atoms.py │ └── web/ │ ├── css/ │ │ ├── estilos.css │ │ └── index.html │ ├── index.html │ ├── js.js │ └── loop.js ├── competitive-programming/ │ ├── 4clojure/ │ │ ├── problem01.clj │ │ ├── problem02.clj │ │ ├── problem03.clj │ │ ├── problem04.clj │ │ ├── problem05.clj │ │ ├── problem06.clj │ │ ├── problem07.clj │ │ ├── problem19.clj │ │ └── problem20.clj │ ├── acm-icpc-br/ │ │ ├── regionals_2011/ │ │ │ ├── armstrong.cpp │ │ │ ├── calculadora.cpp │ │ │ ├── cartoes.cpp │ │ │ ├── concurso.cpp │ │ │ ├── coral.cpp │ │ │ ├── elevador.cpp │ │ │ ├── estacionamento.cpp │ │ │ ├── extenso.cpp │ │ │ ├── goldbach.cpp │ │ │ ├── matriz_esparsa.cpp │ │ │ ├── pascal.cpp │ │ │ ├── polinomio.cpp │ │ │ ├── quadrado.cpp │ │ │ └── vagas.cpp │ │ ├── regionals_2017_1/ │ │ │ └── A.cpp │ │ └── regionals_2017_2/ │ │ ├── D.cpp │ │ ├── F.cpp │ │ ├── J.py │ │ └── M.cpp │ ├── codeforces/ │ │ └── div2/ │ │ ├── black_square.cpp │ │ ├── karen_and_morning.cpp │ │ ├── keyboard_layouts.cpp │ │ ├── the_child_and_the_homework.cpp │ │ ├── the_child_and_toy.cpp │ │ └── valera_and_plates.cpp │ ├── exercism/ │ │ ├── clojure/ │ │ │ ├── armstrong-numbers/ │ │ │ │ ├── .exercism/ │ │ │ │ │ └── metadata.json │ │ │ │ ├── .lein-failures │ │ │ │ ├── .lein-repl-history │ │ │ │ ├── README.md │ │ │ │ ├── project.clj │ │ │ │ ├── src/ │ │ │ │ │ └── armstrong_numbers.clj │ │ │ │ ├── target/ │ │ │ │ │ ├── classes/ │ │ │ │ │ │ └── META-INF/ │ │ │ │ │ │ └── maven/ │ │ │ │ │ │ └── armstrong-numbers/ │ │ │ │ │ │ └── armstrong-numbers/ │ │ │ │ │ │ └── pom.properties │ │ │ │ │ └── stale/ │ │ │ │ │ └── leiningen.core.classpath.extract-native-dependencies │ │ │ │ └── test/ │ │ │ │ └── armstrong_numbers_test.clj │ │ │ ├── hello-world/ │ │ │ │ ├── README.md │ │ │ │ ├── project.clj │ │ │ │ ├── src/ │ │ │ │ │ └── hello-world.clj │ │ │ │ └── test/ │ │ │ │ └── hello-world-test.clj │ │ │ └── two-fer/ │ │ │ ├── .exercism/ │ │ │ │ └── metadata.json │ │ │ ├── .lein-failures │ │ │ ├── .nrepl-port │ │ │ ├── README.md │ │ │ ├── project.clj │ │ │ ├── src/ │ │ │ │ └── two_fer.clj │ │ │ ├── target/ │ │ │ │ ├── classes/ │ │ │ │ │ └── META-INF/ │ │ │ │ │ └── maven/ │ │ │ │ │ └── two-fer/ │ │ │ │ │ └── two-fer/ │ │ │ │ │ └── pom.properties │ │ │ │ ├── repl-port │ │ │ │ └── stale/ │ │ │ │ └── leiningen.core.classpath.extract-native-dependencies │ │ │ └── test/ │ │ │ └── two_fer_test.clj │ │ └── javascript/ │ │ ├── allergies.js │ │ ├── collatz-conjecture.js │ │ ├── count-words.js │ │ ├── etl.js │ │ ├── flatten-array.js │ │ ├── gigasecond.js │ │ ├── hello-world.js │ │ ├── leap.js │ │ ├── perfect-numbers.js │ │ ├── phone-number.js │ │ ├── resistor-color.js │ │ ├── resistor-colors.js │ │ ├── reverse-string.js │ │ ├── sublist.js │ │ ├── sum-of-multiples.js │ │ ├── triangle.js │ │ └── two-fer.js │ ├── hacker-rank/ │ │ ├── algorithms/ │ │ │ ├── strings/ │ │ │ │ └── palindrome_index.py │ │ │ └── warmup/ │ │ │ ├── birthday_cake_candles.py │ │ │ └── mini_max_sum.py │ │ ├── cpp/ │ │ │ └── introduction/ │ │ │ ├── angry_professor.cpp │ │ │ ├── arrays_introduction.cpp │ │ │ ├── diagonal_difference.cpp │ │ │ ├── input_and_output.cpp │ │ │ ├── library_fine.cpp │ │ │ ├── plus_minus.cpp │ │ │ ├── staircase.cpp │ │ │ ├── time_conversion.cpp │ │ │ ├── vector_erase.cpp │ │ │ └── vector_sort.cpp │ │ ├── data_structures/ │ │ │ └── trees/ │ │ │ ├── in_order_traversal.py │ │ │ ├── post_order_traversal.py │ │ │ └── pre_order_traversal.py │ │ ├── functional-programming/ │ │ │ ├── array_of_n_elements/ │ │ │ │ ├── array_of_n_elements.clj │ │ │ │ └── array_of_n_elements_without_range.clj │ │ │ ├── basics/ │ │ │ │ ├── hello_world.clj │ │ │ │ ├── hello_world_n_times.clj │ │ │ │ └── solve_me_first.clj │ │ │ ├── eval_ex/ │ │ │ │ └── main.clj │ │ │ ├── filter_array/ │ │ │ │ └── filter_array.clj │ │ │ ├── filter_positions_in_a_list/ │ │ │ │ └── filter_positions_in_a_list.clj │ │ │ ├── list_length/ │ │ │ │ ├── list_length.clj │ │ │ │ └── list_length_reduce.clj │ │ │ ├── list_replication/ │ │ │ │ └── list_replication.clj │ │ │ ├── reverse_a_list/ │ │ │ │ ├── reverse_a_list.clj │ │ │ │ ├── reverse_a_list_into.clj │ │ │ │ └── reverse_a_list_reduce.clj │ │ │ ├── sum_of_odd_elements/ │ │ │ │ └── sum_of_odd_elements.clj │ │ │ └── update_list/ │ │ │ ├── update_list.clj │ │ │ ├── update_list_anonymous.clj │ │ │ ├── update_list_map.clj │ │ │ └── update_list_map_anonymous.clj │ │ └── python/ │ │ ├── basic_data_types/ │ │ │ ├── finding_the_percentage.py │ │ │ ├── lists.py │ │ │ ├── nested_list.py │ │ │ ├── runner_up_score.py │ │ │ └── tuple.py │ │ ├── introduction/ │ │ │ ├── arithmetic_operators.py │ │ │ ├── division.py │ │ │ └── if_else.py │ │ ├── sets/ │ │ │ └── intro_to_sets.py │ │ └── strings/ │ │ ├── find_a_string.py │ │ ├── mutate_string.py │ │ ├── split_and_join.py │ │ ├── string_validators.py │ │ ├── swap_case.py │ │ ├── text_wrap.py │ │ └── whats_your_name.py │ ├── interfatecs/ │ │ ├── 1_2016/ │ │ │ ├── a.cpp │ │ │ ├── b.cpp │ │ │ ├── g.cpp │ │ │ └── i.cpp │ │ └── 1_2018/ │ │ ├── a.cpp │ │ ├── b.cpp │ │ ├── c.cpp │ │ ├── d.py │ │ ├── e.py │ │ ├── f.py │ │ ├── g.cpp │ │ ├── h.cpp │ │ ├── i.py │ │ └── j.cpp │ ├── spoj-br/ │ │ ├── aero.cpp │ │ ├── bafo.cpp │ │ ├── bapostas.cpp │ │ ├── bit.cpp │ │ ├── calcula.cpp │ │ ├── calculadora.cpp │ │ ├── dentista.cpp │ │ ├── desculpa.cpp │ │ ├── eleicoes1.cpp │ │ ├── eleicoes2.cpp │ │ ├── estagio.cpp │ │ ├── fatorial.cpp │ │ ├── feyman.cpp │ │ ├── fliperam.cpp │ │ ├── gangorra.cpp │ │ ├── guardacosta.cpp │ │ ├── impedido.cpp │ │ ├── letra.cpp │ │ ├── loopmusi.cpp │ │ ├── lua.cpp │ │ ├── macaco.cpp │ │ ├── minhoca.cpp │ │ ├── miojo.cpp │ │ ├── obi.cpp │ │ ├── obihanoi.cpp │ │ ├── parprox.cpp │ │ ├── peca.cpp │ │ ├── primo.cpp │ │ ├── rumo9s.cpp │ │ ├── saldo.cpp │ │ ├── saldo13.cpp │ │ ├── sorvete.cpp │ │ ├── sudoku.cpp │ │ ├── telefone.cpp │ │ ├── transporte.cpp │ │ ├── troco13.cpp │ │ ├── vivo.cpp │ │ └── wcw.cpp │ ├── timus/ │ │ └── a+b_problem.cpp │ ├── ucoder/ │ │ ├── armstrong_numbers.cpp │ │ ├── historico_de_comandos.cpp │ │ ├── imperador_cassius.cpp │ │ ├── matriz_esparsa.cpp │ │ ├── obi.cpp │ │ └── tsetse.cpp │ ├── uri/ │ │ ├── 3d_virtual_museum.cpp │ │ ├── a_long_time_ago.cpp │ │ ├── above_average.cpp │ │ ├── above_secundary_diagonal.cpp │ │ ├── above_the_main_diagonal.cpp │ │ ├── abracadabra.cpp │ │ ├── advancing_letters.cpp │ │ ├── age_in_day.cpp │ │ ├── ages.cpp │ │ ├── alarm_clock.cpp │ │ ├── alliteration.cpp │ │ ├── andys_first_dictionary.cpp │ │ ├── angry_ducks.cpp │ │ ├── animal.cpp │ │ ├── approximate_number_of_primes.cpp │ │ ├── area.cpp │ │ ├── area_of_circle.cpp │ │ ├── arranging_tasks.cpp │ │ ├── array_123.cpp │ │ ├── array_change_1.cpp │ │ ├── array_fill_1.cpp │ │ ├── array_fill_2.cpp │ │ ├── array_fill_3.cpp │ │ ├── array_fill_4.cpp │ │ ├── array_hash.cpp │ │ ├── array_replacement_1.cpp │ │ ├── array_selection_1.cpp │ │ ├── as_abas_de_pericles.cpp │ │ ├── ascending_and_descending.cpp │ │ ├── assigning_teams.cpp │ │ ├── automated_checking_machine.cpp │ │ ├── average_1.cpp │ │ ├── average_2.cpp │ │ ├── average_3.cpp │ │ ├── average_speed.cpp │ │ ├── back_to_high_school_physics.cpp │ │ ├── bacteria_1.cpp │ │ ├── banknotes.cpp │ │ ├── banknotes_and_coins.cpp │ │ ├── baskharas_formula.cpp │ │ ├── batmain.cpp │ │ ├── bazinga.cpp │ │ ├── below_the_main_diagonal.cpp │ │ ├── below_the_secundary_diagonal.cpp │ │ ├── bill.cpp │ │ ├── bingo.cpp │ │ ├── bla.cpp │ │ ├── blobs.cpp │ │ ├── bloggo_shotcuts.cpp │ │ ├── bob_conduit.cpp │ │ ├── bodybuilder.cpp │ │ ├── brazil_world_cup.cpp │ │ ├── brazilian_economy.cpp │ │ ├── brick_game.cpp │ │ ├── bubbles_and_bucket.cpp │ │ ├── bubbles_and_bucket_2.cpp │ │ ├── building_houses.cpp │ │ ├── building_walls.cpp │ │ ├── buttlerflies.cpp │ │ ├── c_mais_ou_menos.cpp │ │ ├── caeser_cipher.cpp │ │ ├── cannon.cpp │ │ ├── canteen_queue.cpp │ │ ├── cash_roial.cpp │ │ ├── chinese_whispers.cpp │ │ ├── chirrin_chirrion.cpp │ │ ├── chocolate_factory.cpp │ │ ├── christmas_decoration.cpp │ │ ├── christmas_olympic.cpp │ │ ├── christmas_trapeziums.cpp │ │ ├── christmas_tree.cpp │ │ ├── close_the_doors.cpp │ │ ├── coast_guard.cpp │ │ ├── coffee_machine.cpp │ │ ├── colision.cpp │ │ ├── collectable_cards.cpp │ │ ├── colourful_flowers.cpp │ │ ├── column_in_array.cpp │ │ ├── combiner.cpp │ │ ├── compare_substring.cpp │ │ ├── complete_sequence.cpp │ │ ├── consumption.cpp │ │ ├── contando_ciclos.cpp │ │ ├── contest.cpp │ │ ├── contract_revision.cpp │ │ ├── converting_to_hexadecimal.cpp │ │ ├── coordinates_of_a_point.cpp │ │ ├── correct_colourful_flower.cpp │ │ ├── corrida.cpp │ │ ├── counting_crow.cpp │ │ ├── counting_sheeps.cpp │ │ ├── cutoff_rounder.cpp │ │ ├── cutoff_rounder_2.cpp │ │ ├── dancing_sentence.cpp │ │ ├── dangerous_dive.cpp │ │ ├── dating_online.cpp │ │ ├── deciphering_the_encrypted_card.cpp │ │ ├── delaunay_triangulation.cpp │ │ ├── desafio_de_bino.cpp │ │ ├── detective_watson_1.cpp │ │ ├── detective_watson_2.cpp │ │ ├── diamonds_and_sand.cpp │ │ ├── diet_plan.cpp │ │ ├── difference.cpp │ │ ├── different_digits.cpp │ │ ├── difn.cpp │ │ ├── dijkstra.cpp │ │ ├── discovering_password.cpp │ │ ├── distance.cpp │ │ ├── distance_between_two_points.cpp │ │ ├── dividers.cpp │ │ ├── dividing_x_by_y.cpp │ │ ├── diving.cpp │ │ ├── division_of_nlogonia.cpp │ │ ├── divisors_1.cpp │ │ ├── dracarys.cpp │ │ ├── drought.cpp │ │ ├── easy_difference_dates.cpp │ │ ├── easy_fibonacci.cpp │ │ ├── easy_problem_from_rujia_liu_1.cpp │ │ ├── easy_problem_from_rujia_liu_2.cpp │ │ ├── eletrical_outlet.cpp │ │ ├── encryption.cpp │ │ ├── engine_failure.cpp │ │ ├── erasing_and_winning.cpp │ │ ├── estimating_the_mean.cpp │ │ ├── etiquetas_de_noel.cpp │ │ ├── even_and_odd.cpp │ │ ├── even_between_five_numbers.cpp │ │ ├── even_numbers.cpp │ │ ├── even_or_odd.cpp │ │ ├── even_square.cpp │ │ ├── event.cpp │ │ ├── event_time.cpp │ │ ├── exceeding_z.cpp │ │ ├── exchanging_cards.cpp │ │ ├── experiments.cpp │ │ ├── extremely_basic.cpp │ │ ├── face_2015_free_gift.cpp │ │ ├── factorial.cpp │ │ ├── factorial_again.cpp │ │ ├── factorial_sum.cpp │ │ ├── fake_tickets.cpp │ │ ├── fans_and_ballons.cpp │ │ ├── farm_robot.cpp │ │ ├── fase.cpp │ │ ├── fast_fibonacci.cpp │ │ ├── fast_prime_number.cpp │ │ ├── feedback.cpp │ │ ├── feyman.cpp │ │ ├── fibonacci_again.cpp │ │ ├── fibonacci_array.cpp │ │ ├── fila_do_supermercado.cpp │ │ ├── fire_flowers.cpp │ │ ├── fit_or_dont_fit_1.cpp │ │ ├── fit_or_dont_fit_2.cpp │ │ ├── fixed_password.cpp │ │ ├── flavious_josephus_legend.cpp │ │ ├── flavious_josephus_legend2.cpp │ │ ├── flavious_josephus_legend3.cpp │ │ ├── flowers_flourish_from_france.cpp │ │ ├── football.cpp │ │ ├── frequent_asked_questions.cpp │ │ ├── friends_of_habey.cpp │ │ ├── fuel_spent.cpp │ │ ├── functions.cpp │ │ ├── galopeira.cpp │ │ ├── game_of_the_greatness.cpp │ │ ├── general_exam.cpp │ │ ├── getline_fruits.cpp │ │ ├── getline_one.cpp │ │ ├── getline_three_shoes.cpp │ │ ├── going_to_the_market.cpp │ │ ├── grains_in_a_chess_board.cpp │ │ ├── grenais.cpp │ │ ├── growing_sequences.cpp │ │ ├── guess_what.cpp │ │ ├── guilherme_and_his_kites.cpp │ │ ├── guru_da_sorte.cpp │ │ ├── hailstone_sequences.cpp │ │ ├── hall_of_murderers.cpp │ │ ├── hall_of_murderers_2.cpp │ │ ├── hall_of_murderers_3.cpp │ │ ├── hamekameka.cpp │ │ ├── handball.cpp │ │ ├── hardwood_species.cpp │ │ ├── hash_tables.cpp │ │ ├── hashmat_the_brave_warrior.cpp │ │ ├── hay_points.cpp │ │ ├── he_is_offside!.cpp │ │ ├── head_or_tails.cpp │ │ ├── height.cpp │ │ ├── hello_galaxy.cpp │ │ ├── help!.cpp │ │ ├── help_girafales.cpp │ │ ├── help_seu_madruga.cpp │ │ ├── help_seu_madruga_int.cpp │ │ ├── help_the_federation.cpp │ │ ├── hexagonal_tiles_1.cpp │ │ ├── hexagonal_tiles_2.cpp │ │ ├── hidden_message.cpp │ │ ├── highest_and_position.cpp │ │ ├── hohoho.cpp │ │ ├── honey_reservoir.cpp │ │ ├── hours_and_minutes.cpp │ │ ├── how_easy.cpp │ │ ├── huehue.cpp │ │ ├── i_am_toorg.cpp │ │ ├── ice_statuses.cpp │ │ ├── identifying_tea.cpp │ │ ├── image.cpp │ │ ├── impar_par_roubo.cpp │ │ ├── inferior_area.cpp │ │ ├── inside_out.cpp │ │ ├── international_chat.cpp │ │ ├── internship.cpp │ │ ├── interval.cpp │ │ ├── interval2.cpp │ │ ├── inverse_numbers.cpp │ │ ├── is_triangle.cpp │ │ ├── jetiqui.cpp │ │ ├── jingle_composing.cpp │ │ ├── jogatina_ufpa.cpp │ │ ├── jogo_da_boca.py │ │ ├── jollo.cpp │ │ ├── joulupukki.cpp │ │ ├── jumping_frog.cpp │ │ ├── just_in_time.cpp │ │ ├── justifier.cpp │ │ ├── justifier_2.cpp │ │ ├── kage_bunshin_no_jutsu.cpp │ │ ├── kiloman.cpp │ │ ├── koch_snowflake.cpp │ │ ├── lap.cpp │ │ ├── laser_sculpture.cpp │ │ ├── last_analogimon.cpp │ │ ├── laundry.cpp │ │ ├── leaders_impeachment.cpp │ │ ├── led.cpp │ │ ├── left_area.cpp │ │ ├── libertadores_1.cpp │ │ ├── libertadores_2.cpp │ │ ├── line_in_array.cpp │ │ ├── linear_parking_lot.cpp │ │ ├── little_ant.cpp │ │ ├── little_ducks.py │ │ ├── logical_sequence.cpp │ │ ├── logical_sequence_2.cpp │ │ ├── lost_boots.cpp │ │ ├── lowest_number_and_position.cpp │ │ ├── lu_di_oh.cpp │ │ ├── lucro.cpp │ │ ├── lucro_otimizado.cpp │ │ ├── macpronalts.cpp │ │ ├── maesters_map.cpp │ │ ├── mean_median_problem.cpp │ │ ├── medal_table.cpp │ │ ├── merry_christmaaaas.cpp │ │ ├── mirror_sequence.cpp │ │ ├── mjolnir.cpp │ │ ├── monetary_formatting.cpp │ │ ├── montanha_russa.cpp │ │ ├── month.cpp │ │ ├── moon_phases.cpp │ │ ├── morse.cpp │ │ ├── motoboy.cpp │ │ ├── multiple_of_13.cpp │ │ ├── multiple_reading.cpp │ │ ├── multiples.cpp │ │ ├── multiplication_table.cpp │ │ ├── musical_loop.cpp │ │ ├── name_at_form.cpp │ │ ├── natural_sum.cpp │ │ ├── new_record.cpp │ │ ├── nine.cpp │ │ ├── number_frequence.cpp │ │ ├── obi_uri.cpp │ │ ├── odd_numbers.cpp │ │ ├── og.cpp │ │ ├── one_two_three.cpp │ │ ├── operator_game.cpp │ │ ├── optical_reader.cpp │ │ ├── our_days_are_never_coming_back.cpp │ │ ├── painel_led.cpp │ │ ├── palindrome_game.cpp │ │ ├── pandorgas.cpp │ │ ├── pao_de_queijo_sweeper.cpp │ │ ├── parafusos_e_porcas.cpp │ │ ├── parenthesis_balance.cpp │ │ ├── parity.cpp │ │ ├── pascal_library.cpp │ │ ├── password.cpp │ │ ├── password_validator.cpp │ │ ├── paulas_mathematic_game.cpp │ │ ├── peaks_and_valleys.cpp │ │ ├── pedrinhos_christmas.cpp │ │ ├── pepe.cpp │ │ ├── perfect_number.cpp │ │ ├── phin_bonati.cpp │ │ ├── pizza_pre_bh.cpp │ │ ├── pokemon.cpp │ │ ├── pomekon_collection.cpp │ │ ├── pomekons_battle.cpp │ │ ├── population_increase.cpp │ │ ├── positive_numbers.cpp │ │ ├── positives_and_average.cpp │ │ ├── power_crisis.cpp │ │ ├── preface.cpp │ │ ├── presents.cpp │ │ ├── primary_arithmatic.cpp │ │ ├── prime_number.cpp │ │ ├── pum.cpp │ │ ├── quadrant.cpp │ │ ├── queen.cpp │ │ ├── radares.cpp │ │ ├── rails.cpp │ │ ├── rails_again.cpp │ │ ├── reading_books.cpp │ │ ├── regular_simple_polygon.cpp │ │ ├── remaining2.cpp │ │ ├── removing_letter.cpp │ │ ├── rest_of_a_division.cpp │ │ ├── right_area.cpp │ │ ├── rlj.cpp │ │ ├── robot_instructions.cpp │ │ ├── rock_paper_airstrike.cpp │ │ ├── rock_paper_scissors_lizard_spock.cpp │ │ ├── roman_numerals_for_page_numbers.cpp │ │ ├── rot13.cpp │ │ ├── s_sequence.cpp │ │ ├── s_sequence_2.cpp │ │ ├── salary.cpp │ │ ├── salary_with_bonus.cpp │ │ ├── santas_translator.cpp │ │ ├── scientific_notation.cpp │ │ ├── score_validation.cpp │ │ ├── searching_for_nessy.cpp │ │ ├── searching_subsequences.cpp │ │ ├── selection_test_1.cpp │ │ ├── sequence_ij_1.cpp │ │ ├── sequence_ij_2.cpp │ │ ├── sequence_ij_3.cpp │ │ ├── sequence_ij_4.cpp │ │ ├── sequence_of_numbers_and_sum.cpp │ │ ├── sequence_of_sequence.cpp │ │ ├── seven.cpp │ │ ├── several_scores_with_validation.cpp │ │ ├── short_attendance.cpp │ │ ├── short_story.cpp │ │ ├── simple_calculate.cpp │ │ ├── simple_factorial.cpp │ │ ├── simple_prod.cpp │ │ ├── simple_sort.cpp │ │ ├── simple_sum.cpp │ │ ├── simulator.cpp │ │ ├── six_odd_numbers.cpp │ │ ├── snack.cpp │ │ ├── sort_by_length.cpp │ │ ├── sort_sort_and_sort.cpp │ │ ├── sphere.cpp │ │ ├── spurs_rock.cpp │ │ ├── square_array_4.cpp │ │ ├── square_game.cpp │ │ ├── square_matrix_1.cpp │ │ ├── square_matrix_2.cpp │ │ ├── square_matrix_3.cpp │ │ ├── square_root_of_10.cpp │ │ ├── square_root_of_2.cpp │ │ ├── square_spiral.cpp │ │ ├── squared_and_cubic.cpp │ │ ├── ssn_1.cpp │ │ ├── star_trek.cpp │ │ ├── start_grid.cpp │ │ ├── stick_collector_robot.cpp │ │ ├── sticks_game.cpp │ │ ├── strategy_game.cpp │ │ ├── subprime.cpp │ │ ├── sucessor_par.cpp │ │ ├── sudoku.cpp │ │ ├── sum_of_consecutive_even_numbers.cpp │ │ ├── sum_of_consecutive_odd_numbers_3.cpp │ │ ├── sum_of_consecutive_odd_numbers_I.cpp │ │ ├── sum_of_consecutive_odd_numbers_II.cpp │ │ ├── sum_of_two_squares.cpp │ │ ├── summer_camp.cpp │ │ ├── summing_consecutive_integers.cpp │ │ ├── sunday_morning.cpp │ │ ├── superior_area.cpp │ │ ├── system_of_download.cpp │ │ ├── taxes_of_project.cpp │ │ ├── tda_rational_1.cpp │ │ ├── tda_rational_2.cpp │ │ ├── tell_me_the_frequencies.cpp │ │ ├── the_chosen.cpp │ │ ├── the_force_awakens.cpp │ │ ├── the_greater_one_digit_number.cpp │ │ ├── the_greatest.cpp │ │ ├── the_library_of_mr_severino.cpp │ │ ├── the_motion_picture.cpp │ │ ├── the_pythagorean_theorem.cpp │ │ ├── the_race_of_slugs.cpp │ │ ├── the_return_of_radar.cpp │ │ ├── the_return_of_the_king.cpp │ │ ├── the_square_game.cpp │ │ ├── the_wrath_of_khan.cpp │ │ ├── theons_answer.cpp │ │ ├── threebonacci_sequence.cpp │ │ ├── throwing_cards_away.cpp │ │ ├── time_conversion.cpp │ │ ├── time_zone.cpp │ │ ├── to_care_or_not_to_care.cpp │ │ ├── to_care_or_not_to_care2.cpp │ │ ├── top_n.cpp │ │ ├── tornado.cpp │ │ ├── train_swaping.cpp │ │ ├── tri-du.cpp │ │ ├── triangle.cpp │ │ ├── triangle_types.cpp │ │ ├── triangles.cpp │ │ ├── tribol.cpp │ │ ├── trinomial_triangle.cpp │ │ ├── tshirt2.cpp │ │ ├── tshirts.cpp │ │ ├── tug_of_war.cpp │ │ ├── turma_jb6.cpp │ │ ├── turn_left.cpp │ │ ├── turn_left2.cpp │ │ ├── tustin_and_his_new_die.cpp │ │ ├── twilight_at_portland.cpp │ │ ├── twitting.cpp │ │ ├── two_bills.cpp │ │ ├── type_of_fuel.cpp │ │ ├── upset_fracil.cpp │ │ ├── uri.cpp │ │ ├── vai_na_sort.cpp │ │ ├── variations.cpp │ │ ├── virus.cpp │ │ ├── vitoria_and_her_indecision.cpp │ │ ├── volleyball.cpp │ │ ├── weighted_averages.cpp │ │ ├── welcome_to_the_winter.cpp │ │ ├── wertyu.cpp │ │ ├── where_is_the_marble.cpp │ │ ├── which_triangle.cpp │ │ ├── who_turn_is_it.cpp │ │ ├── wills_message.cpp │ │ ├── world_cup.cpp │ │ ├── zero_means_zero.cpp │ │ └── zero_or_one.cpp │ ├── uva/ │ │ └── 280-vertex.cpp │ └── weekend-code-challenge/ │ ├── 01-object-to-array-of-objects/ │ │ ├── README.md │ │ └── soluition1.js │ ├── 02-my-likes/ │ │ ├── README.md │ │ ├── solution1.js │ │ └── solution2.js │ ├── 03-ch-ch-ch-changes/ │ │ ├── README.md │ │ └── solution.js │ ├── 07-zero-to-hero/ │ │ ├── README.md │ │ └── solution1.js │ ├── 08-first-non-repeat/ │ │ ├── README.md │ │ └── solution1.js │ ├── 09-big-three/ │ │ ├── README.md │ │ ├── solution1.js │ │ └── solution2.js │ ├── 10-get-the-photo/ │ │ ├── README.md │ │ └── solution1.js │ └── 11-threes-a-crowd/ │ ├── README.md │ └── solution1.js ├── computer_science/ │ ├── README.md │ ├── algorithms/ │ │ ├── binary-search/ │ │ │ ├── binary-search.js │ │ │ └── tests/ │ │ │ └── binary-search.test.js │ │ ├── bubble-sort/ │ │ │ ├── bubble-sort.js │ │ │ └── tests/ │ │ │ └── bubble-sort.test.js │ │ ├── dynamic_programming/ │ │ │ ├── factorial.cpp │ │ │ └── fibonacci.cpp │ │ ├── find_kth_element/ │ │ │ └── find_kth_element_1.cpp │ │ ├── graphs/ │ │ │ ├── bfs.cpp │ │ │ └── dfs.cpp │ │ ├── is-prime/ │ │ │ └── is-prime.js │ │ ├── kadane/ │ │ │ └── kadane.js │ │ ├── knapsack/ │ │ │ ├── knapsack1.cpp │ │ │ └── knapsack2.cpp │ │ ├── least_common_multiple/ │ │ │ └── least_common_multiple.cpp │ │ ├── linear-search/ │ │ │ ├── linear-search.js │ │ │ └── tests/ │ │ │ └── linear-search.test.js │ │ ├── maximum_subsequence_sum/ │ │ │ ├── maximum_subsequence_sum_1.cpp │ │ │ └── maximum_subsequence_sum_2.cpp │ │ ├── min_and_max/ │ │ │ └── minimax.cpp │ │ ├── parse_strings/ │ │ │ └── parse_strings.cpp │ │ ├── pointers/ │ │ │ └── pointer.cpp │ │ ├── prime_number/ │ │ │ └── prime_number.cpp │ │ ├── recursion/ │ │ │ ├── fibonacci/ │ │ │ │ ├── fibonacci.c │ │ │ │ └── fibonacci.py │ │ │ ├── log_2.c │ │ │ ├── palindromo.c │ │ │ ├── regua.c │ │ │ ├── reverse.c │ │ │ └── sum.py │ │ ├── reverse-string/ │ │ │ ├── reverse-string-in-place.js │ │ │ ├── reverse-string.js │ │ │ └── tests/ │ │ │ └── reverse-string.test.js │ │ ├── search/ │ │ │ ├── binary_search.cpp │ │ │ ├── binary_search.py │ │ │ ├── recursive_binary_search.py │ │ │ └── sequential_search.py │ │ ├── segment-tree/ │ │ │ └── sum/ │ │ │ └── lazy_update.cpp │ │ ├── sorting/ │ │ │ ├── bubble_sort/ │ │ │ │ ├── bubble_sort.cpp │ │ │ │ ├── bubble_sort.py │ │ │ │ └── test_bubble_sort.py │ │ │ ├── insertion_sort.cpp │ │ │ ├── merge_sort.cpp │ │ │ ├── reverse_insertion_sort.cpp │ │ │ ├── selection_sort.cpp │ │ │ └── string_insertion_sort.cpp │ │ ├── string_to_int/ │ │ │ └── string_to_int.cpp │ │ └── subset/ │ │ └── subset.js │ ├── big_o/ │ │ ├── README.md │ │ ├── example1.py │ │ ├── example10.py │ │ ├── example11.py │ │ ├── example12.py │ │ ├── example13.py │ │ ├── example14.py │ │ ├── example15.py │ │ ├── example16.py │ │ ├── example17.py │ │ ├── example18.py │ │ ├── example19.py │ │ ├── example2.py │ │ ├── example20.py │ │ ├── example21.py │ │ ├── example22.py │ │ ├── example3.py │ │ ├── example4.py │ │ ├── example5.py │ │ ├── example6.py │ │ ├── example7.py │ │ └── example9.py │ └── data_structures/ │ ├── array/ │ │ ├── array.cpp │ │ ├── big_o.py │ │ ├── list.py │ │ └── vectors.cpp │ ├── binary-heap/ │ │ ├── README.md │ │ ├── min-heap.js │ │ └── min-heap.test.js │ ├── binary_search_tree/ │ │ ├── BinarySearchTree/ │ │ │ ├── index.js │ │ │ └── index.test.js │ │ ├── big_o.py │ │ ├── binary_search_tree.py │ │ ├── test_binary_search_tree.py │ │ └── test_node.py │ ├── binary_search_tree_without_node/ │ │ ├── binary_search_tree.py │ │ └── test_binary_search_tree.py │ ├── binary_tree/ │ │ ├── BinaryTree/ │ │ │ ├── index.js │ │ │ └── index.test.js │ │ ├── big_o.py │ │ ├── binary_tree.py │ │ └── test_binary_tree.py │ ├── graph/ │ │ ├── AdjacentListGraph/ │ │ │ ├── AdjacentListGraph.js │ │ │ └── example.js │ │ ├── README.md │ │ ├── adjacency_list.cpp │ │ ├── graph.js │ │ ├── graph.py │ │ └── test_graph.py │ ├── hash_table/ │ │ ├── big_o.py │ │ ├── dictionary.py │ │ └── maps.cpp │ ├── linked_list/ │ │ ├── big-o.js │ │ ├── big_o.py │ │ ├── linked-list.js │ │ ├── linked_list.py │ │ ├── test_linked_list.py │ │ ├── test_node.py │ │ └── tests/ │ │ └── linked-list.test.js │ ├── queue/ │ │ ├── big_o.py │ │ ├── queue.js │ │ ├── queue.py │ │ └── tests/ │ │ └── queue.test.js │ ├── segment_tree/ │ │ ├── frequency.cpp │ │ ├── max.cpp │ │ ├── min.cpp │ │ └── sum.cpp │ ├── set/ │ │ ├── set.js │ │ ├── sets.cpp │ │ └── tests/ │ │ └── set.test.js │ ├── stack/ │ │ ├── deque_api.py │ │ ├── stack.cpp │ │ ├── stack.js │ │ ├── stack.py │ │ ├── stack_class.js │ │ └── stack_closure.js │ └── string/ │ └── strings.cpp ├── package.json ├── problem-solving.md └── system-design.md