├── .gitignore ├── 01Matrix ├── 01_matrix.dart ├── 01_matrix.go └── 01_matrix.md ├── 3SumClosest ├── 3_sum_closest.dart ├── 3_sum_closest.go └── 3_sum_closest.md ├── AddBinary ├── add_binary.dart ├── add_binary.go └── add_binary.md ├── AddDigits ├── add_digits.dart ├── add_digits.go └── add_digits.md ├── AddOneRowToTree ├── add_one_row_to_tree.dart ├── add_one_row_to_tree.go └── add_one_row_to_tree.md ├── AddStrings ├── add_strings.dart ├── add_strings.go └── add_strings.md ├── AddToArrayFormOfInteger ├── add_to_array_form_of_integer.dart ├── add_to_array_form_of_integer.go └── add_to_array_form_of_integer.md ├── AllNodesDistanceKInBinaryTree ├── all_nodes_distance_k_in_binary_tree.dart ├── all_nodes_distance_k_in_binary_tree.go └── all_nodes_distance_k_in_binary_tree.md ├── ArithmeticSlicesII-Subsequence ├── arithmetic_slices_II_subsequence.dart ├── arithmetic_slices_II_subsequence.go └── arithmetic_slices_II_subsequence.md ├── ArithmeticSubarrays ├── arithmetic_subarrays.dart ├── arithmetic_subarrays.go └── arithmetic_subarrays.md ├── AsFarFromLandAsPossible ├── as_far_from_land_as_possible.dart ├── as_far_from_land_as_possible.go └── as_far_from_land_as_possible.md ├── AsteroidCollision ├── asteroid_collision.dart ├── asteroid_collision.go └── asteroid_collision.md ├── BagOfTokens ├── bag_of_tokens.dart ├── bag_of_tokens.go └── bag_of_tokens.md ├── BalancedBinaryTree ├── balanced_binary_tree.dart ├── balanced_binary_tree.go └── balanced_binary_tree.md ├── BasicCalculator ├── basic_calculator.dart ├── basic_calculator.go └── basic_calculator.md ├── BestTeamWithNoConflicts ├── best_team_with_no_conflicts.dart ├── best_team_with_no_conflicts.go └── best_team_with_no_conflicts.md ├── BestTimeToBuyAndSellStock ├── best_time_to_buy_and_sell_stock.dart ├── best_time_to_buy_and_sell_stock.go └── best_time_to_buy_and_sell_stock.md ├── BestTimeToBuyAndSellStockWithTransactionFee ├── best_time_to_buy_and_sell_stock_with_transaction_fee.dart ├── best_time_to_buy_and_sell_stock_with_transaction_fee.go └── best_time_to_buy_and_sell_stock_with_transaction_fee.md ├── BestTimeToBuyAndSellStock_IV ├── best_time_to_buy_and_sell_stock_IV.dart └── best_time_to_buy_and_sell_stock_IV.md ├── BinaryTreeInOrderTrasversel ├── binary_tree_inorder_trasversal.dart └── binary_tree_inorder_trasversal.md ├── BinaryTreeMaximumPathSum ├── binary_tree_maximum_path_sum.dart ├── binary_tree_maximum_path_sum.go └── binary_tree_maximum_path_sum.md ├── BinaryTreePaths ├── binary_tree_paths.dart ├── binary_tree_paths.go └── binary_tree_paths.md ├── BinaryTreePostorderTraversal ├── binary_tree_postorder_traversal.dart ├── binary_tree_postorder_traversal.go └── binary_tree_postorder_traversal.md ├── BinaryTreePreorderTraversal ├── binary_tree_preorder_traversal.dart ├── binary_tree_preorder_traversal.go └── binary_tree_preorder_traversal.md ├── BinaryWatch ├── binary_watch.dart ├── binary_watch.go └── binary_watch.md ├── BitwiseAndOfNumbersRange ├── bitwise_and_of_numbers_range.dart ├── bitwise_and_of_numbers_range.go └── bitwise_and_of_numbers_range.md ├── BreakAPalindrome ├── break_a_palindrome.dart ├── break_a_palindrome.go └── break_a_palindrome.md ├── BuddyStrings ├── buddy_strings.dart ├── buddy_strings.go └── buddy_strings.md ├── CanMakeArithmeticProgressionFromSequence ├── can_make_arithmetic_progression_from_sequence.dart ├── can_make_arithmetic_progression_from_sequence.go └── can_make_arithmetic_progression_from_sequence.md ├── CheapestFlightsWithinKStops ├── cheapest_flights_within_k_stops.dart ├── cheapest_flights_within_k_stops.go └── cheapest_flights_within_k_stops.md ├── CheckIfItIsAStraightLine ├── check_if_it_is_a_straight_line.dart ├── check_if_it_is_a_straight_line.go └── check_if_it_is_a_straight_line.md ├── CheckIfTheSentenceIsPangram ├── check_if_the_sentence_is_pangram.dart ├── check_if_the_sentence_is_pangram.go └── check_if_the_sentence_is_pangram.md ├── CheckIfThereIsAValidPartitionForTheArray ├── check_if_there_is_a_valid_partition_for_the_array.dart ├── check_if_there_is_a_valid_partition_for_the_array.go └── check_if_there_is_a_valid_partition_for_the_array.md ├── CheckIfTwoStringArraysAreEquivalent ├── check_if_two_string_arrays_are_equivalent.dart ├── check_if_two_string_arrays_are_equivalent.go └── check_if_two_string_arrays_are_equivalent.md ├── ClimbingStairs ├── climbing_stairs.dart ├── climbing_stairs.md └── climibing_stairs.go ├── CoinChangeII ├── coin_change_ii.dart ├── coin_change_ii.go └── coin_change_ii.md ├── CombinationSumIV ├── combination_sum_iv.dart ├── combination_sum_iv.go └── combination_sum_iv.md ├── ConcatenatedWords ├── concatenated_words.dart ├── concatenated_words.go └── concatenated_words.md ├── ConcatenationofConsecutiveBinaryNumbers ├── concatenation_of_consecutive_binary_numbers.dart ├── concatenation_of_consecutive_binary_numbers.go └── concatenation_of_consecutive_binary_numbers.md ├── ContainsDuplicate-II ├── contains_duplicate_II.dart ├── contains_duplicate_II.go └── contains_duplicate_II.md ├── ContainsDuplicate ├── contains_duplicate.dart ├── contains_duplicate.go └── contains_duplicate.md ├── ContinuousSubarraySum ├── continuous_subarray_sum.dart ├── continuous_subarray_sum.go └── continuous_subarray_sum.md ├── ConvertANumberToHexadecimal ├── convert_a_number_to_hexadecimal.dart ├── convert_a_number_to_hexadecimal.go └── convert_a_number_to_hexadecimal.md ├── ConvertSortedArrayToBinarySearchTree ├── convert_sorted_array_to_binary_search_tree.dart ├── convert_sorted_array_to_binary_search_tree.go └── convert_sorted_array_to_binary_search_tree.md ├── CopyListWithRandomPointer ├── copy_list_with_random_pointer.dart ├── copy_list_with_random_pointer.go └── copy_list_with_random_pointer.md ├── CountAndSay ├── count_and_say.dart ├── count_and_say.go └── count_and_say.md ├── CountCompleteTreeNodes ├── count_complete_tree_nodes.dart ├── count_complete_tree_nodes.go └── count_complete_tree_nodes.md ├── CountNegativeNumbersInASortedMatrix ├── count_negative_numbers_in_a_sorted_matrix.dart ├── count_negative_numbers_in_a_sorted_matrix.go └── count_negative_numbers_in_a_sorted_matrix.md ├── CountOddNumbersInAnIntervalRange ├── count_odd_numbers_in_an_interval_range.dart ├── count_odd_numbers_in_an_interval_range.go └── count_odd_numbers_in_an_interval_range.md ├── CountingBits ├── counting_bits.dart ├── counting_bits.go └── counting_bits.md ├── CourseSchedule ├── course_schedule.dart ├── course_schedule.go └── course_schedule.md ├── Create-File.ps1 ├── Create-Folder.ps1 ├── DailyTemperatures ├── daily_temperatures.dart ├── daily_temperatures.go └── daily_temperatures.md ├── DataStreamAsDisjointIntervals ├── data_stream_as_disjoint_intervals.dart ├── data_stream_as_disjoint_intervals.go └── data_stream_as_disjoint_intervals.md ├── DecodeWays ├── decode_ways.dart ├── decode_ways.go └── decode_ways.md ├── DeleteColumnsToMakeSorted ├── delete_columns_to_make_sorted.dart ├── delete_columns_to_make_sorted.go └── delete_columns_to_make_sorted.md ├── DeleteNodeInALinkedList ├── delete_node_in_a_linked_list.dart ├── delete_node_in_a_linked_list.go └── delete_node_in_a_linked_list.md ├── DeleteTheMiddleNodeOfALinkedList ├── delete_the_middle_node_of_a_linked_list.dart ├── delete_the_middle_node_of_a_linked_list.go └── delete_the_middle_node_of_a_linked_list.md ├── DesignBrowserHistory ├── design_browser_history.dart ├── design_browser_history.go └── design_browser_history.md ├── DesignCircularQueue ├── design_circular_queue.dart ├── design_circular_queue.go └── design_circular_queue.md ├── DesignHashSet ├── design_hashSet.dart ├── design_hashSet.go └── design_hashSet.md ├── DesignUndergroundSystem ├── design_underground_system.dart ├── design_underground_system.go └── design_underground_system.md ├── DetectCapital ├── detect_capital.dart ├── detect_capital.go └── detect_capital.md ├── DetermineIfStringHalvesAreAlike ├── determine_if_string_halves_are_alike.dart ├── determine_if_string_halves_are_alike.go └── determine_if_string_halves_are_alike.md ├── DetermineIfTwoStringsAreClose ├── determine_if_two_strings_are_close.dart ├── determine_if_two_strings_are_close.go └── determine_if_two_strings_are_close.md ├── DetonateTheMaximumBombs ├── detonate_the_maximum_bombs.dart ├── detonate_the_maximum_bombs.go └── detonate_the_maximum_bombs.md ├── DiagonalTraverseIi ├── diagonal_traverse_ii.dart ├── diagonal_traverse_ii.go └── diagonal_traverse_ii.md ├── EarliestPossibleDayOfFullBloom ├── earliest_possible_day_of_full_bloom.dart ├── earliest_possible_day_of_full_bloom.go └── earliest_possible_day_of_full_bloom.md ├── EqualRowAndColumnPairs ├── equal_row_and_column_pairs.dart ├── equal_row_and_column_pairs.go └── equal_row_and_column_pairs.md ├── ErectTheFence ├── erect_the_fence.dart ├── erect_the_fence.go └── erect_the_fence.md ├── EvaluateReversePolishNotation ├── evaluate_reverse_polish_notation.dart ├── evaluate_reverse_polish_notation.go └── evaluate_reverse_polish_notation.md ├── ExcelSheetColumnNumber ├── excel_sheet_colum_number.dart ├── excel_sheet_colum_number.dart.md └── excel_sheet_colum_number.go ├── ExcelSheetColumnTitle ├── excel_sheet_column_title.dart ├── excel_sheet_column_title.go └── excel_sheet_column_title.md ├── FindClosestNodeToGivenTwoNodes ├── find_closest_node_to_given_two_nodes.dart ├── find_closest_node_to_given_two_nodes.go └── find_closest_node_to_given_two_nodes.md ├── FindCriticalAndPseudoCriticalEdgesInMinimumSpanningTree ├── find_critical_and_pseudocritical_edges_in_minimum_spanning_tree.dart ├── find_critical_and_pseudocritical_edges_in_minimum_spanning_tree.go └── find_critical_and_pseudocritical_edges_in_minimum_spanning_tree.md ├── FindDuplicateFileInSystem ├── find_duplicate_file_in_system.dart ├── find_duplicate_file_in_system.go └── find_duplicate_file_in_system.md ├── FindIfPathExistsInGraph ├── find_if_path_exists_in_graph.dart ├── find_if_path_exists_in_graph.go └── find_if_path_exists_in_graph.md ├── FindKClosestElements ├── find_k_closest_elements.dart ├── find_k_closest_elements.go └── find_k_closest_elements.md ├── FindMedianFromDataStream ├── find_median_from_data_stream.dart ├── find_median_from_data_stream.go └── find_median_from_data_stream.md ├── FindOriginalArrayFromDoubledArray ├── find_original_array_from_doubled_array.dart ├── find_original_array_from_doubled_array.go └── find_original_array_from_doubled_array.md ├── FindPlayersWithZeroOrOneLosses ├── find_players_with_zero_or_one_losses.dart ├── find_players_with_zero_or_one_losses.go └── find_players_with_zero_or_one_losses.md ├── FindSmallestLetterGreaterThanTarget ├── find_smallest_letter_greater_than_target.dart ├── find_smallest_letter_greater_than_target.go └── find_smallest_letter_greater_than_target.md ├── FindTheDifference ├── find_the_difference.dart ├── find_the_difference.go └── find_the_difference.md ├── FindTheHighestAltitude ├── find_the_highest_altitude.dart ├── find_the_highest_altitude.go └── find_the_highest_altitude.md ├── FirstBadVersion ├── first_bad_version.dart ├── first_bad_version.go └── first_bad_version.md ├── FirstUniqueCharacterInAString ├── first_unique_character_in_a_string.dart ├── first_unique_character_in_a_string.go └── first_unique_character_in_a_string.md ├── FizzBuzz ├── fizz_buzz.dart ├── fizz_buzz.go └── fizz_buzz.md ├── FlipStringToMonotoneIncreasing ├── flip_string_to_monotone_increasing.dart ├── flip_string_to_monotone_increasing.go └── flip_string_to_monotone_increasing.md ├── FruitIntoBaskets ├── fruit_into_baskets.dart ├── fruit_into_baskets.go └── fruit_into_baskets.md ├── GreatestCommonDivisorOfStrings ├── greatest_common_divisor_of_strings.dart ├── greatest_common_divisor_of_strings.go └── greatest_common_divisor_of_strings.md ├── GroupAnagrams ├── group_anagrams.dart ├── group_anagrams.go └── group_anagrams.md ├── GroupThePeopleGivenTheGroupSizeTheyBelongTo ├── group_the_people_given_the_group_size_they_belong_to.dart ├── group_the_people_given_the_group_size_they_belong_to.go └── group_the_people_given_the_group_size_they_belong_to.md ├── GuessNumberHigherOrLower ├── guess_number_higher_or_lower.dart ├── guess_number_higher_or_lower.go └── guess_number_higher_or_lower.md ├── HappyNumber ├── happy_number.dart ├── happy_number.go └── happy_number.md ├── HouseRobber ├── house_robber.dart ├── house_robber.go └── house_robber.md ├── ImageOverlap ├── image_overlap.dart ├── image_overlap.go └── image_overlap.md ├── ImplementQueueUsingStacks ├── implement_queue_using_stacks.dart ├── implement_queue_using_stacks.go └── implement_queue_using_stacks.md ├── ImplementStackUsingQueues ├── implement_stack_using_queues.dart ├── implement_stack_using_queues.go └── implement_stack_using_queues.md ├── ImplementstrStr ├── implement_strStr.dart └── implement_strStr.md ├── IncreasingTripletSubsequence ├── increasing_triplet_subsequence.dart ├── increasing_triplet_subsequence.go └── increasing_triplet_subsequence.md ├── InsertDeleteGetRandom-01 ├── insert_delete_getrandom_O1.dart ├── insert_delete_getrandom_O1.go └── insert_delete_getrandom_O1.md ├── InsertInterval ├── insert_interval.dart ├── insert_interval.go └── insert_interval.md ├── IntegerToRoman ├── integer_to_roman.dart ├── integer_to_roman.go └── integer_to_roman.md ├── InterleavingString ├── interleaving_string.dart ├── interleaving_string.go └── interleaving_string.md ├── IntersectionOfTwoArrays ├── intersection_of_two_arrays.dart ├── intersection_of_two_arrays.go └── intersection_of_two_arrays.md ├── IntersectionOfTwoArraysII ├── intersection_of_two_arrays_II.dart ├── intersection_of_two_arrays_II.go └── intersection_of_two_arrays_II.md ├── IntersectionOfTwoLinkedLists ├── intersection_of_two_linked_lists.dart ├── intersection_of_two_linked_lists.go └── intersection_of_two_linked_lists.md ├── InvertBinaryTree ├── invert_binary_tree.dart ├── invert_binary_tree.go └── invert_binary_tree.md ├── IsSubsequence ├── is_subsequence.dart ├── is_subsequence.go └── is_subsequence.md ├── IsomorphicStrings ├── isomorphic_strings.dart ├── isomorphic_strings.go └── isomorphic_strings.md ├── JumpGameII ├── jump_game_ii.dart ├── jump_game_ii.go └── jump_game_ii.md ├── KRadiusSubarrayAverages ├── k_radius_subarray_averages.dart ├── k_radius_subarray_averages.go └── k_radius_subarray_averages.md ├── KeysAndRooms ├── keys_and_rooms.dart ├── keys_and_rooms.go └── keys_and_rooms.md ├── LFUCache ├── lfu_cache.dart ├── lfu_cache.go └── lfu_cache.md ├── LRUCache ├── lru_cache.dart ├── lru_cache.go └── lru_cache.md ├── LargestPerimeterTriangle ├── largest_perimeter_triangle.dart ├── largest_perimeter_triangle.go └── largest_perimeter_triangle.md ├── LastDayWhereYouCanStillCross ├── last_day_where_you_can_still_cross.dart ├── last_day_where_you_can_still_cross.go └── last_day_where_you_can_still_cross.md ├── LeafSimilarTrees ├── leaf_similar_trees.dart ├── leaf_similar_trees.go └── leaf_similar_trees.md ├── LengthOfLastWord ├── length_of_last_word.dart └── length_of_last_word.md ├── LexicographicallySmallestEquivalentString ├── lexicographically_smallest_equivalent_string.dart ├── lexicographically_smallest_equivalent_string.go └── lexicographically_smallest_equivalent_string.md ├── LinkedListCycle ├── linked_list_cycle..go ├── linked_list_cycle.dart └── linked_list_cycle.md ├── LongestArithmeticSubsequence ├── longest_arithmetic_subsequence.dart ├── longest_arithmetic_subsequence.go └── longest_arithmetic_subsequence.md ├── LongestCommonPrefix ├── longest_common_prefix.dart └── longest_common_prefix.md ├── LongestCommonSubsequence ├── longest_common_subsequence.dart ├── longest_common_subsequence.go └── longest_common_subsequence.md ├── LongestPalindrome ├── longest_palindrome.dart ├── longest_palindrome.go └── longest_palindrome.md ├── LongestPalindromeByConcatenatingTwoLetterWords ├── longest_palindrome_by_concatenating_two_letter_words.dart ├── longest_palindrome_by_concatenating_two_letter_words.go └── longest_palindrome_by_concatenating_two_letter_words.md ├── LongestPathWithDifferentAdjacentCharacters ├── longest_path_with_Different_adjacent_characters.dart ├── longest_path_with_Different_adjacent_characters.go └── longest_path_with_Different_adjacent_characters.md ├── LongestSubarrayOf1SAfterDeletingOneElement ├── longest_subarray_of_1s_after_deleting_one_element.dart ├── longest_subarray_of_1s_after_deleting_one_element.go └── longest_subarray_of_1s_after_deleting_one_element.md ├── MajorityElement ├── majority_element.dart ├── majority_element.go └── majority_element.md ├── MakeArrayStrictlyIncreasing ├── make_array_strictly_increasing.dart ├── make_array_strictly_increasing.go └── make_array_strictly_increasing.md ├── MaxPointsOnALine ├── max_points_on_a_line.dart ├── max_points_on_a_line.go └── max_points_on_a_line.md ├── MaximalNetworkRank ├── maximal_network_rank.dart ├── maximal_network_rank.go └── maximal_network_rank.md ├── MaximizeTheConfusionOfAnExam ├── maximize_the_confusion_of_an_exam.dart ├── maximize_the_confusion_of_an_exam.go └── maximize_the_confusion_of_an_exam.md ├── MaximumDepthOfBinaryTree ├── maximum_depth_of_binary_tree.dart └── maximum_depth_of_binary_tree.md ├── MaximumDifferenceBetweenNodeAndAncestor ├── maximum_difference_between_node_and_ancestor.dart ├── maximum_difference_between_node_and_ancestor.go └── maximum_difference_between_node_and_ancestor.md ├── MaximumIceCreamBars ├── maximum_ice_cream_bars.dart ├── maximum_ice_cream_bars.go └── maximum_ice_cream_bars.md ├── MaximumLengthOfAConcatenatedStringWithUniqueCharacters ├── maximum_length_of_a_concatenated_string_with_unique_characters.dart ├── maximum_length_of_a_concatenated_string_with_unique_characters.go └── maximum_length_of_a_concatenated_string_with_unique_characters.md ├── MaximumLengthOfPairChain ├── maximum_length_of_pair_chain.dart ├── maximum_length_of_pair_chain.go └── maximum_length_of_pair_chain.md ├── MaximumLengthofRepeatedSubarray ├── maximum_length_of_repeated_subarray.dart ├── maximum_length_of_repeated_subarray.go └── maximum_length_of_repeated_subarray.md ├── MaximumLevelSumOfABinaryTree ├── maximum_level_sum_of_a_binary_tree.dart ├── maximum_level_sum_of_a_binary_tree.go └── maximum_level_sum_of_a_binary_tree.md ├── MaximumNumberOfCoinsYouCanGet ├── maximum_number_of_coins_you_can_get.dart ├── maximum_number_of_coins_you_can_get.go └── maximum_number_of_coins_you_can_get.md ├── MaximumPerformanceofaTeam ├── maximum_performance_of_a_team.dart ├── maximum_performance_of_a_team.go └── maximum_performance_of_a_team.md ├── MaximumProductOfSplittedBinaryTree ├── maximum_product_of_splitted_binary_tree.dart ├── maximum_product_of_splitted_binary_tree.go └── maximum_product_of_splitted_binary_tree.md ├── MaximumProfitInJobScheduling ├── maximum_profit_in_job_scheduling.dart ├── maximum_profit_in_job_scheduling.go └── maximum_profit_in_job_scheduling.md ├── MaximumScorefromPerformingMultiplicationOperations ├── Maximum score_from_performing_multiplication_operations.dart ├── Maximum score_from_performing_multiplication_operations.go └── Maximum score_from_performing_multiplication_operations.md ├── MaximumSumCircularSubarray ├── maximum_sum_circular_subarray.dart ├── maximum_sum_circular_subarray.go └── maximum_sum_circular_subarray.md ├── MaximumValueAtAGivenIndexInABoundedArray ├── maximum_value_at_a_given_index_in_a_bounded_array.dart ├── maximum_value_at_a_given_index_in_a_bounded_array.go └── maximum_value_at_a_given_index_in_a_bounded_array.md ├── MeetingRooms ├── meeting_rooms.dart ├── meeting_rooms.go └── meeting_rooms.md ├── MergeSortedArray ├── merge_sorted_array.dart └── merge_sorted_array.md ├── MergeTwoSortedLists ├── merge_two_sorted_lists.dart └── merge_two_sorted_lists.md ├── MiddleOfTheLinkedList ├── middle_of_the_linked_list.dart ├── middle_of_the_linked_list.go └── middle_of_the_linked_list.md ├── MinCostToConnectAllPoints ├── min_cost_to_connect_all_points.dart ├── min_cost_to_connect_all_points.go └── min_cost_to_connect_all_points.md ├── MinimizeTheMaximumDifferenceOfPairs ├── minimize_the_maximum_difference_of_pairs.dart ├── minimize_the_maximum_difference_of_pairs.go └── minimize_the_maximum_difference_of_pairs.md ├── MinimumAverageDifference ├── minimum_average_difference.dart ├── minimum_average_difference.go └── minimum_average_difference.md ├── MinimumCostToCutAStick ├── minimum_cost_to_cut_a_stick.dart ├── minimum_cost_to_cut_a_stick.go └── minimum_cost_to_cut_a_stick.md ├── MinimumDeletionsToMakeCharacterFrequenciesUnique ├── minimum_deletions_to_make_character_frequencies_unique.dart ├── minimum_deletions_to_make_character_frequencies_unique.go └── minimum_deletions_to_make_character_frequencies_unique.md ├── MinimumDepthofBinaryTree ├── minimum_depth_of_binary_tree.dart ├── minimum_depth_of_binary_tree.go └── minimum_depth_of_binary_tree.md ├── MinimumDifficultyOfAJobSchedule ├── minimum_difficulty_of_a_job_schedule.dart ├── minimum_difficulty_of_a_job_schedule.go └── minimum_difficulty_of_a_job_schedule.md ├── MinimumFallingPathSum ├── minimum_falling_path_sum.dart ├── minimum_falling_path_sum.go └── minimum_falling_path_sum.md ├── MinimumFuelCostToReportToTheCapital ├── minimum_fuel_cost_to_report_to_the_capital.dart ├── minimum_fuel_cost_to_report_to_the_capital.go └── minimum_fuel_cost_to_report_to_the_capital.md ├── MinimumGeneticMutation ├── minimum_genetic_mutation.dart ├── minimum_genetic_mutation.go └── minimum_genetic_mutation.md ├── MinimumNumberOfArrowsToBurstBalloons ├── minimum_number_of_arrows_to_burst_balloons.dart ├── minimum_number_of_arrows_to_burst_balloons.go └── minimum_number_of_arrows_to_burst_balloons.md ├── MinimumPenaltyForAShop ├── minimum_penalty_for_a_shop.dart ├── minimum_penalty_for_a_shop.go └── minimum_penalty_for_a_shop.md ├── MinimumReplacementsToSortTheArray ├── minimum_replacements_to_sort_the_array.dart ├── minimum_replacements_to_sort_the_array.go └── minimum_replacements_to_sort_the_array.md ├── MinimumRoundsToCompleteAllTasks ├── minimum_rounds_to_complete_all_tasks.dart ├── minimum_rounds_to_complete_all_tasks.go └── minimum_rounds_to_complete_all_tasks.md ├── MinimumSpeedToArriveOnTime ├── minimum_speed_to_arrive_on_time.dart ├── minimum_speed_to_arrive_on_time.go └── minimum_speed_to_arrive_on_time.md ├── MinimumTimeToCollectAllApplesInATree ├── minimum_time_to_collect_all_apples_in_a_tree.dart ├── minimum_time_to_collect_all_apples_in_a_tree.go └── minimum_time_to_collect_all_apples_in_a_tree.md ├── MinimumTimeToMakeRopeColorful ├── minimum_time_to_make_rope_colorful.dart ├── minimum_time_to_make_rope_colorful.go └── minimum_time_to_make_rope_colorful.md ├── MinimumWindowSubstring ├── minimum_window_substring.dart ├── minimum_window_substring.go └── minimum_window_substring.md ├── MissingNumber ├── missing_number.dart ├── missing_number.go └── missing_number.md ├── MissingRanges ├── missing_ranges.dart ├── missing_ranges.go └── missing_ranges.md ├── MostStonesRemovedWithSameRowOrColumn ├── most_stones_removed_with_same_row_or_column.dart ├── most_stones_removed_with_same_row_or_column.go └── most_stones_removed_with_same_row_or_column.md ├── MoveZeroes ├── move_zeroes.dart ├── move_zeroes.go └── move_zeroes.md ├── MyCalendar-III ├── my_calendar_III.dart ├── my_calendar_III.go └── my_calendar_III.md ├── N-thTribonacciNumber ├── n_th_tribonacci_number.dart ├── n_th_tribonacci_number.go └── n_th_tribonacci_number.md ├── NamingACompany ├── naming_a_company.dart ├── naming_a_company.go └── naming_a_company.md ├── NearestExitFromEntranceInMaze ├── nearest_exit_from_entrance_in_maze.dart ├── nearest_exit_from_entrance_in_maze.go └── nearest_exit_from_entrance_in_maze.md ├── New21Game ├── new_21_game.dart ├── new_21_game.go └── new_21_game.md ├── NimGame ├── nim_game.dart ├── nim_game.go └── nim_game.md ├── Non-DecreasingSubsequences ├── non_decreasing_subsequences.dart ├── non_decreasing_subsequences.go └── non_decreasing_subsequences.md ├── NumberOf-1-Bits ├── number_of_1_bits.dart ├── number_of_1_bits.go └── number_of_1_bits.md ├── NumberOfDiceRollsWithTargetSum ├── number_of_dice_rolls_with_target_sum.dart ├── number_of_dice_rolls_with_target_sum.go └── number_of_dice_rolls_with_target_sum.md ├── NumberOfGoodPaths ├── number_of_good_paths.dart ├── number_of_good_paths.go └── number_of_good_paths.md ├── NumberOfLongestIncreasingSubsequence ├── number_of_longest_increasing_subsequence.dart ├── number_of_longest_increasing_subsequence.go └── number_of_longest_increasing_subsequence.md ├── NumberOfNodesInTheSub-TreeWithTheSameLabel ├── number_of_nodes_in_the_sub_tree_with_the_same_label.dart ├── number_of_nodes_in_the_sub_tree_with_the_same_label.go └── number_of_nodes_in_the_sub_tree_with_the_same_label.md ├── NumberOfWaysToReorderArrayToGetSameBst ├── number_of_ways_to_reorder_array_to_get_same_bst.dart ├── number_of_ways_to_reorder_array_to_get_same_bst.go └── number_of_ways_to_reorder_array_to_get_same_bst.md ├── OddEvenLinkedList ├── odd_even_linked_list.dart ├── odd_even_linked_list.go └── odd_even_linked_list.md ├── PalindromeLinkedList ├── palindrome_linked_list.dart ├── palindrome_linked_list.go └── palindrome_linked_list.md ├── PalindromeNumber ├── palindrome_number.dart └── palindrome_number.md ├── PalindromePairs ├── demo.dart ├── palindrome_pairs.dart ├── palindrome_pairs.go └── palindrome_pairs.md ├── PalindromePartitioning ├── palindrome_partitioning.dart ├── palindrome_partitioning.go └── palindrome_partitioning.md ├── PartitionList ├── partition_list.dart ├── partition_list.go └── partition_list.md ├── Pascal'sTriangle-II ├── pascals_riangle_II.dart ├── pascals_riangle_II.go └── pascals_riangle_II.md ├── Pascal'sTriangle ├── pascals_triangle.dart ├── pascals_triangle.go └── pascals_triangle.md ├── PathSum ├── path_sum.dart ├── path_sum.go └── path_sum.md ├── PathSumII ├── path_sum_II.dart ├── path_sum_II.go └── path_sum_II.md ├── PathWithMinimumEffort ├── path_with_minimum_effort.dart ├── path_with_minimum_effort.go └── path_with_minimum_effort.md ├── PeakIndexInAMountainArray ├── peak_index_in_a_mountain_array.dart ├── peak_index_in_a_mountain_array.go └── peak_index_in_a_mountain_array.md ├── PerfectSquares ├── perfect_squares.dart ├── perfect_squares.go └── perfect_squares.md ├── PlusOne ├── plus_one.dart └── plus_one.md ├── PossibleBipartition ├── possible_bipartition.dart ├── possible_bipartition.go └── possible_bipartition.md ├── PowOfXN ├── pow_of_x_n.dart ├── pow_of_x_n.go └── pow_of_x_n.md ├── PowerOfFour ├── power_of_four.dart ├── power_of_four.go └── power_of_four.md ├── PowerOfThree ├── power_of_three.dart ├── power_of_three.go └── power_of_three.md ├── PowerOfTwo ├── power_of_two.dart ├── power_of_two.go └── power_of_two.md ├── PredictTheWinner ├── predict_the_winner.dart ├── predict_the_winner.go └── predict_the_winner.md ├── Pseudo-PalindromicPathsInABinaryTree ├── pseudo_palindromic_paths_in_a_binary_tree.dart ├── pseudo_palindromic_paths_in_a_binary_tree.go └── pseudo_palindromic_paths_in_a_binary_tree.md ├── PushDominoes ├── push_dominoes.dart ├── push_dominoes.go └── push_dominoes.md ├── PutMarblesInBags ├── put_marbles_in_bags.dart ├── put_marbles_in_bags.go └── put_marbles_in_bags.md ├── README.md ├── RangeSumOfBST ├── range_sum_of_bst.dart ├── range_sum_of_bst.go └── range_sum_of_bst.md ├── RangeSumQuery-Immutable ├── range_sum_query_immutable.dart ├── range_sum_query_immutable.go └── range_sum_query_immutable.md ├── RansomNote ├── ransom_note.dart ├── ransom_note.go └── ransom_note.md ├── ReadNCharactersGivenRead4 ├── read_n_characters_given_read4.dart ├── read_n_characters_given_read4.go └── read_n_characters_given_read4.md ├── RectangleArea ├── rectangle_area.dart ├── rectangle_area.go └── rectangle_area.md ├── RemoveDuplicatesfromSortedArray ├── remove_duplicates_from_sorted_array.dart └── remove_duplicates_from_sorted_array.md ├── RemoveDuplicatesfromSortedList ├── remove_duplicates_from_sorted_list.dart └── remove_duplicates_from_sorted_list.md ├── RemoveElement ├── remove_element.dart └── remove_element.md ├── RemoveLinkedListElements ├── remove_linked_list_elements..md ├── remove_linked_list_elements.dart └── remove_linked_list_elements.go ├── RemoveNthNodeFromEndOfList ├── remove_nth_node_from_end_of_list.dart ├── remove_nth_node_from_end_of_list.go └── remove_nth_node_from_end_of_list.md ├── RestoreIPAddresses ├── restore_ip_addresses.dart ├── restore_ip_addresses.go └── restore_ip_addresses.md ├── ReverseBits ├── reverse_bits.dart ├── reverse_bits.go └── reverse_bits.md ├── ReverseInteger ├── reverse_integer.go ├── reverse_integer.md └── reverse_integer.py ├── ReverseLinkedList ├── reverse_linked_list.dart ├── reverse_linked_list.go └── reverse_linked_list.md ├── ReverseString ├── reverse_string.dart ├── reverse_string.go └── reverse_string.md ├── ReverseVowelsOfAString ├── reverse_vowels_of_a_string.dart ├── reverse_vowels_of_a_string.go └── reverse_vowels_of_a_string.md ├── ReverseWordsInAString ├── reverse_words_in_a_string.dart ├── reverse_words_in_a_string.go └── reverse_words_in_a_string.md ├── ReverseWordsInAString_III ├── reverse_words_in_a_string_III.dart ├── reverse_words_in_a_string_III.go └── reverse_words_in_a_string_III.md ├── RomanToInteger ├── roman_to_integer.dart └── roman_to_integer.md ├── SameTree ├── same_tree.dart ├── same_tree.go └── same_tree.md ├── SatisfiabilityOfEqualityEquations ├── satisfiability_of_equality_equations.dart ├── satisfiability_of_equality_equations.go └── satisfiability_of_equality_equations.md ├── SearchA2DMatrix ├── search_a_2d_matrix.dart ├── search_a_2d_matrix.go └── search_a_2d_matrix.md ├── SearchInRotatedSortedArrayIi ├── search_in_rotated_sorted_array_ii.dart ├── search_in_rotated_sorted_array_ii.go └── search_in_rotated_sorted_array_ii.md ├── SearchInsertPosition ├── search_insert_position.dart └── search_insert_position.md ├── SetMismatch ├── set_mismatch.dart ├── set_mismatch.go └── set_mismatch.md ├── ShortestPathInAGridWithObstaclesElimination ├── shortest_path_in_a_grid_with_obstacles_elimination.dart ├── shortest_path_in_a_grid_with_obstacles_elimination.go └── shortest_path_in_a_grid_with_obstacles_elimination.md ├── ShortestPathToGetAllKeys ├── shortest_path_to_get_all_keys.dart ├── shortest_path_to_get_all_keys.go └── shortest_path_to_get_all_keys.md ├── ShortestPathWithAlternatingColors ├── shortest_path_with_alternating_colors.dart ├── shortest_path_with_alternating_colors.go └── shortest_path_with_alternating_colors.md ├── ShortestWordDistance ├── shortest_word_distance.dart ├── shortest_word_distance.go └── shortest_word_distance.md ├── ShuffleTheArray ├── shuffle_the_array.dart ├── shuffle_the_array.go └── shuffle_the_array.md ├── SingleNumber ├── single_number.dart ├── single_number.go └── single_number.md ├── SingleNumberII ├── single_number_ii.dart ├── single_number_ii.go └── single_number_ii.md ├── SlidingWindowMaximum ├── sliding_window_maximum.dart ├── sliding_window_maximum.go └── sliding_window_maximum.md ├── SnakesAndLadders ├── snakes_and_ladders.dart ├── snakes_and_ladders.go └── snakes_and_ladders.md ├── SortCharactersByFrequency ├── sort_characters_by_frequency.dart ├── sort_characters_by_frequency.go └── sort_characters_by_frequency.md ├── SortItemsByGroupsRespectingDependencies ├── sort_items_by_groups_respecting_dependencies.dart ├── sort_items_by_groups_respecting_dependencies.go └── sort_items_by_groups_respecting_dependencies.md ├── SoupServings ├── soup_servings.dart ├── soup_servings.go └── soup_servings.md ├── SplitLinkedListInParts ├── split_linked_list_in_parts.dart ├── split_linked_list_in_parts.go └── split_linked_list_in_parts.md ├── SqrtX ├── sqrt_x.dart └── sqrt_x.md ├── StringCompression-II ├── string_compression_II.dart ├── string_compression_II.go └── string_compression_II.md ├── StringToInteger ├── string_to_integer.go ├── string_to_integer.md └── string_to_integer.py ├── StrobogrammaticNumber ├── strobogrammatic_number.dart ├── strobogrammatic_number.go └── strobogrammatic_number.md ├── SubarraySumsDivisibleByK ├── subarray_sums_divisible_by_k.dart ├── subarray_sums_divisible_by_k.go └── subarray_sums_divisible_by_k.md ├── SumOfAbsoluteDifferencesInASortedArray ├── sum_of_absolute_differences_in_a_sorted_array.dart ├── sum_of_absolute_differences_in_a_sorted_array.go └── sum_of_absolute_differences_in_a_sorted_array.md ├── SumOfLeftLeaves ├── sum_of_left_leaves.dart ├── sum_of_left_leaves.go └── sum_of_left_leaves.md ├── SumOfSubarrayMinimums ├── sum_of_subarray_minimums.dart ├── sum_of_subarray_minimums.go └── sum_of_subarray_minimums.md ├── SummaryRanges ├── summary_ranges.dart ├── summary_ranges.go └── summary_ranges.md ├── SumofEvenNumbersAfterQueries ├── sum_of_even_numbers_after_queries.dart ├── sum_of_even_numbers_after_queries.go └── sum_of_even_numbers_after_queries.md ├── SymmetricTree ├── symmetric_tree.dart ├── symmetric_tree.go └── symmetric_tree.md ├── TallestBillboard ├── tallest_billboard.dart ├── tallest_billboard.go └── tallest_billboard.md ├── TheKWeakestRowsInAMatrix ├── the_k_weakest_rows_in_a_matrix.dart ├── the_k_weakest_rows_in_a_matrix.go └── the_k_weakest_rows_in_a_matrix.md ├── TheNumberOfWeekCharactersInTheGame ├── the_number_of_week_characters_in_the_game.dart └── the_number_of_week_characters_in_the_game.md ├── TheSkylineProblem ├── the_skyline_problem.dart ├── the_skyline_problem.go └── the_skyline_problem.md ├── ThirdMaximumNumber ├── third_maximum_number.dart ├── third_maximum_number.go └── third_maximum_number.md ├── TimeBasedKeyValueStore ├── time_based_key_value_store.dart ├── time_based_key_value_store.go └── time_based_key_value_store.md ├── TimeNeededToInformAllEmployees ├── time_needed_to_inform_all_employees.dart ├── time_needed_to_inform_all_employees.go └── time_needed_to_inform_all_employees.md ├── ToeplitzMatrix ├── toeplitz_matrix.dart ├── toeplitz_matrix.go └── toeplitz_matrix.md ├── TopKFrequentElements ├── top_k_frequent_elements.dart ├── top_k_frequent_elements.go └── top_k_frequent_elements.md ├── TopKFrequentWords ├── top_k_frequent_words.dart ├── top_k_frequent_words.go └── top_k_frequent_words.md ├── TrappingRainWater ├── trapping_rain_water.dart ├── trapping_rain_water.go └── trapping_rain_water.md ├── TwoSum-III-DataStructureDesign ├── two_sum_III_data_structure_design.dart ├── two_sum_III_data_structure_design.go └── two_sum_III_data_structure_design.md ├── TwoSum ├── twosum.dart └── twosum.md ├── TwoSumIV-InputIsABST ├── two_sum_IV_input_is_a_bst.dart ├── two_sum_IV_input_is_a_bst.go └── two_sum_IV_input_is_a_bst.md ├── UTF-8Validation ├── uft_8_validation.dart ├── uft_8_validation.go └── uft_8_validation.md ├── UglyNumber ├── ugly_number.dart ├── ugly_number.go └── ugly_number.md ├── UniqueBinarySearchTreesIi ├── unique_binary_search_trees_ii.dart ├── unique_binary_search_trees_ii.go └── unique_binary_search_trees_ii.md ├── UniqueNumberOfOccurrences ├── unique_number_of_occurrences.dart ├── unique_number_of_occurrences.go └── unique_number_of_occurrences.md ├── UniquePathsIII ├── unique_paths_iii.dart ├── unique_paths_iii.go └── unique_paths_iii.md ├── ValidAnagram ├── valid_anagram.dart ├── valid_anagram.go └── valid_anagram.md ├── ValidPalindrome ├── valid_palindrome.dart ├── valid_palindrome.go └── valid_palindrome.md ├── ValidParentheses ├── valid_parentheses.dart └── valid_parentheses.md ├── ValidPerfectSquare ├── valid_perfect_square.dart ├── valid_perfect_square.go └── valid_perfect_square.md ├── ValidSudoku ├── valid_sudoku.dart ├── valid_sudoku.go └── valid_sudoku.md ├── VerifyingAnAlienDictionary ├── verifying_an_alien_dictionary.dart ├── verifying_an_alien_dictionary.go └── verifying_an_alien_dictionary.md ├── WhereWillTheBallFall ├── where_will_the_ball_fall.dart ├── where_will_the_ball_fall.go └── where_will_the_ball_fall.md ├── WordBreak ├── word_break.dart ├── word_break.go └── word_break.md ├── WordPattern ├── word_pattern.dart ├── word_pattern.go └── word_pattern.md ├── WordSearch ├── word_search.dart ├── word_search.go └── word_search.md └── ZigzagConversion ├── zigzag_conversion.dart ├── zigzag_conversion.go └── zigzag_conversion.md /.gitignore: -------------------------------------------------------------------------------- 1 | go.mod 2 | go.work 3 | text.txt 4 | golangci.yml 5 | -------------------------------------------------------------------------------- /01Matrix/01_matrix.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func updateMatrix(mat [][]int) [][]int { 4 | n := len(mat) 5 | m := len(mat[0]) 6 | 7 | if mat[0][0] != 0 { 8 | mat[0][0] = m + n 9 | } 10 | 11 | // Travel top down 12 | for j := 1; j < m; j++ { 13 | if mat[0][j] != 0 { 14 | mat[0][j] = mat[0][j-1] + 1 15 | } 16 | } 17 | for i := 1; i < n; i++ { 18 | if mat[i][0] != 0 { 19 | mat[i][0] = mat[i-1][0] + 1 20 | } 21 | } 22 | for i := 1; i < n; i++ { 23 | for j := 1; j < m; j++ { 24 | if mat[i][j] != 0 { 25 | mat[i][j] = min(mat[i-1][j], mat[i][j-1]) + 1 26 | } 27 | } 28 | } 29 | 30 | // Travel up 31 | for j := m - 2; j >= 0; j-- { 32 | if mat[n-1][j] != 0 { 33 | mat[n-1][j] = min(mat[n-1][j], mat[n-1][j+1]+1) 34 | } 35 | } 36 | for i := n - 2; i >= 0; i-- { 37 | if mat[i][m-1] != 0 { 38 | mat[i][m-1] = min(mat[i][m-1], mat[i+1][m-1]+1) 39 | } 40 | } 41 | for i := n - 2; i >= 0; i-- { 42 | for j := m - 2; j >= 0; j-- { 43 | if mat[i][j] != 0 { 44 | mat[i][j] = min(mat[i][j], min(mat[i+1][j], mat[i][j+1])+1) 45 | } 46 | } 47 | } 48 | 49 | return mat 50 | } 51 | 52 | func min(a, b int) int { 53 | if a < b { 54 | return a 55 | } 56 | return b 57 | } 58 | -------------------------------------------------------------------------------- /3SumClosest/3_sum_closest.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func abs(x int) int { 6 | if x < 0 { 7 | return -x 8 | } 9 | return x 10 | } 11 | 12 | func threeSumClosest(nums []int, target int) int { 13 | l := len(nums) 14 | sort.Slice(nums, func(i, j int) bool { return nums[i] < nums[j] }) 15 | 16 | // take arbitrary sum as closest 17 | closest := nums[0] + nums[1] + nums[2] 18 | 19 | for i := 0; i < l-2; i++ { 20 | // ideal sum for (2nd+3rd) 21 | c := target - nums[i] 22 | // start looking at ends 23 | l, h := i+1, l-1 24 | for l < h { 25 | v := nums[l] + nums[h] 26 | w := nums[i] + v 27 | // for each three numbers check if their sum is smaller than current closest number 28 | if abs(target-w) < abs(target-closest) { 29 | closest = w 30 | } 31 | if v > c { 32 | // if sum of (2nd+3rd) is larger that ideal, try to decrease it 33 | h-- 34 | } else if v < c { 35 | // if sum of (2nd+3rd) is smaller than ideal, try to increase it 36 | l++ 37 | } else { 38 | // we found exact match, bail out 39 | return target 40 | } 41 | } 42 | } 43 | 44 | return closest 45 | } 46 | -------------------------------------------------------------------------------- /AddDigits/add_digits.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func addDigits(num int) int { 4 | if num == 0 { 5 | return 0 6 | } 7 | if num%9 == 0 { 8 | return 9 9 | } 10 | return num % 9 11 | } 12 | -------------------------------------------------------------------------------- /AddOneRowToTree/add_one_row_to_tree.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for a binary tree node. 4 | type TreeNode struct { 5 | Val int 6 | Left *TreeNode 7 | Right *TreeNode 8 | } 9 | 10 | func addOneRow(root *TreeNode, val int, depth int) *TreeNode { 11 | if depth == 1 { 12 | return &TreeNode{ 13 | Val: val, 14 | Left: root, 15 | Right: nil, 16 | } 17 | } 18 | 19 | var queue []*TreeNode 20 | queue = append(queue, root) 21 | 22 | currentDepth := 1 23 | 24 | for len(queue) > 0 { 25 | currentDepth++ 26 | length := len(queue) 27 | 28 | for i := 0; i < length; i++ { 29 | if currentDepth == depth { 30 | left := queue[i].Left 31 | right := queue[i].Right 32 | 33 | newLeftNode := &TreeNode{ 34 | Val: val, 35 | Left: nil, 36 | Right: nil, 37 | } 38 | 39 | newRightNode := &TreeNode{ 40 | Val: val, 41 | Left: nil, 42 | Right: nil, 43 | } 44 | 45 | queue[i].Left = newLeftNode 46 | queue[i].Right = newRightNode 47 | 48 | newLeftNode.Left = left 49 | newRightNode.Right = right 50 | } 51 | 52 | if queue[i].Left != nil { 53 | queue = append(queue, queue[i].Left) 54 | } 55 | 56 | if queue[i].Right != nil { 57 | queue = append(queue, queue[i].Right) 58 | } 59 | } 60 | 61 | queue = queue[length:] 62 | } 63 | 64 | return root 65 | } 66 | -------------------------------------------------------------------------------- /AddStrings/add_strings.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "strconv" 5 | "strings" 6 | ) 7 | 8 | func addStrings(num1 string, num2 string) string { 9 | var sb strings.Builder 10 | 11 | i, j := len(num1)-1, len(num2)-1 12 | carry := 0 13 | 14 | for i >= 0 || j >= 0 { 15 | sum := carry 16 | 17 | if i >= 0 { 18 | digit, _ := strconv.Atoi(string(num1[i])) 19 | sum += digit 20 | i-- 21 | } 22 | if j >= 0 { 23 | digit, _ := strconv.Atoi(string(num2[j])) 24 | sum += digit 25 | j-- 26 | } 27 | 28 | sb.WriteString(strconv.Itoa(sum % 10)) 29 | carry = sum / 10 30 | } 31 | 32 | if carry != 0 { 33 | sb.WriteString(strconv.Itoa(carry)) 34 | } 35 | 36 | result := sb.String() 37 | reversedResult := reverseString(result) 38 | return reversedResult 39 | } 40 | 41 | func reverseString(s string) string { 42 | runes := []rune(s) 43 | for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 { 44 | runes[i], runes[j] = runes[j], runes[i] 45 | } 46 | return string(runes) 47 | } 48 | -------------------------------------------------------------------------------- /AddToArrayFormOfInteger/add_to_array_form_of_integer.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func addToArrayForm(num []int, k int) []int { 4 | res := []int{} 5 | size := len(num) - 1 6 | for size >= 0 || k > 0 { 7 | if size >= 0 { 8 | k += num[size] 9 | size-- 10 | } 11 | res = append([]int{k % 10}, res...) 12 | k /= 10 13 | } 14 | return res 15 | } 16 | -------------------------------------------------------------------------------- /AsFarFromLandAsPossible/as_far_from_land_as_possible.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func min(a int, b int) int { 4 | if a < b { 5 | return a 6 | } 7 | return b 8 | } 9 | 10 | func max(a int, b int) int { 11 | if a > b { 12 | return a 13 | } 14 | return b 15 | } 16 | 17 | func maxDistance(grid [][]int) int { 18 | var m int = len(grid) 19 | var n int = len(grid[0]) 20 | var x int = n + m 21 | for i := 0; i < m; i++ { 22 | for j := 0; j < n; j++ { 23 | if grid[i][j] == 1 { 24 | continue 25 | } 26 | var top int = x 27 | var left int = x 28 | if i-1 >= 0 { 29 | top = grid[i-1][j] 30 | } 31 | if j-1 >= 0 { 32 | left = grid[i][j-1] 33 | } 34 | grid[i][j] = min(top, left) + 1 35 | } 36 | } 37 | for i := m - 1; i >= 0; i-- { 38 | for j := n - 1; j >= 0; j-- { 39 | if grid[i][j] == 1 { 40 | continue 41 | } 42 | var bottom int = x 43 | var right int = x 44 | if i+1 < m { 45 | bottom = grid[i+1][j] 46 | } 47 | if j+1 < n { 48 | right = grid[i][j+1] 49 | } 50 | grid[i][j] = min(grid[i][j], min(bottom, right)+1) 51 | } 52 | } 53 | var count int = 0 54 | for i := 0; i < m; i++ { 55 | for j := 0; j < n; j++ { 56 | count = max(count, grid[i][j]) 57 | } 58 | 59 | } 60 | if count-1 == n+m+1 || count-1 == 0 { 61 | return -1 62 | } 63 | return count - 1 64 | } 65 | -------------------------------------------------------------------------------- /BagOfTokens/bag_of_tokens.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func bagOfTokensScore(tokens []int, P int) int { 6 | // to hold the value of our score 7 | var score int = 0 8 | // sorting the token and slicing because sort.slice is more stable 9 | sort.Slice(tokens, func(i, j int) bool { return tokens[i] < tokens[j] }) 10 | // loop if the token length is greater than 0 abd power is also greater and equal 11 | // than the first value of the token list 12 | for len(tokens) > 0 && P >= tokens[0] { 13 | // we will decrement the first value of token from the power 14 | P = P - tokens[0] 15 | // increment the score because we point a score 16 | score++ 17 | tokens = tokens[1:] 18 | // if the length of the list of tokens is more than 1 and power is less than first value of the list 19 | if len(tokens) > 1 && P < tokens[0] { 20 | // than we will increment the value of power inside the first index of the token 21 | P = P + tokens[len(tokens)-1] 22 | // we will decrement the score 23 | score-- 24 | tokens = tokens[:len(tokens)-1] 25 | } 26 | } 27 | // than we will total score we have achieved 28 | return score 29 | } 30 | -------------------------------------------------------------------------------- /BalancedBinaryTree/balanced_binary_tree.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /BalancedBinaryTree/balanced_binary_tree.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/BalancedBinaryTree/balanced_binary_tree.md -------------------------------------------------------------------------------- /BasicCalculator/basic_calculator.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strings" 4 | 5 | func calculate(s string) int { 6 | // for easier code, remove all blank and append a ")" 7 | s = strings.ReplaceAll(s, " ", "") + ")" 8 | result, _ := calcUntilBrackets(s, 0) 9 | return result 10 | } 11 | 12 | // return calc result and endIndex 13 | func calcUntilBrackets(s string, startIndex int) (int, int) { 14 | calcResult := 0 15 | current := 0 16 | sign := 1 17 | for i := startIndex; i < len(s); i++ { 18 | v := s[i] 19 | if v >= '0' && v <= '9' { 20 | current = current*10 + int(v-'0') 21 | continue 22 | } 23 | 24 | calcResult += current * sign 25 | current = 0 26 | 27 | if v == '(' { 28 | inner, bracket := calcUntilBrackets(s, i+1) 29 | i = bracket 30 | calcResult += inner * sign 31 | } else if v == ')' { 32 | return calcResult, i 33 | } else if v == '+' { 34 | sign = 1 35 | } else if v == '-' { 36 | sign = -1 37 | } 38 | } 39 | // code reach here is impossible 40 | return calcResult, -1 41 | } 42 | -------------------------------------------------------------------------------- /BestTeamWithNoConflicts/best_team_with_no_conflicts.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func max(a, b int) int { 6 | if a > b { 7 | return a 8 | } 9 | return b 10 | } 11 | 12 | func bestTeamScore(scores []int, ages []int) int { 13 | var n int = len(ages) 14 | player := [][]int{} 15 | for i := 0; i < n; i++ { 16 | player = append(player, []int{ages[i], scores[i]}) 17 | } 18 | sort.Slice(player, func(i, j int) bool { 19 | return player[i][0] < player[j][0] || (player[i][0] == player[j][0] && player[i][1] < player[j][1]) 20 | }) 21 | var ans int = 0 22 | DP := make([]int, n+1) 23 | for i := 0; i < n; i++ { 24 | DP[i+1] = player[i][1] 25 | for j := 0; j < i; j++ { 26 | if player[j][1] > player[i][1] { 27 | continue 28 | } 29 | DP[i+1] = max(DP[i+1], player[i][1]+DP[j+1]) 30 | } 31 | ans = max(ans, DP[i+1]) 32 | } 33 | return ans 34 | } 35 | -------------------------------------------------------------------------------- /BestTimeToBuyAndSellStock/best_time_to_buy_and_sell_stock.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func maxProfit(prices []int) int { 4 | var buy int = 0 5 | var maxProfit int = 0 6 | for i := 0; i < len(prices); i++ { 7 | if prices[i] < buy { 8 | buy = prices[i] 9 | } else if prices[i]-buy > maxProfit { 10 | maxProfit = prices[i] - buy 11 | } 12 | } 13 | 14 | return maxProfit 15 | } 16 | -------------------------------------------------------------------------------- /BestTimeToBuyAndSellStock/best_time_to_buy_and_sell_stock.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/BestTimeToBuyAndSellStock/best_time_to_buy_and_sell_stock.md -------------------------------------------------------------------------------- /BestTimeToBuyAndSellStockWithTransactionFee/best_time_to_buy_and_sell_stock_with_transaction_fee.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func maxProfit(prices []int, fee int) int { 4 | if len(prices) == 0 { 5 | return 0 6 | } 7 | 8 | n := len(prices) 9 | dp := make([][2]int, n) 10 | 11 | // Initialize base cases 12 | dp[0][0] = 0 13 | dp[0][1] = -prices[0] 14 | 15 | for i := 1; i < n; i++ { 16 | // Calculate the maximum profit when not holding a stock 17 | dp[i][0] = dp[i-1][0] 18 | if dp[i-1][1]+prices[i]-fee > dp[i][0] { 19 | dp[i][0] = dp[i-1][1] + prices[i] - fee 20 | } 21 | 22 | // Calculate the maximum profit when holding a stock 23 | dp[i][1] = dp[i-1][1] 24 | if dp[i-1][0]-prices[i] > dp[i][1] { 25 | dp[i][1] = dp[i-1][0] - prices[i] 26 | } 27 | } 28 | 29 | return dp[n-1][0] 30 | } 31 | -------------------------------------------------------------------------------- /BestTimeToBuyAndSellStock_IV/best_time_to_buy_and_sell_stock_IV.md: -------------------------------------------------------------------------------- 1 | # Golang Solution 2 | 3 | ```go 4 | func maxProfit(k int, prices []int) int { 5 | 6 | if len(prices) == 0 { 7 | return 0 8 | } 9 | n := len(prices) 10 | 11 | if k > n / 2{ 12 | return bf(prices) 13 | } 14 | 15 | dp := make([][]int, k+1) 16 | for i := 0; i < k+1; i++ { 17 | dp[i] = make([]int, n+1) 18 | } 19 | 20 | // dp[k][i] = max(dp[k][i-1], prices[i] - prices[j] + dp[k-1][j-1]) 21 | for j := 1; j < k+1; j++ { 22 | min_price := prices[0] 23 | for i := 1; i < n+1; i++ { 24 | min_price = Min(min_price, prices[i-1]-dp[j-1][i-1]) 25 | dp[j][i] = Max(dp[j][i-1], prices[i-1]-min_price) 26 | } 27 | } 28 | 29 | return dp[k][n] 30 | } 31 | 32 | func bf(prices []int) int { 33 | profit := 0 34 | for i:=1; i< len(prices); i++ { 35 | if prices[i]>prices[i-1] { 36 | profit += (prices[i]-prices[i-1]) 37 | } 38 | } 39 | return profit 40 | } 41 | 42 | func Min(x, y int) int { 43 | if x < y { 44 | return x 45 | } 46 | return y 47 | } 48 | 49 | func Max(x, y int) int { 50 | if x > y { 51 | return x 52 | } 53 | return y 54 | } 55 | ``` 56 | -------------------------------------------------------------------------------- /BinaryTreePostorderTraversal/binary_tree_postorder_traversal.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for a binary tree node. 4 | type TreeNode struct { 5 | Val int 6 | Left *TreeNode 7 | Right *TreeNode 8 | } 9 | 10 | func postorderTraversal(root *TreeNode) []int { 11 | 12 | // empty tree 13 | if root == nil { 14 | return []int{} 15 | } 16 | 17 | nodeStack := []*TreeNode{root} // the nodes 18 | nodesSeen := []bool{false} // whether a node already seen 19 | values := make([]int, 0) // values in postorder 20 | 21 | // traverse tree with stack 22 | for len(nodeStack) != 0 { 23 | node := nodeStack[len(nodeStack)-1] 24 | 25 | // leaf -> node seen; or children traversed 26 | if (node.Left == nil && node.Right == nil) || nodesSeen[len(nodesSeen)-1] { 27 | values = append(values, node.Val) 28 | nodeStack = nodeStack[:len(nodeStack)-1] // pop node 29 | nodesSeen = nodesSeen[:len(nodesSeen)-1] 30 | continue 31 | } 32 | 33 | nodesSeen[len(nodesSeen)-1] = true // mark node as seen 34 | 35 | // push children on stack 36 | if node.Right != nil { 37 | nodeStack = append(nodeStack, node.Right) 38 | nodesSeen = append(nodesSeen, false) 39 | } 40 | if node.Left != nil { // traversed first, therefore put on stack second 41 | nodeStack = append(nodeStack, node.Left) 42 | nodesSeen = append(nodesSeen, false) 43 | } 44 | } 45 | 46 | return values 47 | } 48 | -------------------------------------------------------------------------------- /BinaryTreePreorderTraversal/binary_tree_preorder_traversal.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | /* 10 | 11 | Runtime: 0 ms, faster than 100.00% of Go online submissions for Binary Tree PreOrder Traversal. 12 | Memory Usage: 2.1 MB, less than 40.85% of Go online submissions for Binary Tree PreOrder Traversal. 13 | 14 | */ 15 | 16 | func preOrderTraversal(root *TreeNode) []int { 17 | var res []int 18 | helper(root, &res) 19 | return res 20 | } 21 | 22 | func helper(root *TreeNode, res *[]int) { 23 | if root == nil { 24 | return 25 | } 26 | *res = append(*res, root.Val) 27 | helper(root.Left, res) 28 | helper(root.Right, res) 29 | } 30 | -------------------------------------------------------------------------------- /BitwiseAndOfNumbersRange/bitwise_and_of_numbers_range.dart: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 4 | -* 201 Bitwise AND of Numbers Range *- 5 | 6 | 7 | Given two integers left and right that represent the range [left, right], return the bitwise AND of all numbers in this range, inclusive. 8 | 9 | 10 | 11 | Example 1: 12 | 13 | Input: left = 5, right = 7 14 | Output: 4 15 | Example 2: 16 | 17 | Input: left = 0, right = 0 18 | Output: 0 19 | Example 3: 20 | 21 | Input: left = 1, right = 2147483647 22 | Output: 0 23 | 24 | 25 | Constraints: 26 | 27 | 0 <= left <= right <= 231 - 1 28 | 29 | */ 30 | 31 | class Solution { 32 | int rangeBitwiseAnd(int left, int right) { 33 | int shiftCount = 0; 34 | while (left < right) { 35 | left >>= 1; 36 | right >>= 1; 37 | shiftCount += 1; 38 | } 39 | return left << shiftCount; 40 | } 41 | int rangeBitwiseAnd2(int left, int right) { 42 | while (right > left) { 43 | right &= (right - 1); 44 | } 45 | return right; 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /BitwiseAndOfNumbersRange/bitwise_and_of_numbers_range.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func rangeBitwiseAnd(left int, right int) int { 4 | var shift_count int = 0 5 | for left < right { 6 | left >>= 1 7 | right >>= 1 8 | shift_count += 1 9 | } 10 | return left << shift_count 11 | 12 | for left < right { 13 | right &= (right - 1) 14 | 15 | } 16 | return right 17 | } 18 | -------------------------------------------------------------------------------- /BreakAPalindrome/break_a_palindrome.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func breakPalindrome(palindrome string) string { 4 | if len(palindrome) == 1 { 5 | return "" 6 | } 7 | 8 | s := []byte(palindrome) 9 | for i := 0; i < len(s)/2; i++ { 10 | if s[i] != 'a' { 11 | s[i] = 'a' 12 | return string(s) 13 | } 14 | } 15 | 16 | s[len(s)-1] = 'b' 17 | return string(s) 18 | } 19 | -------------------------------------------------------------------------------- /BuddyStrings/buddy_strings.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func buddyStrings(s string, goal string) bool { 4 | n := len(s) 5 | 6 | if s == goal { 7 | temp := make(map[rune]bool) 8 | for _, c := range s { 9 | temp[c] = true 10 | } 11 | return len(temp) < len(goal) // Swapping same characters 12 | } 13 | 14 | i := 0 15 | j := n - 1 16 | 17 | for i < j && s[i] == goal[i] { 18 | i++ 19 | } 20 | 21 | for j >= 0 && s[j] == goal[j] { 22 | j-- 23 | } 24 | 25 | if i < j { 26 | sArr := []rune(s) 27 | temp := sArr[i] 28 | sArr[i] = sArr[j] 29 | sArr[j] = temp 30 | s = string(sArr) 31 | } 32 | 33 | return s == goal 34 | } 35 | -------------------------------------------------------------------------------- /BuddyStrings/buddy_strings.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/BuddyStrings/buddy_strings.md -------------------------------------------------------------------------------- /CanMakeArithmeticProgressionFromSequence/can_make_arithmetic_progression_from_sequence.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // func canMakeArithmeticProgression(arr []int) bool { 4 | // length := len(arr) 5 | // minVal := arr[0] 6 | // maxVal := arr[0] 7 | 8 | // for _, num := range arr { 9 | // if num < minVal { 10 | // minVal = num 11 | // } 12 | // if num > maxVal { 13 | // maxVal = num 14 | // } 15 | // } 16 | 17 | // diff := float64(maxVal-minVal) / float64(length-1) 18 | 19 | // for i := 0; i < length; i++ { 20 | // expected := float64(minVal) + float64(i)*diff 21 | // found := false 22 | // for _, num := range arr { 23 | // if math.Abs(float64(num)-expected) < 1e-9 { 24 | // found = true 25 | // break 26 | // } 27 | // } 28 | // if !found { 29 | // return false 30 | // } 31 | // } 32 | 33 | // return true 34 | // } 35 | 36 | func canMakeArithmeticProgression(arr []int) bool { 37 | seed := 1000001 38 | last := -seed 39 | 40 | for _, x := range arr { 41 | if x < seed { 42 | seed = x 43 | } 44 | if x > last { 45 | last = x 46 | } 47 | } 48 | 49 | diff := last - seed 50 | if diff == 0 { 51 | return true 52 | } 53 | if diff%(len(arr)-1) != 0 { 54 | return false 55 | } 56 | diff /= len(arr) - 1 57 | 58 | res := 0 59 | for i, x := range arr { 60 | index := x - seed 61 | if index%diff != 0 { 62 | return false 63 | } 64 | index /= diff 65 | res ^= i ^ index 66 | } 67 | 68 | return res == 0 69 | } 70 | -------------------------------------------------------------------------------- /CanMakeArithmeticProgressionFromSequence/can_make_arithmetic_progression_from_sequence.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/CanMakeArithmeticProgressionFromSequence/can_make_arithmetic_progression_from_sequence.md -------------------------------------------------------------------------------- /CheckIfTheSentenceIsPangram/check_if_the_sentence_is_pangram.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func checkIfPangram(sentence string) bool { 4 | var indices [26]int 5 | var sumIndices int 6 | for i := 0; i < len(sentence); i++ { 7 | indices[sentence[i]-97] = 1 8 | } 9 | for i := 0; i < len(indices); i++ { 10 | sumIndices += indices[i] 11 | } 12 | return sumIndices == 26 13 | } 14 | -------------------------------------------------------------------------------- /CheckIfThereIsAValidPartitionForTheArray/check_if_there_is_a_valid_partition_for_the_array.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func validPartition(nums []int) bool { 4 | n := len(nums) 5 | vp := make([]bool, n+1) 6 | vp[0] = true 7 | 8 | if nums[1] == nums[0] { 9 | vp[2] = true 10 | } 11 | for i := 2; i < n; i++ { 12 | if nums[i] == nums[i-1] { 13 | vp[i+1] = vp[i+1] || vp[i-1] 14 | } 15 | if nums[i] == nums[i-1] && nums[i] == nums[i-2] { 16 | vp[i+1] = vp[i+1] || vp[i-2] 17 | } 18 | if nums[i] == nums[i-1]+1 && nums[i] == nums[i-2]+2 { 19 | vp[i+1] = vp[i+1] || vp[i-2] 20 | } 21 | } 22 | return vp[n] 23 | } 24 | -------------------------------------------------------------------------------- /CheckIfThereIsAValidPartitionForTheArray/check_if_there_is_a_valid_partition_for_the_array.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/CheckIfThereIsAValidPartitionForTheArray/check_if_there_is_a_valid_partition_for_the_array.md -------------------------------------------------------------------------------- /CheckIfTwoStringArraysAreEquivalent/check_if_two_string_arrays_are_equivalent.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strings" 4 | 5 | func arrayStringsAreEqual(word1 []string, word2 []string) bool { 6 | return strings.Join(word1, "") == strings.Join(word2, "") 7 | } 8 | -------------------------------------------------------------------------------- /ClimbingStairs/climibing_stairs.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // func climbStairs(n int) int { 4 | // if n == 0 || n == 1 || n == 2 || n == 3 { 5 | // return n 6 | // } 7 | // var sum int = 0 8 | // var left int = 1 9 | // var right int = 1 10 | // for i := 2; i < n; i++ { 11 | // sum = left + right 12 | // left = right 13 | // right = sum 14 | // } 15 | // return sum 16 | // } 17 | 18 | func climbStairs(n int) int { 19 | var one int = 1 20 | var two int = 0 21 | for i := 2; i <= n; i++ { 22 | var temp int = one 23 | one += two 24 | two = temp 25 | } 26 | return one 27 | } 28 | -------------------------------------------------------------------------------- /CoinChangeII/coin_change_ii.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func change(amount int, coins []int) int { 4 | dp := make([]int, amount+1) 5 | dp[0] = 1 6 | 7 | for i := 0; i < len(coins); i++ { 8 | for j := coins[i]; j <= amount; j++ { 9 | dp[j] += dp[j-coins[i]] 10 | } 11 | } 12 | 13 | return dp[amount] 14 | } 15 | -------------------------------------------------------------------------------- /CoinChangeII/coin_change_ii.md: -------------------------------------------------------------------------------- 1 | # Coin Change 2 | 3 | ## [GO](https://leetcode.com/problems/coin-change-ii/solutions/3893332/go-dynamic-simple-fast-and-easy-with-explanation/) 4 | 5 | ## [DART](https://leetcode.com/problems/coin-change-ii/solutions/3893321/dynamic-programming-simple-fast-and-easy-with-explanation/) 6 | -------------------------------------------------------------------------------- /CombinationSumIV/combination_sum_iv.dart: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | -* 377. Combination Sum IV *- 4 | 5 | Given an array of distinct integers nums and a target integer target, return the number of possible combinations that add up to target. 6 | 7 | The test cases are generated so that the answer can fit in a 32-bit integer. 8 | 9 | 10 | 11 | Example 1: 12 | 13 | Input: nums = [1,2,3], target = 4 14 | Output: 7 15 | Explanation: 16 | The possible combination ways are: 17 | (1, 1, 1, 1) 18 | (1, 1, 2) 19 | (1, 2, 1) 20 | (1, 3) 21 | (2, 1, 1) 22 | (2, 2) 23 | (3, 1) 24 | Note that different sequences are counted as different combinations. 25 | Example 2: 26 | 27 | Input: nums = [9], target = 3 28 | Output: 0 29 | 30 | 31 | Constraints: 32 | 33 | 1 <= nums.length <= 200 34 | 1 <= nums[i] <= 1000 35 | All the elements of nums are unique. 36 | 1 <= target <= 1000 37 | 38 | 39 | Follow up: What if negative numbers are allowed in the given array? How does it change the problem? What limitation we need to add to the question to allow negative numbers? 40 | 41 | 42 | */ 43 | 44 | class Solution { 45 | int combinationSum4(List nums, int target) { 46 | final List dp = List.filled(nums.length, target + 1); 47 | dp[0] = 1; 48 | 49 | for (int i = 1; i <= target; i++) { 50 | for (int number in nums) { 51 | if (i - number >= 0) { 52 | dp[i] += dp[i - number]; 53 | } 54 | } 55 | } 56 | 57 | return dp[target]; 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /CombinationSumIV/combination_sum_iv.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func helper(nums []int, n int, memo map[int]int) int { 6 | if val, found := memo[n]; found { 7 | return val 8 | } 9 | if n == 0 { 10 | return 1 11 | } 12 | if n < nums[0] { 13 | return 0 14 | } 15 | 16 | count := 0 17 | for _, num := range nums { 18 | if n-num < 0 { 19 | break 20 | } 21 | count += helper(nums, n-num, memo) 22 | } 23 | 24 | memo[n] = count 25 | return count 26 | } 27 | 28 | func combinationSum4(nums []int, target int) int { 29 | sort.Ints(nums) 30 | memo := make(map[int]int) 31 | return helper(nums, target, memo) 32 | } 33 | -------------------------------------------------------------------------------- /ContainsDuplicate-II/contains_duplicate_II.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func containsNearbyDuplicate(nums []int, k int) bool { 4 | seen := map[int]int{} 5 | for idx, val := range nums { 6 | if value, ok := seen[val]; ok && idx-value <= k { 7 | return true 8 | } 9 | seen[val] = idx 10 | } 11 | return false 12 | } 13 | -------------------------------------------------------------------------------- /ContainsDuplicate/contains_duplicate.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func containsDuplicate(nums []int) bool { 4 | if len(nums) == 0 { 5 | return true 6 | } 7 | for i := 0; i < len(nums); i++ { 8 | for j := i + 1; j < len(nums); j++ { 9 | if nums[i] == nums[j] { 10 | return true 11 | } 12 | } 13 | } 14 | return false 15 | } 16 | -------------------------------------------------------------------------------- /ContinuousSubarraySum/continuous_subarray_sum.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func checkSubarraySum(nums []int, k int) bool { 4 | res := 0 5 | var m map[int]int 6 | m = make(map[int]int) 7 | for i := 0; i < len(nums); i++ { 8 | res = (res + nums[i]) % k 9 | if i > 0 && res == 0 { 10 | return true 11 | } 12 | if m[res] != 0 { 13 | if i+1-m[res] > 1 { 14 | return true 15 | } 16 | } else { 17 | m[res] = i + 1 18 | } 19 | } 20 | return false 21 | } 22 | -------------------------------------------------------------------------------- /ConvertSortedArrayToBinarySearchTree/convert_sorted_array_to_binary_search_tree.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /ConvertSortedArrayToBinarySearchTree/convert_sorted_array_to_binary_search_tree.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/ConvertSortedArrayToBinarySearchTree/convert_sorted_array_to_binary_search_tree.md -------------------------------------------------------------------------------- /CopyListWithRandomPointer/copy_list_with_random_pointer.md: -------------------------------------------------------------------------------- 1 | # [DART](https://leetcode.com/problems/copy-list-with-random-pointer/solutions/4003948/o-n-simple-fast-and-easy-with-explanation/) 2 | 3 | ## [GO](https://leetcode.com/problems/copy-list-with-random-pointer/solutions/4003932/go-fastest-o-n-simple-fast-and-easy-with-explanation/) 4 | -------------------------------------------------------------------------------- /CountCompleteTreeNodes/count_complete_tree_nodes.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for a binary tree node. 4 | type TreeNode struct { 5 | Val int 6 | Left *TreeNode 7 | Right *TreeNode 8 | } 9 | 10 | func countNodes(root *TreeNode) int { 11 | if root == nil { 12 | return 0 13 | } 14 | return 1 + countNodes(root.Left) + countNodes(root.Right) 15 | } 16 | -------------------------------------------------------------------------------- /CountNegativeNumbersInASortedMatrix/count_negative_numbers_in_a_sorted_matrix.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func countNegatives1(grid [][]int) int { 6 | var count int = 0 7 | var rows int = len(grid) 8 | var columns int = len(grid[0]) 9 | var row int = rows - 1 10 | var column int = 0 11 | for column < columns && row >= 0 { 12 | if grid[row][column] < 0 { 13 | count += columns - column 14 | row-- 15 | } else { 16 | column++ 17 | } 18 | } 19 | return count 20 | } 21 | 22 | func countNegatives(grid [][]int) int { 23 | var gridRowsLength int = len(grid) 24 | var count int = 0 25 | 26 | for i := 0; i < gridRowsLength; i++ { 27 | sort.Sort(sort.Reverse(sort.IntSlice(grid[i]))) 28 | upperBound := sort.Search(len(grid[i]), func(j int) bool { 29 | return grid[i][j] < 0 30 | }) 31 | count += len(grid[i]) - upperBound 32 | } 33 | 34 | return count 35 | } 36 | -------------------------------------------------------------------------------- /CountNegativeNumbersInASortedMatrix/count_negative_numbers_in_a_sorted_matrix.md: -------------------------------------------------------------------------------- 1 | # A 2 | 3 | To count negative numbers in a sorted matrix, you can use a simple algorithm that takes advantage of the sorted property of the matrix. Here's a step-by-step approach to count negative numbers efficiently: 4 | 5 | 1. Initialize a count variable to 0, which will store the number of negative numbers encountered. 6 | 2. Start from the top-right corner of the matrix. 7 | 3. Compare the current element with 0: 8 | - If the current element is less than 0, it means the entire column to the left of the current element will also be negative. Increment the count variable by the number of elements in that column (including the current element). 9 | - If the current element is greater than or equal to 0, move to the next row (go down). 10 | 4. Repeat step 3 until you reach the bottom-left corner of the matrix. 11 | 5. Return the count variable, which will contain the total count of negative numbers in the matrix. 12 | 13 | Here's a Python code implementation of the algorithm: 14 | 15 | ```dart 16 | 17 | ``` 18 | 19 | You can use this function by passing your sorted matrix as an argument. It will return the count of negative numbers in the matrix. 20 | -------------------------------------------------------------------------------- /CountOddNumbersInAnIntervalRange/count_odd_numbers_in_an_interval_range.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func countOdds1(low int, high int) int { 4 | 5 | return ((high + 1) / 2) - (low / 2) 6 | } 7 | 8 | func countOdds2(low int, high int) int { 9 | if (high & 1) == 0 { 10 | high-- 11 | } 12 | if low > high { 13 | return 0 14 | } 15 | return ((high + 1) / 2) - (low / 2) 16 | } 17 | 18 | func countOdds3(low int, high int) int { 19 | var total int = high - low + 1 20 | if total%2 == 0 { 21 | return total / 2 22 | } else { 23 | if low%2 != 0 { 24 | return (total / 2) + 1 25 | 26 | } 27 | } 28 | return total / 2 29 | 30 | } 31 | -------------------------------------------------------------------------------- /CountingBits/counting_bits.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // func countBits(n int) []int { 4 | // arr := make([]int, n+1) 5 | // arr[0] = 0 6 | // prevPow := 1 7 | // for i := 1; i <= n; i++ { 8 | // if i&(i-1) == 0 { 9 | // arr[i] = 1 10 | // prevPow = i 11 | // continue 12 | // } 13 | // arr[i] = 1 + arr[i-prevPow] 14 | // } 15 | // return arr 16 | // } 17 | 18 | func countBits(n int) []int { 19 | var array []int = make([]int, n+1) 20 | for i := 1; i <= n; i++ { 21 | array[i] = array[i>>1] + (i & 1) 22 | } 23 | return array 24 | } 25 | -------------------------------------------------------------------------------- /CourseSchedule/course_schedule.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | 4 | 5 | 6 | func canFinish(numCourses int, prerequisites [][]int) bool { 7 | graph := make([][]int, numCourses) 8 | for i := 0; i < numCourses; i++ { 9 | graph[i] = make([]int, 0) 10 | } 11 | 12 | for _, pre := range prerequisites { 13 | x := pre[0] 14 | y := pre[1] 15 | graph[x] = append(graph[x], y) 16 | } 17 | 18 | visited := make([]int, numCourses) 19 | for i := 0; i < numCourses; i++ { 20 | if hasCycle(graph, visited, i) { 21 | return false // Cycle detected 22 | } 23 | } 24 | 25 | return true 26 | } 27 | 28 | func hasCycle(graph [][]int, visited []int, node int) bool { 29 | if visited[node] == 1 { 30 | return true // Cycle detected 31 | } 32 | if visited[node] == -1 { 33 | return false // Already visited and no cycle 34 | } 35 | 36 | visited[node] = 1 // Mark node as visited 37 | 38 | for _, neighbor := range graph[node] { 39 | if hasCycle(graph, visited, neighbor) { 40 | return true // Cycle detected 41 | } 42 | } 43 | 44 | visited[node] = -1 // Mark node as visited and no cycle 45 | return false 46 | } 47 | 48 | 49 | 50 | 51 | -------------------------------------------------------------------------------- /CourseSchedule/course_schedule.md: -------------------------------------------------------------------------------- 1 | # 2 | 3 | ## Topological Sort 4 | 5 | ```dart 6 | import 'dart:collection'; 7 | 8 | class Solution { 9 | bool canFinish(int numCourses, List> prerequisites) { 10 | final List answer = []; 11 | final Map> map = Map(); 12 | final List result = List.filled(numCourses, 0); 13 | 14 | for (final List x in prerequisites) { 15 | map[x[1]] = [...map[x[1]] ?? [], x[0]]; 16 | result[x[0]]++; 17 | } 18 | 19 | final Queue q = Queue(); 20 | for (int i = 0; i < numCourses; i++) { 21 | if (result[i] == 0) { 22 | q.add(i); 23 | } 24 | } 25 | 26 | while (q.isNotEmpty) { 27 | final int fr = q.removeFirst(); 28 | answer.add(fr); 29 | 30 | for (final int x in map[fr] ?? []) { 31 | result[x]--; 32 | if (result[x] == 0) { 33 | q.add(x); 34 | } 35 | } 36 | } 37 | 38 | return answer.length == numCourses; 39 | } 40 | } 41 | ``` 42 | -------------------------------------------------------------------------------- /Create-File.ps1: -------------------------------------------------------------------------------- 1 | # Create File in a directory 2 | 3 | # Use: ../Create-File.ps1 -FileName "Your_File_Name.extention" 4 | 5 | Param( 6 | [Parameter(Mandatory=$true)] 7 | [string]$FileName 8 | ) 9 | 10 | # Convert the file name to lowercase 11 | $NewFileName = $FileName.ToLower() 12 | 13 | # Replace spaces with underscores 14 | $NewFileName = $NewFileName -replace '\s', '_' 15 | 16 | # Create an array of extensions to use 17 | $extensions = @('.md', '.go', '.py') 18 | 19 | foreach ($ext in $extensions) { 20 | $fullFileName = $NewFileName + $ext 21 | 22 | # Check if the file already exists 23 | if (Test-Path -Path $fullFileName -PathType Leaf) { 24 | Write-Output "File '$fullFileName' already exists." 25 | # You can choose to skip the creation of the new file or rename the existing file here. 26 | } 27 | else { 28 | # Create a new file with the modified name and extension 29 | $NewFile = New-Item -ItemType File -Path $fullFileName -ErrorAction Stop 30 | # Output the new file name 31 | Write-Output "New file created: $fullFileName" 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /Create-Folder.ps1: -------------------------------------------------------------------------------- 1 | # # Create Folder in Directory 2 | 3 | # ## Use: ./Create-Folder.ps1 -folderName "ayoub ali" 4 | 5 | param ( 6 | [Parameter(Mandatory=$true)] 7 | [string]$folderName 8 | ) 9 | 10 | # Function to capitalize the first letter of each word 11 | function Capitalize-FirstLetter { 12 | param ( 13 | [Parameter(Mandatory=$true, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true)] 14 | [string]$string 15 | ) 16 | 17 | $cultureInfo = (Get-Culture).TextInfo 18 | $cultureInfo.ToTitleCase($string.ToLower()) 19 | } 20 | 21 | # Split the folder name into individual words 22 | $words = $folderName -split ' ' 23 | 24 | # Remove spaces from each word and capitalize the first letter 25 | $capitalizedWords = foreach ($word in $words) { 26 | $word = $word -replace '\s', '' 27 | Capitalize-FirstLetter -string $word 28 | } 29 | 30 | # Join the capitalized words back into a single string 31 | $folderName = $capitalizedWords -join '' 32 | 33 | # Check if the folder already exists 34 | if (Test-Path $folderName) { 35 | Write-Host "Folder '$folderName' already exists." 36 | exit 1 37 | } 38 | 39 | # Create the folder 40 | New-Item -ItemType Directory -Path $folderName -Force | Out-Null 41 | 42 | # Change the current location to the newly created folder 43 | Set-Location -Path $folderName 44 | 45 | Write-Host "Folder '$folderName' created successfully and current location set to the new folder." 46 | -------------------------------------------------------------------------------- /DailyTemperatures/daily_temperatures.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func dailyTemperatures(temperatures []int) []int { 4 | var res []int = make([]int, len(temperatures)) 5 | for i := len(temperatures) - 2; i >= 0; i-- { 6 | var next int = i + 1 7 | for next < len(temperatures) && temperatures[next] <= temperatures[i] { 8 | if res[next] == 0 { 9 | next = len(temperatures) 10 | break 11 | } 12 | next += res[next] 13 | } 14 | if next < len(temperatures) { 15 | res[i] = next - i 16 | } 17 | } 18 | return res 19 | } 20 | -------------------------------------------------------------------------------- /DataStreamAsDisjointIntervals/data_stream_as_disjoint_intervals.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type SummaryRanges struct { 4 | nums []bool 5 | } 6 | 7 | func Constructor() SummaryRanges { 8 | return SummaryRanges{ 9 | nums: make([]bool, 10002), 10 | } 11 | } 12 | 13 | func (this *SummaryRanges) AddNum(value int) { 14 | this.nums[value] = true 15 | } 16 | 17 | func (this *SummaryRanges) GetIntervals() [][]int { 18 | res := make([][]int, 0) 19 | lo, hi := -1, -1 20 | for i := range this.nums { 21 | if !this.nums[i] { 22 | if lo != -1 { 23 | res = append(res, []int{lo, hi}) 24 | lo, hi = -1, -1 25 | } 26 | continue 27 | } 28 | if lo == -1 { 29 | lo, hi = i, i 30 | continue 31 | } 32 | hi = i 33 | } 34 | return res 35 | 36 | } 37 | 38 | // O(N) O(1) 39 | // O(1) O(N) 40 | 41 | /** 42 | * Your SummaryRanges object will be instantiated and called as such: 43 | * obj := Constructor(); 44 | * obj.AddNum(value); 45 | * param_2 := obj.GetIntervals(); 46 | */ 47 | -------------------------------------------------------------------------------- /DecodeWays/decode_ways.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strconv" 4 | 5 | func numDecodings(s string) int { 6 | sol := Solution{mp: map[string]int{}} 7 | return sol.Decode(s) 8 | } 9 | 10 | type Solution struct { 11 | mp map[string]int 12 | } 13 | 14 | func (sol *Solution) Decode(s string) int { 15 | if n, ok := sol.mp[s]; ok { 16 | return n 17 | } 18 | if len(s) <= 1 && s != "0" { 19 | return 1 20 | } 21 | if s[0] == '0' { 22 | return 0 23 | } 24 | num := sol.Decode(s[1:]) 25 | if n, _ := strconv.Atoi(s[:2]); n >= 10 && n <= 26 { 26 | num += sol.Decode(s[2:]) 27 | } 28 | sol.mp[s] = num 29 | return num 30 | } 31 | 32 | /* 33 | Iterative 34 | func numDecodings(s string) int { 35 | if s == "0" { 36 | return 0 37 | } 38 | if len(s) <= 1 { 39 | return 1 40 | } 41 | dp := make([]int, len(s)+1) 42 | dp[0], dp[1] = 1, 1 43 | if s[0] == '0' { 44 | dp[1] = 0 45 | } 46 | for i := 2; i <= len(s); i++ { 47 | if single, _ := strconv.Atoi(s[i-1 : i]); single > 0 { 48 | dp[i] = dp[i-1] 49 | } 50 | if double, _ := strconv.Atoi(s[i-2 : i]); double >= 10 && double <= 26 { 51 | dp[i] += dp[i-2] 52 | } 53 | } 54 | return dp[len(s)] 55 | } 56 | */ 57 | -------------------------------------------------------------------------------- /DeleteColumnsToMakeSorted/delete_columns_to_make_sorted.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // func minDeletionSize(strs []string) int { 4 | // var count int = 0 5 | // if len(strs) <= 1 { 6 | // return 0 7 | // } 8 | // for i := 0; i < len(strs[0]); i++ { 9 | // for j := 0; j < len(strs)-1; j++ { 10 | // if strs[j+1][i] < strs[j][i] { 11 | // count++ 12 | // break 13 | // } 14 | // } 15 | // } 16 | // return count 17 | // } 18 | 19 | func minDeletionSize(strs []string) int { 20 | var deleted int = 0 21 | if len(strs) == 0 { 22 | return deleted 23 | } 24 | var rowSize int = len(strs[0]) 25 | for col := 0; col < rowSize; col++ { 26 | if !isSorted(strs, col) { 27 | deleted++ 28 | } 29 | } 30 | return deleted 31 | } 32 | 33 | func isSorted(strs []string, col int) bool { 34 | var size int = len(strs) 35 | var previous byte = 0 36 | for i := 0; i < size; i++ { 37 | var c byte = strs[i][col] 38 | if c < previous { 39 | return false 40 | } 41 | previous = c 42 | 43 | } 44 | return true 45 | } 46 | -------------------------------------------------------------------------------- /DeleteNodeInALinkedList/delete_node_in_a_linked_list.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // Runtime: 4 ms, faster than 72.67% of Go online submissions for Delete Node in a Linked List. 9 | // Memory Usage: 2.9 MB, less than 67.73% of Go online submissions for Delete Node in a Linked List. 10 | // func deleteNode(node *ListNode) { 11 | 12 | // node.Val = node.Next.Val 13 | // node.Next = node.Next.Next 14 | // } 15 | 16 | func deleteNode(node *ListNode) { 17 | 18 | node.Val = node.Next.Val 19 | node.Next = node.Next.Next 20 | 21 | } 22 | -------------------------------------------------------------------------------- /DeleteTheMiddleNodeOfALinkedList/delete_the_middle_node_of_a_linked_list.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for singly-linked list. 4 | type ListNode struct { 5 | Val int 6 | Next *ListNode 7 | } 8 | 9 | func deleteMiddle(head *ListNode) *ListNode { 10 | if head == nil || head.Next == nil { 11 | return nil 12 | } 13 | 14 | var previous, slow, fast *ListNode = nil, head, head 15 | 16 | // Time: O(n/2) = O(n) 17 | for slow != nil && fast != nil && fast.Next != nil { 18 | previous, slow, fast = slow, slow.Next, fast.Next.Next 19 | } 20 | 21 | previous.Next = slow.Next 22 | 23 | return head 24 | } 25 | -------------------------------------------------------------------------------- /DesignBrowserHistory/design_browser_history.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type BrowserHistory struct { 4 | root *Node 5 | } 6 | 7 | type Node struct { 8 | value string 9 | next *Node 10 | previous *Node 11 | } 12 | 13 | func Constructor(homepage string) BrowserHistory { 14 | return BrowserHistory{ 15 | root: &Node{ 16 | value: homepage, 17 | }, 18 | } 19 | } 20 | 21 | func (this *BrowserHistory) Visit(url string) { 22 | node := Node{ 23 | value: url, 24 | } 25 | node.previous = this.root 26 | this.root.next = &node 27 | this.root = this.root.next 28 | } 29 | 30 | func (this *BrowserHistory) Back(steps int) string { 31 | 32 | for steps > 0 && this.root.previous != nil { 33 | this.root = this.root.previous 34 | steps -= 1 35 | } 36 | return this.root.value 37 | } 38 | 39 | func (this *BrowserHistory) Forward(steps int) string { 40 | for steps > 0 && this.root.next != nil { 41 | this.root = this.root.next 42 | steps -= 1 43 | } 44 | return this.root.value 45 | } 46 | 47 | /** 48 | * Your BrowserHistory object will be instantiated and called as such: 49 | * obj := Constructor(homepage); 50 | * obj.Visit(url); 51 | * param_2 := obj.Back(steps); 52 | * param_3 := obj.Forward(steps); 53 | 54 | */ 55 | -------------------------------------------------------------------------------- /DesignHashSet/design_hashSet.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type MyHashSet struct { 4 | mp []uint32 5 | } 6 | 7 | func Constructor() MyHashSet { 8 | return MyHashSet{ 9 | mp: make([]uint32, 125001), 10 | } 11 | } 12 | 13 | func (this *MyHashSet) Add(key int) { 14 | index := key / 32 15 | bitPosition := uint32(key % 32) 16 | this.mp[index] |= (1 << bitPosition) 17 | } 18 | 19 | func (this *MyHashSet) Remove(key int) { 20 | index := key / 32 21 | bitPosition := uint32(key % 32) 22 | this.mp[index] &= ^(1 << bitPosition) 23 | } 24 | 25 | func (this *MyHashSet) Contains(key int) bool { 26 | index := key / 32 27 | bitPosition := uint32(key % 32) 28 | return (this.mp[index] & (1 << bitPosition)) != 0 29 | } 30 | -------------------------------------------------------------------------------- /DesignUndergroundSystem/design_underground_system.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/DesignUndergroundSystem/design_underground_system.md -------------------------------------------------------------------------------- /DetectCapital/detect_capital.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strings" 4 | 5 | // 1. using strings' build-in func 6 | func detectCapitalUse(word string) bool { 7 | return word == strings.ToLower(word) || word == strings.ToUpper(word) || word == strings.Title(strings.ToLower(word)) 8 | } 9 | 10 | // 2. set condition for judging 11 | func isCapital(letter int32) bool { 12 | return letter <= 'Z' && letter >= 'A' 13 | } 14 | 15 | /* 16 | func detectCapitalUse(word string) bool { 17 | var condition = 0 18 | 19 | for index, letter := range word { 20 | switch isCapital(letter) { 21 | case true: 22 | if condition == 0 { 23 | condition = 1 24 | continue 25 | } else if condition == 1 { 26 | continue 27 | } else if condition == 2 || condition == 3 { 28 | return false 29 | } 30 | case false: 31 | if condition == 0 { 32 | condition = 2 33 | } else if condition == 1{ 34 | if index == 1 { 35 | condition = 3 36 | } else { 37 | return false 38 | } 39 | } else if condition == 2 || condition == 3{ 40 | continue 41 | } 42 | } 43 | } 44 | 45 | return true 46 | } 47 | 48 | */ 49 | -------------------------------------------------------------------------------- /DetermineIfTwoStringsAreClose/determine_if_two_strings_are_close.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func closeStrings(word1 string, word2 string) bool { 4 | var ctr1, ctr2 [26]int 5 | 6 | if len(word1) != len(word2) { 7 | return false 8 | } 9 | for i := 0; i < len(word1); i++ { 10 | ctr1[word1[i]-byte('a')]++ 11 | ctr2[word2[i]-byte('a')]++ 12 | } 13 | for i := 0; i < len(ctr1); i++ { 14 | if (ctr1[i] != 0) != (ctr2[i] != 0) { 15 | return false 16 | } 17 | } 18 | cctr := make(map[int]int) 19 | for i := 0; i < len(ctr1); i++ { 20 | cctr[ctr1[i]]++ 21 | cctr[ctr2[i]]-- 22 | } 23 | for _, c := range cctr { 24 | if c != 0 { 25 | return false 26 | } 27 | } 28 | return true 29 | } 30 | -------------------------------------------------------------------------------- /DetonateTheMaximumBombs/detonate_the_maximum_bombs.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "math" 5 | ) 6 | 7 | func maximumDetonation(bombs [][]int) int { 8 | n := len(bombs) 9 | maxBombs := 0 10 | graph := make(map[int][]int) 11 | 12 | for i := 0; i < n; i++ { 13 | for j := 0; j < n; j++ { 14 | if i == j { 15 | continue 16 | } 17 | if math.Pow(float64(bombs[i][2]), 2) >= math.Pow(float64(bombs[i][0]-bombs[j][0]), 2)+math.Pow(float64(bombs[i][1]-bombs[j][1]), 2) { 18 | neighbors := graph[i] 19 | neighbors = append(neighbors, j) 20 | graph[i] = neighbors 21 | } 22 | } 23 | } 24 | 25 | for i := 0; i < n; i++ { 26 | visited := make(map[int]bool) 27 | visited[i] = true 28 | dfs(i, visited, graph) 29 | maxBombs = int(math.Max(float64(maxBombs), float64(len(visited)))) 30 | } 31 | 32 | return maxBombs 33 | } 34 | 35 | func dfs(node int, visited map[int]bool, graph map[int][]int) { 36 | neighbors := graph[node] 37 | for _, child := range neighbors { 38 | if !visited[child] { 39 | visited[child] = true 40 | dfs(child, visited, graph) 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /DiagonalTraverseIi/diagonal_traverse_ii.dart: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | -- 1424. Diagonal Traverse II-- 4 | 5 | 6 | Given a 2D integer array nums, return all elements of nums in diagonal order as shown in the below images. 7 | 8 | 9 | 10 | Example 1: 11 | 12 | 13 | Input: nums = [[1,2,3],[4,5,6],[7,8,9]] 14 | Output: [1,4,2,7,5,3,8,6,9] 15 | Example 2: 16 | 17 | 18 | Input: nums = [[1,2,3,4,5],[6,7],[8],[9,10,11],[12,13,14,15,16]] 19 | Output: [1,6,2,8,7,3,9,4,12,10,5,13,11,14,15,16] 20 | 21 | 22 | Constraints: 23 | 24 | 1 <= nums.length <= 105 25 | 1 <= nums[i].length <= 105 26 | 1 <= sum(nums[i].length) <= 105 27 | 1 <= nums[i][j] <= 105 28 | 29 | */ 30 | 31 | import 'dart:collection'; 32 | 33 | 34 | class Solution { 35 | List findDiagonalOrder(List> nums) { 36 | final HashMap> diagonals = HashMap(); 37 | final List ans = []; 38 | final int n = nums.length; 39 | 40 | for (int i = 0; i < n; i++) { 41 | final int m = nums[i].length; 42 | for (int j = 0; j < m; j++) { 43 | final int sum = i + j; 44 | if (!diagonals.containsKey(sum)) { 45 | diagonals[sum] = []; 46 | } 47 | diagonals[sum]?.add(nums[i][j]); 48 | } 49 | } 50 | 51 | diagonals.forEach((sum, arr) { 52 | for (int i = arr.length - 1; i >= 0; i--) { 53 | ans.add(arr[i]); 54 | } 55 | }); 56 | 57 | return ans; 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /EarliestPossibleDayOfFullBloom/earliest_possible_day_of_full_bloom.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func earliestFullBloom(plantTime []int, growTime []int) int { 6 | t := times{plantTime, growTime} 7 | sort.Sort(t) 8 | 9 | res, curDay := 0, 0 10 | for i := range plantTime { 11 | res = max(res, curDay+plantTime[i]+growTime[i]) 12 | curDay += plantTime[i] 13 | } 14 | 15 | return res 16 | } 17 | 18 | type times struct { 19 | grow, plant []int 20 | } 21 | 22 | func (t times) Len() int { return len(t.plant) } 23 | func (t times) Less(i, j int) bool { return t.plant[i] > t.plant[j] } 24 | func (t times) Swap(i, j int) { 25 | t.plant[i], t.plant[j] = t.plant[j], t.plant[i] 26 | t.grow[i], t.grow[j] = t.grow[j], t.grow[i] 27 | } 28 | 29 | func max(a, b int) int { 30 | if a > b { 31 | return a 32 | } 33 | 34 | return b 35 | } 36 | -------------------------------------------------------------------------------- /EqualRowAndColumnPairs/equal_row_and_column_pairs.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func transpose(grid [][]int) [][]int { 4 | n := len(grid) 5 | gc := make([][]int, n) 6 | 7 | for i := 0; i < n; i++ { 8 | v := make([]int, n) 9 | for j := 0; j < n; j++ { 10 | v[j] = grid[j][i] // column-wise pushing 11 | } 12 | gc[i] = v 13 | } 14 | 15 | return gc 16 | } 17 | 18 | func isListEqual(firstList []int, secondList []int) bool { 19 | if len(firstList) != len(secondList) { 20 | return false 21 | } 22 | 23 | for i := 0; i < len(firstList); i++ { 24 | if firstList[i] != secondList[i] { 25 | return false 26 | } 27 | } 28 | 29 | return true 30 | } 31 | 32 | func equalPairs(grid [][]int) int { 33 | gc := transpose(grid) 34 | n := len(grid) 35 | 36 | ans := 0 37 | for i := 0; i < n; i++ { 38 | for j := 0; j < n; j++ { 39 | if isListEqual(grid[i], gc[j]) { 40 | ans++ 41 | } 42 | } 43 | } 44 | 45 | return ans 46 | } 47 | -------------------------------------------------------------------------------- /EvaluateReversePolishNotation/evaluate_reverse_polish_notation.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strconv" 4 | 5 | var m = map[string]func(int, int) int{ 6 | "+": func(lhs, rhs int) int { return lhs + rhs }, 7 | "-": func(lhs, rhs int) int { return lhs - rhs }, 8 | "*": func(lhs, rhs int) int { return lhs * rhs }, 9 | "/": func(lhs, rhs int) int { return lhs / rhs }, 10 | } 11 | 12 | func evalRPN(tokens []string) int { 13 | var stk []int 14 | for _, val := range tokens { 15 | var num int 16 | if fn, ok := m[val]; ok { 17 | var lhs, rhs int 18 | stk, lhs, rhs = popTopTwo(stk) 19 | num = fn(lhs, rhs) 20 | } else { 21 | num, _ = strconv.Atoi(val) 22 | } 23 | 24 | stk = append(stk, num) 25 | } 26 | 27 | return stk[0] 28 | } 29 | 30 | func popTopTwo(stk []int) ([]int, int, int) { 31 | rhs := stk[len(stk)-1] 32 | stk = stk[:len(stk)-1] 33 | 34 | lhs := stk[len(stk)-1] 35 | stk = stk[:len(stk)-1] 36 | 37 | return stk, lhs, rhs 38 | } 39 | -------------------------------------------------------------------------------- /ExcelSheetColumnNumber/excel_sheet_colum_number.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "math" 5 | "strings" 6 | ) 7 | 8 | func titleToNumber(columnTitle string) int { 9 | result := 0.0 10 | s := strings.ToLower(columnTitle) 11 | size := len(s) 12 | for i := 0; i < size; i++ { 13 | num := s[i] % 96 14 | n := size - 1 - i 15 | result += math.Pow(float64(26), float64(n)) * float64(num) 16 | } 17 | return int(result) 18 | } 19 | -------------------------------------------------------------------------------- /ExcelSheetColumnTitle/excel_sheet_column_title.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | 4 | 5 | // func convertToTitle(n int) string { 6 | // result := "" 7 | // for n != 0 { 8 | // fmt.Println(n) 9 | // result = string('A'+(n-1)%26) + result 10 | // n = (n - 1) / 26 11 | // } 12 | // return result 13 | // } 14 | /* 15 | func convertToTitle(n int) string { 16 | result := "" 17 | for n != 0 { 18 | fmt.Println(n) 19 | result = string(rune('A'+(n-1)%26)) + result 20 | n = (n - 1) / 26 21 | } 22 | return result 23 | } 24 | 25 | */ 26 | func convertToTitle(columnNumber int) string { 27 | if columnNumber == 0 { 28 | return "" 29 | } 30 | columnNumber-- 31 | return convertToTitle(columnNumber/26) + string((columnNumber%26)+'A') 32 | } 33 | -------------------------------------------------------------------------------- /FindClosestNodeToGivenTwoNodes/find_closest_node_to_given_two_nodes.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func closestMeetingNode(edges []int, node1 int, node2 int) int { 4 | return bellmanFord(edges, node1, node2) 5 | } 6 | 7 | func bellmanFord(edges []int, node1 int, node2 int) int { 8 | bf1 := calculateBellmanFord(node1, edges) 9 | bf2 := calculateBellmanFord(node2, edges) 10 | 11 | //max Integer 12 | minPath := 1 << 31 13 | result := -1 14 | for i := range bf1 { 15 | if bf1[i] == 1<<31 || bf2[i] == 1<<31 { 16 | continue 17 | } 18 | 19 | v := max(bf1[i], bf2[i]) 20 | if v < minPath { 21 | minPath = v 22 | result = i 23 | } 24 | } 25 | 26 | return result 27 | } 28 | 29 | func calculateBellmanFord(root int, edges []int) []int { 30 | distances := make([]int, len(edges)) 31 | for i := range distances { 32 | distances[i] = 1 << 31 33 | } 34 | distances[root] = 0 35 | 36 | node := root 37 | for edges[node] != -1 { 38 | next := edges[node] 39 | if distances[next] > distances[node]+1 { 40 | distances[next] = distances[node] + 1 41 | node = next 42 | } else { 43 | break 44 | } 45 | } 46 | 47 | return distances 48 | } 49 | 50 | func max(a, b int) int { 51 | if a > b { 52 | return a 53 | } 54 | 55 | return b 56 | } 57 | 58 | /* 59 | 60 | bellman ford: 61 | 62 | root as node0: 63 | [0,MaxInt,1,2] 64 | 65 | root as node1: 66 | [MaxInt,0,1,2] 67 | 68 | */ 69 | -------------------------------------------------------------------------------- /FindCriticalAndPseudoCriticalEdgesInMinimumSpanningTree/find_critical_and_pseudocritical_edges_in_minimum_spanning_tree.md: -------------------------------------------------------------------------------- 1 | # 2 | 3 | ## [DART](https://leetcode.com/problems/find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree/solutions/3929888/kruskal-s-algorithm-disjointset-simple-fast-and-easy-with-explanation/) 4 | 5 | ## [GO](https://leetcode.com/problems/find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree/solutions/3929871/kruskal-s-algorithm-disjointset-simple-fast-and-easy-with-explanation/) 6 | -------------------------------------------------------------------------------- /FindDuplicateFileInSystem/find_duplicate_file_in_system.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strings" 4 | 5 | func findDuplicate(paths []string) [][]string { 6 | files := make(map[string][]string) 7 | for _, path := range paths { 8 | ps := strings.Split(path, " ") 9 | for _, file := range ps[1:] { 10 | fs := strings.Split(file, "(") 11 | files[fs[1]] = append(files[fs[1]], ps[0]+"/"+fs[0]) 12 | } 13 | } 14 | 15 | out := [][]string{} 16 | for _, file := range files { 17 | if len(file) > 1 { 18 | out = append(out, file) 19 | } 20 | } 21 | 22 | return out 23 | } 24 | -------------------------------------------------------------------------------- /FindDuplicateFileInSystem/find_duplicate_file_in_system.md: -------------------------------------------------------------------------------- 1 | # ️‍🔥 Dart 🔥 || 2 | -------------------------------------------------------------------------------- /FindIfPathExistsInGraph/find_if_path_exists_in_graph.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | func validPath(n int, edges [][]int, start int, end int) bool { 6 | way := make([]int, n) 7 | for i := range way { 8 | way[i] = i 9 | } 10 | root := func(n int, way []int) int { 11 | for way[n] != n { 12 | n = way[n] 13 | } 14 | return n 15 | } 16 | for _, e := range edges { 17 | root0, root1 := root(e[0], way), root(e[1], way) 18 | minValue := min(root0, root1) 19 | way[e[0]] = minValue 20 | way[e[1]] = minValue 21 | way[root0] = minValue 22 | way[root1] = minValue 23 | } 24 | return root(start, way) == root(end, way) 25 | } 26 | 27 | func min(values ...int) int { 28 | minValue := math.MaxInt64 29 | for _, v := range values { 30 | if v < minValue { 31 | minValue = v 32 | } 33 | } 34 | return minValue 35 | } 36 | -------------------------------------------------------------------------------- /FindMedianFromDataStream/find_median_from_data_stream.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/FindMedianFromDataStream/find_median_from_data_stream.md -------------------------------------------------------------------------------- /FindOriginalArrayFromDoubledArray/find_original_array_from_doubled_array.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func findOriginalArray(changed []int) []int { 6 | //if the total len is odd, return empty array 7 | if len(changed)%2 != 0 { 8 | return []int{} 9 | } 10 | //sort the array 11 | sort.Ints(changed) 12 | 13 | //populate the frequency map 14 | freq := make(map[int]int) 15 | for _, val := range changed { 16 | freq[val]++ 17 | } 18 | 19 | result := []int{} 20 | //iterate thru the original array 21 | for _, val := range changed { 22 | cnt := freq[val] 23 | //no need for check for existence ; element would be present 24 | if cnt > 0 { 25 | //if the count is greater than 0 26 | //reduce the count 27 | freq[val]-- 28 | //check for double 29 | dbl := val * 2 30 | //if present and value is greater than 0 31 | //then it is candidate 32 | //however if not present or count is not greater 33 | //than zero then return empty array 34 | if v, ok := freq[dbl]; ok { 35 | if v > 0 { 36 | result = append(result, val) 37 | freq[dbl]-- 38 | } else { 39 | return []int{} 40 | } 41 | } else { 42 | return []int{} 43 | } 44 | } 45 | } 46 | 47 | return result 48 | } 49 | -------------------------------------------------------------------------------- /FindOriginalArrayFromDoubledArray/find_original_array_from_doubled_array.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/FindOriginalArrayFromDoubledArray/find_original_array_from_doubled_array.md -------------------------------------------------------------------------------- /FindPlayersWithZeroOrOneLosses/find_players_with_zero_or_one_losses.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func findWinners(matches [][]int) [][]int { 4 | // fixed length of winners 5 | var won []int = make([]int, 100001) 6 | // fixed length of the loser 7 | var loss []int = make([]int, 100001) 8 | // for in loop 9 | for _, match := range matches { 10 | won[match[0]]++ 11 | loss[match[1]]++ 12 | } 13 | // 2D Array 14 | var ans [][]int 15 | // List of who won the math 16 | var wonAllMatches []int 17 | // list of who lose the match 18 | var lostOneMatch []int 19 | 20 | // looping through the lit of winners 21 | for i := 0; i < len(won); i++ { 22 | // if the winner value at i is greater than zeo and loser value is equal to zero 23 | if won[i] > 0 && loss[i] == 0 { 24 | // we will add winner value to winner list 25 | wonAllMatches = append(wonAllMatches, i) 26 | } 27 | 28 | // if loser value is equal to one like we have a loser 29 | if loss[i] == 1 { 30 | // we will add that value to our list 31 | lostOneMatch = append(lostOneMatch, i) 32 | 33 | } 34 | } 35 | // at the end we will add both of winner and loser list into result list 36 | ans = append(ans, wonAllMatches) 37 | ans = append(ans, lostOneMatch) 38 | return ans 39 | } 40 | -------------------------------------------------------------------------------- /FindSmallestLetterGreaterThanTarget/find_smallest_letter_greater_than_target.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func nextGreatestLetter(letters []byte, target byte) byte { 4 | left := 0 5 | right := len(letters) - 1 6 | 7 | for left <= right { 8 | mid := left + (right-left)/2 9 | 10 | if letters[mid] > target { 11 | right = mid - 1 12 | } else { 13 | left = mid + 1 14 | } 15 | } 16 | 17 | return letters[left%len(letters)] 18 | } 19 | -------------------------------------------------------------------------------- /FindTheHighestAltitude/find_the_highest_altitude.dart: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 4 | -* 1732. Find the Highest Altitude *- 5 | 6 | 7 | There is a biker going on a road trip. The road trip consists of n + 1 points at different altitudes. The biker starts his trip on point 0 with altitude equal 0. 8 | 9 | You are given an integer array gain of length n where gain[i] is the net gain in altitude between points i​​​​​​ and i + 1 for all (0 <= i < n). Return the highest altitude of a point. 10 | 11 | 12 | 13 | Example 1: 14 | 15 | Input: gain = [-5,1,5,0,-7] 16 | Output: 1 17 | Explanation: The altitudes are [0,-5,-4,1,1,-6]. The highest is 1. 18 | Example 2: 19 | 20 | Input: gain = [-4,-3,-2,-1,4,3,2] 21 | Output: 0 22 | Explanation: The altitudes are [0,-4,-7,-9,-10,-6,-3,-1]. The highest is 0. 23 | 24 | 25 | Constraints: 26 | 27 | n == gain.length 28 | 1 <= n <= 100 29 | -100 <= gain[i] <= 100 30 | 31 | 32 | */ 33 | 34 | import 'dart:math'; 35 | 36 | class Solution { 37 | int largestAltitude(List gain) { 38 | int currentAltitude = 0; 39 | int maxAltitude = 0; 40 | for (int i = 0; i < gain.length; i++) { 41 | currentAltitude = gain[i]; 42 | maxAltitude = max(maxAltitude, currentAltitude); 43 | } 44 | return maxAltitude; 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /FindTheHighestAltitude/find_the_highest_altitude.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func largestAltitude(gain []int) int { 4 | var maxAltitude int = 0 5 | var currentAltitude int = 0 6 | 7 | for i := 0; i < len(gain); i++ { 8 | currentAltitude += gain[i] 9 | maxAltitude = max(maxAltitude, currentAltitude) 10 | } 11 | return maxAltitude 12 | 13 | } 14 | 15 | func max(first int, second int) int { 16 | if first > second { 17 | return first 18 | } 19 | return second 20 | } 21 | -------------------------------------------------------------------------------- /FindTheHighestAltitude/find_the_highest_altitude.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/FindTheHighestAltitude/find_the_highest_altitude.md -------------------------------------------------------------------------------- /FirstBadVersion/first_bad_version.dart: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | -* First Bad Version *- 4 | 5 | You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check. Since each version is developed based on the previous version, all the versions after a bad version are also bad. 6 | 7 | Suppose you have n versions [1, 2, ..., n] and you want to find out the first bad one, which causes all the following ones to be bad. 8 | 9 | You are given an API bool isBadVersion(version) which returns whether version is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API. 10 | 11 | 12 | 13 | Example 1: 14 | 15 | Input: n = 5, bad = 4 16 | Output: 4 17 | Explanation: 18 | call isBadVersion(3) -> false 19 | call isBadVersion(5) -> true 20 | call isBadVersion(4) -> true 21 | Then 4 is the first bad version. 22 | Example 2: 23 | 24 | Input: n = 1, bad = 1 25 | Output: 1 26 | 27 | 28 | Constraints: 29 | 30 | 1 <= bad <= n <= 231 - 1 31 | 32 | */ 33 | 34 | bool isBadVersion(int version) { 35 | return false; 36 | } 37 | 38 | class Solution { 39 | int firstBadVersion(int n) { 40 | int start = 1; 41 | int end = n; 42 | while (start <= end) { 43 | int mid = end + (end - start) ~/ 2; 44 | if (isBadVersion(mid)) { 45 | end = mid + 1; 46 | } else { 47 | start = mid - 1; 48 | } 49 | } 50 | return start; 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /FirstBadVersion/first_bad_version.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func isBadVersion(version int) bool 4 | 5 | func firstBadVersion(n int) int { 6 | var start int = 1 7 | var end int = n 8 | for start <= end { 9 | var mid int = start + (end-start)/2 10 | 11 | if isBadVersion(mid) { 12 | end = mid - 1 13 | } else { 14 | start = mid + 1 15 | } 16 | 17 | } 18 | return start 19 | 20 | } 21 | -------------------------------------------------------------------------------- /FirstBadVersion/first_bad_version.md: -------------------------------------------------------------------------------- 1 | # 🔥 First Bad Version 🔥 || Simple Fast and Easy || with Explanation 2 | 3 | ## Solution - 1 Binary Search 4 | 5 | ```dart 6 | class Solution { 7 | int firstBadVersion(int n) { 8 | int start = 1; 9 | int end = n; 10 | while (start <= end) { 11 | int mid = end + (end - start) ~/ 2; 12 | if (isBadVersion(mid)) { 13 | end = mid + 1; 14 | } else { 15 | start = mid - 1; 16 | } 17 | } 18 | return start; 19 | } 20 | } 21 | ``` 22 | 23 | ### Disclaimer:- 24 | 25 | This Solution is not available in DART Programing language with is a bummer. Hurts my feeling. But as a man we should implement it no matter what. We are not bunch of wussies who gonna skip it if it's not available in one language we love. Instead we will conquer the sea and rivers and cross the mountains so see what's lies beyond our horizons. 26 | 27 | ## Solution - 2 28 | 29 | ```go 30 | func firstBadVersion(n int) int { 31 | var start int = 1 32 | var end int = n 33 | for start <= end { 34 | var mid int = start + (end-start)/2 35 | 36 | if isBadVersion(mid) { 37 | end = mid - 1 38 | } else { 39 | start = mid + 1 40 | } 41 | 42 | } 43 | return start 44 | 45 | } 46 | ``` 47 | -------------------------------------------------------------------------------- /FirstUniqueCharacterInAString/first_unique_character_in_a_string.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func firstUniqChar(s string) int { 4 | flags := make([]int, 26) 5 | for i := range flags { 6 | flags[i] = -1 7 | } 8 | slen := len(s) 9 | 10 | for i, ch := range s { 11 | idx := byte(ch - 'a') 12 | if flags[idx] == -1 { 13 | flags[idx] = i 14 | } else { 15 | flags[idx] = slen 16 | } 17 | } 18 | 19 | min := slen 20 | for i := range flags { 21 | if flags[i] >= 0 && flags[i] < len(s) && flags[i] < min { 22 | min = flags[i] 23 | } 24 | } 25 | 26 | if min == slen { 27 | return -1 28 | } 29 | return min 30 | } 31 | -------------------------------------------------------------------------------- /FizzBuzz/fizz_buzz.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func fizzBuzz(n int) []string { 6 | var answer []string 7 | for index := 1; index <= n; index++ { 8 | if index%3 == 0 && index%5 == 0 { 9 | answer = append(answer, "FizzBuzz") 10 | } else if index%3 == 0 { 11 | answer = append(answer, "Fizz") 12 | } else if index%5 == 0 { 13 | answer = append(answer, "Buzz") 14 | } else { 15 | str := fmt.Sprintf("%d", index) 16 | answer = append(answer, str) 17 | } 18 | } 19 | return answer 20 | } 21 | 22 | func fizzBuzz2(n int) []string { 23 | answer := make([]string, 0, n) 24 | for index := 1; index <= n; index++ { 25 | switch index % 15 { 26 | case 0: 27 | answer = append(answer, "FizzBuzz") 28 | case 3, 6, 9, 12: 29 | answer = append(answer, "Fizz") 30 | case 5, 10: 31 | answer = append(answer, "Buzz") 32 | default: 33 | answer = append(answer, fmt.Sprintf("%d", index)) 34 | } 35 | } 36 | return answer 37 | } 38 | 39 | func fizzBuzz3(n int) []string { 40 | answer := make([]string, n) 41 | for i := 1; i <= n; i++ { 42 | switch { 43 | case i%3 == 0 && i%5 == 0: 44 | answer[i-1] = "FizzBuzz" 45 | case i%3 == 0: 46 | answer[i-1] = "Fizz" 47 | case i%5 == 0: 48 | answer[i-1] = "Buzz" 49 | default: 50 | answer[i-1] = fmt.Sprintf("%d", i) 51 | } 52 | } 53 | return answer 54 | } 55 | -------------------------------------------------------------------------------- /FizzBuzz/fizz_buzz.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/FizzBuzz/fizz_buzz.md -------------------------------------------------------------------------------- /FruitIntoBaskets/fruit_into_baskets.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func totalFruit(f []int) int { 4 | if len(f) == 0 { 5 | return 0 6 | } 7 | 8 | if len(f) == 1 { 9 | return 1 10 | } 11 | 12 | res := -1 << 63 13 | 14 | m := make(map[int]int) 15 | 16 | l := 0 17 | m[f[l]]++ 18 | 19 | for i := 1; i < len(f); i++ { 20 | m[f[i]]++ 21 | 22 | for len(m) > 2 { 23 | m[f[l]]-- 24 | 25 | if m[f[l]] == 0 { 26 | delete(m, f[l]) 27 | } 28 | 29 | l++ 30 | } 31 | 32 | if i-l+1 > res { 33 | res = i - l + 1 34 | } 35 | } 36 | 37 | return res 38 | } 39 | -------------------------------------------------------------------------------- /GreatestCommonDivisorOfStrings/greatest_common_divisor_of_strings.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func gcdOfStrings(str1 string, str2 string) string { 4 | if str1 == str2 { 5 | return str1 6 | } 7 | 8 | if len(str2) > len(str1) { 9 | str1, str2 = str2, str1 10 | } 11 | 12 | if str1[:len(str2)] != str2 { 13 | return "" 14 | } 15 | 16 | return gcdOfStrings(str1[len(str2):], str2) 17 | } 18 | -------------------------------------------------------------------------------- /GroupAnagrams/group_anagrams.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "bytes" 4 | 5 | func groupAnagrams(strs []string) [][]string { 6 | alphaBits := make(map[string][]string, 0) 7 | for _, str := range strs { 8 | idx := getAlphabetBit(str) 9 | alphaBits[idx] = append(alphaBits[idx], str) 10 | } 11 | 12 | var res = make([][]string, len(alphaBits)) 13 | var i = 0 14 | for _, strs := range alphaBits { 15 | res[i] = strs 16 | i += 1 17 | } 18 | return res 19 | } 20 | 21 | func getAlphabetBit(str string) string { 22 | res := make([]int, 26) 23 | for _, ch := range str { 24 | chInt := int(ch - 'a') 25 | res[chInt] += 1 26 | } 27 | var b bytes.Buffer 28 | for _, bit := range res { 29 | b.WriteByte(byte(int('0') + bit)) 30 | } 31 | return b.String() 32 | } 33 | -------------------------------------------------------------------------------- /GroupThePeopleGivenTheGroupSizeTheyBelongTo/group_the_people_given_the_group_size_they_belong_to.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | 4 | 5 | type NodeList struct { 6 | Val int 7 | Next *NodeList 8 | } 9 | 10 | type LinkedList struct { 11 | Head *NodeList 12 | Length int // Add a Length field to keep track of the list length 13 | } 14 | 15 | func NewLinkedList() *LinkedList { 16 | return &LinkedList{nil, 0} 17 | } 18 | 19 | func (ll *LinkedList) Add(val int) { 20 | newNode := &NodeList{Val: val, Next: nil} 21 | if ll.Head == nil { 22 | ll.Head = newNode 23 | } else { 24 | current := ll.Head 25 | for current.Next != nil { 26 | current = current.Next 27 | } 28 | current.Next = newNode 29 | } 30 | ll.Length++ // Increase the length when adding a node 31 | } 32 | 33 | func groupThePeople(groupSizes []int) [][]int { 34 | groupMap := make(map[int]*LinkedList) 35 | result := make([][]int, 0) 36 | 37 | for person, groupSize := range groupSizes { 38 | if _, exists := groupMap[groupSize]; !exists { 39 | groupMap[groupSize] = NewLinkedList() 40 | } 41 | groupMap[groupSize].Add(person) 42 | 43 | if groupMap[groupSize].Length == groupSize { 44 | group := make([]int, groupSize) 45 | current := groupMap[groupSize].Head 46 | for i := 0; i < groupSize; i++ { 47 | group[i] = current.Val 48 | current = current.Next 49 | } 50 | result = append(result, group) 51 | delete(groupMap, groupSize) 52 | } 53 | } 54 | 55 | return result 56 | } 57 | 58 | 59 | -------------------------------------------------------------------------------- /GroupThePeopleGivenTheGroupSizeTheyBelongTo/group_the_people_given_the_group_size_they_belong_to.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/GroupThePeopleGivenTheGroupSizeTheyBelongTo/group_the_people_given_the_group_size_they_belong_to.md -------------------------------------------------------------------------------- /GuessNumberHigherOrLower/guess_number_higher_or_lower.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //* Forward declaration of guess API. 4 | //* @param num your guess 5 | //* @return -1 if num is higher than the picked number 6 | //* 1 if num is lower than the picked number 7 | //* otherwise return 0 8 | func guess(num int) int 9 | 10 | // func guessNumber(n int) int { 11 | // var low int = 1 12 | // var high int = n 13 | // for low <= high { 14 | // var mid int = low + (high-low)/2 15 | // var g int = guess(mid) 16 | // if g == 0 { 17 | // return mid 18 | // } else if g == -1 { 19 | // high = mid - 1 20 | // } else { 21 | // low = mid + 1 22 | // } 23 | // } 24 | 25 | // return -1 26 | // } 27 | 28 | func guessNumber(n int) int { 29 | return binarySearch(0, n) 30 | } 31 | 32 | func binarySearch(start, finish int) int { 33 | if start > finish { 34 | return -1 35 | } 36 | dot := (finish-start)/2 + start 37 | 38 | switch guess(dot) { 39 | case -1: 40 | return binarySearch(start, dot-1) 41 | case 1: 42 | return binarySearch(dot+1, finish) 43 | default: 44 | return dot 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /HappyNumber/happy_number.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /* 4 | Runtime: 0 ms, faster than 100.00% of Go online submissions for Happy Number. 5 | Memory Usage: 2 MB, less than 93.92% of Go online submissions for Happy Number. 6 | */ 7 | 8 | func isHappy(n int) bool { 9 | i := 10 10 | for i > 0 { 11 | happy := sums(n) 12 | if happy == 1 { 13 | return true 14 | } 15 | n = happy 16 | i-- 17 | } 18 | return false 19 | } 20 | func sums(n int) int { 21 | var sum int = 0 22 | for i := 0; n != 0; i++ { 23 | r := n % 10 24 | sum = sum + r*r 25 | n = n / 10 26 | } 27 | return sum 28 | } 29 | -------------------------------------------------------------------------------- /HouseRobber/house_robber.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func rob(nums []int) int { 4 | //max money can get if rob current house 5 | var previous int = 0 6 | //max money can get if not rob current house 7 | var last int = 0 8 | //if rob current value, previous house must not be robbed 9 | for i := 0; i < len(nums); i++ { 10 | var current int = last + nums[i] 11 | //if not rob ith house, take the max value of robbed (i-1)th house and not rob (i-1)th house 12 | last = max(last, previous) 13 | previous = current 14 | } 15 | return max(previous, last) 16 | } 17 | 18 | func max(a int, b int) int { 19 | if a > b { 20 | return a 21 | } else { 22 | return b 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /ImplementQueueUsingStacks/implement_queue_using_stacks.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type MyQueue struct { 4 | stack1 Stack 5 | stack2 Stack 6 | } 7 | 8 | func Constructor() MyQueue { 9 | return *new(MyQueue) 10 | } 11 | 12 | func (this *MyQueue) Push(x int) { 13 | 14 | for !this.stack1.IsEmpty() { 15 | pop, _ := this.stack1.Pop() 16 | this.stack2.Push(pop) 17 | } 18 | 19 | this.stack1.Push(x) 20 | 21 | for !this.stack2.IsEmpty() { 22 | pop, _ := this.stack2.Pop() 23 | this.stack1.Push(pop) 24 | } 25 | } 26 | 27 | func (this *MyQueue) Pop() int { 28 | pop, _ := this.stack1.Pop() 29 | return pop 30 | } 31 | 32 | func (this *MyQueue) Peek() int { 33 | peek, _ := this.stack1.Peek() 34 | return peek 35 | } 36 | 37 | func (this *MyQueue) Empty() bool { 38 | return this.stack1.IsEmpty() 39 | } 40 | 41 | type Stack []int 42 | 43 | func (s *Stack) IsEmpty() bool { 44 | return len(*s) == 0 45 | } 46 | func (s *Stack) Push(num int) { 47 | *s = append(*s, num) 48 | } 49 | func (s *Stack) Len() int { 50 | return len(*s) 51 | } 52 | func (s *Stack) Pop() (int, bool) { 53 | if s.IsEmpty() { 54 | return 0, false 55 | } else { 56 | index := len(*s) - 1 57 | elem := (*s)[index] 58 | *s = (*s)[:index] 59 | return elem, true 60 | } 61 | } 62 | 63 | func (s *Stack) Peek() (int, bool) { 64 | if s.IsEmpty() { 65 | return 0, false 66 | } else { 67 | index := len(*s) - 1 68 | elem := (*s)[index] 69 | return elem, true 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /ImplementQueueUsingStacks/implement_queue_using_stacks.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/ImplementQueueUsingStacks/implement_queue_using_stacks.md -------------------------------------------------------------------------------- /ImplementstrStr/implement_strStr.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/ImplementstrStr/implement_strStr.md -------------------------------------------------------------------------------- /IncreasingTripletSubsequence/increasing_triplet_subsequence.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | func increasingTriplet(nums []int) bool { 6 | length := len(nums) 7 | if length < 3 { 8 | return false 9 | } 10 | 11 | first := nums[0] 12 | second := math.MaxInt32 13 | 14 | for i := 1; i < length; i++ { 15 | num := nums[i] 16 | if num > second { 17 | return true 18 | } else if num > first { 19 | second = num 20 | } else { 21 | first = num 22 | } 23 | } 24 | 25 | return false 26 | } 27 | -------------------------------------------------------------------------------- /InsertDeleteGetRandom-01/insert_delete_getrandom_O1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math/rand" 4 | 5 | type RandomizedSet struct { 6 | data []int 7 | size int /* store array size for faster process */ 8 | indexes map[int]int 9 | } 10 | 11 | func Constructor() RandomizedSet { 12 | return RandomizedSet{ 13 | data: []int{}, 14 | size: 0, 15 | indexes: map[int]int{}} 16 | } 17 | 18 | func (this *RandomizedSet) Insert(val int) bool { 19 | var ( 20 | ok bool 21 | ) 22 | 23 | if _, ok = this.indexes[val]; ok { 24 | return false 25 | } 26 | 27 | this.data = append(this.data, val) 28 | this.indexes[val] = this.size 29 | this.size++ 30 | 31 | return true 32 | } 33 | 34 | func (this *RandomizedSet) Remove(val int) bool { 35 | var ( 36 | index int 37 | ok bool 38 | ) 39 | 40 | if index, ok = this.indexes[val]; !ok { 41 | return false 42 | } 43 | 44 | this.size-- 45 | this.data[index] = this.data[this.size] 46 | this.indexes[this.data[this.size]] = index 47 | this.data = this.data[:this.size] 48 | delete(this.indexes, val) 49 | 50 | return true 51 | } 52 | 53 | func (this *RandomizedSet) GetRandom() int { 54 | return this.data[rand.Intn(this.size)] 55 | } 56 | -------------------------------------------------------------------------------- /InsertInterval/insert_interval.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func min(a, b int) int { 6 | if a <= b { 7 | return a 8 | } 9 | return b 10 | } 11 | 12 | func max(a, b int) int { 13 | if a >= b { 14 | return a 15 | } 16 | return b 17 | } 18 | 19 | func insert(intervals [][]int, newInterval []int) [][]int { 20 | idx := sort.Search(len(intervals), func(i int) bool { 21 | return intervals[i][1] >= newInterval[0] 22 | }) 23 | idx2 := sort.Search(len(intervals), func(i int) bool { 24 | return intervals[i][0] > newInterval[1] 25 | }) 26 | if idx == idx2 && (idx == len(intervals) || newInterval[1] < intervals[idx][0]) { 27 | result := make([][]int, len(intervals)+1) 28 | copy(result, intervals[:idx]) 29 | result[idx] = newInterval 30 | copy(result[idx+1:], intervals[idx:]) 31 | return result 32 | } 33 | intervals[idx][0] = min(intervals[idx][0], newInterval[0]) 34 | intervals[idx][1] = max(intervals[idx2-1][1], newInterval[1]) 35 | if diff := idx2 - idx; diff > 1 { 36 | copy(intervals[idx+1:], intervals[idx2:]) 37 | intervals = intervals[:len(intervals)-(diff-1)] 38 | } 39 | return intervals 40 | } 41 | -------------------------------------------------------------------------------- /IntegerToRoman/integer_to_roman.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strings" 4 | 5 | type tuple struct { 6 | char string 7 | val int 8 | } 9 | 10 | func intToRoman(num int) string { 11 | 12 | //Step1: Store roman characters along with the corresponding value in decreasing order of the integer value 13 | slice := make([]tuple, 13) 14 | slice[0] = tuple{"M", 1000} 15 | slice[1] = tuple{"CM", 900} 16 | slice[2] = tuple{"D", 500} 17 | slice[3] = tuple{"CD", 400} 18 | slice[4] = tuple{"C", 100} 19 | slice[5] = tuple{"XC", 90} 20 | slice[6] = tuple{"L", 50} 21 | slice[7] = tuple{"XL", 40} 22 | slice[8] = tuple{"X", 10} 23 | slice[9] = tuple{"IX", 9} 24 | slice[10] = tuple{"V", 5} 25 | slice[11] = tuple{"IV", 4} 26 | slice[12] = tuple{"I", 1} 27 | 28 | var res strings.Builder 29 | //Step2: Loop through the slice, and divide the number to get the count. 30 | //Repeat the corresponding roman character by count in the result string. 31 | //Take the remainder and repeat the loop 32 | for i := 0; i < 13; i++ { 33 | count := num / slice[i].val 34 | if count > 0 { 35 | str := strings.Repeat(slice[i].char, count) 36 | res.WriteString(str) 37 | } 38 | num = num % slice[i].val 39 | //Optimization: once num becomes 0, break out of the loop 40 | if num == 0 { 41 | break 42 | } 43 | } 44 | 45 | return res.String() 46 | } 47 | -------------------------------------------------------------------------------- /InterleavingString/interleaving_string.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func isInterleave(s1 string, s2 string, s3 string) bool { 4 | m, n, k := len(s1), len(s2), len(s3) 5 | if m+n != k { 6 | return false 7 | } 8 | 9 | dp1 := 1 10 | for i := 1; i <= n; i++ { 11 | if s2[i-1] == s3[i-1] && dp1&1 == 1 { 12 | dp1 = (dp1 << 1) + 1 13 | } else { 14 | dp1 = dp1 << 1 15 | } 16 | } 17 | 18 | for j := 1; j <= m; j++ { 19 | dp2 := 0 20 | if s1[j-1] == s3[j-1] && dp1&(1< 0 { 16 | resultSet[num]++ 17 | } 18 | } 19 | 20 | var res []int 21 | 22 | for i := 0; i < 1001; i++ { 23 | if resultSet[i] > 0 { 24 | res = append(res, i) 25 | } 26 | } 27 | 28 | return res 29 | } 30 | 31 | // Solution - 2 32 | func interSection(nums1 []int, nums2 []int) []int { 33 | var result []int 34 | if nums1 == nil || nums2 == nil { 35 | return result 36 | } 37 | sort.Ints(nums1) 38 | sort.Ints(nums2) 39 | for i, j := 0, 0; i < len(nums1) && j < len(nums2); { 40 | if nums1[i] == nums2[j] { 41 | var size int = len(result) 42 | i++ 43 | j++ 44 | if size != 0 && result[size-1] == nums1[i-1] { 45 | continue 46 | } 47 | result = append(result, nums1[i-1]) 48 | } else if nums1[i] < nums2[j] { 49 | i++ 50 | } else { 51 | j++ 52 | } 53 | } 54 | return result 55 | } 56 | -------------------------------------------------------------------------------- /IntersectionOfTwoArraysII/intersection_of_two_arrays_II.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func intersect(nums1 []int, nums2 []int) []int { 6 | sort.Ints(nums1) 7 | sort.Ints(nums2) 8 | var result []int 9 | var left int = 0 10 | var right int = 0 11 | for left < len(nums1) && right < len(nums2) { 12 | if nums1[left] == nums2[right] { 13 | result = append(result, nums1[left]) 14 | left++ 15 | right++ 16 | } else if nums1[left] < nums2[right] { 17 | left++ 18 | } else { 19 | right++ 20 | } 21 | } 22 | return result 23 | } 24 | -------------------------------------------------------------------------------- /IntersectionOfTwoLinkedLists/intersection_of_two_linked_lists.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for singly-linked list. 4 | type ListNode struct { 5 | Val int 6 | Next *ListNode 7 | } 8 | 9 | func getIntersectionNode(headA, headB *ListNode) *ListNode { 10 | curA, curB := headA, headB 11 | 12 | // A, B will meet at either intersection node or Nil on the tail 13 | for curA != curB { 14 | 15 | if curA != nil { 16 | curA = curA.Next 17 | 18 | } else { 19 | // hop to headB if current A is Nil 20 | curA = headB 21 | } 22 | 23 | if curB != nil { 24 | curB = curB.Next 25 | } else { 26 | // hop to headA if current B is nil 27 | curB = headA 28 | } 29 | 30 | } 31 | 32 | return curA 33 | } 34 | -------------------------------------------------------------------------------- /InvertBinaryTree/invert_binary_tree.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for a binary tree node. 4 | type TreeNode struct { 5 | Val int 6 | Left *TreeNode 7 | Right *TreeNode 8 | } 9 | 10 | func invertTree(root *TreeNode) *TreeNode { 11 | stack := []*TreeNode{root} 12 | 13 | for len(stack) != 0 { 14 | pop := stack[len(stack)-1] 15 | stack = stack[:len(stack)-1] 16 | 17 | if pop != nil { 18 | pop.Right, pop.Left = pop.Left, pop.Right 19 | stack = append(stack, pop.Right, pop.Left) 20 | } 21 | 22 | } 23 | 24 | return root 25 | } 26 | -------------------------------------------------------------------------------- /IsomorphicStrings/isomorphic_strings.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func isIsomorphic(s string, t string) bool { 4 | if len(s) != len(t) { 5 | return false 6 | } 7 | 8 | m := make(map[byte]byte) 9 | mt := make(map[byte]byte) 10 | 11 | for i := 0; i < len(s); i++ { 12 | t1 := t[i] 13 | 14 | if value, ok := m[t1]; ok { 15 | if value != s[i] { 16 | return false 17 | } 18 | } else { 19 | m[t1] = s[i] 20 | } 21 | 22 | s1 := s[i] 23 | 24 | if value, ok := mt[s1]; ok { 25 | if value != t[i] { 26 | return false 27 | } 28 | } else { 29 | mt[s1] = t[i] 30 | } 31 | } 32 | 33 | return true 34 | } 35 | -------------------------------------------------------------------------------- /JumpGameII/jump_game_ii.dart: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 4 | -* 45. Jump Game II *- 5 | 6 | You are given a 0-indexed array of integers nums of length n. You are initially positioned at nums[0]. 7 | 8 | Each element nums[i] represents the maximum length of a forward jump from index i. In other words, if you are at nums[i], you can jump to any nums[i + j] where: 9 | 10 | 0 <= j <= nums[i] and 11 | i + j < n 12 | Return the minimum number of jumps to reach nums[n - 1]. The test cases are generated such that you can reach nums[n - 1]. 13 | 14 | 15 | 16 | Example 1: 17 | 18 | Input: nums = [2,3,1,1,4] 19 | Output: 2 20 | Explanation: The minimum number of jumps to reach the last index is 2. Jump 1 step from index 0 to 1, then 3 steps to the last index. 21 | Example 2: 22 | 23 | Input: nums = [2,3,0,1,4] 24 | Output: 2 25 | 26 | 27 | Constraints: 28 | 29 | 1 <= nums.length <= 104 30 | 0 <= nums[i] <= 1000 31 | 32 | 33 | */ 34 | 35 | import 'dart:math'; 36 | 37 | class A { 38 | int jump(List nums) { 39 | int ans = 0; 40 | int size = nums.length; 41 | int currentEnd = 0; 42 | int currentFarthest = 0; 43 | 44 | for (int i = 0; i < size - 1; i++) { 45 | currentFarthest = max(currentFarthest, i + nums[i]); 46 | if (i == currentEnd) { 47 | ans++; 48 | currentEnd = currentFarthest; 49 | } 50 | } 51 | return ans; 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /JumpGameII/jump_game_ii.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func jump(nums []int) int { 4 | if len(nums) == 1 { 5 | return 0 6 | } 7 | var maximum int = 0 8 | var current int = 0 9 | var count int = 0 10 | for i := 0; i < len(nums)-1; i++ { 11 | maximum = max(maximum, i+nums[i]) 12 | if current == i { 13 | current = maximum 14 | count++ 15 | } 16 | if current > len(nums)-1 { 17 | return count 18 | } 19 | } 20 | return count 21 | } 22 | 23 | func max(a int, b int) int { 24 | if a > b { 25 | return a 26 | } 27 | return b 28 | } 29 | -------------------------------------------------------------------------------- /JumpGameII/jump_game_ii.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/JumpGameII/jump_game_ii.md -------------------------------------------------------------------------------- /KRadiusSubarrayAverages/k_radius_subarray_averages.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func getAverages(nums []int, k int) []int { 4 | n := len(nums) 5 | windowSize := 2*k + 1 6 | 7 | var windowSum int64 8 | result := make([]int, n) 9 | for i := 0; i < n; i++ { 10 | result[i]=-1 11 | windowSum += int64(nums[i]) 12 | 13 | if i >= windowSize { 14 | windowSum -= int64(nums[i-windowSize]) 15 | } 16 | 17 | if i >= windowSize-1 { 18 | result[i-k] = int(windowSum / int64(windowSize)) 19 | } 20 | } 21 | 22 | return result 23 | } 24 | -------------------------------------------------------------------------------- /KeysAndRooms/keys_and_rooms.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // func canVisitAllRooms(rooms [][]int) bool { 4 | // if len(rooms) == 0 { 5 | // return true 6 | // } 7 | // var visited []bool = make([]bool, len(rooms)) 8 | // depthFirstSearch(0, rooms, visited) 9 | // for i := 0; i < len(rooms); i++ { 10 | // if !visited[i] { 11 | // return false 12 | // } 13 | // } 14 | // return true 15 | // } 16 | 17 | // func depthFirstSearch(index int, rooms [][]int, visited []bool) { 18 | // visited[index] = true 19 | // for _, n := range rooms[index] { 20 | // if !visited[n] { 21 | // depthFirstSearch(n, rooms, visited) 22 | // } 23 | // } 24 | // } 25 | 26 | // breadth fist search 27 | func canVisitAllRooms(rooms [][]int) bool { 28 | visited := make([]bool, len(rooms)) 29 | visited[0] = true 30 | q := []int{0} 31 | locked := len(rooms) - 1 32 | 33 | for len(q) > 0 && locked != 0 { 34 | v := q[0] 35 | q = q[1:] 36 | 37 | for _, keys := range rooms[v] { 38 | if visited[keys] { 39 | continue 40 | } 41 | q = append(q, keys) 42 | visited[keys] = true 43 | locked-- 44 | } 45 | } 46 | 47 | return locked == 0 48 | } 49 | -------------------------------------------------------------------------------- /LargestPerimeterTriangle/largest_perimeter_triangle.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func largestPerimeter(nums []int) int { 6 | sort.Slice(nums, func(i, j int) bool { 7 | return nums[i] > nums[j] 8 | }) 9 | for i := 0; i < len(nums)-2; i++ { 10 | a := nums[i] 11 | b := nums[i+1] 12 | c := nums[i+2] 13 | if a < (b + c) { 14 | return a + b + c 15 | } 16 | } 17 | return 0 18 | } 19 | -------------------------------------------------------------------------------- /LeafSimilarTrees/leaf_similar_trees.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for a binary tree node. 4 | type TreeNode struct { 5 | Val int 6 | Left *TreeNode 7 | Right *TreeNode 8 | } 9 | 10 | func leafSimilar(root1 *TreeNode, root2 *TreeNode) bool { 11 | ch1, ch2 := make(chan int), make(chan int) 12 | // add third parameter to separate root node and intermediate nodes 13 | go iterate(root1, ch1, true) 14 | go iterate(root2, ch2, true) 15 | for true { 16 | v1, ok1 := <-ch1 17 | v2, ok2 := <-ch2 18 | // if the lengths are different, ok values will be different too 19 | if ok1 != ok2 || v1 != v2 { 20 | return false 21 | } 22 | // both channels are closed, we're done 23 | if !ok1 && !ok2 { 24 | return true 25 | } 26 | } 27 | return false 28 | } 29 | 30 | func iterate(node *TreeNode, ch chan int, isRoot bool) { 31 | if node == nil { 32 | if isRoot { 33 | close(ch) 34 | } 35 | return 36 | } 37 | if node.Left != nil { 38 | iterate(node.Left, ch, false) 39 | } 40 | if node.Right != nil { 41 | iterate(node.Right, ch, false) 42 | } 43 | if node.Left == nil && node.Right == nil { 44 | ch <- node.Val 45 | } 46 | // close channel after all leaves are visited 47 | if isRoot { 48 | close(ch) 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /LexicographicallySmallestEquivalentString/lexicographically_smallest_equivalent_string.go: -------------------------------------------------------------------------------- 1 | package main -------------------------------------------------------------------------------- /LexicographicallySmallestEquivalentString/lexicographically_smallest_equivalent_string.md: -------------------------------------------------------------------------------- 1 | # A 2 | 3 | ## Solution - Union Find 4 | 5 | ```dart 6 | class UnionFind { 7 | List parent = List.filled(26, 0); 8 | 9 | UnionFind() { 10 | for (int i = 0; i < 26; ++i) { 11 | parent[i] = i; 12 | } 13 | } 14 | 15 | int find(int a) { 16 | if (a != parent[a]) { 17 | parent[a] = find(parent[a]); 18 | } 19 | return parent[a]; 20 | } 21 | 22 | void union(int a, int b) { 23 | int parentA = find(a); 24 | int parentB = find(b); 25 | 26 | if (parentA == parentB) return; 27 | 28 | if (parentA < parentB) { 29 | parent[parentB] = parentA; 30 | } else { 31 | parent[parentA] = parentB; 32 | } 33 | } 34 | } 35 | 36 | /* ================================Solution===================================== */ 37 | 38 | class Solution { 39 | String smallestEquivalentString(String s1, String s2, String baseStr) { 40 | UnionFind uf = UnionFind(); 41 | for (int i = 0; i < s1.length; ++i) { 42 | uf.union(s1.codeUnitAt(i) - 'a'.codeUnitAt(0), 43 | s2.codeUnitAt(i) - 'a'.codeUnitAt(0)); 44 | } 45 | 46 | StringBuffer sb = StringBuffer(); 47 | for (String ch in baseStr.split("")) { 48 | sb.writeCharCode( 49 | ('a'.codeUnitAt(0) + uf.find(ch.codeUnitAt(0) - 'a'.codeUnitAt(0)))); 50 | } 51 | return sb.toString(); 52 | } 53 | } 54 | ```` 55 | -------------------------------------------------------------------------------- /LinkedListCycle/linked_list_cycle..go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for singly-linked list. 4 | type ListNode struct { 5 | Val int 6 | Next *ListNode 7 | } 8 | 9 | func hasCycle(head *ListNode) bool { 10 | if head == nil || head.Next == nil { 11 | return false 12 | } 13 | 14 | //set the 'mark' is over 10^5 15 | mark := 100001 16 | //marking 17 | head.Val = mark 18 | //move to next 19 | head = head.Next 20 | 21 | for head != nil && head.Next != nil { 22 | 23 | //When 'head' becomes the same as 'mark', it's Cycle. 24 | if head.Val == mark || head.Next.Val == mark { 25 | return true 26 | } 27 | 28 | //marking & move to next ( Two ahead ) 29 | head.Val = mark 30 | head = head.Next.Next 31 | 32 | } 33 | 34 | return false 35 | 36 | } 37 | -------------------------------------------------------------------------------- /LongestArithmeticSubsequence/longest_arithmetic_subsequence.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func longestArithSeqLength(nums []int) int { 6 | hash := make(map[int][]int) 7 | for i, num := range nums { 8 | hash[num] = append(hash[num], i) 9 | } 10 | 11 | maxCount := 0 12 | for i := 0; i < len(nums); i++ { 13 | for j := i + 1; j < len(nums); j++ { 14 | d := nums[j] - nums[i] 15 | ls := nums[j] 16 | cnt := 2 17 | li := j 18 | for ls >= 0 { 19 | v := hash[ls+d] 20 | if d == 0 { 21 | cnt = len(v) 22 | break 23 | } 24 | ind := sort.Search(len(v), func(k int) bool { return v[k] > li }) 25 | if ind >= len(v) { 26 | break 27 | } 28 | cnt++ 29 | ls += d 30 | li = v[ind] 31 | } 32 | if cnt > maxCount { 33 | maxCount = cnt 34 | } 35 | } 36 | } 37 | return maxCount 38 | } 39 | -------------------------------------------------------------------------------- /LongestCommonSubsequence/longest_common_subsequence.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func longestCommonSubsequence(text1 string, text2 string) int { 4 | len1 := len(text1) 5 | len2 := len(text2) 6 | dp := make([][]int, len1+1) 7 | for i := range dp { 8 | dp[i] = make([]int, len2+1) 9 | } 10 | for i := 1; i <= len1; i++ { 11 | for j := 1; j <= len2; j++ { 12 | if text1[i-1] == text2[j-1] { 13 | dp[i][j] = dp[i-1][j-1] + 1 14 | } else { 15 | dp[i][j] = max(dp[i-1][j], dp[i][j-1]) 16 | } 17 | } 18 | } 19 | return dp[len1][len2] 20 | } 21 | 22 | func max(a, b int) int { 23 | if a > b { 24 | return a 25 | } 26 | return b 27 | } 28 | -------------------------------------------------------------------------------- /LongestPalindrome/longest_palindrome.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func longestPalindrome1(s string) int { 4 | frequency := make(map[string]int) 5 | length := 0 6 | 7 | // Count the frequency of each letter 8 | for i := 0; i < len(s); i++ { 9 | char := string(s[i]) 10 | frequency[char] = frequency[char] + 1 11 | } 12 | 13 | // Iterate through the frequency counts 14 | for _, count := range frequency { 15 | if count%2 == 0 { 16 | length += count 17 | } else { 18 | length += count - 1 19 | } 20 | } 21 | 22 | // Check for remaining letters with odd counts 23 | if length < len(s) { 24 | length += 1 25 | } 26 | 27 | return length 28 | } 29 | 30 | // type Solution struct{} 31 | 32 | func longestPalindrome(str string) int { 33 | count := make([]int, 256) 34 | odds := 0 35 | 36 | for _, char := range str { 37 | count[char]++ 38 | if count[char]&1 == 1 { 39 | odds++ 40 | } else { 41 | odds-- 42 | } 43 | } 44 | 45 | return len(str) - odds + boolToInt(odds > 0) 46 | } 47 | 48 | func boolToInt(b bool) int { 49 | if b { 50 | return 1 51 | } 52 | return 0 53 | } 54 | -------------------------------------------------------------------------------- /LongestPalindrome/longest_palindrome.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/LongestPalindrome/longest_palindrome.md -------------------------------------------------------------------------------- /LongestPalindromeByConcatenatingTwoLetterWords/longest_palindrome_by_concatenating_two_letter_words.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func longestPalindrome(words []string) int { 4 | freqMap := make(map[string]int) 5 | 6 | res := 0 7 | 8 | for _, word := range words { 9 | freqMap[word]++ 10 | } 11 | 12 | for word, freq := range freqMap { 13 | if word[0] == word[1] { 14 | if freq%2 == 0 { 15 | res += 2 * freq 16 | freqMap[word] = 0 17 | } else { 18 | res += 2 * (freq - 1) 19 | freqMap[word] = 1 20 | } 21 | 22 | continue 23 | } 24 | 25 | reversedWord := string([]byte{word[1], word[0]}) 26 | 27 | if reversedWordFre, ok := freqMap[reversedWord]; ok { 28 | m := min(freq, reversedWordFre) 29 | res += 4 * m 30 | 31 | freqMap[word] -= m 32 | freqMap[reversedWord] -= m 33 | } 34 | } 35 | 36 | for word, freq := range freqMap { 37 | if word[0] == word[1] && freq > 0 { 38 | res += 2 39 | break 40 | } 41 | } 42 | 43 | return res 44 | } 45 | 46 | func min(a, b int) int { 47 | if a < b { 48 | return a 49 | } 50 | 51 | return b 52 | } 53 | -------------------------------------------------------------------------------- /LongestPalindromeByConcatenatingTwoLetterWords/longest_palindrome_by_concatenating_two_letter_words.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/LongestPalindromeByConcatenatingTwoLetterWords/longest_palindrome_by_concatenating_two_letter_words.md -------------------------------------------------------------------------------- /LongestPathWithDifferentAdjacentCharacters/longest_path_with_Different_adjacent_characters.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func longestPath(parent []int, s string) (max int) { 6 | gr := make([][]int, len(parent)) 7 | for ch := 1; ch < len(parent); ch++ { 8 | gr[parent[ch]] = append(gr[parent[ch]], ch) 9 | } 10 | dfs(0, gr, []byte(s), &max) 11 | return 12 | } 13 | 14 | func dfs(cur int, gr [][]int, s []byte, max *int) int { 15 | maxpq := []int{} 16 | for _, ch := range gr[cur] { 17 | l := dfs(ch, gr, s, max) 18 | if s[cur] != s[ch] { 19 | maxpq = append(maxpq, l) 20 | } 21 | } 22 | sort.Ints(maxpq) 23 | locmax, retmax := 1, 1 24 | if len(maxpq) > 0 { 25 | locmax += maxpq[len(maxpq)-1] 26 | retmax += maxpq[len(maxpq)-1] 27 | } 28 | if len(maxpq) > 1 { 29 | locmax += maxpq[len(maxpq)-2] 30 | } 31 | 32 | if *max < locmax { 33 | *max = locmax 34 | } 35 | 36 | return retmax 37 | } 38 | -------------------------------------------------------------------------------- /LongestPathWithDifferentAdjacentCharacters/longest_path_with_Different_adjacent_characters.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/LongestPathWithDifferentAdjacentCharacters/longest_path_with_Different_adjacent_characters.md -------------------------------------------------------------------------------- /MajorityElement/majority_element.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /MajorityElement/majority_element.md: -------------------------------------------------------------------------------- 1 | # 🔥 Majority Element 🔥 || 2 Solutions || Simple Fast and Easy || with Explanation 2 | 3 | ## Solution - 1 4 | 5 | ```dart 6 | class Solution { 7 | // Runtime: 512 ms, faster than 58.33% of Dart online submissions for Majority Element. 8 | // Memory Usage: 147.1 MB, less than 66.67% of Dart online submissions for Majority Element. 9 | 10 | int majorityElement(List nums) { 11 | int n = nums.length; 12 | int majEle = nums[0]; 13 | int count = 1; 14 | 15 | for (int i = 1; i < n; i++) { 16 | if (nums[i] == majEle) { 17 | count++; 18 | } else { 19 | count--; 20 | if (count == 0) { 21 | majEle = nums[i]; 22 | count = 1; 23 | } 24 | } 25 | } 26 | 27 | return majEle; 28 | } 29 | } 30 | ``` 31 | 32 | ## Solution - 2 33 | 34 | ```dart 35 | class Solution { 36 | // Runtime: 505 ms, faster than 61.11% of Dart online submissions for Majority Element. 37 | // Memory Usage: 146.7 MB, less than 94.44% of Dart online submissions for Majority Element. 38 | int majorityElement(List nums) { 39 | int major = nums[0], count = 1; 40 | for (int i = 1; i < nums.length; i++) { 41 | if (count == 0) { 42 | count++; 43 | major = nums[i]; 44 | } else if (major == nums[i]) { 45 | count++; 46 | } else 47 | count--; 48 | } 49 | return major; 50 | } 51 | } 52 | ``` 53 | -------------------------------------------------------------------------------- /MaxPointsOnALine/max_points_on_a_line.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func maxPoints(points [][]int) int { 4 | ans := 1 5 | n := len(points) 6 | for i := 0; i < n-1; i++ { 7 | mp := make(map[float64]int) 8 | for j := i + 1; j < n; j++ { 9 | if points[j][1] == points[i][1] { 10 | mp[-90]++ 11 | } else { 12 | x := float64(points[j][0]-points[i][0]) / float64(points[j][1]-points[i][1]) 13 | mp[x]++ 14 | } 15 | } 16 | temp := 0 17 | for _, v := range mp { 18 | temp = max(temp, v+1) 19 | } 20 | ans = max(temp, ans) 21 | } 22 | return ans 23 | } 24 | 25 | func max(x, y int) int { 26 | if x > y { 27 | return x 28 | } 29 | return y 30 | } 31 | -------------------------------------------------------------------------------- /MaximalNetworkRank/maximal_network_rank.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/MaximalNetworkRank/maximal_network_rank.md -------------------------------------------------------------------------------- /MaximumDifferenceBetweenNodeAndAncestor/maximum_difference_between_node_and_ancestor.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for a binary tree node. 4 | type TreeNode struct { 5 | Val int 6 | Left *TreeNode 7 | Right *TreeNode 8 | } 9 | 10 | func maxAncestorDiff(root *TreeNode) int { 11 | res := 0 12 | if root == nil { 13 | return res 14 | } 15 | dfs(root, root.Val, root.Val, &res) 16 | 17 | return res 18 | } 19 | 20 | func dfs(root *TreeNode, minimum, maximum int, res *int) { 21 | if root == nil { 22 | return 23 | } 24 | minimum, maximum = min(root.Val, minimum), max(root.Val, maximum) 25 | *res = max(*res, maximum-minimum) 26 | 27 | dfs(root.Left, minimum, maximum, res) 28 | dfs(root.Right, minimum, maximum, res) 29 | } 30 | 31 | func min(a, b int) int { 32 | if a < b { 33 | return a 34 | } 35 | 36 | return b 37 | } 38 | 39 | func max(a, b int) int { 40 | if a > b { 41 | return a 42 | } 43 | 44 | return b 45 | } 46 | -------------------------------------------------------------------------------- /MaximumIceCreamBars/maximum_ice_cream_bars.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // func maxIceCream(costs []int, coins int) int { 6 | // sort.Ints(costs) 7 | // var size int = len(costs) 8 | // var answer int = 0 9 | // for i := 0; i < size; i++ { 10 | // if answer+costs[i] > coins { 11 | // return i 12 | // } 13 | // answer += costs[i] 14 | // } 15 | // return len(costs) 16 | // } 17 | func maxIceCream(costs []int, coins int) int { 18 | sort.Ints(costs) 19 | var result int = 0 20 | var sum int = 0 21 | for _, cost := range costs { 22 | sum += cost 23 | if sum > coins { 24 | return result 25 | } 26 | result++ 27 | if sum == coins { 28 | return result 29 | } 30 | } 31 | return result 32 | } 33 | -------------------------------------------------------------------------------- /MaximumLengthOfPairChain/maximum_length_of_pair_chain.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func findLongestChain(pairs [][]int) int { 6 | sort.Slice(pairs, func(i, j int) bool { 7 | return pairs[i][1] < pairs[j][1] 8 | }) 9 | 10 | count := 1 11 | pairEnd := pairs[0][1] 12 | 13 | for i := 1; i < len(pairs); i++ { 14 | if pairs[i][0] > pairEnd { 15 | count++ 16 | pairEnd = pairs[i][1] 17 | } 18 | } 19 | 20 | return count 21 | } 22 | -------------------------------------------------------------------------------- /MaximumLengthofRepeatedSubarray/maximum_length_of_repeated_subarray.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // DP 4 | // func findLength(A []int, B []int) int { 5 | // dp := make([][]int, len(A)+1) 6 | // for i := range dp { 7 | // dp[i] = make([]int, len(B)+1) 8 | // } 9 | // max := 0 10 | // for i, a := range A { 11 | // for j, b := range B { 12 | // if a == b { 13 | // dp[i+1][j+1] = dp[i][j] + 1 14 | // if dp[i+1][j+1] > max { 15 | // max = dp[i+1][j+1] 16 | // } 17 | // } 18 | // } 19 | // } 20 | // return max 21 | // } 22 | 23 | // Brute Force 24 | func findLength(A []int, B []int) int { 25 | maxLength := 0 26 | for i := 0; i < len(A); i++ { 27 | indexA := i 28 | indexB := 0 29 | current := 0 30 | for indexA < len(A) && indexB < len(B) { 31 | if A[indexA] == B[indexB] { 32 | current++ 33 | if current > maxLength { 34 | maxLength = current 35 | } 36 | } else { 37 | current = 0 38 | } 39 | indexA++ 40 | indexB++ 41 | } 42 | } 43 | for i := 0; i < len(B); i++ { 44 | indexA := 0 45 | indexB := i 46 | current := 0 47 | for indexA < len(A) && indexB < len(B) { 48 | if A[indexA] == B[indexB] { 49 | current++ 50 | if current > maxLength { 51 | maxLength = current 52 | } 53 | } else { 54 | current = 0 55 | } 56 | indexA++ 57 | indexB++ 58 | } 59 | } 60 | return maxLength 61 | } 62 | -------------------------------------------------------------------------------- /MaximumLevelSumOfABinaryTree/maximum_level_sum_of_a_binary_tree.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | func maxLevelSum(root *TreeNode) int { 10 | levelSums := make([]int, 100) 11 | height := 1 12 | 13 | dfs(root, 1, &levelSums, &height) 14 | 15 | maxSumLevel := 1 16 | for level := 2; level <= height; level++ { 17 | if levelSums[maxSumLevel] < levelSums[level] { 18 | maxSumLevel = level 19 | } 20 | } 21 | 22 | return maxSumLevel 23 | } 24 | 25 | func dfs(root *TreeNode, level int, levelSums *[]int, height *int) { 26 | if root == nil { 27 | return 28 | } 29 | 30 | if level > *height { 31 | *height = level 32 | } 33 | ensureCapacity(levelSums, *height) 34 | 35 | (*levelSums)[level] += root.Val 36 | 37 | dfs(root.Left, level+1, levelSums, height) 38 | dfs(root.Right, level+1, levelSums, height) 39 | } 40 | 41 | func ensureCapacity(levelSums *[]int, height int) { 42 | if height == len(*levelSums) { 43 | newLevelSums := make([]int, height<<1) 44 | copy(newLevelSums, *levelSums) 45 | *levelSums = newLevelSums 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /MaximumNumberOfCoinsYouCanGet/maximum_number_of_coins_you_can_get.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func maxCoins(piles []int) int { 6 | sort.Ints(piles) 7 | var n int = len(piles) 8 | var kt int = n / 3 9 | var i int = n - 2 10 | var ans int = 0 11 | 12 | for kt > 0 { 13 | kt-- 14 | ans += piles[i] 15 | i = i - 2 16 | } 17 | return ans 18 | } 19 | -------------------------------------------------------------------------------- /MaximumPerformanceofaTeam/maximum_performance_of_a_team.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/MaximumPerformanceofaTeam/maximum_performance_of_a_team.md -------------------------------------------------------------------------------- /MaximumProductOfSplittedBinaryTree/maximum_product_of_splitted_binary_tree.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for a binary tree node. 4 | type TreeNode struct { 5 | Val int 6 | Left *TreeNode 7 | Right *TreeNode 8 | } 9 | 10 | func maxProduct(root *TreeNode) int { 11 | pos := make([]int64, 0) 12 | sum := helper(root, &pos) 13 | mod := int64(1e9) + 7 14 | res := int64(0) 15 | for i := range pos { 16 | temp := int64(sum-pos[i]) * int64(pos[i]) 17 | res = max(res, temp) 18 | } 19 | return int(res % mod) 20 | } 21 | 22 | func helper(root *TreeNode, pos *[]int64) int64 { 23 | if root == nil { 24 | return 0 25 | } else { 26 | l := helper(root.Left, pos) 27 | r := helper(root.Right, pos) 28 | temp := l + r + int64(root.Val) 29 | *pos = append(*pos, temp) 30 | return temp 31 | } 32 | } 33 | func max(a, b int64) int64 { 34 | if a > b { 35 | return a 36 | } 37 | return b 38 | } 39 | -------------------------------------------------------------------------------- /MaximumProductOfSplittedBinaryTree/maximum_product_of_splitted_binary_tree.md: -------------------------------------------------------------------------------- 1 | # All DART Solution are Turning into STACK OVER FLOW 2 | 3 | BECAUSE DART Complied `ìnt` into JAVASCRIPT - That is ridiculous 4 | 5 | ## Disclaimer:- STACK OVER FLOW only if it run in browser because DART int type is not ```int``` according to JAVASCRIPT - Ridiculous 6 | -------------------------------------------------------------------------------- /MaximumProfitInJobScheduling/maximum_profit_in_job_scheduling.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func jobScheduling(startTime []int, endTime []int, profit []int) int { 6 | // Initialize jobs array 7 | type Job struct { 8 | start, end, profit int 9 | } 10 | jobs := make([]Job, len(startTime)) 11 | for i := 0; i < len(startTime); i++ { 12 | jobs[i] = Job{startTime[i], endTime[i], profit[i]} 13 | } 14 | // Sort it on start time 15 | sort.Slice(jobs, func(i, j int) bool { return jobs[i].start < jobs[j].start }) 16 | 17 | nonConflictingJob := func(i int) int { 18 | left, right := i+1, len(jobs)-1 19 | for left <= right { 20 | mid := (left + right) / 2 21 | if jobs[mid].start >= jobs[i].end { 22 | left, right = left, mid-1 23 | } else { 24 | left, right = mid+1, right 25 | } 26 | } 27 | return left 28 | } 29 | 30 | memo := make(map[int]int) // Profit that can be made at position 31 | var dfs func(int) int 32 | dfs = func(pos int) int { 33 | // Exit condition 34 | if pos == len(jobs) { 35 | return 0 36 | } 37 | // Memoized branch 38 | if ans, ok := memo[pos]; ok { 39 | return ans 40 | } 41 | // Work branch 42 | var ans int 43 | ans += jobs[pos].profit 44 | ans += dfs(nonConflictingJob(pos)) 45 | ans2 := dfs(pos + 1) 46 | if ans < ans2 { 47 | ans = ans2 48 | } 49 | memo[pos] = ans 50 | return ans 51 | } 52 | 53 | return dfs(0) 54 | } 55 | -------------------------------------------------------------------------------- /MaximumScorefromPerformingMultiplicationOperations/Maximum score_from_performing_multiplication_operations.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /MaximumSumCircularSubarray/maximum_sum_circular_subarray.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func maxSubarraySumCircular(nums []int) int { 4 | var totalSum int = 0 5 | var maxSum int = -30012 6 | var curMax int = 0 7 | var minSum int = 3012 8 | var curMin = 0 9 | for _, x := range nums { 10 | curMax = max(x, curMax+x) 11 | maxSum = max(maxSum, curMax) 12 | curMin = min(x, curMin+x) 13 | minSum = min(minSum, curMin) 14 | totalSum += x 15 | } 16 | if maxSum > 0 { 17 | return max(maxSum, totalSum-minSum) 18 | } else { 19 | return maxSum 20 | } 21 | } 22 | 23 | func max(a int, b int) int { 24 | if a > b { 25 | return a 26 | } else { 27 | return b 28 | } 29 | } 30 | func min(a int, b int) int { 31 | if a < b { 32 | return a 33 | } else { 34 | return b 35 | } 36 | } 37 | 38 | /* 39 | 40 | 41 | 42 | 43 | int totalSum = 0, maxSum = -30012, curMax = 0, minSum = 30012, curMin = 0; 44 | for (int x in nums) { 45 | curMax = max(x, curMax + x); //update the current max sub-array sum 46 | maxSum = max(maxSum, curMax); //update the overall max sub-array sum 47 | curMin = min(x, curMin + x); //update the current min sub-array sum 48 | minSum = min(minSum, curMin); //update the overall min sub-array sum 49 | totalSum += x; 50 | } 51 | return maxSum > 0 ? max(maxSum, totalSum - minSum) : maxSum; 52 | 53 | 54 | 55 | */ 56 | -------------------------------------------------------------------------------- /MaximumValueAtAGivenIndexInABoundedArray/maximum_value_at_a_given_index_in_a_bounded_array.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | func maxValue(n, index, maxSum int) int { 6 | maxSum -= n 7 | left := index + 1 8 | right := n - index 9 | 10 | small := min(left, right) 11 | large := max(left, right) 12 | 13 | a := s(large, large) + s(large, small) - large 14 | if maxSum >= a { 15 | return large + (maxSum-a)/n + 1 16 | } 17 | 18 | b := s(small, small)*2 - small 19 | if maxSum >= b { 20 | return small + findExtra(small*2, 1, maxSum-b) + 1 21 | } 22 | 23 | return findExtra(1, 2, maxSum) + 1 24 | } 25 | 26 | func s(h, l int) int { 27 | return (2*h - l + 1) * l / 2 28 | } 29 | 30 | func findExtra(start, increment, maxSum int) int { 31 | b := start*2/increment - 1 32 | c := 2 * maxSum / increment 33 | 34 | d := int(math.Sqrt(float64(b*b + 4*c))) 35 | n := (d - b) / 2 36 | return n 37 | } 38 | 39 | func min(a, b int) int { 40 | if a < b { 41 | return a 42 | } 43 | return b 44 | } 45 | 46 | func max(a, b int) int { 47 | if a > b { 48 | return a 49 | } 50 | return b 51 | } 52 | -------------------------------------------------------------------------------- /MeetingRooms/meeting_rooms.dart: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | -* Meeting Rooms *- 4 | 5 | 6 | Given an array of meeting time intervals consisting of start and end times[[s1,e1],[s2,e2],...](si< ei), determine if a person could attend all meetings. 7 | Example 1: 8 | Input: 9 | [[0,30],[5,10],[15,20]] 10 | Output: 11 | false 12 | Example 2: 13 | Input: 14 | [[7,10],[2,4]] 15 | 16 | Output: 17 | true 18 | 19 | */ 20 | 21 | // Definition for an interval. 22 | //import 'dart:core'; 23 | 24 | class Interval { 25 | int start; 26 | int end; 27 | 28 | Interval([this.start = 0, this.end = 0]); 29 | Interval.copy(int s, int e) 30 | : this.start = s, 31 | this.end = e; 32 | } 33 | 34 | class Solution { 35 | bool canAttendMeetings(List intervals) { 36 | intervals.sort( 37 | ((Interval i, Interval t) { 38 | return i.start - t.start; 39 | }), 40 | ); 41 | 42 | Interval? last = null; 43 | for (Interval i in intervals) { 44 | if (last != null && i.start < last.end) { 45 | return false; 46 | } 47 | last = i; 48 | } 49 | return true; 50 | } 51 | } 52 | 53 | class B { 54 | bool canAttendMeetings(List intervals) { 55 | intervals.sort( 56 | (a, b) => a.start - b.start, 57 | ); 58 | for (int i = 1; i < intervals.length; i++) 59 | if (intervals[i - 1].end > intervals[i].start) return false; 60 | return true; 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /MeetingRooms/meeting_rooms.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /MergeSortedArray/merge_sorted_array.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/MergeSortedArray/merge_sorted_array.md -------------------------------------------------------------------------------- /MiddleOfTheLinkedList/middle_of_the_linked_list.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for singly-linked list. 4 | type ListNode struct { 5 | Val int 6 | Next *ListNode 7 | } 8 | 9 | func middleNode(head *ListNode) *ListNode { 10 | var N int = 0 11 | var Temp *ListNode = head 12 | 13 | for Temp.Next != nil { 14 | Temp = Temp.Next 15 | N++ 16 | } 17 | var mid int 18 | if N%2 == 0 { 19 | mid = N / 2 20 | } else { 21 | mid = N/2 + 1 22 | } 23 | var node *ListNode = head 24 | var i int = 0 25 | for i < mid { 26 | node = node.Next 27 | i++ 28 | } 29 | return node 30 | } 31 | 32 | // ===== 2 33 | 34 | // func middleNode(head *ListNode) *ListNode { 35 | // var slow *ListNode = head 36 | // var fast *ListNode = head 37 | // for fast != nil && fast.Next != nil { 38 | // slow = slow.Next 39 | // fast = fast.Next.Next 40 | // } 41 | // return slow 42 | // } 43 | 44 | // ========== 3 45 | 46 | // func middleNode(head *ListNode) *ListNode { 47 | // var n int = 0 48 | // var current *ListNode = head 49 | // for current != nil { 50 | // n++ 51 | // current = current.Next 52 | // } 53 | // current = head 54 | // for i := 0; i < n/2; i++ { 55 | // current = current.Next 56 | // } 57 | // return current 58 | // } 59 | -------------------------------------------------------------------------------- /MinimizeTheMaximumDifferenceOfPairs/minimize_the_maximum_difference_of_pairs.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func solve(nums []int, mid int) int { 6 | pairs := 0 7 | for j := 0; j+1 < len(nums); j++ { 8 | if nums[j+1]-nums[j] <= mid { 9 | pairs++ 10 | j++ 11 | } 12 | } 13 | return pairs 14 | } 15 | 16 | func minimizeMax(nums []int, p int) int { 17 | sort.Ints(nums) 18 | sols := 0 19 | low, high := 0, nums[len(nums)-1] 20 | for low <= high { 21 | mid := (high + low) / 2 22 | pairs := solve(nums, mid) 23 | if pairs >= p { 24 | sols = mid 25 | high = mid - 1 26 | } else { 27 | low = mid + 1 28 | } 29 | } 30 | return sols 31 | } 32 | -------------------------------------------------------------------------------- /MinimizeTheMaximumDifferenceOfPairs/minimize_the_maximum_difference_of_pairs.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/MinimizeTheMaximumDifferenceOfPairs/minimize_the_maximum_difference_of_pairs.md -------------------------------------------------------------------------------- /MinimumAverageDifference/minimum_average_difference.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | func ToFloat64(in int) float64 { 6 | return float64(in) 7 | } 8 | func minimumAverageDifference(nums []int) int { 9 | // if there is only one element then itself would be the ans (index 0). 10 | if len(nums) == 1 { 11 | return 0 12 | } 13 | // finding total sum of vector (using int int to prevent overflow) 14 | var sum int = 0 15 | 16 | for _, a := range nums { 17 | sum += a 18 | } 19 | //initially left side sum will be zero and right side sum will be total sum 20 | var leftSum int = 0 21 | var rightSum int = sum 22 | // this will be used to keep track of minimum 23 | var avgDiff float64 24 | var mini int = -1 25 | var minIndex int = -1 26 | var n = len(nums) 27 | for i := 0; i < n-1; i++ { 28 | // increasing left sum and decreasing right sum 29 | leftSum += nums[i] 30 | rightSum -= nums[i] 31 | // finding avgDiff , (here (n-i-1) represents element count in right part, ans (i+1) in left part) 32 | avgDiff = math.Abs(ToFloat64((leftSum / (i + 1)) - (rightSum / (n - i - 1)))) 33 | //updating mini 34 | if mini == -1 { 35 | mini = int(avgDiff) 36 | minIndex = i 37 | } else if mini > int(avgDiff) { 38 | mini = int(avgDiff) 39 | minIndex = i 40 | } 41 | } 42 | // check for last element 43 | avgDiff = math.Round(ToFloat64(sum / n)) 44 | if mini > int(avgDiff) { 45 | mini = int(avgDiff) 46 | minIndex = n - 1 47 | } 48 | return minIndex 49 | } 50 | -------------------------------------------------------------------------------- /MinimumCostToCutAStick/minimum_cost_to_cut_a_stick.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "math" 6 | ) 7 | 8 | type Solution struct { 9 | set []int 10 | n int 11 | memo map[int]int 12 | } 13 | 14 | func minCost(n int, cuts []int) int { 15 | s := Solution{} 16 | s.set = make([]int, len(cuts)) 17 | copy(s.set, cuts) 18 | s.n = n 19 | s.memo = make(map[int]int) 20 | 21 | return s.helper(0, n) 22 | } 23 | 24 | func (s *Solution) helper(i, j int) int { 25 | key := i*(s.n+1) + j 26 | if val, ok := s.memo[key]; ok { 27 | return val 28 | } 29 | 30 | res := math.MaxInt32 31 | for _, c := range s.set { 32 | if c > i && c < j { 33 | res = min(res, (j-i)+s.helper(i, c)+s.helper(c, j)) 34 | } 35 | } 36 | 37 | if res == math.MaxInt32 { 38 | res = 0 39 | } 40 | s.memo[key] = res 41 | 42 | return res 43 | } 44 | 45 | func min(a, b int) int { 46 | if a < b { 47 | return a 48 | } 49 | return b 50 | } 51 | 52 | func main() { 53 | n := 9 54 | cuts := []int{5, 6, 1, 4, 2} 55 | fmt.Println(minCost(n, cuts)) 56 | } 57 | -------------------------------------------------------------------------------- /MinimumDeletionsToMakeCharacterFrequenciesUnique/minimum_deletions_to_make_character_frequencies_unique.md: -------------------------------------------------------------------------------- 1 | # READ-HERE 2 | 3 | ## [GO](https://leetcode.com/problems/minimum-deletions-to-make-character-frequencies-unique/solutions/4034198/go-union-find-simple-fast-and-easy-with-explanation/) 4 | 5 | ## [DART](https://leetcode.com/problems/minimum-deletions-to-make-character-frequencies-unique/solutions/4034210/union-find-simple-fast-and-easy-with-explanation/) 6 | -------------------------------------------------------------------------------- /MinimumDifficultyOfAJobSchedule/minimum_difficulty_of_a_job_schedule.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | var mem [][]int 6 | 7 | func max(x, y int) int { 8 | if x > y { 9 | return x 10 | } 11 | return y 12 | } 13 | 14 | func min(x, y int) int { 15 | if x < y { 16 | return x 17 | } 18 | return y 19 | } 20 | 21 | func minDifficulty(jd []int, d int) int { 22 | if d > len(jd) { 23 | return -1 24 | } 25 | 26 | mem = make([][]int, len(jd)) 27 | for i := 0; i < len(mem); i++ { 28 | mem[i] = make([]int, d+1) 29 | for j := range mem[i] { 30 | mem[i][j] = -1 31 | } 32 | } 33 | 34 | return dp(jd, 0, d) 35 | } 36 | 37 | func dp(jd []int, start, day int) (ans int) { 38 | if mem[start][day] != -1 { 39 | return mem[start][day] 40 | } 41 | defer func() { mem[start][day] = ans }() 42 | 43 | if day == 1 { 44 | ans = jd[start] 45 | for i := start; i < len(jd); i++ { 46 | ans = max(jd[i], ans) 47 | } 48 | return 49 | } 50 | 51 | curMax := -1 52 | ans = math.MaxInt32 53 | for i := start; len(jd)-i > day-1; i++ { 54 | curMax = max(curMax, jd[i]) 55 | result := curMax + dp(jd, i+1, day-1) 56 | ans = min(ans, result) 57 | } 58 | return ans 59 | } 60 | -------------------------------------------------------------------------------- /MinimumFallingPathSum/minimum_falling_path_sum.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | func minFallingPathSum(A [][]int) int { 6 | m, n := len(A), len(A[0]) 7 | dp := make([][]int, m) 8 | for i := 0; i < m; i++ { 9 | dp[i] = make([]int, n) 10 | for j := 0; j < n; j++ { 11 | if i == 0 { 12 | dp[i][j] = A[i][j] 13 | } else { 14 | min := math.MaxInt32 15 | offset := []int{-1, 0, 1} 16 | for k := 0; k < len(offset); k++ { 17 | if j+offset[k] < n && j+offset[k] >= 0 && dp[i-1][j+offset[k]] < min { 18 | min = dp[i-1][j+offset[k]] 19 | } 20 | } 21 | dp[i][j] = A[i][j] + min 22 | } 23 | } 24 | } 25 | res := math.MaxInt32 26 | for i := 0; i < n; i++ { 27 | if dp[m-1][i] < res { 28 | res = dp[m-1][i] 29 | } 30 | } 31 | return res 32 | } 33 | -------------------------------------------------------------------------------- /MinimumFuelCostToReportToTheCapital/minimum_fuel_cost_to_report_to_the_capital.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func minimumFuelCost(roads [][]int, seats int) int64 { 4 | adjList := make([][]int, len(roads)+1) 5 | for i := range roads { 6 | a, b := roads[i][0], roads[i][1] 7 | adjList[a] = append(adjList[a], b) 8 | adjList[b] = append(adjList[b], a) 9 | } 10 | var fuel int64 11 | dfs(0, -1, adjList, seats, &fuel) 12 | return fuel 13 | } 14 | 15 | func dfs(city int, parent int, adjList [][]int, seats int, fuel *int64) int { 16 | numNodesInSubtree := 1 17 | for _, nextCity := range adjList[city] { 18 | if nextCity == parent { 19 | continue 20 | } 21 | numNodes := dfs(nextCity, city, adjList, seats, fuel) 22 | numNodesInSubtree += numNodes 23 | (*fuel) += int64(numNodes / seats) 24 | if numNodes%seats != 0 { 25 | (*fuel)++ 26 | } 27 | } 28 | return numNodesInSubtree 29 | } 30 | -------------------------------------------------------------------------------- /MinimumPenaltyForAShop/minimum_penalty_for_a_shop.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /* 4 | int yes = 0; 5 | final int n = customers.length; 6 | for (int i = 0; i < n; i++) { 7 | if (customers[i] == 'Y') yes++; 8 | } 9 | int ans = 0; 10 | int pen = yes; 11 | int no = 0; 12 | for (int i = 0; i < n; i++) { 13 | if (customers[i] == 'N') { 14 | no++; 15 | } else 16 | yes--; 17 | int currentPen = yes + no; 18 | if (currentPen < pen) { 19 | ans = i + 1; 20 | pen = currentPen; 21 | } 22 | } 23 | return ans; 24 | 25 | 26 | */ 27 | 28 | func bestClosingTime(customers string) int { 29 | var yes int = 0 30 | var n int = len(customers) 31 | for i := 0; i < n; i++ { 32 | if customers[i] == 'Y' { 33 | yes++ 34 | } 35 | } 36 | var ans int = 0 37 | var pen int = yes 38 | var no int = 0 39 | for i := 0; i < n; i++ { 40 | if customers[i] == 'N' { 41 | no++ 42 | } else { 43 | yes-- 44 | } 45 | var currentPen int = yes + no 46 | if currentPen < pen { 47 | ans = i + 1 48 | pen = currentPen 49 | } 50 | } 51 | 52 | return ans 53 | } 54 | -------------------------------------------------------------------------------- /MinimumReplacementsToSortTheArray/minimum_replacements_to_sort_the_array.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func minimumReplacement(nums []int) int64 { 4 | n := len(nums) 5 | 6 | if n == 1 { 7 | return 0 8 | } 9 | 10 | return helper(n-1, nums, 0, n) 11 | } 12 | 13 | func helper(index int, nums []int, min int, n int) int64 { 14 | if index == n-1 { 15 | return helper(index-1, nums, nums[index], n) 16 | } else { 17 | ec := 0 18 | if nums[index] > min { 19 | if nums[index]%min == 0 { 20 | ec = nums[index] / min 21 | } else { 22 | ec = nums[index]/min + 1 23 | } 24 | 25 | nMin := nums[index] / ec 26 | lc := int64(ec) 27 | 28 | if index == 0 { 29 | return lc - 1 30 | } else { 31 | return lc - 1 + helper(index-1, nums, nMin, n) 32 | } 33 | } else { 34 | if index == 0 { 35 | return 0 36 | } else { 37 | return helper(index-1, nums, nums[index], n) 38 | } 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /MinimumReplacementsToSortTheArray/minimum_replacements_to_sort_the_array.md: -------------------------------------------------------------------------------- 1 | # 2 | -------------------------------------------------------------------------------- /MinimumRoundsToCompleteAllTasks/minimum_rounds_to_complete_all_tasks.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | var mem = map[int]int{} 4 | 5 | func steps(n int) int { 6 | if n <= 1 { 7 | return -1 8 | } 9 | if ret, ok := mem[n]; ok { 10 | return ret 11 | } 12 | if n == 2 { 13 | return 1 14 | } 15 | if n%3 == 0 { 16 | mem[n] = n / 3 17 | return n / 3 18 | } 19 | out := 1 + steps(n-2) 20 | mem[n] = out 21 | return out 22 | } 23 | 24 | func minimumRounds(tasks []int) int { 25 | dic := map[int]int{} 26 | for _, t := range tasks { 27 | dic[t]++ 28 | } 29 | out := 0 30 | for _, n := range dic { 31 | s := steps(n) 32 | if s == -1 { 33 | return -1 34 | } 35 | out += s 36 | } 37 | return out 38 | } 39 | -------------------------------------------------------------------------------- /MinimumSpeedToArriveOnTime/minimum_speed_to_arrive_on_time.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | func isPossible(dist []int, speed int, hour float64) bool { 6 | var ans float64 7 | for i := 0; i < len(dist); i++ { 8 | d := float64(dist[i]) / float64(speed) 9 | if i != len(dist)-1 { 10 | ans += math.Ceil(d) 11 | } else { 12 | ans += d 13 | } 14 | if ans > hour { 15 | return false 16 | } 17 | } 18 | return ans <= hour 19 | } 20 | 21 | func minSpeedOnTime(dist []int, hour float64) int { 22 | i := 1 23 | j := int(1e7) 24 | var minSpeed = -1 // Initialize minSpeed to -1 25 | for i <= j { 26 | mid := i + (j-i)/2 27 | if isPossible(dist, mid, hour) { 28 | minSpeed = mid 29 | j = mid - 1 30 | } else { 31 | i = mid + 1 32 | } 33 | } 34 | return minSpeed 35 | } 36 | 37 | /* 38 | import "math" 39 | 40 | func minSpeedOnTime(dist []int, hour float64) int { 41 | n := len(dist) 42 | if hour <= float64(n-1) { 43 | return -1 44 | } 45 | l, r := 1, int(1e7) 46 | for l < r { 47 | mid := l + (r-l)/2 48 | time := 0.0 49 | for i := 0; i < n-1; i++ { 50 | time += math.Ceil(float64(dist[i]) / float64(mid)) 51 | } 52 | time += float64(dist[n-1]) / float64(mid) 53 | 54 | if time <= hour { 55 | r = mid 56 | } else { 57 | l = mid + 1 58 | } 59 | } 60 | return l 61 | } 62 | */ 63 | func ceil(x, y int) int { 64 | div, rem := x/y, x%y 65 | if rem > 0 { 66 | div++ 67 | } 68 | return div 69 | } 70 | -------------------------------------------------------------------------------- /MinimumSpeedToArriveOnTime/minimum_speed_to_arrive_on_time.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/MinimumSpeedToArriveOnTime/minimum_speed_to_arrive_on_time.md -------------------------------------------------------------------------------- /MinimumTimeToCollectAllApplesInATree/minimum_time_to_collect_all_apples_in_a_tree.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func minTime(n int, edges [][]int, hasApple []bool) int { 4 | graph := make([][]int, n) 5 | for _, edge := range edges { 6 | graph[edge[0]] = append(graph[edge[0]], edge[1]) 7 | graph[edge[1]] = append(graph[edge[1]], edge[0]) 8 | } 9 | 10 | out := 0 11 | visited := make([]bool, n) 12 | visited[0] = true 13 | for _, node := range graph[0] { 14 | out += traverse(graph, node, hasApple, visited) 15 | } 16 | return out 17 | } 18 | 19 | func traverse(graph [][]int, node int, hasApple []bool, visited []bool) int { 20 | out := 0 21 | visited[node] = true 22 | for _, n := range graph[node] { 23 | if !visited[n] { 24 | out += traverse(graph, n, hasApple, visited) 25 | } 26 | } 27 | if hasApple[node] || out != 0 { 28 | out += 2 29 | } 30 | return out 31 | } 32 | -------------------------------------------------------------------------------- /MinimumTimeToMakeRopeColorful/minimum_time_to_make_rope_colorful.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func minCost(colors string, neededTime []int) int { 6 | res := 0 7 | r := 0 8 | for i := 1; i < len(colors); i++ { 9 | if colors[i-1] == colors[i] { 10 | r, i = findSame(i-1, colors, neededTime) 11 | res += r 12 | continue 13 | } 14 | 15 | } 16 | return res 17 | } 18 | 19 | func findSame(idx int, s string, neededTime []int) (rs int, ix int) { 20 | i := idx 21 | res := 0 22 | for i < len(s)-1 { 23 | if s[i+1] != s[i] { 24 | break 25 | } 26 | i++ 27 | } 28 | 29 | same := neededTime[idx : i+1] 30 | sort.Ints(same) 31 | 32 | for i := 0; i < len(same)-1; i++ { 33 | res += same[i] 34 | } 35 | 36 | return res, i + 1 37 | } 38 | -------------------------------------------------------------------------------- /MinimumWindowSubstring/minimum_window_substring.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func minWindow(s string, t string) string { 4 | rem := 0 5 | counter := make(map[byte]int) 6 | for i := range t { 7 | rem++ 8 | counter[t[i]]++ 9 | } 10 | if rem > len(s) { 11 | return "" 12 | } 13 | var ret = string(make([]byte, len(s))) 14 | start, end := 0, 0 15 | for end < len(s) { 16 | if v, ok := counter[s[end]]; ok { 17 | if v > 0 { 18 | rem-- 19 | } 20 | counter[s[end]]-- 21 | } 22 | for rem <= 0 { 23 | if len(ret) >= len(s[start:end+1]) { 24 | ret = s[start : end+1] 25 | } 26 | if _, ok := counter[s[start]]; ok { 27 | counter[s[start]]++ 28 | if counter[s[start]] > 0 { 29 | rem++ 30 | } 31 | } 32 | start++ 33 | } 34 | end++ 35 | } 36 | 37 | if ret == string(make([]byte, len(s))) { 38 | return "" 39 | } 40 | return ret 41 | } 42 | -------------------------------------------------------------------------------- /MissingNumber/missing_number.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func missingNumber(nums []int) int { 4 | var sum int = 0 5 | var total int = len(nums) * (len(nums) + 1) / 2 6 | for i := 0; i < len(nums); i++ { 7 | sum += nums[i] 8 | } 9 | return total - sum 10 | } 11 | -------------------------------------------------------------------------------- /MissingRanges/missing_ranges.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /MissingRanges/missing_ranges.md: -------------------------------------------------------------------------------- 1 | # 🔥 Dart || Missing Ranges ||Simple Fast Easy || with Explanation 2 | 3 | ```dart 4 | class Solution { 5 | List findMissingRanges(List nums, int lower, int upper) { 6 | // array to add ranges 7 | List result = []; 8 | // start at lower - 1 for edge case where lower === nums[0] 9 | int previous = lower - 1; 10 | // loop for nums.length times so we can compare the last value with upper 11 | for (int i = 0; i <= nums.length; i++) { 12 | // current number to compare to prev 13 | // when i === nums.length we will compare prev = nums[nums.length-1] and upper 14 | // the upper+1 is to account for nums[nums.length-1]===upper 15 | int current = (i < nums.length) ? nums[i] : upper + 1; 16 | // check if we need to add a range to the array 17 | if (previous + 1 <= current - 1) { 18 | // if equal then add any of the numbers to the array 19 | // if < than, then add the range string to the array 20 | result.add(previous + 1 == current - 1 21 | ? '${previous + 1}' 22 | : '${previous + 1}->${current - 1}'); 23 | } 24 | // set prev to compare in the next iteration 25 | previous = current; 26 | } 27 | return result; 28 | } 29 | } 30 | ``` 31 | -------------------------------------------------------------------------------- /MostStonesRemovedWithSameRowOrColumn/most_stones_removed_with_same_row_or_column.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func removeStones(stones [][]int) int { 4 | n := len(stones) 5 | parent := make([]int, n) 6 | for i := 0; i < n; i++ { 7 | parent[i] = i 8 | } 9 | 10 | for i := 0; i < n; i++ { 11 | for j := i + 1; j < n; j++ { 12 | s1, s2 := stones[i], stones[j] 13 | if s1[0] == s2[0] || s1[1] == s2[1] { 14 | pi, pj := find(parent, i), find(parent, j) 15 | parent[pj] = pi 16 | } 17 | } 18 | } 19 | 20 | res := 0 21 | for i := 0; i < n; i++ { 22 | if parent[i] == i { 23 | res++ 24 | } 25 | } 26 | 27 | return n - res 28 | } 29 | 30 | func find(parent []int, idx int) int { 31 | i := idx 32 | for parent[i] != i { 33 | i = parent[i] 34 | } 35 | parent[idx] = i 36 | return i 37 | } 38 | -------------------------------------------------------------------------------- /MoveZeroes/move_zeroes.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func moveZeroes(nums []int) { 4 | var left int = 0 5 | var right int = 1 6 | for left < len(nums) && right < len(nums) { 7 | if nums[left] == 0 && nums[right] != 0 { 8 | var temp int = nums[left] 9 | nums[left] = nums[right] 10 | nums[right] = temp 11 | } else if nums[left] == 0 && nums[right] == 0 { 12 | right++ 13 | } else if nums[left] != 0 { 14 | right++ 15 | left++ 16 | } else { 17 | left++ 18 | } 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /N-thTribonacciNumber/n_th_tribonacci_number.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // func tribonacci(n int) int { 4 | // if n == 0 { 5 | // return 0 6 | // } 7 | // if n == 1 || n == 2 { 8 | // return 1 9 | // } 10 | // var Tribonacci []int = make([]int, n+1) 11 | // Tribonacci[0] = 0 12 | // Tribonacci[1] = 1 13 | // Tribonacci[2] = 1 14 | // for i := 3; i < n+1; i++ { 15 | // Tribonacci[i] = Tribonacci[i-1] + Tribonacci[i-2] + Tribonacci[i-3] 16 | // } 17 | // return Tribonacci[n] 18 | // } 19 | 20 | // func tribonacci(n int) int { 21 | // if n == 0 { 22 | // return 0 23 | // } 24 | // if n == 1 || n == 2 { 25 | // return 1 26 | // } 27 | 28 | // var a int = 0 29 | // var b int = 1 30 | // var c int = 1 31 | // var d int = 0 32 | // for i := 3; i <= n; i++ { 33 | // d = a + b + c 34 | // a = b 35 | // b = c 36 | // c = d 37 | // } 38 | // return d 39 | // } 40 | 41 | func tribonacci(n int) int { 42 | if n == 0 { 43 | return 0 44 | } 45 | if n == 1 || n == 2 { 46 | return 1 47 | } 48 | return tribonacci(n-1) + tribonacci(n-2) + tribonacci(n-3) 49 | } 50 | -------------------------------------------------------------------------------- /NamingACompany/naming_a_company.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func distinctNames(ideas []string) int64 { 4 | count := make(map[rune]map[string]bool) 5 | for _, a := range ideas { 6 | firstLetter := []rune(a)[0] 7 | if _, ok := count[firstLetter]; !ok { 8 | count[firstLetter] = make(map[string]bool) 9 | } 10 | count[firstLetter][a[1:]] = true 11 | } 12 | res := 0 13 | for a, seta := range count { 14 | for b, setB := range count { 15 | if a >= b { 16 | continue 17 | } 18 | same := 0 19 | for s := range seta { 20 | if setB[s] { 21 | same++ 22 | } 23 | } 24 | res += (len(seta) - same) * (len(setB) - same) 25 | } 26 | } 27 | return int64(res * 2) 28 | } 29 | -------------------------------------------------------------------------------- /NearestExitFromEntranceInMaze/nearest_exit_from_entrance_in_maze.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type State struct { 4 | r, c, l int 5 | } 6 | 7 | func nearestExit(maze [][]byte, entrance []int) int { 8 | m, n := len(maze), len(maze[0]) 9 | q := []State{{entrance[0], entrance[1], 0}} 10 | v := make(map[State]struct{}) 11 | var state, vState State 12 | var rr, cc int 13 | d4 := [][]int{{1, 0}, {-1, 0}, {0, 1}, {0, -1}} 14 | 15 | for len(q) > 0 { 16 | state, q = q[0], q[1:] 17 | 18 | vState = State{state.r, state.c, 0} 19 | if _, ok := v[vState]; ok { 20 | continue 21 | } 22 | v[vState] = struct{}{} 23 | 24 | if (state.r == 0 || state.r == m-1 || state.c == 0 || state.c == n-1) && (state.r != entrance[0] || state.c != entrance[1]) { 25 | return state.l 26 | } 27 | 28 | for _, d := range d4 { 29 | rr, cc = state.r+d[0], state.c+d[1] 30 | if rr >= 0 && rr < m && cc >= 0 && cc < n && maze[rr][cc] == '.' { 31 | q = append(q, State{rr, cc, state.l + 1}) 32 | } 33 | } 34 | 35 | } 36 | 37 | return -1 38 | } 39 | -------------------------------------------------------------------------------- /NimGame/nim_game.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /NimGame/nim_game.md: -------------------------------------------------------------------------------- 1 | # 🔥 Nim Game 🔥 || || 3 Approaches Simple Fast and Easy || with Explanation 2 | 3 | ## Solution - 1 4 | 5 | ```dart 6 | class Solution { 7 | bool canWinNim(int n) { 8 | // if the remainder is not 0 because if there is remainder than nim will win 9 | return n % 4 != 0; 10 | } 11 | } 12 | ``` 13 | 14 | ## Solution - 2 Recursive 15 | 16 | ```dart 17 | class Solution { 18 | bool canWinNim(int n) { 19 | // if the number is less than zero or equal nothing to do here 20 | if (n <= 0) return false; 21 | // because we can pick 0-3 pick one time so true 22 | if (n == 1 || n == 2 || n == 3) return true; 23 | // recursive to see after picking 0,1,2,3 if there is something left we lost 24 | if (canWinNim(n - 1) && canWinNim(n - 2) && canWinNim(n - 3)) return false; 25 | return true; 26 | } 27 | } 28 | ``` 29 | 30 | ## Solution - 3 31 | 32 | ```dart 33 | class Solution { 34 | bool canWinNim(int n) { 35 | if (n >= 134882061) return n % 4 != 0; 36 | bool result = true; 37 | bool first = true; 38 | bool second = true; 39 | bool third = true; 40 | for (int i = 4; i <= n; i++) { 41 | result = (first && second && third) ? false : true; 42 | first = second; 43 | second = third; 44 | third = result; 45 | } 46 | return result; 47 | } 48 | } 49 | ``` 50 | -------------------------------------------------------------------------------- /Non-DecreasingSubsequences/non_decreasing_subsequences.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func findSubsequences(nums []int) (res [][]int) { 4 | var dfs func(int, []int) 5 | dfs = func(l int, sl []int) { 6 | if len(sl) > 1 { 7 | cp := make([]int, len(sl)) 8 | copy(cp, sl) 9 | res = append(res, cp) 10 | } 11 | seen := make(map[int]bool, len(nums)-l) 12 | for r := l; r < len(nums); r++ { 13 | if (l > 0 && nums[r] < nums[l-1]) || seen[nums[r]] { 14 | continue 15 | } 16 | seen[nums[r]] = true 17 | dfs(r+1, append(sl, nums[r])) 18 | } 19 | } 20 | 21 | dfs(0, []int{}) 22 | 23 | return res 24 | } 25 | -------------------------------------------------------------------------------- /Non-DecreasingSubsequences/non_decreasing_subsequences.md: -------------------------------------------------------------------------------- 1 | # 🔥 100% Fast 🔥 || Simple Fast and Easy || with Explanation 2 | 3 | ## Solution - 1 Depth first Search 4 | 5 | ### Approach 6 | 7 | Backtracking using HashSet 8 | 9 | ### Complexity 10 | 11 | #### - Time complexity : O(n.2^n) 12 | 13 | #### - Space complexity : O(n^2) 14 | 15 | ```dart 16 | class Solution { 17 | List> findSubsequences(List nums) { 18 | List> ans = []; 19 | // use a List to store the unique sub sequences 20 | dfs(nums, 0, [], ans); 21 | return ans; 22 | } 23 | 24 | void dfs(List nums, int s, List path, List> ans) { 25 | if (path.length > 1) ans.add(path.toList()); 26 | 27 | HashSet used = HashSet(); 28 | 29 | for (int i = s; i < nums.length; ++i) { 30 | if (used.contains(nums[i])) continue; 31 | // if the path is empty or the current element is greater than or equal to the last element in the path 32 | if (path.isEmpty || nums[i] >= path.last) { 33 | // add the current element to the used and recursively call dfs 34 | used.add(nums[i]); 35 | path.add(nums[i]); 36 | // recursively call dfs without adding the current element to the path 37 | dfs(nums, i + 1, path, ans); 38 | path.removeLast(); // remove the last element from the path before returning 39 | } 40 | } 41 | } 42 | } 43 | ``` 44 | -------------------------------------------------------------------------------- /NumberOf-1-Bits/number_of_1_bits.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /* 4 | int c = 0; 5 | while (nums != 0) { 6 | nums = (nums - 1 & nums); 7 | c++; 8 | } 9 | return c; 10 | } 11 | */ 12 | func hammingWeight(num uint32) int { 13 | var ret int 14 | for i := 0; i < 32; i++ { 15 | if num%2 == 1 { 16 | ret++ 17 | } 18 | num /= 2 19 | } 20 | return ret 21 | } 22 | -------------------------------------------------------------------------------- /NumberOfDiceRollsWithTargetSum/number_of_dice_rolls_with_target_sum.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // func solve(n int, k int, target int) int { 4 | // if n == 0 && target == 0 { 5 | // return 1 6 | // } 7 | 8 | // if n <= 0 || target <= 0 { 9 | // return 0 10 | // } 11 | 12 | // ans := 0 13 | // for i := 1; i <= k; i++ { 14 | // ans += solve(n-1, k, target-i) 15 | // } 16 | 17 | // return ans 18 | // } 19 | 20 | // func numRollsToTarget(n int, k int, target int) int { 21 | // return solve(n, k, target) 22 | // } 23 | 24 | func numRollsToTarget(n int, k int, target int) int { 25 | const mod int = 1e9 + 7 26 | var ans [1001]int 27 | for i := 1; i <= k; i++ { 28 | ans[i] = 1 29 | } 30 | for n--; n > 0; n-- { 31 | var last, sum = ans, 0 32 | for i := 1; i <= target; i++ { 33 | sum += last[i-1] 34 | if i-k-1 > 0 { 35 | sum -= last[i-k-1] 36 | } 37 | ans[i] = sum % mod 38 | } 39 | } 40 | return ans[target] 41 | } 42 | -------------------------------------------------------------------------------- /NumberOfNodesInTheSub-TreeWithTheSameLabel/number_of_nodes_in_the_sub_tree_with_the_same_label.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func countSubTrees(n int, edges [][]int, labels string) []int { 4 | var graph = make([][]int, n) 5 | for row := range graph { 6 | graph[row] = make([]int, 0) 7 | } 8 | 9 | for _, edge := range edges { 10 | graph[edge[0]] = append(graph[edge[0]], edge[1]) 11 | graph[edge[1]] = append(graph[edge[1]], edge[0]) 12 | } 13 | 14 | var visited = make([]bool, n) 15 | var ans = make([]int, n) 16 | dfs(0, graph, visited, &ans, labels) 17 | return ans 18 | } 19 | 20 | func dfs(currentNode int, graph [][]int, visited []bool, ans *[]int, labels string) []int { 21 | var cnt = make([]int, 26) 22 | if visited[currentNode] { 23 | return cnt 24 | } 25 | 26 | visited[currentNode] = true 27 | var currentChar byte = labels[currentNode] 28 | 29 | for i := 0; i < len(graph[currentNode]); i++ { 30 | sub := dfs(graph[currentNode][i], graph, visited, ans, labels) 31 | for j := 0; j < 26; j++ { 32 | cnt[j] += sub[j] 33 | } 34 | } 35 | 36 | cnt[currentChar-'a']++ 37 | (*ans)[currentNode] = cnt[currentChar-'a'] 38 | return cnt 39 | } 40 | -------------------------------------------------------------------------------- /NumberOfNodesInTheSub-TreeWithTheSameLabel/number_of_nodes_in_the_sub_tree_with_the_same_label.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/NumberOfNodesInTheSub-TreeWithTheSameLabel/number_of_nodes_in_the_sub_tree_with_the_same_label.md -------------------------------------------------------------------------------- /NumberOfWaysToReorderArrayToGetSameBst/number_of_ways_to_reorder_array_to_get_same_bst.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | var pascal [][]int 4 | 5 | func numOfWays() { 6 | 7 | // Initialize the Pascal triangle. 8 | for i := 0; i <= 100; i++ { 9 | pascal = append(pascal, make([]int, i+1)) 10 | for j := 0; j <= i; j++ { 11 | if j == 0 || j == i { 12 | pascal[i][j] = 1 13 | } else { 14 | pascal[i][j] = (pascal[i-1][j] + pascal[i-1][j-1]) % (1e9 + 7) 15 | } 16 | } 17 | } 18 | 19 | } 20 | 21 | func dfs(nums []int) int { 22 | n := len(nums) 23 | if n <= 2 { 24 | return 1 25 | } 26 | 27 | left := make([]int, 0) 28 | right := make([]int, 0) 29 | for i := 1; i < n; i++ { 30 | if nums[i] < nums[0] { 31 | left = append(left, nums[i]) 32 | } else { 33 | right = append(right, nums[i]) 34 | } 35 | } 36 | 37 | return (dfs(left) * pascal[n-1][len(left)]) % (1e9 + 7) * dfs(right) % (1e9 + 7) 38 | } 39 | -------------------------------------------------------------------------------- /NumberOfWaysToReorderArrayToGetSameBst/number_of_ways_to_reorder_array_to_get_same_bst.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/NumberOfWaysToReorderArrayToGetSameBst/number_of_ways_to_reorder_array_to_get_same_bst.md -------------------------------------------------------------------------------- /OddEvenLinkedList/odd_even_linked_list.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for singly-linked list. 4 | type ListNode struct { 5 | Val int 6 | Next *ListNode 7 | } 8 | 9 | func oddEvenList(head *ListNode) *ListNode { 10 | if head == nil || head.Next == nil { 11 | return head 12 | } 13 | var evenList *ListNode = &ListNode{Val: -1} 14 | var oddList *ListNode = &ListNode{Val: -1} 15 | var currentEven *ListNode = evenList 16 | var currentOdd *ListNode = oddList 17 | var current *ListNode = head 18 | var i int = 1 19 | for current != nil { 20 | if i%2 != 0 { 21 | currentOdd.Next = current 22 | currentOdd = current 23 | current = current.Next 24 | } else { 25 | currentEven.Next = current 26 | currentEven = current 27 | current = current.Next 28 | } 29 | i++ 30 | } 31 | currentOdd.Next = evenList.Next 32 | currentEven.Next = nil 33 | return oddList.Next 34 | } 35 | 36 | // func oddEvenList(head *ListNode) *ListNode { 37 | // if head == nil { 38 | // return head 39 | // } 40 | // oddNode := head 41 | // evenNode := head.Next 42 | // even := evenNode 43 | // for evenNode != nil && evenNode.Next != nil { 44 | // oddNode.Next = oddNode.Next.Next 45 | // evenNode.Next = evenNode.Next.Next 46 | // oddNode = oddNode.Next 47 | // evenNode = evenNode.Next 48 | // } 49 | // oddNode.Next = even 50 | // return head 51 | // } 52 | -------------------------------------------------------------------------------- /PalindromeNumber/palindrome_number.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/PalindromeNumber/palindrome_number.md -------------------------------------------------------------------------------- /PalindromePairs/demo.dart: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/PalindromePairs/demo.dart -------------------------------------------------------------------------------- /PalindromePairs/palindrome_pairs.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/PalindromePairs/palindrome_pairs.md -------------------------------------------------------------------------------- /PalindromePartitioning/palindrome_partitioning.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func partition(s string) [][]string { 4 | result := [][]string{} 5 | seq := make([]string, 0, len(s)) 6 | dfs(s, &result, seq) 7 | return result 8 | } 9 | 10 | func dfs(s string, result *[][]string, seq []string) { 11 | if len(s) == 0 { 12 | cp := make([]string, len(seq)) 13 | copy(cp, seq) 14 | *result = append(*result, cp) 15 | return 16 | } 17 | 18 | for i := 1; i <= len(s); i++ { 19 | subStr := s[:i] 20 | if isPalindrome(subStr) { 21 | dfs(s[i:], result, append(seq, subStr)) 22 | } 23 | } 24 | } 25 | 26 | func isPalindrome(s string) bool { 27 | l, r := 0, len(s)-1 28 | for l < r { 29 | if s[l] != s[r] { 30 | return false 31 | } 32 | l++ 33 | r-- 34 | } 35 | return true 36 | } 37 | -------------------------------------------------------------------------------- /PalindromePartitioning/palindrome_partitioning.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/PalindromePartitioning/palindrome_partitioning.md -------------------------------------------------------------------------------- /PartitionList/partition_list.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func merge(firstList *ListNode, secondList *ListNode, x int) *ListNode { 9 | if firstList == nil { 10 | return secondList 11 | } 12 | if secondList == nil { 13 | return firstList 14 | } 15 | 16 | newHead := &ListNode{Val: -9} 17 | temp := newHead 18 | 19 | for firstList != nil && secondList != nil { 20 | if firstList.Val < x { 21 | temp.Next = firstList 22 | firstList = firstList.Next 23 | } else if secondList.Val < x { 24 | temp.Next = secondList 25 | secondList = secondList.Next 26 | } else { 27 | break 28 | } 29 | temp = temp.Next 30 | } 31 | 32 | if firstList != nil { 33 | temp.Next = firstList 34 | for temp.Next != nil { 35 | temp = temp.Next 36 | } 37 | } 38 | 39 | if secondList != nil { 40 | temp.Next = secondList 41 | } 42 | 43 | return newHead.Next 44 | } 45 | 46 | func partition(head *ListNode, x int) *ListNode { 47 | if head == nil || head.Next == nil { 48 | return head 49 | } 50 | 51 | temp := head 52 | slow := head.Next 53 | fast := slow.Next 54 | 55 | for fast != nil && fast.Next != nil { 56 | temp = slow 57 | slow = slow.Next 58 | fast = fast.Next.Next 59 | } 60 | 61 | temp.Next = nil 62 | 63 | return merge(partition(head, x), partition(slow, x), x) 64 | } 65 | -------------------------------------------------------------------------------- /PartitionList/partition_list.md: -------------------------------------------------------------------------------- 1 | # DOC 2 | 3 | [GO](https://leetcode.com/problems/partition-list/solutions/3911577/go-merge-sort-simple-fast-and-easy-with-explanation/) 4 | 5 | [DART](https://leetcode.com/problems/partition-list/solutions/3911626/binary-tree-merge-sort-simple-fast-and-easy-with-explanation/) 6 | -------------------------------------------------------------------------------- /Pascal'sTriangle-II/pascals_riangle_II.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func getRow(r int) []int { 4 | var ans []int = make([]int, r+1) 5 | ans[0] = 1 6 | ans[r] = 1 7 | for i := 1; i <= r; i++ { 8 | ans[i] = ans[i-1] * (r - i + 1) / i 9 | } 10 | return ans 11 | } 12 | -------------------------------------------------------------------------------- /Pascal'sTriangle/pascals_triangle.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func generate(numRows int) [][]int { 4 | // Runtime: 0 ms, faster than 100.00% of Go online submissions for Pascal's Triangle. 5 | // Memory Usage: 2.1 MB, less than 55.27% of Go online submissions for Pascal's Triangle. 6 | ans := [][]int{{1}} 7 | 8 | for i := 0; i < numRows; i++ { 9 | v := make([]int, i+1) 10 | v[0] = 1 11 | v[i] = 1 12 | for j := 1; j < len(v)-1; j++ { 13 | v[j] = ans[i][j] + ans[i][j-1] 14 | } 15 | ans = append(ans, v) 16 | } 17 | return ans[1:] 18 | } 19 | -------------------------------------------------------------------------------- /PathSum/path_sum.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for a binary tree node. 4 | type TreeNode struct { 5 | Val int 6 | Left *TreeNode 7 | Right *TreeNode 8 | } 9 | 10 | // Runtime: 0 ms, faster than 100.00% of Go online submissions for Path Sum. 11 | // Memory Usage: 4.6 MB, less than 94.24% of Go online submissions for Path Sum. 12 | func hasPathSum(root *TreeNode, targetSum int) bool { 13 | if root == nil { 14 | return false 15 | } 16 | if root.Left == nil && root.Right == nil { 17 | return root.Val == targetSum 18 | } 19 | return hasPathSum(root.Left, targetSum-root.Val) || 20 | hasPathSum(root.Right, targetSum-root.Val) 21 | } 22 | -------------------------------------------------------------------------------- /PeakIndexInAMountainArray/peak_index_in_a_mountain_array.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func peakIndexInMountainArray(arr []int) int { 4 | return getPeak(len(arr)/2, arr, 0, len(arr)-1) 5 | } 6 | 7 | func getPeak(current int, arr []int, start int, end int) int { 8 | if arr[current] < arr[current+1] { 9 | start = current 10 | current = (start + end) / 2 11 | return getPeak(current, arr, start, end) 12 | } 13 | if arr[current] < arr[current-1] { 14 | end = current 15 | current = (end - start) / 2 16 | return getPeak(current/2, arr, start, end) 17 | } 18 | return current 19 | } 20 | -------------------------------------------------------------------------------- /PerfectSquares/perfect_squares.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | func numSquares(n int) int { 6 | // Four-square and three-square theorems. 7 | if isSquare(n) { 8 | return 1 9 | } 10 | for n&3 == 0 { // n % 4 == 0 11 | n >>= 2 // n /= 4 12 | } 13 | if n&7 == 7 { // n % 8 == 7 14 | return 4 15 | } 16 | 17 | // Check if the number can be decomposed into sum of two squares. 18 | for i := 1; i*i <= n; i++ { 19 | if isSquare(n - i*i) { 20 | return 2 21 | } 22 | } 23 | // Bottom case of three-square theorem. 24 | return 3 25 | } 26 | 27 | func isSquare(n int) bool { 28 | var squareRootN int = (int)(math.Sqrt(float64(n))) 29 | return squareRootN*squareRootN == n 30 | } 31 | -------------------------------------------------------------------------------- /PlusOne/plus_one.md: -------------------------------------------------------------------------------- 1 | # ✅ Dart | 100% faster | 0ms 🔥🔥 2 | -------------------------------------------------------------------------------- /PossibleBipartition/possible_bipartition.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func possibleBipartition(n int, dislikes [][]int) bool { 4 | var graph = make([][]int, n) 5 | 6 | for _, pair := range dislikes { 7 | i := pair[0] - 1 8 | j := pair[1] - 1 9 | graph[i] = append(graph[i], j) 10 | graph[j] = append(graph[j], i) 11 | } 12 | 13 | var colors = make([]int, n) 14 | 15 | for i := 0; i < n; i++ { 16 | if colors[i] == 0 && !isValid(&graph, &colors, i, 1) { 17 | return false 18 | } 19 | } 20 | 21 | return true 22 | } 23 | 24 | func isValid(graph *[][]int, colors *[]int, i int, color int) bool { 25 | if (*colors)[i] != 0 { 26 | return (*colors)[i] == color 27 | } 28 | 29 | (*colors)[i] = color 30 | 31 | for _, j := range (*graph)[i] { 32 | if (*colors)[i] == (*colors)[j] || !isValid(graph, colors, j, -color) { 33 | return false 34 | } 35 | } 36 | 37 | return true 38 | } 39 | -------------------------------------------------------------------------------- /PowOfXN/pow_of_x_n.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/PowOfXN/pow_of_x_n.md -------------------------------------------------------------------------------- /PowerOfFour/power_of_four.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func isPowerOfFour(n int) bool { 4 | if n <= 0 { 5 | return false 6 | } 7 | 8 | for n%4 == 0 { 9 | n /= 4 10 | } 11 | return n == 1 12 | } 13 | -------------------------------------------------------------------------------- /PowerOfFour/power_of_four.md: -------------------------------------------------------------------------------- 1 | # 🔥 Power of Four 🔥 || 4 Approaches || Simple Fast and Easy || with Explanation 2 | 3 | ## Solution - 1 4 | 5 | ```dart 6 | class Solution { 7 | bool isPowerOfFour(int n) { 8 | if (n <= 0) return false; 9 | while (n % 3 == 0) { 10 | n ~/= 3; 11 | } 12 | return n == 1; 13 | } 14 | } 15 | ``` 16 | 17 | ## Solution - 2 18 | 19 | ```dart 20 | class Solution { 21 | bool isPowerOfFour(int n) { 22 | if (n <= 1) return n == 1; 23 | return n % 4 == 0 && isPowerOfFour(n ~/ 4); 24 | } 25 | } 26 | ``` 27 | 28 | ## Solution - 3 29 | 30 | ```dart 31 | class Solution { 32 | bool isPowerOfFour(int n) { 33 | return (log(n) / log(4)) % 1 == 0; 34 | } 35 | } 36 | ``` 37 | 38 | ## Solution - 4 39 | 40 | ```dart 41 | class Solution { 42 | bool isPowerOfThree(int n) { 43 | if (n < 1) return false; 44 | String nBase4 = ""; 45 | while (n != 0) nBase4 += (n % 4).toString(); 46 | n ~/= 3; // conversion to base 3 47 | int i = 0; 48 | while (i < nBase4.length - 1) 49 | if (nBase4[i++] != '0') 50 | return false; // checking if all digits in base 3 converted number except first one are 0 51 | return nBase4[i] == '1'; // check if starting digit is 1 52 | } 53 | } 54 | ``` 55 | -------------------------------------------------------------------------------- /PowerOfThree/power_of_three.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func isPowerOfThree(n int) bool { 4 | if n <= 0 { 5 | return false 6 | } 7 | for n%3 == 0 { 8 | n /= 3 9 | } 10 | return n == 1 11 | } 12 | -------------------------------------------------------------------------------- /PowerOfTwo/power_of_two.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Runtime: 0 ms, faster than 100.00% of Go online submissions for Power of Two. 4 | // Memory Usage: 2.1 MB, less than 10.91% of Go online submissions for Power of Two. 5 | func isPowerOfTwo(n int) bool { 6 | return n > 0 && ((n & (n - 1)) == 0) 7 | } 8 | -------------------------------------------------------------------------------- /PowerOfTwo/power_of_two.md: -------------------------------------------------------------------------------- 1 | # 🔥 Power of Two 🔥 || 5 Solutions || Simple Fast and Easy || with Explanation 2 | 3 | ## Solution - 1 Bit Manipulation 4 | 5 | ```dart 6 | class Solution { 7 | 8 | bool isPowerOfTwo(int n) { 9 | return n > 0 && ((n & (n - 1)) == 0); 10 | } 11 | } 12 | ``` 13 | 14 | ## Solution - 2 Iterative 15 | 16 | ```dart 17 | class Solution { 18 | bool isPowerOfTwo(int n) { 19 | if (n <= 0) return false; 20 | while (n % 2 == 0) n ~/= 2; 21 | return n == 1; 22 | } 23 | } 24 | ``` 25 | 26 | ## Solution - 3 27 | 28 | ```dart 29 | class Solution { 30 | bool isPowerOfTwo(int n) { 31 | return n > 0 && (n == 1 || (n % 2 == 0 && isPowerOfTwo(n ~/ 2))); 32 | } 33 | } 34 | ``` 35 | 36 | ## Solution - 4 37 | 38 | ```dart 39 | class Solution { 40 | bool isPowerOfTwo(int n) { 41 | return n > 0 && (1073741824 % n == 0); 42 | } 43 | } 44 | ``` 45 | 46 | ## SOlution - 5 47 | 48 | ```go 49 | // Runtime: 0 ms, faster than 100.00% of Go online submissions for Power of Two. 50 | // Memory Usage: 2.1 MB, less than 10.91% of Go online submissions for Power of Two. 51 | func isPowerOfTwo(n int) bool { 52 | return n > 0 && ((n & (n - 1)) == 0) 53 | } 54 | ``` 55 | -------------------------------------------------------------------------------- /Pseudo-PalindromicPathsInABinaryTree/pseudo_palindromic_paths_in_a_binary_tree.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for a binary tree node. 4 | type TreeNode struct { 5 | Val int 6 | Left *TreeNode 7 | Right *TreeNode 8 | } 9 | 10 | func pseudoPalindromicPaths(root *TreeNode) int { 11 | bitMask, resCnt := 0, 0 12 | maskQueue, nodeQueue := []int{0}, []*TreeNode{root} 13 | curNode := root 14 | for len(nodeQueue) > 0 { 15 | curNode, nodeQueue = nodeQueue[0], nodeQueue[1:] 16 | bitMask, maskQueue = maskQueue[0], maskQueue[1:] 17 | if curNode.Left == nil && curNode.Right == nil { 18 | bitMask ^= 1 << curNode.Val 19 | if bitMask&(bitMask-1) == 0 { 20 | resCnt += 1 21 | } 22 | } 23 | if curNode.Left != nil { 24 | maskQueue = append(maskQueue, bitMask^(1< len(magazine) { 5 | return false 6 | } 7 | var freqMap [26]int 8 | 9 | for _, char := range magazine { 10 | freqMap[char-'a']++ 11 | } 12 | 13 | for _, char := range ransomNote { 14 | freqMap[char-'a']-- 15 | 16 | if freqMap[char-'a'] < 0 { 17 | return false 18 | } 19 | } 20 | 21 | return true 22 | } 23 | -------------------------------------------------------------------------------- /ReadNCharactersGivenRead4/read_n_characters_given_read4.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /RectangleArea/rectangle_area.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /* 4 | 5 | int computeArea( 6 | int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) { 7 | int a = (ax2 - ax1) * (ay2 - ay1); 8 | int b = (bx2 - bx1) * (by2 - by1); 9 | 10 | if (ax1 >= bx2 || ax2 <= bx1 || ay2 <= by1 || ay1 >= by2) return a + b; 11 | 12 | return (a + 13 | b - 14 | (min(bx2, ax2) - max(ax1, bx1)) * (min(ay2, by2) - max(ay1, by1))) 15 | .toInt(); 16 | } 17 | 18 | */ 19 | 20 | func computeArea(ax1 int, ay1 int, ax2 int, ay2 int, bx1 int, by1 int, bx2 int, by2 int) int { 21 | var a int = (ax2 - ax1) * (ay2 - ay1) 22 | var b int = (bx2 - bx1) * (by2 - by1) 23 | if ax1 >= bx2 || ax2 <= bx1 || ay2 <= by1 || ay1 >= by2 { 24 | return a + b 25 | } 26 | 27 | return a + 28 | b - 29 | (min(bx2, ax2)-max(ax1, bx1))*(min(ay2, by2)-max(ay1, by1)) 30 | } 31 | 32 | func min(a, b int) int { 33 | if a < b { 34 | return a 35 | } 36 | return b 37 | } 38 | 39 | func max(a, b int) int { 40 | if a > b { 41 | return a 42 | } 43 | return b 44 | } 45 | -------------------------------------------------------------------------------- /RemoveLinkedListElements/remove_linked_list_elements.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for singly-linked list. 4 | type ListNode struct { 5 | Val int 6 | Next *ListNode 7 | } 8 | 9 | func removeElements(head *ListNode, val int) *ListNode { 10 | if head == nil { 11 | return nil 12 | } 13 | head.Next = removeElements(head.Next, val) 14 | if head.Val == val { 15 | return head.Next 16 | } 17 | return head 18 | } 19 | -------------------------------------------------------------------------------- /RemoveNthNodeFromEndOfList/remove_nth_node_from_end_of_list.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for singly-linked list. 4 | type ListNode struct { 5 | Val int 6 | Next *ListNode 7 | } 8 | 9 | func removeNthFromEnd(head *ListNode, n int) *ListNode { 10 | dummy := new(ListNode) 11 | dummy.Next = head 12 | fast := head 13 | slow := dummy 14 | for i := 0; i < n; i++ { 15 | fast = fast.Next 16 | } 17 | 18 | for fast != nil { 19 | fast = fast.Next 20 | slow = slow.Next 21 | } 22 | 23 | slow.Next = slow.Next.Next 24 | 25 | return dummy.Next 26 | } 27 | -------------------------------------------------------------------------------- /RestoreIPAddresses/restore_ip_addresses.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func restoreOctets(s string, octetsNumber int8) []string { 4 | if len(s) == 0 { 5 | return nil 6 | } 7 | if octetsNumber == 1 { 8 | if (s[0] == '0' && len(s) != 1) || len(s) > 3 || (len(s) == 3 && (s[0] > '2' || (s[0] == '2' && (s[1]-'0')*10+s[2]-'0' > 55))) { 9 | return nil 10 | } 11 | return []string{s} 12 | } 13 | var result []string 14 | if s[0] == '0' { 15 | for _, s2 := range restoreOctets(s[1:], octetsNumber-1) { 16 | result = append(result, "0."+s2) 17 | } 18 | } else { 19 | num := 0 20 | for i := 0; i < len(s); i++ { 21 | num = num*10 + int(s[i]-'0') 22 | if num > 255 { 23 | break 24 | } 25 | for _, s2 := range restoreOctets(s[i+1:], octetsNumber-1) { 26 | result = append(result, s[:i+1]+"."+s2) 27 | } 28 | } 29 | } 30 | return result 31 | } 32 | 33 | func restoreIpAddresses(s string) []string { 34 | return restoreOctets(s, 4) 35 | } 36 | -------------------------------------------------------------------------------- /ReverseBits/reverse_bits.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Runtime: 0 ms, faster than 100.00% of Go online submissions for Reverse Bits. 4 | // Memory Usage: 2.5 MB, less than 99.52% of Go online submissions for Reverse Bits. 5 | func reverseBits(num uint32) uint32 { 6 | num = (num >> 16) | (num << 16) 7 | num = ((num & 0xff00ff00) >> 8) | ((num & 0x00ff00ff) << 8) 8 | num = ((num & 0xf0f0f0f0) >> 4) | ((num & 0x0f0f0f0f) << 4) 9 | num = ((num & 0xcccccccc) >> 2) | ((num & 0x33333333) << 2) 10 | num = ((num & 0xaaaaaaaa) >> 1) | ((num & 0x55555555) << 1) 11 | return num 12 | } 13 | -------------------------------------------------------------------------------- /ReverseInteger/reverse_integer.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | func reverse(x int) int { 6 | 7 | var neg bool 8 | if x < 0 { 9 | neg = true 10 | x = x * -1 11 | } 12 | 13 | revX := getReversed(x) 14 | if neg == true { 15 | return revX * -1 16 | } 17 | return revX 18 | } 19 | 20 | func getReversed(x int) int { 21 | var rev, lastDigit int 22 | for x > 0 { 23 | lastDigit = x % 10 24 | x = x / 10 25 | rev = rev*10 + lastDigit 26 | } 27 | if rev > (math.MaxInt32) { 28 | return 0 29 | } 30 | return rev 31 | } 32 | -------------------------------------------------------------------------------- /ReverseInteger/reverse_integer.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def reverse(self, x: int) -> int: 3 | neg = False 4 | if x < 0: 5 | neg = True 6 | x = abs(x) 7 | 8 | revX = getReversed(x) 9 | 10 | if neg: 11 | return -revX 12 | return revX 13 | 14 | def getReversed(x: int) -> int: 15 | rev = 0 16 | while x > 0: 17 | lastDigit = x % 10 18 | x //= 10 19 | rev = rev * 10 + lastDigit 20 | 21 | if rev > 2**31 - 1: 22 | return 0 23 | return rev 24 | -------------------------------------------------------------------------------- /ReverseLinkedList/reverse_linked_list.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for singly-linked list. 4 | type ListNode struct { 5 | Val int 6 | Next *ListNode 7 | } 8 | 9 | func reverseList(head *ListNode) *ListNode { 10 | // Runtime: 0 ms, faster than 100.00% of Go online submissions for Reverse Linked List. 11 | // Memory Usage: 2.6 MB, less than 77.80% of Go online submissions for Reverse Linked List. 12 | var previous, current *ListNode = nil, head 13 | for current != nil { 14 | previous, current, current.Next = current, current.Next, previous 15 | } 16 | return previous 17 | } 18 | -------------------------------------------------------------------------------- /ReverseString/reverse_string.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func reverseString(s []byte) { 4 | l, r := 0, len(s)-1 5 | for i := 0; i < len(s)/2; i++ { 6 | l = i 7 | r = len(s) - (i + 1) 8 | s[l], s[r] = s[r], s[l] 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /ReverseVowelsOfAString/reverse_vowels_of_a_string.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "unicode" 4 | 5 | // Time Complexity: O(N) 6 | // Space Complexity: O(N) 7 | 8 | // fun fact: 9 | // `Y` and `y` can be a vowel as well sometimes. 10 | // glad the problem statement defines it well 11 | func isVowel(c rune) bool { 12 | // alternatively, we can just check 13 | // return c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U' || 14 | // c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' 15 | c = unicode.ToLower(c) 16 | return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' 17 | } 18 | 19 | func reverseVowels(s string) string { 20 | ss := []rune(s) 21 | n := len(ss) 22 | l, r := 0, n-1 23 | for l < r { 24 | // find the index of the first vowel in the given range 25 | for l < r && !isVowel(ss[l]) { 26 | l += 1 27 | } 28 | // find the index of last vowel in the given range 29 | for r > l && !isVowel(ss[r]) { 30 | r -= 1 31 | } 32 | // swap ss[l] and ss[r] 33 | ss[l], ss[r] = ss[r], ss[l] 34 | // since we've processed the character ss[l], 35 | // we move the left pointer to the right 36 | l += 1 37 | // since we've processed the character ss[r], 38 | // we move the right pointer to the left 39 | r -= 1 40 | } 41 | return string(ss) 42 | } 43 | -------------------------------------------------------------------------------- /ReverseWordsInAString/reverse_words_in_a_string.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strings" 4 | 5 | func reverseWords(s string) string { 6 | var ans strings.Builder 7 | 8 | p1, p2 := len(s), len(s) 9 | 10 | for p1 >= 0 { 11 | p1-- 12 | 13 | if p1 >= 0 && s[p1] != ' ' { 14 | continue 15 | } 16 | 17 | if p1+1 == p2 { //to remove any trailing white spaces 18 | p2 = p1 19 | continue 20 | } 21 | 22 | if len(ans.String()) > 0 { // to add spaces between words but after the first word 23 | ans.WriteString(" ") 24 | } 25 | 26 | ans.WriteString(s[p1+1 : p2]) 27 | p2 = p1 28 | } 29 | 30 | return ans.String() 31 | } 32 | -------------------------------------------------------------------------------- /ReverseWordsInAString/reverse_words_in_a_string.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/ReverseWordsInAString/reverse_words_in_a_string.md -------------------------------------------------------------------------------- /ReverseWordsInAString_III/reverse_words_in_a_string_III.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strings" 4 | 5 | // func reverseWords(s string) string { 6 | // // split by space 7 | // w := strings.Split(s, " ") 8 | // // iterate each word 9 | // for k, v := range w { 10 | // // convert to bytes array 11 | // b := []byte(v) 12 | // // length of current word 13 | // n := len(v) 14 | // // for each word, we iterate n / 2 times 15 | // for i := 0; i < n/2; i++ { 16 | // // swap the characters 17 | // b[i], b[n-1-i] = b[n-1-i], b[i] 18 | // // w[k] here is the reversed version of v 19 | // w[k] = string(b) 20 | // } 21 | // } 22 | // // build the final string 23 | // return strings.Join(w, " ") 24 | // } 25 | 26 | func reverseWords(s string) string { 27 | byteArr := []byte(s) 28 | low, high := 0, len(byteArr)-1 29 | for low < high { 30 | tmp := byteArr[low] 31 | byteArr[low] = byteArr[high] 32 | byteArr[high] = tmp 33 | low++ 34 | high-- 35 | } 36 | 37 | arr := strings.Split(string(byteArr), " ") 38 | 39 | l, h := 0, len(arr)-1 40 | for l < h { 41 | t := arr[l] 42 | arr[l] = arr[h] 43 | arr[h] = t 44 | l++ 45 | h-- 46 | } 47 | 48 | return strings.Join(arr, " ") 49 | } 50 | -------------------------------------------------------------------------------- /SameTree/same_tree.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | // Time: O(n) where n = number of nodes 10 | func isSameTree(p *TreeNode, q *TreeNode) bool { 11 | if p == nil && q == nil { 12 | return true 13 | } 14 | if p == nil || q == nil || p.Val != q.Val { 15 | return false 16 | } 17 | return isSameTree(p.Left, q.Left) && isSameTree(p.Right, q.Right) 18 | } 19 | -------------------------------------------------------------------------------- /SameTree/same_tree.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/SameTree/same_tree.md -------------------------------------------------------------------------------- /SearchA2DMatrix/search_a_2d_matrix.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func search(v []int, target int) int { 4 | index := lowerBound(v, target) 5 | return index 6 | } 7 | 8 | func searchMatrix(matrix [][]int, target int) bool { 9 | n := len(matrix) 10 | m := len(matrix[0]) 11 | 12 | if n == 1 { 13 | j := search(matrix[0], target) 14 | if j == m { 15 | return false 16 | } 17 | return matrix[0][j] == target 18 | } 19 | 20 | col0 := make([]int, n) 21 | for i := 0; i < n; i++ { 22 | col0[i] = matrix[i][0] 23 | } 24 | 25 | i0 := search(col0, target) 26 | 27 | if i0 == n { 28 | j := search(matrix[i0-1], target) 29 | if j == m { 30 | return false 31 | } 32 | return matrix[i0-1][j] == target 33 | } else if col0[i0] == target { 34 | return true 35 | } else if i0 == 0 { 36 | return false 37 | } else { 38 | j := search(matrix[i0-1], target) 39 | if j == m { 40 | return false 41 | } 42 | return matrix[i0-1][j] == target 43 | } 44 | } 45 | 46 | func lowerBound(array []int, target int) int { 47 | left := 0 48 | right := len(array) 49 | for left < right { 50 | mid := left + (right-left)/2 51 | if array[mid] < target { 52 | left = mid + 1 53 | } else { 54 | right = mid 55 | } 56 | } 57 | return left 58 | } 59 | -------------------------------------------------------------------------------- /SearchA2DMatrix/search_a_2d_matrix.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/SearchA2DMatrix/search_a_2d_matrix.md -------------------------------------------------------------------------------- /SearchInRotatedSortedArrayIi/search_in_rotated_sorted_array_ii.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "sort" 5 | ) 6 | 7 | func search(nums []int, target int) bool { 8 | // Order the array in order to search 9 | ordered := append([]int{}, nums...) 10 | sort.Ints(ordered) 11 | 12 | init := 0 13 | end := len(ordered) - 1 14 | 15 | // To memoize the computed values 16 | memo := make(map[int]int) 17 | 18 | for { 19 | // Change the middle index based on the last init/end index value 20 | mid := (end + init) / 2 21 | 22 | // Memoize the computed indexes to avoid infinite loop 23 | // If they were computed before, it means the value does not exist in the array 24 | // If the value doesn't exist, break the loop and return false 25 | if _, ok := memo[mid]; ok { 26 | return false 27 | } else { 28 | memo[mid] = 0 29 | } 30 | 31 | // Regular binary search 32 | if ordered[mid] == target { 33 | return true 34 | } else if ordered[mid] < target { 35 | init = mid + 1 36 | } else { 37 | end = mid - 1 38 | } 39 | } 40 | } 41 | 42 | 43 | func searchONE(nums []int, target int) bool { 44 | for _, num := range nums { 45 | if num == target { 46 | return true 47 | } 48 | } 49 | return false 50 | } 51 | -------------------------------------------------------------------------------- /SearchInRotatedSortedArrayIi/search_in_rotated_sorted_array_ii.md: -------------------------------------------------------------------------------- 1 | # Doc 2 | 3 | ## [GO](https://leetcode.com/problems/search-in-rotated-sorted-array-ii/solutions/3890111/go-xor-memoization-simple-fast-and-easy-with-explanation/) 4 | 5 | ## [DART](https://leetcode.com/problems/search-in-rotated-sorted-array-ii/solutions/3890102/3-solutions-simple-fast-and-easy-with-explanation/) 6 | -------------------------------------------------------------------------------- /SetMismatch/set_mismatch.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // func findErrorNums(nums []int) []int { 4 | 5 | // var ans []int = make([]int, 0) 6 | // for i := 0; i < len(nums); i++ { 7 | // val := math.Abs(nums[i]) 8 | // ans[1] ^= (i + 1) ^ int(val) 9 | // if nums[val - 1] < 0 { 10 | 11 | // } 12 | 13 | // } 14 | // } 15 | 16 | func findErrorNums(nums []int) (res []int) { 17 | var a int 18 | for i, n := range nums { 19 | a ^= n // XOR once per number in nums 20 | a ^= i + 1 // XOR once per expected number 21 | } 22 | 23 | // find lowest bit, it belongs either to the missing or double value 24 | lowbit := a & -a 25 | b := a 26 | for i, n := range nums { 27 | // filter by low bit 28 | // this will skip either the missing or double value 29 | if n&lowbit > 0 { 30 | b ^= n 31 | } 32 | if (i+1)&lowbit > 0 { 33 | b ^= i + 1 34 | } 35 | } 36 | 37 | // XOR a with b to remove b from a 38 | a ^= b 39 | 40 | // At this stage, a and b are the double and missing values, but we don't 41 | // know which one is which! Do a final loop to figure out the return order. 42 | for _, n := range nums { 43 | if n == a { 44 | return []int{a, b} 45 | } 46 | if n == b { 47 | return []int{b, a} 48 | } 49 | } 50 | return nil 51 | } 52 | -------------------------------------------------------------------------------- /ShortestWordDistance/shortest_word_distance.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | /* 6 | 7 | int shortestDistance(List wordsDict, String word1, String word2) { 8 | int ans = double.maxFinite.toInt(), pos1 = -1, pos2 = -1; 9 | for (int i = 0; i < wordsDict.length; i++) { 10 | if (wordsDict[i] == word1) { 11 | pos1 = i; 12 | } 13 | if (wordsDict[i] == word2) { 14 | pos2 = i; 15 | } 16 | if (pos1 != -1 && pos2 != -1) { 17 | ans = min(ans, (pos1 - pos2).abs()); 18 | } 19 | } 20 | return ans; 21 | } 22 | */ 23 | 24 | func shortestDistance(wordsDict []string, word1 string, word2 string) int { 25 | ans := math.MaxInt32 26 | firstPosition := -1 27 | secondPosition := -1 28 | for i := 0; i < len(wordsDict); i++ { 29 | if wordsDict[i] == word1 { 30 | firstPosition = i 31 | } 32 | if wordsDict[i] == word2 { 33 | secondPosition = i 34 | } 35 | if firstPosition != -1 && secondPosition != -1 { 36 | ans = int(math.Min(float64(ans), math.Abs(float64(firstPosition)-float64(secondPosition)))) 37 | } 38 | } 39 | return ans 40 | 41 | } 42 | -------------------------------------------------------------------------------- /ShuffleTheArray/shuffle_the_array.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | func shuffle(nums []int, n int) []int { 6 | nums[0] *= -1 7 | for i := 1; i < len(nums); i++ { 8 | 9 | var j int = i 10 | var currentNumber int = nums[i] 11 | for nums[j] > 0 { 12 | var target int 13 | if j < n { 14 | target = j * 2 15 | } else { 16 | target = (j-n)*2 + 1 17 | } 18 | var temp int = nums[target] 19 | nums[target] = currentNumber 20 | currentNumber = temp 21 | nums[j] *= -1 22 | j = target 23 | } 24 | } 25 | for i := 0; i < len(nums); i++ { 26 | nums[i] = int(math.Abs(float64(nums[i]))) 27 | } 28 | return nums 29 | } 30 | -------------------------------------------------------------------------------- /SingleNumber/single_number.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func singleNumber(nums []int) int { 6 | var ones int = 0 7 | var twos int = 0 8 | 9 | for i := 0; i < len(nums); i++ { 10 | var number int = nums[i] 11 | ones ^= (number & ^twos) 12 | twos ^= (number & ^ones) 13 | } 14 | 15 | return ones 16 | } 17 | 18 | func anotherSingle(nums []int) int { 19 | var index int = len(nums) - 1 20 | sort.Ints(nums) 21 | var value int = 0 22 | for value < index { 23 | if nums[value] != nums[value+1] { 24 | return nums[value] 25 | } else { 26 | 27 | value += 2 28 | } 29 | if index%2 == 1 { 30 | return nums[index] 31 | } 32 | } 33 | return -1 34 | } 35 | -------------------------------------------------------------------------------- /SingleNumberII/single_number_ii.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /*--------------------- Bit Manipulation 4 | 5 | 6 | func singleNumber(nums []int) int { 7 | var ans int = 0 8 | 9 | for i := 0; i < 32; i++ { 10 | var sum int = 0 11 | for _, number := range nums { 12 | sum += (number >> i) & 1 13 | } 14 | sum %= 3 15 | ans |= (sum << i) 16 | } 17 | 18 | // Handle negative numbers 19 | if (ans & (1 << 31)) != 0 { 20 | ans = -(1 << 31) | (ans & ((1 << 31) - 1)) 21 | } 22 | 23 | return ans 24 | } 25 | 26 | */ 27 | 28 | func singleNumber(nums []int) int { 29 | var ones int = 0 30 | var twos int = 0 31 | 32 | for i := 0; i < len(nums); i++ { 33 | var number int = nums[i] 34 | ones ^= (number & ^twos) 35 | twos ^= (number & ^ones) 36 | } 37 | 38 | return ones 39 | } 40 | -------------------------------------------------------------------------------- /SnakesAndLadders/snakes_and_ladders.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /SortCharactersByFrequency/sort_characters_by_frequency.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "sort" 5 | "strings" 6 | ) 7 | 8 | // func frequencySort(s string) string { 9 | // l, ans := len(s), "" 10 | // F, S := make([]int, 128), make([]string, l+1) 11 | // for _, v := range s { 12 | // F[v]++ 13 | // } 14 | // for i, v := range F { 15 | // if v != 0 { 16 | // S[v] += strings.Repeat(string(rune(i)), v) 17 | // } 18 | // } 19 | // for i := l; i > 0; i-- { 20 | // if S[i] != "" { 21 | // ans += S[i] 22 | // } 23 | // } 24 | // return ans 25 | // } 26 | 27 | type Row struct { 28 | c byte 29 | n int 30 | } 31 | 32 | func frequencySort(s string) string { 33 | f := make([]int, 128) 34 | for i := 0; i < len(s); i++ { 35 | f[s[i]]++ 36 | } 37 | var table []Row 38 | var res string 39 | for i, v := range f { 40 | if v != 0 { 41 | table = append(table, Row{byte(i), v}) 42 | } 43 | } 44 | sort.Slice(table, func(i, j int) bool { 45 | return table[i].n > table[j].n 46 | }) 47 | for _, v := range table { 48 | res += strings.Repeat(string(v.c), v.n) 49 | // n := v.n 50 | // for n != 0 { 51 | // res += string(v.c) 52 | // n-- 53 | // } 54 | } 55 | return res 56 | } 57 | -------------------------------------------------------------------------------- /SortCharactersByFrequency/sort_characters_by_frequency.md: -------------------------------------------------------------------------------- 1 | # 🔥 Sort Characters By Frequency 🔥 || Simple Fast and Easy || with Explanation 2 | 3 | ## Solution - 1 4 | 5 | ```dart 6 | import 'dart:collection'; 7 | 8 | class Solution { 9 | String frequencySort(String s) { 10 | HashMap map = HashMap(); 11 | for (int i = 0; i < s.length; i++) { 12 | map[s[i]] = (map[s[i]] ?? 0) + 1; 13 | } 14 | // convert map into the list for comparison 15 | List> list = map.entries.toList(); 16 | 17 | // sorting the list for the elements 18 | list.sort((a, b) => b.value.compareTo(a.value)); 19 | 20 | StringBuffer sb = StringBuffer(); 21 | for (MapEntry e in list) { 22 | int i = e.value; 23 | while (i > 0) { 24 | sb.write(e.key); 25 | i--; 26 | } 27 | } 28 | return sb.toString(); 29 | } 30 | } 31 | ``` 32 | -------------------------------------------------------------------------------- /SplitLinkedListInParts/split_linked_list_in_parts.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for singly-linked list. 4 | type ListNode struct { 5 | Val int 6 | Next *ListNode 7 | } 8 | 9 | func splitListToParts(head *ListNode, k int) []*ListNode { 10 | current := head 11 | answer := make([]*ListNode, k) 12 | ptr := 0 13 | listLength := 0 14 | 15 | // Calculate the length of the linked list 16 | for current != nil { 17 | listLength++ 18 | current = current.Next 19 | } 20 | 21 | // Calculate the extra elements in some parts 22 | extra := listLength % k 23 | // Calculate the base length for each part 24 | partLength := listLength / k 25 | current = head 26 | 27 | for current != nil { 28 | answer[ptr] = current 29 | // Calculate the length of the current part 30 | currentLength := partLength 31 | if extra > 0 { 32 | currentLength++ 33 | extra-- 34 | } 35 | 36 | // Move the current pointer to the end of the current part 37 | for i := 0; i < currentLength-1; i++ { 38 | current = current.Next 39 | } 40 | 41 | // Disconnect the current part from the next part 42 | temp := current.Next 43 | current.Next = nil 44 | current = temp 45 | 46 | ptr++ 47 | } 48 | 49 | return answer 50 | } 51 | -------------------------------------------------------------------------------- /StringCompression-II/string_compression_II.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | type State struct { 6 | idx int 7 | lastChar byte 8 | lastCharCount int 9 | k int 10 | } 11 | 12 | func getLengthOfOptimalCompression(s string, k int) int { 13 | m := make(map[State]int) 14 | return dp(0, 'a'-1, 0, k, m, s) 15 | } 16 | 17 | func dp(idx int, lastChar byte, lastCharCount int, k int, m map[State]int, s string) int { 18 | state := State{idx, lastChar, lastCharCount, k} 19 | if v, ok := m[state]; ok { 20 | return v 21 | } 22 | 23 | if k < 0 { 24 | return math.MaxInt 25 | } 26 | 27 | if idx == len(s) { 28 | return 0 29 | } 30 | 31 | var keepChar int 32 | deleteChar := dp(idx+1, lastChar, lastCharCount, k-1, m, s) 33 | if s[idx] == lastChar { 34 | keepChar = dp(idx+1, lastChar, lastCharCount+1, k, m, s) 35 | if lastCharCount == 1 || lastCharCount == 9 || lastCharCount == 99 { 36 | keepChar++ 37 | } 38 | } else { 39 | keepChar = dp(idx+1, s[idx], 1, k, m, s) + 1 40 | } 41 | 42 | minV := min(keepChar, deleteChar) 43 | m[state] = minV 44 | return minV 45 | } 46 | 47 | func min(x, y int) int { 48 | if x < y { 49 | return x 50 | } 51 | return y 52 | } 53 | -------------------------------------------------------------------------------- /StringToInteger/string_to_integer.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func myAtoi(s string) int { 4 | if len(s) == 0 { 5 | return 0 6 | } 7 | 8 | sign := 1 // -1 negative 9 | index := 0 10 | val := 0 11 | 12 | for len(s) > index && s[index] == ' ' { 13 | index++ 14 | } 15 | 16 | if index >= len(s) { 17 | return 0 18 | } 19 | 20 | if v := s[index]; v == '-' || v == '+' { 21 | if v == '-' { 22 | sign = -1 23 | } 24 | 25 | index++ 26 | } 27 | 28 | for { 29 | if index == len(s) { 30 | break 31 | } 32 | 33 | if isNumericRune(s[index]) == false { 34 | return sign * val 35 | } 36 | 37 | val = val*10 + int(s[index]) - '0' 38 | 39 | if val > 2147483647 || val < -2147483648 { 40 | if sign == 1 { 41 | return 2147483647 42 | } 43 | 44 | return -2147483648 45 | } 46 | 47 | index++ 48 | } 49 | 50 | return sign * val 51 | } 52 | 53 | func isNumericRune(x byte) bool { 54 | return x >= '0' && x <= '9' 55 | } 56 | -------------------------------------------------------------------------------- /StringToInteger/string_to_integer.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def myAtoi(self, s: str) -> int: 3 | 4 | s = s.strip() 5 | if not s: 6 | return 0 7 | 8 | sign = 1 9 | index = 0 10 | val = 0 11 | 12 | if s[0] == "-": 13 | sign = -1 14 | index += 1 15 | elif s[0] == "+": 16 | index += 1 17 | 18 | while index < len(s) and s[index].isdigit(): 19 | val = val * 10 + int(s[index]) 20 | 21 | if val > 2147483647 or val < -2147483648: 22 | if sign == 1: 23 | return 2147483647 24 | else: 25 | return -2147483648 26 | 27 | index += 1 28 | 29 | return sign * val 30 | -------------------------------------------------------------------------------- /StrobogrammaticNumber/strobogrammatic_number.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /SubarraySumsDivisibleByK/subarray_sums_divisible_by_k.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func subarraysDivByK(nums []int, k int) int { 4 | var mp map[int]int = make(map[int]int) 5 | var ans int 6 | var sum int 7 | for i := 0; i < len(nums); i++ { 8 | sum = (sum + nums[i]) % k 9 | if sum < 0 { 10 | sum = (sum + k) % k 11 | } 12 | if sum == 0 { 13 | ans++ 14 | } 15 | if mp[sum] != 0 { 16 | ans += mp[sum] 17 | mp[sum]++ 18 | } else { 19 | mp[sum] = 1 20 | } 21 | } 22 | return ans 23 | } 24 | -------------------------------------------------------------------------------- /SumOfAbsoluteDifferencesInASortedArray/sum_of_absolute_differences_in_a_sorted_array.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func getSumAbsoluteDifferences(nums []int) []int { 4 | var x, y int = 0, 0 5 | var len int = len(nums) 6 | 7 | for i := 0; i < len; i++ { 8 | y += nums[i] 9 | } 10 | 11 | for i := 0; i < len; i++ { 12 | x += nums[i] 13 | tmp := (nums[i]*(i+1) - x) + (y - nums[i]*(len-i)) 14 | 15 | y -= nums[i] 16 | nums[i] = tmp 17 | } 18 | 19 | return nums 20 | } 21 | -------------------------------------------------------------------------------- /SumOfLeftLeaves/sum_of_left_leaves.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for a binary tree node. 4 | type TreeNode struct { 5 | Val int 6 | Left *TreeNode 7 | Right *TreeNode 8 | } 9 | 10 | func sumOfLeftLeaves(root *TreeNode) int { 11 | ans := 0 12 | for root != nil { 13 | if root.Left != nil { 14 | pre := root.Left 15 | for pre.Right != nil && pre.Right != root { 16 | pre = pre.Right 17 | } 18 | 19 | if pre.Right == nil { 20 | pre.Right = root 21 | root = root.Left 22 | } else { 23 | pre.Right = nil 24 | 25 | if pre == root.Left && pre.Left == nil { 26 | ans += pre.Val 27 | } 28 | root = root.Right 29 | } 30 | } else { 31 | root = root.Right 32 | } 33 | } 34 | return ans 35 | } 36 | -------------------------------------------------------------------------------- /SumOfSubarrayMinimums/sum_of_subarray_minimums.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func sumSubarrayMins(arr []int) int { 4 | arr = append(arr, 0) 5 | stack, res, j := []int{-1}, 0, 0 6 | for i, n := range arr { 7 | for len(stack) > 1 && arr[stack[len(stack)-1]] > n { 8 | j, stack = stack[len(stack)-1], stack[:len(stack)-1] 9 | res += (j - stack[len(stack)-1]) * (i - j) * arr[j] 10 | res %= 1_000_000_007 11 | } 12 | stack = append(stack, i) 13 | } 14 | return res 15 | } 16 | -------------------------------------------------------------------------------- /SummaryRanges/summary_ranges.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func summaryRanges(nums []int) []string { 6 | ans := []string{} 7 | if len(nums) == 0 { 8 | return ans 9 | } 10 | nums = append(nums, nums[len(nums)-1]+2) 11 | start := nums[0] 12 | for i := 1; i < len(nums); i++ { 13 | if nums[i]-nums[i-1] > 1 { 14 | if nums[i-1] == start { 15 | ans = append(ans, fmt.Sprintf("%d", start)) 16 | } else { 17 | ans = append(ans, fmt.Sprintf("%d->%d", start, nums[i-1])) 18 | } 19 | start = nums[i] 20 | } 21 | } 22 | return ans 23 | 24 | } 25 | -------------------------------------------------------------------------------- /SumofEvenNumbersAfterQueries/sum_of_even_numbers_after_queries.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // the idea is we don't calculate the even sum from scratch for each query 4 | // instead, we calculate it at the beginning 5 | // since each query only updates one value, 6 | // so we can adjust the even sum base on the original value and new value 7 | func sumEvenAfterQueries(nums []int, queries [][]int) []int { 8 | evenSum := 0 9 | // calculate the sum of all even numbers 10 | for _, val := range nums { 11 | if val%2 == 0 { 12 | evenSum += val 13 | } 14 | } 15 | ans := make([]int, len(queries)) 16 | for i, q := range queries { 17 | val, idx := q[0], q[1] 18 | // if original nums[idx] is even, then we deduct it from evenSum 19 | if nums[idx]%2 == 0 { 20 | evenSum -= nums[idx] 21 | } 22 | // in-place update nums 23 | nums[idx] += val 24 | // check if we need to update evenSum for the new value 25 | if nums[idx]%2 == 0 { 26 | evenSum += nums[idx] 27 | } 28 | // then we have evenSum after this query, push it to ans 29 | ans[i] = evenSum 30 | } 31 | return ans 32 | } 33 | -------------------------------------------------------------------------------- /TallestBillboard/tallest_billboard.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func max(a, b int) int { 4 | if a > b { 5 | return a 6 | } 7 | return b 8 | } 9 | 10 | func abs(num int) int { 11 | if num < 0 { 12 | return -num 13 | } 14 | return num 15 | } 16 | 17 | func copyFrom(dp map[int]int) map[int]int { 18 | newDP := make(map[int]int) 19 | for key, value := range dp { 20 | newDP[key] = value 21 | } 22 | 23 | return newDP 24 | } 25 | 26 | func tallestBillboard(rods []int) int { 27 | dp := map[int]int{ 28 | 0: 0, 29 | } 30 | 31 | for _, rod := range rods { 32 | newDP := copyFrom(dp) 33 | 34 | for diff, taller := range dp { 35 | shorter := taller - diff 36 | newTaller := newDP[diff+rod] 37 | newDP[diff+rod] = max(newTaller, taller+rod) 38 | newDiff := abs(shorter + rod - taller) 39 | newTaller2 := max(shorter+rod, taller) 40 | newDP[newDiff] = max(newTaller2, newDP[newDiff]) 41 | } 42 | 43 | dp = newDP 44 | } 45 | 46 | return dp[0] 47 | } 48 | -------------------------------------------------------------------------------- /TheKWeakestRowsInAMatrix/the_k_weakest_rows_in_a_matrix.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func kWeakestRows(mat [][]int, k int) []int { 4 | countStore := make([]int, len(mat)) 5 | for i := 0; i < len(mat); i++ { 6 | count := 0 7 | for j := 0; j < len(mat[0]); j++ { 8 | if mat[i][j] == 1 { 9 | count++ 10 | } 11 | } 12 | countStore[i] = count 13 | } 14 | 15 | result := make([]int, k) 16 | indexer := 0 17 | 18 | for k > 0 { 19 | minIndex := 0 20 | for i := 0; i < len(countStore); i++ { 21 | if countStore[i] < countStore[minIndex] { 22 | minIndex = i 23 | } 24 | } 25 | result[indexer] = minIndex 26 | indexer++ 27 | countStore[minIndex] = 101 // Assuming max row count is 100 28 | k-- 29 | } 30 | return result 31 | } 32 | -------------------------------------------------------------------------------- /TheKWeakestRowsInAMatrix/the_k_weakest_rows_in_a_matrix.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/TheKWeakestRowsInAMatrix/the_k_weakest_rows_in_a_matrix.md -------------------------------------------------------------------------------- /ThirdMaximumNumber/third_maximum_number.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func thirdMax(nums []int) int { 6 | // Create a HashSet using a map[int]bool 7 | unique := make(map[int]bool) 8 | 9 | // Add elements to the HashSet 10 | for _, num := range nums { 11 | unique[num] = true 12 | } 13 | 14 | // Create a slice to store unique numbers 15 | uniqueNums := make([]int, 0, len(unique)) 16 | for num := range unique { 17 | uniqueNums = append(uniqueNums, num) 18 | } 19 | 20 | // Sort the unique numbers in ascending order 21 | sort.Ints(uniqueNums) 22 | 23 | // Check if the unique numbers have at least 3 elements 24 | if len(uniqueNums) < 3 { 25 | return uniqueNums[len(uniqueNums)-1] 26 | } 27 | 28 | return uniqueNums[len(uniqueNums)-3] 29 | } 30 | -------------------------------------------------------------------------------- /ThirdMaximumNumber/third_maximum_number.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/ThirdMaximumNumber/third_maximum_number.md -------------------------------------------------------------------------------- /TimeBasedKeyValueStore/time_based_key_value_store.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/TimeBasedKeyValueStore/time_based_key_value_store.md -------------------------------------------------------------------------------- /TimeNeededToInformAllEmployees/time_needed_to_inform_all_employees.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "container/list" 5 | ) 6 | 7 | type Pair struct { 8 | key int 9 | value int 10 | } 11 | 12 | func numOfMinutes(n int, headID int, manager []int, informTime []int) int { 13 | arr := make([][]int, n) 14 | for i := 0; i < n; i++ { 15 | arr[i] = make([]int, 0) 16 | } 17 | 18 | for i := 0; i < n; i++ { 19 | if manager[i] != -1 { 20 | arr[manager[i]] = append(arr[manager[i]], i) 21 | } 22 | } 23 | 24 | q := list.New() 25 | q.PushBack(Pair{key: headID, value: informTime[headID]}) 26 | ans := 0 27 | 28 | for q.Len() > 0 { 29 | si := q.Len() 30 | 31 | for i := 0; i < si; i++ { 32 | t := q.Remove(q.Front()).(Pair) 33 | 34 | for _, x := range arr[t.key] { 35 | if informTime[x] == 0 { 36 | if ans < t.value { 37 | ans = t.value 38 | } 39 | } else { 40 | q.PushBack(Pair{key: x, value: t.value + informTime[x]}) 41 | } 42 | } 43 | } 44 | } 45 | 46 | return ans 47 | } 48 | -------------------------------------------------------------------------------- /ToeplitzMatrix/toeplitz_matrix.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /* 4 | 5 | bool isToeplitzMatrix(List> matrix) { 6 | for (int i = 0; i < matrix.length - 1; i++) { 7 | for (int j = 0; j < matrix[0].length - 1; j++) { 8 | int ele = matrix[i][j]; 9 | if (i < matrix.length - 1 && 10 | j < matrix[0].length - 1 && 11 | matrix[i + 1][j + 1] != ele) { 12 | return false; 13 | } 14 | } 15 | } 16 | return true; 17 | } 18 | */ 19 | func isToeplitzMatrix(matrix [][]int) bool { 20 | for i := 0; i < len(matrix)-1; i++ { 21 | for j := 0; j < len(matrix[0])-1; j++ { 22 | element := matrix[i][j] 23 | if i < len(matrix)-1 && 24 | j < len(matrix[0])-1 && 25 | matrix[i+1][j+1] != element { 26 | return false 27 | } 28 | } 29 | } 30 | return true 31 | } 32 | -------------------------------------------------------------------------------- /TopKFrequentElements/top_k_frequent_elements.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "container/heap" 4 | 5 | type Word struct { 6 | word int 7 | frequency int 8 | } 9 | 10 | func newWord(word int, frequency int) *Word { 11 | return &Word{word: word, frequency: frequency} 12 | } 13 | 14 | type H struct { 15 | items []*Word 16 | } 17 | 18 | func (h *H) Len() int { return len(h.items) } 19 | 20 | func (h *H) Less(i, j int) bool { 21 | if h.items[i].frequency != h.items[j].frequency { 22 | return h.items[i].frequency < h.items[j].frequency 23 | } 24 | return h.items[i].word > h.items[j].word 25 | } 26 | 27 | func (h *H) Swap(i, j int) { h.items[i], h.items[j] = h.items[j], h.items[i] } 28 | 29 | func (h *H) Push(i interface{}) { h.items = append(h.items, i.(*Word)) } 30 | 31 | func (h *H) Pop() interface{} { 32 | n := len(h.items) 33 | item := h.items[n-1] 34 | h.items = h.items[:n-1] 35 | return item 36 | } 37 | 38 | func topKFrequent(words []int, k int) []int { 39 | counts := map[int]int{} 40 | h := &H{} 41 | for _, v := range words { 42 | counts[v]++ 43 | 44 | } 45 | for key, v := range counts { 46 | heap.Push(h, newWord(key, v)) 47 | if h.Len() > k { 48 | heap.Pop(h) 49 | } 50 | } 51 | result := []int{} 52 | for h.Len() > 0 { 53 | result = append([]int{heap.Pop(h).(*Word).word}, result...) 54 | } 55 | return result 56 | } 57 | -------------------------------------------------------------------------------- /TopKFrequentElements/top_k_frequent_elements.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/TopKFrequentElements/top_k_frequent_elements.md -------------------------------------------------------------------------------- /TopKFrequentWords/top_k_frequent_words.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "container/heap" 4 | 5 | type Word struct { 6 | word string 7 | frequency int 8 | } 9 | 10 | func newWord(word string, frequency int) *Word { 11 | return &Word{word: word, frequency: frequency} 12 | } 13 | 14 | type H struct { 15 | items []*Word 16 | } 17 | 18 | func (h *H) Len() int { return len(h.items) } 19 | 20 | func (h *H) Less(i, j int) bool { 21 | if h.items[i].frequency != h.items[j].frequency { 22 | return h.items[i].frequency < h.items[j].frequency 23 | } 24 | return h.items[i].word > h.items[j].word 25 | } 26 | 27 | func (h *H) Swap(i, j int) { h.items[i], h.items[j] = h.items[j], h.items[i] } 28 | 29 | func (h *H) Push(i interface{}) { h.items = append(h.items, i.(*Word)) } 30 | 31 | func (h *H) Pop() interface{} { 32 | n := len(h.items) 33 | item := h.items[n-1] 34 | h.items = h.items[:n-1] 35 | return item 36 | } 37 | 38 | func topKFrequent(words []string, k int) []string { 39 | counts := map[string]int{} 40 | h := &H{} 41 | for _, v := range words { 42 | counts[v]++ 43 | 44 | } 45 | for key, v := range counts { 46 | heap.Push(h, newWord(key, v)) 47 | if h.Len() > k { 48 | heap.Pop(h) 49 | } 50 | } 51 | result := []string{} 52 | for h.Len() > 0 { 53 | result = append([]string{heap.Pop(h).(*Word).word}, result...) 54 | } 55 | return result 56 | } 57 | -------------------------------------------------------------------------------- /TopKFrequentWords/top_k_frequent_words.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/TopKFrequentWords/top_k_frequent_words.md -------------------------------------------------------------------------------- /TwoSum-III-DataStructureDesign/two_sum_III_data_structure_design.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /TwoSum-III-DataStructureDesign/two_sum_III_data_structure_design.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/TwoSum-III-DataStructureDesign/two_sum_III_data_structure_design.md -------------------------------------------------------------------------------- /TwoSumIV-InputIsABST/two_sum_IV_input_is_a_bst.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Definition for a binary tree node. 4 | type TreeNode struct { 5 | Val int 6 | Left *TreeNode 7 | Right *TreeNode 8 | } 9 | 10 | func findTarget(root *TreeNode, k int) bool { 11 | visited := map[int]bool{} 12 | var preorder func(*TreeNode) bool 13 | preorder = func(node *TreeNode) bool { 14 | if node == nil { 15 | return false 16 | } 17 | if visited[k-node.Val] { 18 | return true 19 | } 20 | visited[node.Val] = true 21 | if preorder(node.Left) { 22 | return true 23 | } 24 | if preorder(node.Right) { 25 | return true 26 | } 27 | return false 28 | } 29 | return preorder(root) 30 | } 31 | -------------------------------------------------------------------------------- /UTF-8Validation/uft_8_validation.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /UglyNumber/ugly_number.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Runtime: 0 ms, faster than 100.00% of Go online submissions for Ugly Number. 4 | // Memory Usage: 2.1 MB, less than 5.43% of Go online submissions for Ugly Number. 5 | func isUgly(n int) bool { 6 | if n == 1 { 7 | return true 8 | } else if n <= 0 { 9 | return false 10 | } 11 | 12 | if n%2 == 0 { 13 | return isUgly(n / 2) 14 | } 15 | if n%3 == 0 { 16 | return isUgly(n / 3) 17 | } 18 | if n%5 == 0 { 19 | return isUgly(n / 5) 20 | } 21 | return false 22 | } 23 | 24 | func isReallyUgly(n int) bool { 25 | var arr []int = []int{2, 3, 5} 26 | for i := 0; i < len(arr); i++ { 27 | for n >= arr[i] && n%arr[i] == 0 { 28 | n /= arr[i] 29 | } 30 | } 31 | return n == 1 32 | } 33 | 34 | func isReallyReallyUgly(n int) bool { 35 | if n <= 0 { 36 | return false 37 | } 38 | if n == 1 { 39 | return true 40 | } 41 | 42 | for n%3 == 0 && n >= 3 { 43 | n /= 3 44 | } 45 | for n%5 == 0 && n >= 5 { 46 | n /= 5 47 | } 48 | for n%2 == 0 && n >= 2 { 49 | n /= 2 50 | } 51 | 52 | // if(n==0 || n==1|| n==2 || n==3 || n==5) return true; 53 | if n == 1 { 54 | return true 55 | } 56 | return false 57 | 58 | } 59 | -------------------------------------------------------------------------------- /UniqueBinarySearchTreesIi/unique_binary_search_trees_ii.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/UniqueBinarySearchTreesIi/unique_binary_search_trees_ii.md -------------------------------------------------------------------------------- /UniquePathsIII/unique_paths_iii.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func uniquePathsIII(grid [][]int) int { 4 | x, y := findStart(grid) 5 | return helper(grid, x, y) 6 | } 7 | 8 | func helper(grid [][]int, x, y int) int { 9 | if grid[x][y] == 2 { 10 | if noZeroes(grid) { 11 | return 1 12 | } 13 | return 0 14 | } 15 | 16 | grid[x][y] = 3 17 | ans := 0 18 | 19 | if x-1 >= 0 && (grid[x-1][y] == 0 || grid[x-1][y] == 2) { 20 | ans += helper(grid, x-1, y) 21 | } 22 | if y-1 >= 0 && (grid[x][y-1] == 0 || grid[x][y-1] == 2) { 23 | ans += helper(grid, x, y-1) 24 | } 25 | if x+1 < len(grid) && (grid[x+1][y] == 0 || grid[x+1][y] == 2) { 26 | ans += helper(grid, x+1, y) 27 | } 28 | if y+1 < len(grid[0]) && (grid[x][y+1] == 0 || grid[x][y+1] == 2) { 29 | ans += helper(grid, x, y+1) 30 | } 31 | 32 | grid[x][y] = 0 33 | 34 | return ans 35 | } 36 | 37 | func noZeroes(grid [][]int) bool { 38 | for _, x := range grid { 39 | for _, v := range x { 40 | if v == 0 { 41 | return false 42 | } 43 | } 44 | } 45 | 46 | return true 47 | } 48 | 49 | func findStart(grid [][]int) (int, int) { 50 | for x := 0; x < len(grid); x++ { 51 | for y := 0; y < len(grid[0]); y++ { 52 | if grid[x][y] == 1 { 53 | return x, y 54 | } 55 | } 56 | } 57 | 58 | return -1, -1 //error 59 | } 60 | -------------------------------------------------------------------------------- /ValidAnagram/valid_anagram.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /* 4 | 5 | bool isAnagram(String s, String t) { 6 | if (s.length != t.length) return false; 7 | final Map mapOne = {}; 8 | final Map mapTwo = {}; 9 | 10 | for (int i = 0; i < s.length; i++) { 11 | mapOne[s[i]] = (mapOne[s[i]] ?? 0) + 1; 12 | mapTwo[t[i]] = (mapTwo[t[i]] ?? 0) + 1; 13 | } 14 | final mapOneKeys = mapOne.keys.toList(); 15 | final mapOneValues = mapOne.values.toList(); 16 | 17 | for (int i = 0; i < mapOne.length; i++) { 18 | final key = mapOneKeys[i]; 19 | final value = mapOneValues[i]; 20 | 21 | if (mapTwo[key] != value) return false; 22 | } 23 | return true; 24 | } 25 | 26 | */ 27 | func isAnagram(s string, t string) bool { 28 | sr := map[byte]int{} 29 | tr := map[byte]int{} 30 | 31 | if len(s) != len(t) { 32 | return false 33 | } 34 | 35 | for i := 0; i < len(s); i++ { 36 | sr[s[i]] += 1 37 | tr[t[i]] += 1 38 | } 39 | 40 | for i := 0; i < len(s); i++ { 41 | if sr[s[i]] != tr[s[i]] { 42 | return false 43 | } 44 | } 45 | 46 | return true 47 | } 48 | -------------------------------------------------------------------------------- /ValidAnagram/valid_anagram.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/ValidAnagram/valid_anagram.md -------------------------------------------------------------------------------- /ValidPerfectSquare/valid_perfect_square.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func isPerfectSquare(num int) bool { 4 | var low int = 0 5 | var high int = num 6 | for low <= high { 7 | var mid int = low + (high-low)/2 8 | if mid*mid == num { 9 | return true 10 | } else if mid*mid < num { 11 | low = mid + 1 12 | } else { 13 | high = mid - 1 14 | } 15 | } 16 | return false 17 | } 18 | -------------------------------------------------------------------------------- /ValidSudoku/valid_sudoku.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func isValidPlacement(board [][]byte, number byte, row int, column int) bool { 4 | return !isNumberInRow(board, number, row, column) && 5 | !isNumberInColumn(board, number, row, column) && 6 | !isNumberInBox(board, number, row, column) 7 | } 8 | func isNumberInBox(board [][]byte, number byte, row int, column int) bool { 9 | var boxRow int = row - row%3 10 | var boxColumn int = column - column%3 11 | for i := boxRow; i < boxRow+3; i++ { 12 | for j := boxColumn; j < boxColumn+3; j++ { 13 | if row != i && column != j && board[i][j] == number { 14 | return true 15 | } 16 | } 17 | } 18 | return false 19 | } 20 | 21 | func isNumberInColumn(board [][]byte, number byte, row int, column int) bool { 22 | for i := 0; i < 9; i++ { 23 | if row != i && board[i][column] == number { 24 | return true 25 | } 26 | } 27 | return false 28 | } 29 | 30 | func isNumberInRow(board [][]byte, number byte, row int, column int) bool { 31 | for i := 0; i < 9; i++ { 32 | 33 | if column != i && board[row][i] == number { 34 | return true 35 | } 36 | } 37 | return false 38 | } 39 | 40 | func isValidSudoku(board [][]byte) bool { 41 | for row := 0; row < 9; row++ { 42 | for column := 0; column < 9; column++ { 43 | if board[row][column] != '.' && 44 | !isValidPlacement(board, board[row][column], row, column) { 45 | return false 46 | } 47 | } 48 | } 49 | return true 50 | } 51 | -------------------------------------------------------------------------------- /VerifyingAnAlienDictionary/verifying_an_alien_dictionary.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /WordBreak/word_break.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/WordBreak/word_break.md -------------------------------------------------------------------------------- /WordPattern/word_pattern.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strings" 4 | 5 | func wordPattern(pattern string, s string) bool { 6 | words := strings.Split(s, " ") 7 | if len(words) != len(pattern) { 8 | return false 9 | } 10 | hashMap := make(map[interface{}]int) 11 | for i, word := range words { 12 | if hashMap[word] != hashMap[pattern[i]] { 13 | return false 14 | } 15 | hashMap[word] = i + 1 16 | hashMap[pattern[i]] = i + 1 17 | } 18 | return true 19 | } 20 | -------------------------------------------------------------------------------- /WordSearch/word_search.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | var visited [][]bool 4 | var n, m int 5 | 6 | func exist(board [][]string, word string) bool { 7 | n = len(board) 8 | m = len(board[0]) 9 | visited = make([][]bool, n) 10 | for i := range visited { 11 | visited[i] = make([]bool, m) 12 | } 13 | 14 | for i := 0; i < n; i++ { 15 | for j := 0; j < m; j++ { 16 | if board[i][j] == word[0:1] { 17 | if valid(i, j, 0, board, word) { 18 | return true 19 | } 20 | } 21 | } 22 | } 23 | return false 24 | } 25 | 26 | func valid(i, j, count int, board [][]string, word string) bool { 27 | if i < 0 || i >= n || j < 0 || j >= m { 28 | return false 29 | } 30 | 31 | if visited[i][j] { 32 | return false 33 | } 34 | 35 | if word[count:count+1] != board[i][j] { 36 | return false 37 | } 38 | 39 | if count == len(word)-1 { 40 | return true 41 | } 42 | 43 | visited[i][j] = true 44 | count++ 45 | 46 | if valid(i+1, j, count, board, word) || 47 | valid(i, j+1, count, board, word) || 48 | valid(i-1, j, count, board, word) || 49 | valid(i, j-1, count, board, word) { 50 | return true 51 | } 52 | 53 | visited[i][j] = false 54 | return false 55 | } 56 | -------------------------------------------------------------------------------- /WordSearch/word_search.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/WordSearch/word_search.md -------------------------------------------------------------------------------- /ZigzagConversion/zigzag_conversion.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "bytes" 4 | 5 | func convert(s string, numRows int) string { 6 | if numRows == 1 { 7 | return s 8 | } 9 | rows := make([][]byte, numRows) 10 | curRow, step := 0, 1 11 | for i := range s { 12 | rows[curRow] = append(rows[curRow], s[i]) 13 | curRow += step 14 | if curRow == 0 { 15 | step = 1 16 | } else if curRow == numRows-1 { 17 | step = -1 18 | } 19 | } 20 | 21 | var res bytes.Buffer 22 | for i := range rows { 23 | res.Write(rows[i]) 24 | } 25 | return res.String() 26 | } 27 | -------------------------------------------------------------------------------- /ZigzagConversion/zigzag_conversion.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ayoubzulfiqar/leetcode/14aa06e76b82041b4ca413f482b5d5f0445906d2/ZigzagConversion/zigzag_conversion.md --------------------------------------------------------------------------------