├── .gitignore ├── README.md ├── src ├── Main.java ├── Playground.java ├── additional │ ├── ArrayIndexEqualsValue.java │ ├── CycleInGraph.java │ ├── KMPAlgorithms.java │ ├── LaptopRental.java │ ├── MergeSortedArrays.java │ ├── RearrangeLinkedList.java │ ├── ReverseWordsInString.java │ ├── RotateArray.java │ ├── SearchInSortedMatrix.java │ ├── SortKSortedArray.java │ ├── StringRotation.java │ └── advgraph │ │ ├── BellmanFordAlgorithms.java │ │ ├── DijkstraAlgorithms.java │ │ ├── KruskalAlgorithms.java │ │ └── PrimAlgorithms.java ├── common │ ├── Cell.java │ ├── CellWithDistance.java │ ├── Edge.java │ ├── ImmutableListNode.java │ ├── ListNode.java │ ├── Node.java │ ├── NodeWithRandomPointer.java │ ├── Point.java │ ├── TreeNode.java │ ├── TreeNodeWithNext.java │ ├── Vertex.java │ └── unionfind │ │ ├── UnionFind.java │ │ ├── UnionFindMap.java │ │ └── UnionFindNumArr.java ├── constant │ ├── GraphConstant.java │ └── StringConstant.java ├── datastructurealgorithms │ ├── bigo │ │ ├── 2-img-fix.jpg │ │ ├── ConstantTime.java │ │ ├── ExponentialTime.java │ │ ├── FactorialTime.java │ │ ├── LinearTime.java │ │ ├── LogLinearTime.java │ │ ├── LogNTime.java │ │ ├── QuadraticTime.java │ │ └── QubicTime.java │ ├── bitwise │ │ └── BitHamming.java │ ├── graph │ │ ├── GraphDemo.java │ │ ├── GraphExample.java │ │ ├── GraphPrinter.java │ │ ├── disjointset │ │ │ └── UnionFindDemo.java │ │ ├── mst │ │ │ ├── Edge.java │ │ │ ├── KruskalDemo.java │ │ │ ├── PrimDemo.java │ │ │ └── Util.java │ │ ├── shortestpath │ │ │ ├── BellmanFordDemo.java │ │ │ └── DijsktraDemo.java │ │ └── topological │ │ │ ├── Course.java │ │ │ └── TopologicalDemo.java │ ├── hashtable │ │ ├── HashTable.java │ │ ├── HashTableWithHashMap.java │ │ └── OwnHashTableDemo.java │ ├── heap │ │ ├── HeapExample.java │ │ └── HeapQuestionExample.java │ ├── linkedlist │ │ ├── CircularLinkedListDemo.java │ │ ├── DoublyLinkedListDemo.java │ │ ├── FastNSlowPointer.java │ │ ├── LinkedList.java │ │ ├── RangeBasedLinkedListSmallProject.java │ │ └── SinglyLinkedListDemo.java │ ├── queue │ │ ├── QueueOwnDoublyLinkedList.java │ │ └── QueueWithApi.java │ ├── recursion │ │ ├── BacktrackingExample.java │ │ ├── EasyDpExample.java │ │ └── RecursiveExample.java │ ├── searching │ │ ├── BinarySearch.java │ │ └── LinearSearch.java │ ├── sorting │ │ ├── BubbleSort.java │ │ ├── CountingSort.java │ │ ├── InsertionSort.java │ │ ├── MergeSort.java │ │ ├── QuickSort.java │ │ ├── SelectionSort.java │ │ └── SortingDemo.java │ ├── stack │ │ ├── StackOwnArray.java │ │ ├── StackOwnLinkedList.java │ │ ├── StackUnderflowError.java │ │ └── StackWithApi.java │ ├── tree │ │ ├── Traversal.java │ │ ├── TreeDemo.java │ │ ├── binary │ │ │ ├── BinarySearchTreeNode.java │ │ │ ├── BinaryTreeNode.java │ │ │ └── BstPrinter.java │ │ └── normal │ │ │ └── TreeNode.java │ └── trie │ │ ├── Trie.java │ │ └── TrieExample.java ├── lc │ ├── blind75 │ │ ├── easy │ │ │ ├── BestTimeBuySellStock_121.java │ │ │ ├── ClimbingStairs_70.java │ │ │ ├── ContainsDuplicate_217.java │ │ │ ├── CountingBits_338.java │ │ │ ├── InvertBinaryTree_226.java │ │ │ ├── LcaOfBst_235.java │ │ │ ├── LinkedListCycle_141.java │ │ │ ├── MaximumDepthBT_104.java │ │ │ ├── MaximumSubarray_53.java │ │ │ ├── MeetingRooms_252.java │ │ │ ├── MergeTwoSortedList_21.java │ │ │ ├── MissingNumber_268.java │ │ │ ├── NumberOf1Bits_191.java │ │ │ ├── ReverseBit_190.java │ │ │ ├── ReverseLinkedList_206.java │ │ │ ├── SameTree_100.java │ │ │ ├── SubTreeOfAnotherTree_572.java │ │ │ ├── TwoSum_1.java │ │ │ ├── ValidAnagram_242.java │ │ │ ├── ValidPalindrome_125.java │ │ │ └── ValidParentheses_20.java │ │ ├── hard │ │ │ ├── BinaryTreeMaximumPathSum_124.java │ │ │ ├── FindMedianFromDataStream_295.java │ │ │ ├── MergeKSortedLists_23.java │ │ │ ├── MinimumWindowSubstring_76.java │ │ │ └── WordSearchII_212.java │ │ └── medium │ │ │ ├── BinaryTreeLevelOrderTraversal_102.java │ │ │ ├── CloneGraph_133.java │ │ │ ├── CoinChange_322.java │ │ │ ├── CombinationSum_39.java │ │ │ ├── ConstructBinaryTreeFromPreorderAndInorderTraversal_105.java │ │ │ ├── ContainerWithMostWater_11.java │ │ │ ├── CourseSchedule_207.java │ │ │ ├── DecodeWays_91.java │ │ │ ├── DesignAddSearchWord_211.java │ │ │ ├── EncodeDecodeString_271.java │ │ │ ├── FindMinRotatedSortedArray_153.java │ │ │ ├── GraphValidTree_261.java │ │ │ ├── GroupAnagrams_49.java │ │ │ ├── HouseRobberII_213.java │ │ │ ├── HouseRobber_198.java │ │ │ ├── ImplementTrie_208.java │ │ │ ├── InsertInterval_57.java │ │ │ ├── JumpGame_55.java │ │ │ ├── KthSmallestElementInBST_230.java │ │ │ ├── LcaOfBT_236.java │ │ │ ├── LongestCommonSubsequence_1143.java │ │ │ ├── LongestConsecutiveSequence_128.java │ │ │ ├── LongestIncreasingSubsequence_300.java │ │ │ ├── LongestPalindromeSubstring_5.java │ │ │ ├── LongestRepeatingCharacterReplacement_424.java │ │ │ ├── LongestSubStrWithoutRepChar_3.java │ │ │ ├── MaximumProductSubarray_152.java │ │ │ ├── MeetingRoomsII_253.java │ │ │ ├── MergeInterval_56.java │ │ │ ├── NonOverlappingIntervals_435.java │ │ │ ├── NumberOfConnectComponentInUndirectedGraph_323.java │ │ │ ├── NumberOfIslands_200.java │ │ │ ├── PacificAtlanticWaterFlow_417.java │ │ │ ├── PalindromicSubstrings_647.java │ │ │ ├── ProductOfArrayExceptSelf_238.java │ │ │ ├── RemoveNthNodeFromEndOfList_19.java │ │ │ ├── ReorderList_143.java │ │ │ ├── RotateImage_48.java │ │ │ ├── SearchInRotatedSortedArray_33.java │ │ │ ├── SerializeDeserializeBST_449.java │ │ │ ├── SetMatrixZeros_73.java │ │ │ ├── SpiralMatrix_54.java │ │ │ ├── SumOfTwoInteger_371.java │ │ │ ├── ThreeSum_15.java │ │ │ ├── TopKFrequentElement_347.java │ │ │ ├── UniquePaths_62.java │ │ │ ├── ValidateBST_98.java │ │ │ ├── WordBreak_139.java │ │ │ └── WordSearch_79.java │ ├── general │ │ ├── BestMeetingPoint_296.java │ │ ├── CanPlaceFlowers_605.java │ │ ├── CinemaSeatAllocation_1386.java │ │ ├── CopyListWithRandomPointer_138.java │ │ ├── CountServersThatCommunicate_1267.java │ │ ├── CourseScheduleIV_1462.java │ │ ├── DesignHitCounter_362.java │ │ ├── DesignTicTacToe_348.java │ │ ├── DetermineIfTwoStringsAreClose_1657.java │ │ ├── EqualRowAndColumnPairs_2352.java │ │ ├── EvaluateRPN_150.java │ │ ├── FindNUniqueIntegersSumUpToZero_1304.java │ │ ├── FindPivotIndex_724.java │ │ ├── FindTheDifferenceOfTwoArrays_2215.java │ │ ├── FindWinnerOfTicTacToeGame_1275.java │ │ ├── IncreasingTripletSubsequence_334.java │ │ ├── InsertDeleteGetRandomO1_380.java │ │ ├── Integer2Roman_12.java │ │ ├── IntegerToEnglishWords_273.java │ │ ├── IsGraphBipartite_785.java │ │ ├── IsSubsequence_392.java │ │ ├── KidsWithTheGreatestNumberOfCandies_1431.java │ │ ├── LeastNumberOfUniqueIntegersAfterKRemovals_1481.java │ │ ├── LongestCommonPrefix_14.java │ │ ├── LongestSubarrayOf1sAfterDeletingOneElement_1493.java │ │ ├── MakingFileNamesUnique_1487.java │ │ ├── MaxConsecutiveOnesIII_1004.java │ │ ├── MaxDiffBetweenIncreasingElement_2016.java │ │ ├── MaxNumberOfKSumPairs_1679.java │ │ ├── MaximumAreaPieceOfCakeAfterHorizontalVerticalCuts_1465.java │ │ ├── MaximumLevelSumOfABinaryTree_1161.java │ │ ├── MaximumNumberOfFishInAGrid_2658.java │ │ ├── MaximumNumberOfVowelsInASubstringOfGivenLength_1456.java │ │ ├── MaximumSubsequenceScore_2542.java │ │ ├── MaximumTwinSumOfALinkedList_2130.java │ │ ├── MergeSortedArray_88.java │ │ ├── MinCostConnectAllPoints_1584.java │ │ ├── MinimumDeletionsToMakeCharacterFrequenciesUnique_1647.java │ │ ├── MinimumFlipsToMakeAORBEqualToC_1318.java │ │ ├── NumberDifferentIntegersInString_1805.java │ │ ├── OneEditDistance_161.java │ │ ├── RansomNote_383.java │ │ ├── ReformatDate_1507.java │ │ ├── ReverseWordsInString_151.java │ │ ├── Roman2Integer_13.java │ │ ├── ScoreOfAString_3110.java │ │ ├── SignOfTheProductOfArray_1822.java │ │ ├── SmallestNumberInInfiniteSet_2336.java │ │ ├── StringCompression_443.java │ │ ├── TheKthFactorOfN_1492.java │ │ ├── easy │ │ │ ├── ApplyOperationsToAnArray_2460.java │ │ │ ├── CheckIfArrayIsSortedAndRotated_1752.java │ │ │ ├── CheckIfOneStringSwapCanMakeStringsEqual_1790.java │ │ │ ├── ClearDigits_3174.java │ │ │ ├── ConfusingNumber_1056.java │ │ │ ├── CountingElements_1426.java │ │ │ ├── DegreeOfArray_697.java │ │ │ ├── DesignCompressedStringIterator_604.java │ │ │ ├── DiameterOfBinaryTree_543.java │ │ │ ├── FindAnagramMappings_760.java │ │ │ ├── FindMissingAndRepeatedValues_2965.java │ │ │ ├── LargestUniqueNumber_1133.java │ │ │ ├── LongestPalindrome_409.java │ │ │ ├── LongestStrictlyIncreasingOrStrictlyDecreasingSubarray_3105.java │ │ │ ├── MajorityElement_169.java │ │ │ ├── MaximumCountOfPositiveIntegerAndNegativeInteger_2529.java │ │ │ ├── MovingAverageFromDataStream_346.java │ │ │ ├── PalindromePermutation_266.java │ │ │ ├── PerformStringShifts_1427.java │ │ │ ├── SentenceSimilarity_734.java │ │ │ ├── SingleRowKeyboard_1165.java │ │ │ ├── SpecialArrayI_3151.java │ │ │ └── ValidWordSquare_422.java │ │ └── medium │ │ │ ├── AlternatingGroupsII_3208.java │ │ │ ├── CheckIfNumberIsASumOfPowersOfThree_1780.java │ │ │ ├── ConstructSmallestNumberFromDIString_2375.java │ │ │ ├── ConstructTheLexicographicallyLargestValidSequence_1718.java │ │ │ ├── CountNumberOfBadPairs_2364.java │ │ │ ├── CountOfSubstringsContainingEveryVowelAndKConsonantsII_3306.java │ │ │ ├── DecodeString_394.java │ │ │ ├── DesignANumberContainerSystem_2349.java │ │ │ ├── DesignMostRecentlyUsedQueue_1756.java │ │ │ ├── Dota2Senate_649.java │ │ │ ├── FindTheNumberOfDistinctColorsAmongTheBalls_3160.java │ │ │ ├── FirstUniqueNumber_1429.java │ │ │ ├── LonelyPixelI_531.java │ │ │ ├── MakeThePrefixSumNonNegative_2599.java │ │ │ ├── MaxSumOfAPairWithEqualSumOfDigits_2342.java │ │ │ ├── MaximumAbsoluteSumOfAnySubarray_1749.java │ │ │ ├── MaximumDistanceInArrays_624.java │ │ │ ├── NumberOfSubarraysWithOddSum_1524.java │ │ │ ├── PartitionArrayAccordingToGivenPivot_2161.java │ │ │ ├── ProductOfTheLastKNumbers_1352.java │ │ │ ├── RemoveAllOccurrencesOfASubstring_1910.java │ │ │ ├── RemovingStarsFromAString.java │ │ │ └── TupleWithSameProduct_1726.java │ └── pattern │ │ ├── backtracking │ │ ├── FindThePunishmentNumberOfAnInteger_2698.java │ │ ├── FindUniqueBinaryString_1980.java │ │ ├── LetterCombinationsOfPhoneNumber_17.java │ │ ├── LetterTilePossibilities_1079.java │ │ ├── Permutation_46.java │ │ ├── Subsets_78.java │ │ └── TheKthLexicographicalStringOfAllHappyStringsOfLengthN_1415.java │ │ ├── cyclicsort │ │ └── FirstMissingPositive_41.java │ │ ├── dp │ │ ├── BestTimeToBuyAndSellStockWithTransactionFee_714.java │ │ ├── LongestIncreasingPathInAMatrix_329.java │ │ ├── fibonacci │ │ │ ├── DominoAndTrominoTiling_790.java │ │ │ ├── MinCostClimbingStairs_746.java │ │ │ └── MinimumCostForTickets_983.java │ │ ├── knapsack01 │ │ │ └── LongestIncreasingSubsequence.java │ │ ├── lcs │ │ │ ├── EditDistance_72.java │ │ │ ├── LongestCommonSubsequence.java │ │ │ ├── LongestCommonSubstring.java │ │ │ └── MinDeleteInsertToTransformToAnotherString.java │ │ ├── palindromicsubseq │ │ │ ├── CountOfPalindromeSubstring.java │ │ │ ├── LongestPalindromicSubsequence.java │ │ │ ├── LongestPalindromicSubstring.java │ │ │ └── MinimumDeletionInStringToMakePalindrome.java │ │ └── unboundknapsack │ │ │ └── CoinChange2_518.java │ │ ├── fastnslowpointer │ │ └── DeleteTheMiddleNodeOfALinkedList_2095.java │ │ ├── graphtraversal │ │ ├── FindIfPathExistsInGraph_1971.java │ │ ├── KeysAndRooms_841.java │ │ ├── MaxAreaOfIsland_695.java │ │ ├── MinimumKnightMoves_1197.java │ │ ├── NearestExitFromEntranceInMaze_1926.java │ │ ├── NumberOfClosedIslands_1254.java │ │ ├── ReorderRoutesToMakeAllPathsLeadToTheCityZero_1466.java │ │ ├── RottingOranges_994.java │ │ ├── ShortestPathToGetFood_1730.java │ │ ├── SurroundRegion_130.java │ │ ├── TheMaze_490.java │ │ └── WallsAndGates_286.java │ │ ├── heap │ │ ├── HighFive_1086.java │ │ ├── MinimumCostToConnectSticks_1167.java │ │ └── MinimumOperationsToExceedThresholdValueII_3066.java │ │ ├── inplacelinkedlist │ │ ├── DeleteNNodesAfterMNodesOfALinkedList_1474.java │ │ ├── InsertIntoASortedCircularLinkedList_708.java │ │ ├── LRUCache_146.java │ │ ├── OddEvenLinkedList_328.java │ │ ├── PlusOneLinkedList_369.java │ │ └── PrintImmutableLinkedListInReverse_1265.java │ │ ├── kwaymerge │ │ └── .gitkeep │ │ ├── mergeinterval │ │ ├── MeetingRooms_252.java │ │ ├── MinimumNumberOfArrowsToBurstBalloons_452.java │ │ ├── MissingRanges_163.java │ │ └── RemoveInterval_1272.java │ │ ├── modifiedbinarysearch │ │ ├── FindFirstAndLastPositionInSortedArray_34.java │ │ ├── FindPeakElement_162.java │ │ ├── FindSmallestCommonElementInAllRows_1198.java │ │ ├── MissingNumberInArithmeticProgression_1228.java │ │ ├── SearchSuggestionsSystem_1268.java │ │ └── SuccessfulPairsOfSpellsAndPotions_2300.java │ │ ├── monotonicstack │ │ ├── AsteroidCollision_735.java │ │ ├── DailyTemperature_739.java │ │ ├── NextGreaterElementI_496.java │ │ └── OnlineStockSpan_901.java │ │ ├── prefixsum │ │ └── SubarraySumEqualK_560.java │ │ ├── slidingwindow │ │ ├── FindAllAnagramsInString_438.java │ │ ├── FindKLengthSubstringsWithNoRepeatedCharacters_1100.java │ │ ├── LongestSubstringWithAtMostKDistinctCharacters_340.java │ │ ├── LongestSubstringWithAtMostTwoDistinctCharacters_159.java │ │ ├── MaxConsecutiveOnesII_487.java │ │ ├── MaximumAscendingSubarraySum_1800.java │ │ ├── MinimumRecolorsToGetKConsecutiveBlackBlocks_2379.java │ │ └── SubarrayProductLessThanK_713.java │ │ ├── topkelement │ │ ├── KClosestPointsToOrigin_973.java │ │ ├── KthLargestElementInArray_215.java │ │ ├── LongestHappyString_1405.java │ │ ├── RearrangeStringKDistanceApart_358.java │ │ ├── ReorganizeString_767.java │ │ ├── SortCharactersByFrequency_451.java │ │ └── TopKFrequentWords_692.java │ │ ├── topologicalsort │ │ ├── AlienDictionary_269.java │ │ ├── CourseScheduleII_210.java │ │ ├── MinimumHeightTrees_310.java │ │ ├── ParallelCourses_1136.java │ │ └── TopologicalSort_DFS.java │ │ ├── treebfs │ │ ├── AvgOfLevelsInBinaryTree_637.java │ │ ├── BinaryTreeLevelOrderTraversalII_107.java │ │ ├── BinaryTreeLevelOrderTraversal_102.java │ │ ├── BinaryTreeRightSideView_199.java │ │ ├── BinaryTreeZigzagLevelOrderTraversal_103.java │ │ ├── MinimumDepthOfBinaryTree_111.java │ │ └── PopulatingNextRightPointersEachNode_116.java │ │ ├── treedfs │ │ ├── BalancedBinaryTree_110.java │ │ ├── BinaryTreeLongestConsecutiveSequence_298.java │ │ ├── CountGoodNodesInBinaryTree_1448.java │ │ ├── DeleteNodeInABST_450.java │ │ ├── FindElementsInAContaminatedBinaryTree_1261.java │ │ ├── LongestZigZagPathInABinaryTree_1372.java │ │ ├── PathSumIII_437.java │ │ └── SearchInBST_700.java │ │ ├── trie │ │ ├── DesignInMemoryFileSystem_588.java │ │ └── SearchSuggestionsSystem_1268.java │ │ ├── twoheaps │ │ └── TotalCostToHireKWorkers_2462.java │ │ ├── twopointers │ │ ├── AddBinary_67.java │ │ ├── MergeTwo2DArraysBySummingValues_2570.java │ │ ├── MoveZeroes_283.java │ │ ├── NumberOfSubstringsContainingAllThreeCharacters_1358.java │ │ ├── PalindromeNumber_9.java │ │ ├── ReverseVowelsOfAString_345.java │ │ ├── ReverseWordsInStringII_186.java │ │ └── SortColors_75.java │ │ └── unionfind │ │ ├── EvaluateDivision_399.java │ │ ├── NumberOfProvinces_547.java │ │ └── RedundantConnection_684.java ├── realworld │ └── network │ │ └── TotalTime.java └── utility │ ├── GenerateExample.java │ ├── MathUtil.java │ ├── TreePrinter.java │ └── Util.java └── technicalknowledge ├── README.md ├── db_schema_design.md ├── dsa_java.md ├── high_level_design.md ├── img ├── collections │ ├── collections-framework.jpg │ ├── hashmap.jpg │ ├── hashset.jpg │ └── list.jpg ├── db │ ├── example-icon-db-1.png │ └── example-table-1.png ├── dsa │ ├── 14-hash-table-concept-2.jpg │ ├── 14-hash-table-concept-3.jpg │ ├── 5-pointer.jpg │ ├── bellman-ford-dry-run.jpg │ ├── bellman-ford-negative-cycle.jpg │ ├── bellman-ford-pseudocode.jpg │ ├── dijsktra-graph-example-pseudocode.jpg │ ├── dijsktra-graph-example.jpg │ ├── dijsktra-graph-negative-example.jpg │ ├── linkedlist │ │ ├── 10-range-based-linkedlist.jpg │ │ ├── 11-fast-n-slow-pointer-1.jpg │ │ ├── 11-fast-n-slow-pointer-2.jpg │ │ ├── 6-1.jpg │ │ ├── 6-2.jpg │ │ ├── 6-3.jpg │ │ ├── 6-4.jpg │ │ └── 6-5.jpg │ ├── minimum-spanning-tree.jpg │ ├── sorting │ │ ├── 18-bubble-sort.jpg │ │ ├── 18-insertion-sort.jpg │ │ ├── 18-merge-sort.jpg │ │ ├── 18-quick-sort.jpg │ │ ├── 18-selection-sort.jpg │ │ └── 18-sorting-1.jpg │ └── topological-sort.jpg ├── multithread │ ├── concurrency-vs-parallelism.jpg │ ├── process-thread.jpg │ ├── race-condition.jpg │ ├── thread-life-cycle.jpg │ ├── thread-platform-thread.jpg │ └── thread-virtual-thread.jpg ├── network │ ├── computer-network-diagram.jpg │ ├── full-duplex.png │ ├── half-duplex.png │ ├── lan.jpg │ ├── osi-model.png │ ├── pan.png │ ├── simplex.png │ └── wan.jpg └── oop │ ├── 0-intro.jpg │ ├── 1-object.jpg │ ├── 2-class.jpg │ ├── 3-encapsulation.jpg │ ├── 4-abstraction.jpg │ ├── 5-inheritance.jpg │ ├── 6-polymorphism.jpg │ ├── 7-association.jpg │ ├── 8-aggregation.jpg │ └── 9-composition.jpg ├── network101.md ├── ood.md ├── question_pattern.md ├── sdi_fundemental.md ├── sql_crash_course.md └── testing.md /src/Main.java: -------------------------------------------------------------------------------- 1 | import lc.pattern.modifiedbinarysearch.FindFirstAndLastPositionInSortedArray_34; 2 | import utility.GenerateExample; 3 | 4 | public class Main { 5 | 6 | public static void main(String[] args) { 7 | String creator = "Thanaphoom Babparn"; 8 | System.out.printf("Creator: %s%n", creator); 9 | tryQuestion(new FindFirstAndLastPositionInSortedArray_34()); 10 | } 11 | 12 | public static void tryQuestion(GenerateExample genExample) { 13 | genExample.example(); 14 | } 15 | } -------------------------------------------------------------------------------- /src/Playground.java: -------------------------------------------------------------------------------- 1 | public class Playground { 2 | 3 | public static void main(String[] args) { 4 | System.out.println("Hello World"); 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /src/additional/ArrayIndexEqualsValue.java: -------------------------------------------------------------------------------- 1 | package additional; 2 | 3 | public class ArrayIndexEqualsValue { 4 | 5 | public int arrayIndexEqualsValue(int[] array) { 6 | // Array sorted => if not we can sort them but improve time complexity also 7 | // Return the minimum index where index equals value on that index 8 | int result = -1; 9 | int left = 0; 10 | int right = array.length - 1; 11 | while (left <= right) { 12 | int mid = left + (right - left) / 2; 13 | int diff = mid - array[mid]; 14 | if (diff == 0) { 15 | result = mid; 16 | right = mid - 1; 17 | } else if (diff < 0) { 18 | // It's mean => current of mid value is more than mid index 19 | right = mid - 1; 20 | } else { 21 | // so this one will take opposite side => mid - (-value) 22 | left = mid + 1; 23 | } 24 | } 25 | return result; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/additional/CycleInGraph.java: -------------------------------------------------------------------------------- 1 | package additional; 2 | 3 | public class CycleInGraph { 4 | 5 | private static final int WHITE = 0; // Didn't process 6 | private static final int BLACK = 1; // Mark as not have any loop 7 | private static final int GRAY = 2; // currently progressing 8 | 9 | public boolean cycleInGraph(int[][] edges) { 10 | int n = edges.length; 11 | // Initial with black color 12 | int[] color = new int[n]; 13 | for (int i = 0; i < n; i++) { 14 | if (cycleDetection(edges, i, color)) { 15 | return true; 16 | } 17 | } 18 | return false; 19 | } 20 | 21 | private boolean cycleDetection(int[][] edges, int index, int[] color) { 22 | if (color[index] == GRAY) { 23 | return true; 24 | } 25 | color[index] = GRAY; 26 | for (int next : edges[index]) { 27 | if (cycleDetection(edges, next, color)) { 28 | return true; 29 | } 30 | } 31 | color[index] = BLACK; 32 | return false; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/additional/LaptopRental.java: -------------------------------------------------------------------------------- 1 | package additional; 2 | 3 | import java.util.Comparator; 4 | import java.util.List; 5 | import java.util.PriorityQueue; 6 | 7 | public class LaptopRental { 8 | 9 | public int laptopRental(List> times) { 10 | // Sort by starting time asc 11 | times.sort(Comparator.comparingInt(e -> e.get(0))); 12 | PriorityQueue pq = new PriorityQueue<>(); 13 | int max = 0; 14 | for (List t : times) { 15 | while (!pq.isEmpty() && pq.peek() <= t.get(0)) { 16 | pq.poll(); 17 | } 18 | // Add end time of rent laptop 19 | pq.add(t.get(1)); 20 | max = Integer.max(max, pq.size()); 21 | } 22 | return max; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/additional/RearrangeLinkedList.java: -------------------------------------------------------------------------------- 1 | package additional; 2 | 3 | import common.ListNode; 4 | 5 | public class RearrangeLinkedList { 6 | 7 | public ListNode rearrangeLinkedList(ListNode head, int k) { 8 | // k => pivot value 9 | if (head == null || head.next == null) { 10 | return head; 11 | } 12 | ListNode ptr = head; 13 | ListNode lowerDummy = new ListNode(); 14 | ListNode lower = lowerDummy; 15 | ListNode pivotDummy = new ListNode(); 16 | ListNode pivot = pivotDummy; 17 | ListNode higherDummy = new ListNode(); 18 | ListNode higher = higherDummy; 19 | 20 | while (ptr != null) { 21 | if (ptr.val < k) { 22 | lower.next = ptr; 23 | lower = lower.next; 24 | } else if (ptr.val == k) { 25 | pivot.next = ptr; 26 | pivot = pivot.next; 27 | } else { 28 | higher.next = ptr; 29 | higher = higher.next; 30 | } 31 | ptr = ptr.next; 32 | } 33 | 34 | higher.next = null; 35 | pivot.next = higherDummy.next; 36 | lower.next = pivotDummy.next; 37 | 38 | return lowerDummy.next; 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/additional/ReverseWordsInString.java: -------------------------------------------------------------------------------- 1 | package additional; 2 | 3 | import static utility.Util.reverse; 4 | 5 | public class ReverseWordsInString { 6 | 7 | public String reverseWord(String strs) { 8 | int n = strs.length(); 9 | char[] words = strs.toCharArray(); 10 | // Reverse all character 11 | reverse(words, 0, n - 1); 12 | int start = 0; 13 | int end = 0; 14 | while (end < n) { 15 | while (start < n && (start < end || Character.isWhitespace(words[start]))) { 16 | start++; 17 | } 18 | while (end < n && (end < start || !Character.isWhitespace(words[end]))) { 19 | end++; 20 | } 21 | reverse(words, start, end - 1); 22 | } 23 | return String.valueOf(words); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/additional/RotateArray.java: -------------------------------------------------------------------------------- 1 | package additional; 2 | 3 | import java.util.List; 4 | import utility.Util; 5 | 6 | public class RotateArray { 7 | 8 | /* 9 | * Rotate Amount = 3 10 | * example: [0,1,2,3,4,5] => [3,4,5,0,1,2] 11 | * 1. [0,1,2,3,4,5] 12 | * 2. [5,4,3,2,1,0] (reverse all) 13 | * 3. [3,4,5,2,1,0] (reverse first half) 14 | * 4. [3,4,5,0,1,2] (reverse second half) 15 | * */ 16 | public void rotateArray(int rotateAmount, List A) { 17 | rotateAmount %= A.size(); 18 | // reverse all 19 | Util.reverse(A, 0, A.size() - 1); 20 | // reverse only first part of rotate 21 | Util.reverse(A, 0, rotateAmount - 1); 22 | // reverse second half of rotate 23 | Util.reverse(A, rotateAmount, A.size() - 1); 24 | } 25 | 26 | public void rotateArray(int rotateAmount, int[] A) { 27 | rotateAmount %= A.length; 28 | Util.reverse(A, 0, A.length - 1); 29 | Util.reverse(A, 0, rotateAmount - 1); 30 | Util.reverse(A, rotateAmount, A.length - 1); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/additional/SearchInSortedMatrix.java: -------------------------------------------------------------------------------- 1 | package additional; 2 | 3 | public class SearchInSortedMatrix { 4 | 5 | public int[] searchInSortedMatrix(int[][] matrix, int target) { 6 | int row = 0; 7 | int col = matrix[0].length - 1; 8 | while (row < matrix.length && col >= 0) { 9 | if (matrix[row][col] == target) { 10 | return new int[]{row, col}; 11 | } else if (matrix[row][col] < target) { 12 | row++; 13 | } else { 14 | col--; 15 | } 16 | } 17 | return new int[]{-1, -1}; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/additional/SortKSortedArray.java: -------------------------------------------------------------------------------- 1 | package additional; 2 | 3 | import java.util.PriorityQueue; 4 | 5 | public class SortKSortedArray { 6 | 7 | public int[] sortKSortedArray(int[] array, int k) { 8 | PriorityQueue minHeap = new PriorityQueue<>(); 9 | int[] result = new int[array.length]; 10 | int writeIndex = 0; 11 | for (int n : array) { 12 | minHeap.add(n); 13 | if (minHeap.size() > k) { 14 | result[writeIndex++] = minHeap.poll(); 15 | } 16 | } 17 | while (!minHeap.isEmpty()) { 18 | result[writeIndex++] = minHeap.poll(); 19 | } 20 | return result; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/additional/StringRotation.java: -------------------------------------------------------------------------------- 1 | package additional; 2 | 3 | public class StringRotation { 4 | 5 | public boolean isRotation(String s1, String s2) { 6 | // s1 base 7 | // s2 input 8 | String s1s1 = s1 + s1; 9 | return s1s1.contains(s2); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/additional/advgraph/KruskalAlgorithms.java: -------------------------------------------------------------------------------- 1 | package additional.advgraph; 2 | 3 | import java.util.Comparator; 4 | import java.util.List; 5 | import java.util.PriorityQueue; 6 | import common.Edge; 7 | import common.unionfind.UnionFindNumArr; 8 | 9 | public class KruskalAlgorithms { 10 | 11 | public int kruskalAlgorithms(int n, List edges) { 12 | if (edges == null || edges.isEmpty()) { 13 | return 0; 14 | } 15 | int size = n - 1; 16 | UnionFindNumArr uf = new UnionFindNumArr(n); 17 | PriorityQueue pq = new PriorityQueue<>(Comparator.comparingInt(e -> e.weight)); 18 | pq.addAll(edges); 19 | int cost = 0; 20 | while (!pq.isEmpty() && size > 0) { 21 | Edge edge = pq.poll(); 22 | if (uf.union(edge.u, edge.v)) { 23 | cost += edge.weight; 24 | size--; 25 | } 26 | } 27 | return cost; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/additional/advgraph/PrimAlgorithms.java: -------------------------------------------------------------------------------- 1 | package additional.advgraph; 2 | 3 | import java.util.Comparator; 4 | import java.util.List; 5 | import java.util.PriorityQueue; 6 | import common.Edge; 7 | 8 | public class PrimAlgorithms { 9 | 10 | public int primAlgorithms(int n, List edges) { 11 | if (edges == null || edges.isEmpty()) { 12 | return 0; 13 | } 14 | int size = n - 1; // Prim do (n - 1) times due to edge size 15 | // Min Heap => For combined the shortest distance first 16 | PriorityQueue pq = new PriorityQueue<>(Comparator.comparingInt(e -> e.weight)); 17 | pq.addAll(edges); 18 | 19 | boolean[] visited = new boolean[n]; 20 | Edge sourceNode = pq.peek(); 21 | visited[sourceNode.u] = true; 22 | int cost = 0; 23 | 24 | while (!pq.isEmpty() && size > 0) { 25 | Edge edge = pq.poll(); 26 | if (!visited[edge.v]) { 27 | cost += edge.weight; 28 | size--; 29 | visited[edge.v] = true; 30 | } 31 | } 32 | return cost; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/common/Cell.java: -------------------------------------------------------------------------------- 1 | package common; 2 | 3 | public class Cell { 4 | 5 | public int x; 6 | public int y; 7 | 8 | public Cell(int x, int y) { 9 | this.x = x; 10 | this.y = y; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/common/CellWithDistance.java: -------------------------------------------------------------------------------- 1 | package common; 2 | 3 | public class CellWithDistance extends Cell { 4 | 5 | public int distance; 6 | 7 | public CellWithDistance(int x, int y) { 8 | super(x, y); 9 | } 10 | 11 | public CellWithDistance(int x, int y, int distance) { 12 | super(x, y); 13 | this.distance = distance; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/common/Edge.java: -------------------------------------------------------------------------------- 1 | package common; 2 | 3 | public class Edge { 4 | 5 | public int u; 6 | public int v; 7 | public int weight; 8 | 9 | public Edge(int u, int v, int weight) { 10 | this.u = u; 11 | this.v = v; 12 | this.weight = weight; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/common/ImmutableListNode.java: -------------------------------------------------------------------------------- 1 | package common; 2 | 3 | public class ImmutableListNode { 4 | 5 | int val; 6 | ImmutableListNode next; 7 | 8 | ImmutableListNode(int val, ImmutableListNode next) { 9 | this.val = val; 10 | this.next = next; 11 | } 12 | 13 | ImmutableListNode(int val) { 14 | this.val = val; 15 | } 16 | 17 | public void printValue() { 18 | System.out.println(val); 19 | } 20 | 21 | public ImmutableListNode getNext() { 22 | return next; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/common/ListNode.java: -------------------------------------------------------------------------------- 1 | package common; 2 | 3 | import lc.blind75.easy.ReverseLinkedList_206; 4 | 5 | public class ListNode { 6 | 7 | public int val; 8 | public ListNode next; 9 | 10 | public ListNode() { 11 | } 12 | 13 | public ListNode(int val) { 14 | this.val = val; 15 | } 16 | 17 | public ListNode(int val, ListNode next) { 18 | this.val = val; 19 | this.next = next; 20 | } 21 | 22 | public static ListNode reverseLinkedList(ListNode head) { 23 | return new ReverseLinkedList_206().reverseLinkedList(head); 24 | } 25 | 26 | @Override 27 | public String toString() { 28 | return "[" + val + "]"; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/common/Node.java: -------------------------------------------------------------------------------- 1 | package common; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class Node { 7 | 8 | public int val; 9 | public List neighbors; 10 | 11 | public Node() { 12 | this.val = 0; 13 | this.neighbors = new ArrayList<>(); 14 | } 15 | 16 | public Node(int v) { 17 | this.val = v; 18 | this.neighbors = new ArrayList<>(); 19 | } 20 | 21 | public Node(int v, List neighbors) { 22 | this.val = v; 23 | this.neighbors = neighbors; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/common/NodeWithRandomPointer.java: -------------------------------------------------------------------------------- 1 | package common; 2 | 3 | public class NodeWithRandomPointer { 4 | 5 | public T val; 6 | public NodeWithRandomPointer next; 7 | public NodeWithRandomPointer random; 8 | 9 | public NodeWithRandomPointer(T val) { 10 | this.val = val; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/common/Point.java: -------------------------------------------------------------------------------- 1 | package common; 2 | 3 | public class Point { 4 | 5 | public int x; 6 | public int y; 7 | 8 | public Point(int x, int y) { 9 | this.x = x; 10 | this.y = y; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/common/TreeNode.java: -------------------------------------------------------------------------------- 1 | package common; 2 | 3 | 4 | public class TreeNode { 5 | 6 | public int val; 7 | public TreeNode left; 8 | public TreeNode right; 9 | 10 | public TreeNode() { 11 | } 12 | 13 | public TreeNode(int val) { 14 | this.val = val; 15 | } 16 | 17 | public TreeNode(int val, TreeNode left, TreeNode right) { 18 | this.val = val; 19 | this.left = left; 20 | this.right = right; 21 | } 22 | } -------------------------------------------------------------------------------- /src/common/TreeNodeWithNext.java: -------------------------------------------------------------------------------- 1 | package common; 2 | 3 | public class TreeNodeWithNext { 4 | 5 | public int val; 6 | public TreeNodeWithNext left; 7 | public TreeNodeWithNext right; 8 | public TreeNodeWithNext next; 9 | 10 | public TreeNodeWithNext() { 11 | } 12 | 13 | public TreeNodeWithNext(int val) { 14 | this.val = val; 15 | } 16 | 17 | public TreeNodeWithNext(int val, 18 | TreeNodeWithNext left, 19 | TreeNodeWithNext right, 20 | TreeNodeWithNext next) { 21 | this.val = val; 22 | this.left = left; 23 | this.right = right; 24 | this.next = next; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/common/Vertex.java: -------------------------------------------------------------------------------- 1 | package common; 2 | 3 | public class Vertex { 4 | 5 | public int label; 6 | public int weight; 7 | 8 | public Vertex(int label, int weight) { 9 | this.label = label; 10 | this.weight = weight; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/common/unionfind/UnionFind.java: -------------------------------------------------------------------------------- 1 | package common.unionfind; 2 | 3 | public interface UnionFind { 4 | 5 | boolean union(T x, T y); 6 | 7 | T find(T x); 8 | } 9 | -------------------------------------------------------------------------------- /src/constant/GraphConstant.java: -------------------------------------------------------------------------------- 1 | package constant; 2 | 3 | public class GraphConstant { 4 | 5 | // UP, RIGHT, DOWN, LEFT 6 | // บน ขวา ล่าง ซ้าย 7 | public static final int[][] FOUR_DIRECTIONS = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}}; 8 | public static final int[] DIR_R = {-1, 0, 1, 0}; 9 | public static final int[] DIR_C = {0, 1, 0, -1}; 10 | 11 | // 8 DIRECTIONS 12 | public static final int[][] EIGHT_DIRECTIONS = { 13 | {-1, -1}, {-1, 0}, {-1, 1}, 14 | {0, -1}, /*SKIP CENTER*/ {0, 1}, 15 | {1, -1}, {1, 0}, {1, 1} 16 | }; 17 | 18 | // Knight Possible Moves 19 | public static final int[][] KNIGHT_MOVES = { 20 | {-1, -2}, {1, -2}, 21 | {-2, -1}, {2, -1}, 22 | {-2, 1}, {2, 1}, 23 | {-1, 2}, {1, 2} 24 | }; 25 | } 26 | -------------------------------------------------------------------------------- /src/constant/StringConstant.java: -------------------------------------------------------------------------------- 1 | package constant; 2 | 3 | public class StringConstant { 4 | public static final int LOWERCASE_AMOUNT = 26; 5 | } 6 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/bigo/2-img-fix.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/src/datastructurealgorithms/bigo/2-img-fix.jpg -------------------------------------------------------------------------------- /src/datastructurealgorithms/bigo/ConstantTime.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.bigo; 2 | 3 | public class ConstantTime { 4 | 5 | public static void printData(int data) { 6 | System.out.println("data: " + data); 7 | } 8 | 9 | public static int accessData(int[] nums, int index) { 10 | if (index < 0) { 11 | throw new IllegalArgumentException("Index should not below than zero"); 12 | } 13 | return nums[index]; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/bigo/ExponentialTime.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.bigo; 2 | 3 | import lc.pattern.backtracking.Subsets_78; 4 | import utility.Util; 5 | 6 | import java.util.List; 7 | 8 | public class ExponentialTime { 9 | 10 | public static List> example() { 11 | return new Subsets_78().subsets(Util.listToIntArray(List.of(5,2,6,4))); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/bigo/FactorialTime.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.bigo; 2 | 3 | import lc.pattern.backtracking.Permutation_46; 4 | 5 | import java.util.List; 6 | 7 | public class FactorialTime { 8 | 9 | public List> permute(int[] nums) { 10 | return new Permutation_46().permute(nums); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/bigo/LogLinearTime.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.bigo; 2 | 3 | import datastructurealgorithms.sorting.QuickSort; 4 | import utility.Util; 5 | 6 | import java.util.List; 7 | 8 | public class LogLinearTime { 9 | 10 | public static int[] example() { 11 | return QuickSort.sorted(Util.listToIntArray(List.of(5,2,6,4))); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/bigo/LogNTime.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.bigo; 2 | 3 | public class LogNTime { 4 | 5 | public static int binarySearch(int[] array, int x) { 6 | int left = 0; 7 | int right = array.length - 1; 8 | 9 | while (left <= right) { 10 | int mid = left + (right - left) / 2; 11 | 12 | if (x < array[mid]) { 13 | right = mid - 1; 14 | } else if (x > array[mid]) { 15 | left = mid + 1; 16 | } else { 17 | return mid; 18 | } 19 | } 20 | 21 | return -1; 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/bigo/QuadraticTime.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.bigo; 2 | 3 | import datastructurealgorithms.sorting.BubbleSort; 4 | import utility.Util; 5 | 6 | import java.util.List; 7 | 8 | public class QuadraticTime { 9 | public static int[] example() { 10 | return BubbleSort.sorted(Util.listToIntArray(List.of(5,2,6,4))); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/bigo/QubicTime.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.bigo; 2 | 3 | public class QubicTime { 4 | 5 | public void cubeSum(int n) { 6 | for (int i = 1; i <= n; i++) { 7 | for (int j = 1; j <= n; j++) { 8 | for (int k = 1; k <= n; k++) { 9 | System.out.println(i * i * i + j * j * j + k * k * k); 10 | } 11 | } 12 | } 13 | } 14 | 15 | public int[][] matrixMultiply(int[][] A, int[][] B) { 16 | int m = A.length; 17 | int n = A[0].length; 18 | int k = B[0].length; 19 | 20 | int[][] C = new int[m][k]; 21 | 22 | for (int i = 0; i < m; i++) { 23 | for (int j = 0; j < k; j++) { 24 | C[i][j] = 0; 25 | 26 | for (int p = 0; p < n; p++) { 27 | C[i][j] += A[i][p] * B[p][j]; 28 | } 29 | } 30 | } 31 | 32 | return C; 33 | } 34 | 35 | } 36 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/bitwise/BitHamming.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.bitwise; 2 | 3 | public class BitHamming { 4 | 5 | public static int hammingWeight(int n) { 6 | int count = 0; 7 | while (n != 0) { 8 | n = (n & (n - 1)); 9 | count++; 10 | } 11 | return count; 12 | } 13 | 14 | public static int hammingDistance(int n1, int n2) { 15 | return hammingWeight(n1 ^ n2); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/graph/mst/Edge.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.graph.mst; 2 | 3 | public record Edge(String u, String v, int weight) { 4 | } 5 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/graph/mst/Util.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.graph.mst; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.stream.Collectors; 6 | 7 | class Util { 8 | 9 | public static List mockEdges() { 10 | Edge[] edges = { 11 | new Edge("A", "B", 7), 12 | new Edge("A", "C", 6), 13 | new Edge("A", "D", 4), 14 | new Edge("B", "C", 1), 15 | new Edge("D", "E", 5), 16 | new Edge("D", "F", 8), 17 | new Edge("E", "H", 2), 18 | new Edge("F", "G", 2), 19 | new Edge("F", "H", 3), 20 | new Edge("G", "I", 2), 21 | new Edge("H", "G", 7), 22 | new Edge("H", "I", 6), 23 | new Edge("C", "F", 4) 24 | }; 25 | return Arrays.stream(edges).collect(Collectors.toList()); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/graph/topological/Course.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.graph.topological; 2 | 3 | import java.util.List; 4 | 5 | public record Course(int courseId, String courseName, List prerequisite) { 6 | } 7 | 8 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/hashtable/HashTableWithHashMap.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.hashtable; 2 | 3 | import java.util.HashMap; 4 | 5 | public class HashTableWithHashMap { 6 | public static void example() { 7 | HashMap map = new HashMap<>(); 8 | map.put(1, "One"); 9 | map.put(2, "Two"); 10 | map.put(3, "Three"); 11 | System.out.println(map.get(1)); // prints "One" 12 | System.out.println(map.get(2)); // prints "Two" 13 | System.out.println(map.get(3)); // prints "Three" 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/queue/QueueWithApi.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.queue; 2 | 3 | import java.util.LinkedList; 4 | import java.util.Queue; 5 | 6 | public class QueueWithApi { 7 | 8 | public static void exampleByLinkedList() { 9 | // Create a new queue 10 | Queue queue = new LinkedList<>(); 11 | 12 | // Add elements to the queue 13 | queue.add(1); 14 | queue.add(2); 15 | queue.add(3); 16 | queue.add(4); 17 | queue.add(5); 18 | 19 | // Remove an element from the queue 20 | int removed = queue.remove(); // removed will be 1 21 | 22 | // Peek at the element at the head of the queue 23 | int head = queue.peek(); // head will be 2 24 | 25 | // Check if the queue is empty 26 | boolean isEmpty = queue.isEmpty(); // isEmpty will be false 27 | 28 | // Get the size of the queue 29 | int size = queue.size(); // size will be 4 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/searching/LinearSearch.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.searching; 2 | 3 | public class LinearSearch { 4 | 5 | public static int search(int[] nums, int target) { 6 | for (int i = 0; i < nums.length; i++) { 7 | if (nums[i] == target) { 8 | return i; 9 | } 10 | } 11 | return -1; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/sorting/BubbleSort.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.sorting; 2 | 3 | import utility.Util; 4 | 5 | public class BubbleSort { 6 | 7 | public static int[] sorted(int[] array) { 8 | for (int i = array.length - 1; i >= 0; i--) { 9 | // j < i that's mean even i is last element 10 | // j will not equals i => j + 1 valid 11 | for (int j = 0; j < i; j++) { 12 | if (array[j] > array[j + 1]) { 13 | Util.swap(array, j, j + 1); 14 | } 15 | } 16 | } 17 | return array; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/sorting/CountingSort.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.sorting; 2 | 3 | public class CountingSort { 4 | 5 | // Assume possible elements is in range 0 - 99 6 | public static int[] sorted(int[] array) { 7 | int size = array.length; 8 | int[] counter = new int[100]; 9 | for (int n : array) { 10 | counter[n]++; 11 | } 12 | 13 | int writeIndex = 0; 14 | int[] result = new int[size]; 15 | for (int i = 0; i < counter.length; i++) { 16 | int n = counter[i]; 17 | while (n-- > 0) { 18 | result[writeIndex++] = i; 19 | } 20 | } 21 | 22 | return result; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/sorting/InsertionSort.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.sorting; 2 | 3 | import utility.Util; 4 | 5 | public class InsertionSort { 6 | 7 | public static int[] sorted(int[] array) { 8 | for (int i = 1; i < array.length; i++) { 9 | int j = i; 10 | while (j > 0 && array[j] < array[j - 1]) { 11 | Util.swap(array, j, j - 1); 12 | j--; 13 | } 14 | } 15 | return array; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/sorting/QuickSort.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.sorting; 2 | 3 | import utility.Util; 4 | 5 | public class QuickSort { 6 | 7 | public static int[] sorted(int[] array) { 8 | quickSort(array, 0, array.length - 1); 9 | return array; 10 | } 11 | 12 | private static void quickSort(int[] array, int left, int right) { 13 | int partitionIndex = partition(array, left, right); 14 | if (left < partitionIndex - 1) { 15 | quickSort(array, left, partitionIndex - 1); 16 | } 17 | if (partitionIndex < right) { 18 | quickSort(array, partitionIndex, right); 19 | } 20 | } 21 | 22 | private static int partition(int[] array, int left, int right) { 23 | int pivotIndex = left + (right - left) / 2; 24 | int pivotData = array[pivotIndex]; 25 | while (left <= right) { 26 | while (array[left] < pivotData) { 27 | left++; 28 | } 29 | while (array[right] > pivotData) { 30 | right--; 31 | } 32 | if (left <= right) { 33 | Util.swap(array, left++, right--); 34 | } 35 | } 36 | return left; 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/sorting/SelectionSort.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.sorting; 2 | 3 | import utility.Util; 4 | 5 | public class SelectionSort { 6 | 7 | public static int[] sorted(int[] array) { 8 | for (int i = array.length - 1; i >= 0; i--) { 9 | int largestIndex = 0; 10 | for (int j = 0; j <= i; j++) { 11 | if (array[j] > array[largestIndex]) { 12 | largestIndex = j; 13 | } 14 | } 15 | Util.swap(array, i, largestIndex); 16 | } 17 | return array; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/stack/StackUnderflowError.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.stack; 2 | 3 | public class StackUnderflowError extends VirtualMachineError { 4 | 5 | public StackUnderflowError() { 6 | super(); 7 | } 8 | 9 | public StackUnderflowError(String s) { 10 | super(s); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/tree/binary/BinaryTreeNode.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.tree.binary; 2 | 3 | public class BinaryTreeNode { 4 | public T value; 5 | public BinaryTreeNode left; 6 | public BinaryTreeNode right; 7 | 8 | public BinaryTreeNode(T value) { 9 | this.value = value; 10 | } 11 | 12 | public boolean isLeaf() { 13 | return this.left == null && this.right == null; 14 | } 15 | } 16 | 17 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/tree/normal/TreeNode.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.tree.normal; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class TreeNode { 7 | public T value; 8 | public final List> children; 9 | 10 | public TreeNode(T value) { 11 | this.value = value; 12 | this.children = new ArrayList<>(); 13 | } 14 | 15 | public void addChild(TreeNode child) { 16 | this.children.add(child); 17 | } 18 | 19 | public void addChildren(List> children) { 20 | this.children.addAll(children); 21 | } 22 | 23 | public void removeChild(TreeNode child) { 24 | this.children.remove(child); 25 | } 26 | 27 | public void removeChildren(List> children) { 28 | this.children.removeAll(children); 29 | } 30 | 31 | public boolean isLeaf() { 32 | return this.children.isEmpty(); 33 | } 34 | } 35 | 36 | -------------------------------------------------------------------------------- /src/datastructurealgorithms/trie/TrieExample.java: -------------------------------------------------------------------------------- 1 | package datastructurealgorithms.trie; 2 | 3 | public class TrieExample { 4 | 5 | public static void main(String[] args) { 6 | String[] words = { 7 | "apple", "banana", "grape", "orange", "watermelon", 8 | "kiwi", "strawberry", "blueberry", "mango", "pineapple", 9 | "peach", "cherry", "pear", "plum", "apricot", 10 | "blackberry", "raspberry", "coconut", "papaya", "fig" 11 | }; 12 | var trieRoot = new Trie(); 13 | // Insert 14 | for (String word : words) { 15 | trieRoot.insert(word); 16 | } 17 | // Search 18 | System.out.println("Is banana in trie?: " + trieRoot.search("banana")); 19 | System.out.println("Is coconut in trie?: " + trieRoot.search("coconut")); 20 | System.out.println("Is beef in trie?: " + trieRoot.search("beef")); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/BestTimeBuySellStock_121.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | public class BestTimeBuySellStock_121 { 4 | 5 | public int maxProfit(int[] prices) { 6 | int profit = 0; 7 | int minSoFar = Integer.MAX_VALUE; 8 | for (int p : prices) { 9 | profit = Integer.max(profit, p - minSoFar); 10 | minSoFar = Integer.min(minSoFar, p); 11 | } 12 | return profit; 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/ClimbingStairs_70.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | public class ClimbingStairs_70 { 4 | 5 | public int climbStairs(int n) { 6 | int[] memo = new int[n + 1]; 7 | return climbStairsRecursive(n, memo); 8 | } 9 | 10 | public int climbStairsRecursive(int n, int[] memo) { 11 | if (n <= 1) { 12 | return 1; 13 | } 14 | if (memo[n] == 0) { 15 | int take1Step = climbStairsRecursive(n - 1, memo); 16 | int take2Step = climbStairsRecursive(n - 2, memo); 17 | memo[n] = take1Step + take2Step; 18 | } 19 | return memo[n]; 20 | } 21 | 22 | public int climbStairsIterative(int n) { 23 | if (n <= 1) { 24 | return 1; 25 | } 26 | int n1 = 1; // start from 0 27 | int n2 = 1; // start from 1 28 | for (int i = 2; i <= n; i++) { 29 | int result = n1 + n2; 30 | n1 = n2; 31 | n2 = result; 32 | } 33 | return n2; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/ContainsDuplicate_217.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | import java.util.HashSet; 4 | import java.util.Set; 5 | 6 | public class ContainsDuplicate_217 { 7 | 8 | public boolean containsDuplicate(int[] nums) { 9 | Set set = new HashSet<>(); 10 | for (int n : nums) { 11 | if (!set.add(n)) { 12 | return true; 13 | } 14 | } 15 | return false; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/CountingBits_338.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | public class CountingBits_338 { 4 | 5 | public int[] countBits(int n) { 6 | int[] result = new int[n + 1]; 7 | for (int i = 0; i <= n; i++) { 8 | int count = 0; 9 | int num = i; 10 | while (num != 0) { 11 | // Hamming weight 12 | num = (num & (num - 1)); 13 | count++; 14 | } 15 | result[i] = count; 16 | } 17 | return result; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/InvertBinaryTree_226.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | import common.TreeNode; 4 | 5 | public class InvertBinaryTree_226 { 6 | 7 | public TreeNode invertTree(TreeNode root) { 8 | if (root == null) { 9 | return null; 10 | } 11 | TreeNode invertRight = invertTree(root.right); 12 | TreeNode invertLeft = invertTree(root.left); 13 | root.left = invertRight; 14 | root.right = invertLeft; 15 | return root; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/LcaOfBst_235.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | import common.TreeNode; 4 | 5 | public class LcaOfBst_235 { 6 | 7 | public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { 8 | int value = root.val; 9 | if (p.val < value && q.val < value) { 10 | return lowestCommonAncestor(root.left, p, q); 11 | } else if (p.val > value && q.val > value) { 12 | return lowestCommonAncestor(root.right, p, q); 13 | } 14 | return root; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/LinkedListCycle_141.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | import common.ListNode; 4 | 5 | public class LinkedListCycle_141 { 6 | 7 | public boolean hasCycle(ListNode head) { 8 | ListNode fast = head; 9 | ListNode slow = head; 10 | while (fast != null && fast.next != null) { 11 | fast = fast.next.next; 12 | slow = slow.next; 13 | if (fast == slow) { 14 | break; 15 | } 16 | } 17 | return fast != null && fast.next != null; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/MaximumDepthBT_104.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | import common.TreeNode; 4 | 5 | public class MaximumDepthBT_104 { 6 | 7 | public int maxDepth(TreeNode root) { 8 | if (root == null) { 9 | return 0; 10 | } 11 | return 1 + Integer.max(maxDepth(root.left), maxDepth(root.right)); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/MaximumSubarray_53.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | public class MaximumSubarray_53 { 4 | 5 | public int maxSubArray(int[] nums) { 6 | if (nums == null || nums.length == 0) { 7 | return 0; 8 | } 9 | if (nums.length == 1) { 10 | return nums[0]; 11 | } 12 | int maxSoFar = Integer.MIN_VALUE; 13 | int currMax = 0; 14 | for (int n : nums) { 15 | // Kadane's Algorithms 16 | currMax = Integer.max(currMax + n, n); 17 | maxSoFar = Integer.max(maxSoFar, currMax); 18 | } 19 | return maxSoFar; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/MeetingRooms_252.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | import java.util.Arrays; 4 | import java.util.Collections; 5 | import java.util.Comparator; 6 | import java.util.PriorityQueue; 7 | 8 | public class MeetingRooms_252 { 9 | 10 | public boolean canAttendMeetingsOptimize(int[][] intervals) { 11 | if (intervals.length < 2) { 12 | return true; 13 | } 14 | Arrays.sort(intervals, Comparator.comparingInt(e -> e[0])); 15 | int end = 0; 16 | for (int[] meeting : intervals) { 17 | if (end > meeting[0]) { 18 | return false; 19 | } 20 | end = meeting[1]; 21 | } 22 | return true; 23 | } 24 | 25 | public boolean canAttendMeetings(int[][] intervals) { 26 | if (intervals.length < 2) { 27 | return true; 28 | } 29 | PriorityQueue pq = new PriorityQueue<>(Comparator.comparingInt(e -> e[0])); 30 | Collections.addAll(pq, intervals); 31 | int end = 0; 32 | while (!pq.isEmpty()) { 33 | int[] curr = pq.poll(); 34 | if (end > curr[0]) { 35 | return false; 36 | } 37 | end = curr[1]; 38 | } 39 | return true; 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/MergeTwoSortedList_21.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | import common.ListNode; 4 | 5 | public class MergeTwoSortedList_21 { 6 | 7 | public ListNode mergeTwoLists(ListNode list1, ListNode list2) { 8 | ListNode dummy = new ListNode(); 9 | ListNode l1 = list1; 10 | ListNode l2 = list2; 11 | ListNode itr = dummy; 12 | 13 | while (l1 != null && l2 != null) { 14 | if (l1.val < l2.val) { 15 | itr.next = l1; 16 | l1 = l1.next; 17 | } else { 18 | itr.next = l2; 19 | l2 = l2.next; 20 | } 21 | itr = itr.next; 22 | } 23 | 24 | itr.next = l1 == null ? l2 : l1; 25 | 26 | return dummy.next; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/MissingNumber_268.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | import utility.Util; 4 | 5 | public class MissingNumber_268 { 6 | 7 | public int missingNumber(int[] nums) { 8 | int n = nums.length; 9 | int maxSum = n * (n - 1) / 2; 10 | int actualSum = Util.sum(nums); 11 | return maxSum - actualSum; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/NumberOf1Bits_191.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | public class NumberOf1Bits_191 { 4 | 5 | public int hammingWeight(int n) { 6 | int count = 0; 7 | while (n != 0) { 8 | n = (n & (n - 1)); 9 | count++; 10 | } 11 | return count; 12 | } 13 | 14 | public int hammingWeightShortForUse(int n) { 15 | return Integer.bitCount(n); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/ReverseBit_190.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | public class ReverseBit_190 { 4 | 5 | public int reverseBits(int n) { 6 | int result = 0; 7 | int bit = 31; 8 | /* 9 | * Example 1: 0000 0000 0000 0000 0000 0000 0001 0010 10 | * => 0100 1000 0000 0000 0000 0000 0000 0000 11 | * */ 12 | while (n != 0) { 13 | result += (n & 1) << bit; 14 | n >>= 1; 15 | bit--; 16 | } 17 | return result; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/ReverseLinkedList_206.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | import common.ListNode; 4 | 5 | public class ReverseLinkedList_206 { 6 | 7 | public ListNode reverseLinkedList(ListNode head) { 8 | ListNode prev = null; 9 | ListNode itr = head; 10 | while (itr != null) { 11 | ListNode auxNode = itr.next; 12 | itr.next = prev; 13 | prev = itr; 14 | itr = auxNode; 15 | } 16 | return prev; 17 | } 18 | 19 | public ListNode reverseLinkedListRecursive(ListNode head) { 20 | if (head == null || head.next == null) { 21 | return head; 22 | } 23 | ListNode p = reverseLinkedListRecursive(head.next); 24 | head.next.next = head; 25 | head.next = null; 26 | return p; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/SameTree_100.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | import common.TreeNode; 4 | 5 | public class SameTree_100 { 6 | 7 | public boolean isSameTree(TreeNode p, TreeNode q) { 8 | if (p == null && q == null) { 9 | return true; 10 | } 11 | if (p == null || q == null) { 12 | return false; 13 | } 14 | return p.val == q.val && 15 | isSameTree(p.left, q.left) && 16 | isSameTree(p.right, q.right); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/SubTreeOfAnotherTree_572.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | import common.TreeNode; 4 | 5 | public class SubTreeOfAnotherTree_572 { 6 | 7 | public boolean isSubTree(TreeNode root, TreeNode subRoot) { 8 | if (root == null && subRoot == null) { 9 | return true; 10 | } 11 | if (root == null || subRoot == null) { 12 | return false; 13 | } 14 | if (!isSame(root, subRoot)) { 15 | return true; 16 | } 17 | return isSubTree(root.left, subRoot) || isSubTree(root.right, subRoot); 18 | } 19 | 20 | private boolean isSame(TreeNode root, TreeNode subRoot) { 21 | if (root == null && subRoot == null) { 22 | return true; 23 | } 24 | if (root == null || subRoot == null) { 25 | return false; 26 | } 27 | if (root.val != subRoot.val) { 28 | return false; 29 | } 30 | return isSame(root.left, subRoot.left) && isSame(root.right, subRoot.right); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/TwoSum_1.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class TwoSum_1 { 7 | 8 | public int[] twoSum(int[] nums, int target) { 9 | Map map = new HashMap<>(); 10 | for (int i = 0; i < nums.length; i++) { 11 | if (map.containsKey(nums[i])) { 12 | return new int[]{map.get(nums[i]), i}; 13 | } 14 | int diff = target - nums[i]; 15 | map.put(diff, i); 16 | } 17 | return new int[]{-1, -1}; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/ValidAnagram_242.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | import java.util.Arrays; 4 | 5 | public class ValidAnagram_242 { 6 | 7 | public boolean isAnagram(String s, String t) { 8 | // Unicode size (2^16) 9 | int size = (int) Math.pow(2, 16); 10 | int[] count1 = new int[size]; 11 | for (char c : s.toCharArray()) { 12 | count1[c]++; 13 | } 14 | int[] count2 = new int[size]; 15 | for (char c : t.toCharArray()) { 16 | count2[c]++; 17 | } 18 | // Time/Space complexity: O(s + t) 19 | return Arrays.equals(count1, count2); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/ValidPalindrome_125.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | public class ValidPalindrome_125 { 4 | 5 | // Focus only character and digit 6 | public boolean isPalindrome(String s) { 7 | s = s.trim().toLowerCase(); 8 | if (s.length() == 1) { 9 | return true; 10 | } 11 | int left = 0; 12 | int right = s.length() - 1; 13 | while (left < right) { 14 | while (left < right && !Character.isLetterOrDigit(s.charAt(left))) { 15 | left++; 16 | } 17 | while (left < right && !Character.isLetterOrDigit(s.charAt(right))) { 18 | right--; 19 | } 20 | if (s.charAt(left) != s.charAt(right)) { 21 | return false; 22 | } 23 | left++; 24 | right--; 25 | } 26 | return true; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/lc/blind75/easy/ValidParentheses_20.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.easy; 2 | 3 | import java.util.ArrayDeque; 4 | import java.util.Deque; 5 | import java.util.Map; 6 | 7 | public class ValidParentheses_20 { 8 | 9 | public boolean isValid(String s) { 10 | Map map = Map.of( 11 | ')', '(', 12 | ']', '[', 13 | '}', '{' 14 | ); 15 | 16 | Deque stack = new ArrayDeque<>(); 17 | for (char c : s.toCharArray()) { 18 | if (map.containsKey(c)) { 19 | if (stack.isEmpty()) { 20 | return false; 21 | } 22 | char openChar = stack.removeFirst(); 23 | if (openChar != map.get(c)) { 24 | return false; 25 | } 26 | } else { 27 | stack.addFirst(c); 28 | } 29 | } 30 | 31 | return stack.isEmpty(); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/lc/blind75/hard/BinaryTreeMaximumPathSum_124.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.hard; 2 | 3 | import common.TreeNode; 4 | 5 | public class BinaryTreeMaximumPathSum_124 { 6 | 7 | public int maxPathSum(TreeNode root) { 8 | if (root == null) { 9 | return 0; 10 | } 11 | int[] max = {Integer.MIN_VALUE}; 12 | findMaximum(root, max); 13 | return max[0]; 14 | } 15 | 16 | private int findMaximum(TreeNode node, int[] max) { 17 | if (node == null) { 18 | return 0; 19 | } 20 | int left = Integer.max(0, findMaximum(node.left, max)); 21 | int right = Integer.max(0, findMaximum(node.right, max)); 22 | int current = node.val + left + right; 23 | max[0] = Integer.max(max[0], current); 24 | return node.val + Integer.max(left, right); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/BinaryTreeLevelOrderTraversal_102.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Collections; 5 | import java.util.LinkedList; 6 | import java.util.List; 7 | import java.util.Queue; 8 | import common.TreeNode; 9 | 10 | public class BinaryTreeLevelOrderTraversal_102 { 11 | 12 | public List> levelOrderTraversal(TreeNode root) { 13 | if (root == null) { 14 | return Collections.emptyList(); 15 | } 16 | List> result = new ArrayList<>(); 17 | Queue q = new LinkedList<>(); 18 | q.add(root); 19 | while (!q.isEmpty()) { 20 | int size = q.size(); 21 | List currentLevel = new ArrayList<>(); 22 | while (size-- > 0) { 23 | TreeNode node = q.poll(); 24 | currentLevel.add(node.val); 25 | if (node.left != null) { 26 | q.add(node.left); 27 | } 28 | if (node.right != null) { 29 | q.add(node.right); 30 | } 31 | } 32 | result.add(currentLevel); 33 | } 34 | return result; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/CloneGraph_133.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import java.util.HashMap; 4 | import java.util.LinkedList; 5 | import java.util.Map; 6 | import java.util.Queue; 7 | import common.Node; 8 | 9 | public class CloneGraph_133 { 10 | 11 | public Node cloneGraph(Node node) { 12 | if (node == null) { 13 | return null; 14 | } 15 | Map cloneMap = new HashMap<>(); 16 | cloneMap.put(node, new Node(node.val)); 17 | // Traverse graph with Breath First Search 18 | Queue q = new LinkedList<>(); 19 | q.add(node); 20 | while (!q.isEmpty()) { 21 | Node currNode = q.poll(); 22 | for (Node neighbor : node.neighbors) { 23 | if (!cloneMap.containsKey(neighbor)) { 24 | cloneMap.put(neighbor, new Node(neighbor.val)); 25 | q.add(neighbor); 26 | } 27 | cloneMap.get(currNode).neighbors.add(cloneMap.get(neighbor)); 28 | } 29 | } 30 | return cloneMap.get(node); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/CombinationSum_39.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.LinkedList; 6 | import java.util.List; 7 | 8 | public class CombinationSum_39 { 9 | 10 | public List> combinationSum(int[] candidates, int target) { 11 | Arrays.sort(candidates); 12 | List> result = new ArrayList<>(); 13 | backtracking(candidates, target, 0, result, new LinkedList<>()); 14 | return result; 15 | } 16 | 17 | private void backtracking(int[] candidates, int target, int index, 18 | List> result, LinkedList tmpList) { 19 | if (index == candidates.length) { 20 | return; 21 | } 22 | if (target == 0) { 23 | result.add(new ArrayList<>(tmpList)); 24 | return; 25 | } 26 | for (int i = index; i < candidates.length; i++) { 27 | if (target - candidates[i] < 0) { 28 | continue; 29 | } 30 | tmpList.add(candidates[i]); 31 | // We can reuse current index number 32 | backtracking(candidates, target - candidates[i], i, result, tmpList); 33 | tmpList.pollLast(); 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/ContainerWithMostWater_11.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | public class ContainerWithMostWater_11 { 4 | 5 | public int maxArea(int[] height) { 6 | if (height == null || height.length == 0) { 7 | return 0; 8 | } 9 | 10 | int max = 0; 11 | int left = 0; 12 | int right = height.length - 1; 13 | 14 | while (left < right) { 15 | int width = right - left; 16 | int area = width; 17 | if (height[left] < height[right]) { 18 | area *= height[left]; 19 | left++; 20 | } else { 21 | area *= height[right]; 22 | right--; 23 | } 24 | max = Integer.max(max, area); 25 | } 26 | 27 | return max; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/DecodeWays_91.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | public class DecodeWays_91 { 4 | 5 | public int numDecodings(String s) { 6 | int[] dp = new int[s.length() + 1]; 7 | // s contains only digits and may contain leading zero(s). 8 | dp[0] = 1; 9 | dp[1] = s.charAt(0) == '0' ? 0 : 1; 10 | 11 | for (int i = 2; i <= s.length(); i++) { 12 | if (s.charAt(i - 1) != '0') { 13 | dp[i] += dp[i - 1]; 14 | } 15 | int twoDigit = Integer.parseInt(s.substring(i - 2, i)); 16 | if (twoDigit >= 10 && twoDigit <= 26) { 17 | dp[i] += dp[i - 2]; 18 | } 19 | } 20 | return dp[s.length()]; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/EncodeDecodeString_271.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class EncodeDecodeString_271 { 7 | 8 | private static class Codec { 9 | 10 | public String encode(List strs) { 11 | StringBuilder sb = new StringBuilder(); 12 | for (String s : strs) { 13 | // Concat with some delimiter 14 | sb.append(s.length()).append('#').append(s); 15 | } 16 | return sb.toString(); 17 | } 18 | 19 | public List decode(String s) { 20 | List result = new ArrayList<>(); 21 | int i = 0; 22 | while (i < s.length()) { 23 | // Find next Delimiter 24 | int delimiter = s.indexOf('#', i); 25 | // cut string on part i to delimiter index 26 | int length = Integer.parseInt(s.substring(i, delimiter)); 27 | // delimiter + length of word (like we do encode!) 28 | i = delimiter + length + 1; 29 | result.add(s.substring(delimiter + 1, i)); 30 | } 31 | return result; 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/FindMinRotatedSortedArray_153.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | public class FindMinRotatedSortedArray_153 { 4 | public int findMin(int[] nums) { 5 | int left = 0; 6 | int right = nums.length - 1; 7 | while (left < right) { 8 | int mid = left + (right - left) / 2; 9 | if (nums[mid] > nums[right]) { 10 | left = mid + 1; 11 | } else { 12 | right = mid; 13 | } 14 | } 15 | return nums[left]; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/GraphValidTree_261.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import common.unionfind.UnionFind; 4 | import common.unionfind.UnionFindMap; 5 | import utility.GenerateExample; 6 | 7 | public class GraphValidTree_261 implements GenerateExample { 8 | 9 | public boolean validTree(int n, int[][] edges) { 10 | // check edges case => edge ของ Tree ไม่ครบ 11 | if (n - 1 != edges.length) { 12 | return false; 13 | } 14 | UnionFind uf = new UnionFindMap<>(); 15 | for (int[] edge : edges) { 16 | if (!uf.union(edge[0], edge[1])) { 17 | return false; 18 | } 19 | } 20 | return true; 21 | } 22 | 23 | @Override 24 | public void example() { 25 | boolean case1 = validTree(5, new int[][]{{0, 1}, {0, 2}, {0, 3}, {1, 4}}); 26 | System.out.println("Test Case 1 Result: " + case1); 27 | boolean case2 = validTree(5, new int[][]{{0, 1}, {1, 2}, {2, 3}, {1, 3}, {1, 4}}); 28 | System.out.println("Test Case 2 Result: " + case2); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/HouseRobberII_213.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | public class HouseRobberII_213 { 4 | 5 | public int rob(int[] nums) { 6 | // House planning as cycle 7 | if (nums.length == 1) { 8 | return nums[0]; 9 | } 10 | int plan1 = helper(nums, 0, nums.length - 2); 11 | int plan2 = helper(nums, 1, nums.length - 1); 12 | return Integer.max(plan1, plan2); 13 | } 14 | 15 | private int helper(int[] nums, int start, int end) { 16 | int rob1 = 0; 17 | int rob2 = 0; 18 | for (int i = start; i <= end; i++) { 19 | int newRob = Integer.max(rob2, rob1 + nums[i]); 20 | rob1 = rob2; 21 | rob2 = newRob; 22 | } 23 | return rob2; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/JumpGame_55.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | public class JumpGame_55 { 4 | 5 | public boolean canJump(int[] nums) { 6 | int furthest = 0; 7 | int lastIndex = nums.length - 1; 8 | for (int i = 0; i <= furthest && i < lastIndex; i++) { 9 | furthest = Integer.max(furthest, i + nums[i]); 10 | } 11 | return furthest >= lastIndex; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/KthSmallestElementInBST_230.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import java.util.ArrayDeque; 4 | import java.util.Deque; 5 | import common.TreeNode; 6 | 7 | public class KthSmallestElementInBST_230 { 8 | 9 | // Inorder traverse with K counter 10 | public int kthSmallest(TreeNode root, int k) { 11 | Deque stack = new ArrayDeque<>(); 12 | int value = 0; 13 | TreeNode current = root; 14 | while ((!stack.isEmpty() || current != null) && k != 0) { 15 | // left most first 16 | while (current != null) { 17 | stack.addFirst(current); 18 | current = current.left; 19 | } 20 | current = stack.removeFirst(); 21 | k--; 22 | value = current.val; 23 | current = current.right; 24 | } 25 | return value; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/LcaOfBT_236.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import common.TreeNode; 4 | 5 | public class LcaOfBT_236 { 6 | 7 | public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { 8 | return helper(root, p, q).ancestor; 9 | } 10 | 11 | private LcaStatus helper(TreeNode root, TreeNode p, TreeNode q) { 12 | if (root == null) { 13 | return new LcaStatus(0, null); 14 | } 15 | LcaStatus left = helper(root.left, p, q); 16 | if (left.total == 2) { 17 | return left; 18 | } 19 | LcaStatus right = helper(root.right, p, q); 20 | if (right.total == 2) { 21 | return right; 22 | } 23 | // if face p => increment 24 | // if face q => increment 25 | int count = left.total + right.total + (root == p ? 1 : 0) + (root == q ? 1 : 0); 26 | return new LcaStatus(count, count == 2 ? root : null); 27 | } 28 | 29 | private static class LcaStatus { 30 | 31 | int total; 32 | TreeNode ancestor; 33 | 34 | LcaStatus(int total, TreeNode ancestor) { 35 | this.total = total; 36 | this.ancestor = ancestor; 37 | } 38 | } 39 | } -------------------------------------------------------------------------------- /src/lc/blind75/medium/LongestRepeatingCharacterReplacement_424.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class LongestRepeatingCharacterReplacement_424 { 7 | 8 | public int characterReplacement(String s, int k) { 9 | int windowStart = 0; 10 | int windowEnd = 0; 11 | int longest = 0; 12 | Map map = new HashMap<>(); 13 | int maxRepeat = 0; // most alphabet in text string 14 | while (windowEnd < s.length()) { 15 | char c1 = s.charAt(windowEnd++); 16 | map.put(c1, map.getOrDefault(c1, 0) + 1); 17 | maxRepeat = Integer.max(maxRepeat, map.get(c1)); 18 | while (windowEnd - windowStart - maxRepeat > k) { 19 | char c2 = s.charAt(windowStart++); 20 | map.put(c2, map.get(c2)); 21 | if (map.get(c2) == 0) { 22 | map.remove(c2); 23 | } 24 | } 25 | longest = Integer.max(longest, windowEnd - windowStart); 26 | } 27 | return longest; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/LongestSubStrWithoutRepChar_3.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class LongestSubStrWithoutRepChar_3 { 7 | 8 | public int lengthOfLongestSubstring(String s) { 9 | if (s == null || s.isEmpty()) { 10 | return 0; 11 | } 12 | Map map = new HashMap<>(); 13 | int longest = 0; 14 | int start = 0; 15 | int end = 0; 16 | 17 | while (end < s.length()) { 18 | char endChar = s.charAt(end++); 19 | map.put(endChar, map.getOrDefault(endChar, 0) + 1); 20 | while (map.get(endChar) > 1) { 21 | char startChar = s.charAt(start++); 22 | map.put(startChar, map.get(startChar) - 1); 23 | if (map.get(startChar) == 0) { 24 | map.remove(startChar); 25 | } 26 | } 27 | longest = Integer.max(longest, end - start); 28 | } 29 | 30 | return longest; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/MaximumProductSubarray_152.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import utility.Util; 4 | 5 | public class MaximumProductSubarray_152 { 6 | 7 | public int maxProduct(int[] nums) { 8 | if (nums.length == 0) { 9 | return 0; 10 | } 11 | int maxSoFar = nums[0]; 12 | int minSoFar = nums[0]; 13 | int lastResult = maxSoFar; 14 | 15 | for (int i = 1; i < nums.length; i++) { 16 | int curr = nums[i]; 17 | // Store in tmp for avoid change in find minSoFar 18 | int tmp = Util.max3Elem(curr, curr * maxSoFar, curr * minSoFar); 19 | minSoFar = Util.min3Elem(curr, curr * maxSoFar, curr * minSoFar); 20 | maxSoFar = tmp; 21 | lastResult = Math.max(lastResult, maxSoFar); 22 | } 23 | 24 | return lastResult; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/MeetingRoomsII_253.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import java.util.Arrays; 4 | import java.util.Comparator; 5 | import java.util.PriorityQueue; 6 | 7 | public class MeetingRoomsII_253 { 8 | 9 | public int minMeetingRooms(int[][] intervals) { 10 | if (intervals.length == 1) { 11 | return 1; 12 | } 13 | // Sort by start time 14 | // to reserve earliest room first 15 | Arrays.sort(intervals, Comparator.comparingInt(e -> e[0])); 16 | // then try to use min heap to store earliest end meeting time 17 | PriorityQueue end = new PriorityQueue<>(); 18 | int requiredRooms = 0; 19 | for (int[] interval : intervals) { 20 | int startTime = interval[0]; 21 | int endTime = interval[1]; 22 | while (!end.isEmpty() && end.peek() <= startTime) { 23 | end.poll(); 24 | } 25 | end.add(endTime); 26 | requiredRooms = Integer.max(requiredRooms, end.size()); 27 | } 28 | return requiredRooms; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/MergeInterval_56.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import java.util.Arrays; 4 | import java.util.Comparator; 5 | import java.util.LinkedList; 6 | 7 | public class MergeInterval_56 { 8 | 9 | public int[][] merge(int[][] intervals) { 10 | // Sort ASC by start time 11 | Arrays.sort(intervals, Comparator.comparingInt(e -> e[0])); 12 | LinkedList mergeResult = new LinkedList<>(); 13 | mergeResult.add(intervals[0]); 14 | for (int i = 1; i < intervals.length; i++) { 15 | int[] lastMergedInterval = mergeResult.getLast(); 16 | if (intervals[i][0] <= lastMergedInterval[1]) { 17 | lastMergedInterval[1] = Integer.max(lastMergedInterval[1], intervals[i][1]); 18 | } else { 19 | mergeResult.add(intervals[i]); 20 | } 21 | } 22 | return mergeResult.toArray(new int[0][2]); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/NonOverlappingIntervals_435.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import java.util.Arrays; 4 | import java.util.Comparator; 5 | 6 | public class NonOverlappingIntervals_435 { 7 | 8 | public int eraseOverlapIntervals(int[][] intervals) { 9 | // return minimum number to remove 10 | // to make intervals not overlap at all 11 | int n = intervals.length; 12 | if (n <= 1) { 13 | return 0; 14 | } 15 | // Sort end time ascending 16 | Arrays.sort(intervals, Comparator.comparingInt(e -> e[1])); 17 | int endTime = intervals[0][1]; 18 | int count = 0; 19 | for (int i = 1; i < n; i++) { 20 | if (endTime <= intervals[i][0]) { 21 | endTime = intervals[i][1]; 22 | count++; 23 | } 24 | } 25 | return n - count; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/NumberOfConnectComponentInUndirectedGraph_323.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import java.util.HashSet; 4 | import java.util.Set; 5 | import common.unionfind.UnionFindNumArr; 6 | 7 | public class NumberOfConnectComponentInUndirectedGraph_323 { 8 | 9 | public int countComponent(int n, int[][] edges) { 10 | UnionFindNumArr uf = new UnionFindNumArr(n); 11 | for (int[] edge : edges) { 12 | uf.union(edge[0], edge[1]); 13 | } 14 | Set set = new HashSet<>(); 15 | for (int i = 0; i < n; i++) { 16 | set.add(uf.find(i)); 17 | } 18 | return set.size(); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/NumberOfIslands_200.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import static constant.GraphConstant.DIR_C; 4 | import static constant.GraphConstant.DIR_R; 5 | 6 | import utility.Util; 7 | 8 | public class NumberOfIslands_200 { 9 | 10 | private static final char WATER = '0'; 11 | private static final char LAND = '1'; 12 | 13 | public int numIslands(char[][] grid) { 14 | if (grid == null || grid.length == 0 || grid[0].length == 0) { 15 | return 0; 16 | } 17 | int islands = 0; 18 | for (int r = 0; r < grid.length; r++) { 19 | for (int c = 0; c < grid[0].length; c++) { 20 | if (grid[r][c] == LAND) { 21 | islands++; 22 | turnLandToWater(grid, r, c); 23 | } 24 | } 25 | } 26 | return islands; 27 | } 28 | 29 | private void turnLandToWater(char[][] grid, int r, int c) { 30 | if (!Util.isInbound(grid, r, c) || grid[r][c] == WATER) { 31 | return; 32 | } 33 | grid[r][c] = WATER; 34 | for (int i = 0; i < 4; i++) { 35 | turnLandToWater(grid, r + DIR_R[i], c + DIR_C[i]); 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/PalindromicSubstrings_647.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | public class PalindromicSubstrings_647 { 4 | 5 | public int countSubstrings(String s) { 6 | if (s == null || s.isEmpty()) { 7 | return 0; 8 | } 9 | int counter = 0; 10 | for (int i = 0; i < s.length(); i++) { 11 | // odd-length palindromes, single character center 12 | counter += expandLeftRightWithPalindromeCounter(s, i, i); 13 | // even-length palindromes, consecutive characters center (2 characters at center) 14 | counter += expandLeftRightWithPalindromeCounter(s, i, i + 1); 15 | } 16 | return counter; 17 | } 18 | 19 | private int expandLeftRightWithPalindromeCounter(String s, int left, int right) { 20 | int l = left; 21 | int r = right; 22 | int counter = 0; 23 | while (l >= 0 && r < s.length() && s.charAt(l) == s.charAt(r)) { 24 | l--; 25 | r++; 26 | counter++; 27 | } 28 | return counter; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/ProductOfArrayExceptSelf_238.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | public class ProductOfArrayExceptSelf_238 { 4 | 5 | public int[] productExceptSelf(int[] nums) { 6 | int len = nums.length; 7 | int[] result = new int[len]; 8 | int prefixLeft = 1; 9 | for (int i = 0; i < len; i++) { 10 | result[i] = prefixLeft; 11 | prefixLeft *= nums[i]; 12 | } 13 | int prefixRight = 1; 14 | for (int i = len - 1; i >= 0; i--) { 15 | result[i] *= prefixRight; 16 | prefixRight *= nums[i]; 17 | } 18 | return result; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/RemoveNthNodeFromEndOfList_19.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import common.ListNode; 4 | 5 | public class RemoveNthNodeFromEndOfList_19 { 6 | 7 | public ListNode removeNthFromEnd(ListNode head, int n) { 8 | if (head == null) { 9 | return null; 10 | } 11 | ListNode p1 = head; 12 | ListNode p2 = head; 13 | // Move lead pointer forward n times 14 | // so that's mean, when we try to move lead pointer to end of list 15 | // follow pointer will be at n - 1 node 16 | for (int i = 0; i < n; i++) { 17 | p2 = p2.next; 18 | } 19 | // it's get to the first node 20 | // delete first node 21 | if (p2 == null) { 22 | p1 = head.next; 23 | // Move reference pointer 24 | head = p1; 25 | return head; 26 | } 27 | // In case not first node 28 | while (p2.next != null) { 29 | p1 = p1.next; 30 | p2 = p2.next; 31 | } 32 | p1.next = p1.next.next; 33 | return head; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/ReorderList_143.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import common.ListNode; 4 | 5 | public class ReorderList_143 { 6 | 7 | public void reorderList(ListNode head) { 8 | if (head == null) { 9 | return; 10 | } 11 | ListNode fast = head; 12 | ListNode slow = head; 13 | while (fast != null && fast.next != null) { 14 | slow = slow.next; 15 | fast = fast.next.next; 16 | } 17 | ListNode secondHalf = slow.next; 18 | slow.next = null; 19 | ListNode reverseSecondHalf = ListNode.reverseLinkedList(secondHalf); 20 | 21 | ListNode first = head; 22 | ListNode second = reverseSecondHalf; 23 | while (first != null && second != null) { 24 | // Created auxiliary node 25 | ListNode tmp = first.next; 26 | // Connected first to second 27 | first.next = second; 28 | // Move first 29 | first = tmp; 30 | // Change ref of auxiliary 31 | tmp = second.next; 32 | second.next = first; 33 | second = tmp; 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/SearchInRotatedSortedArray_33.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | public class SearchInRotatedSortedArray_33 { 4 | 5 | // Modified Binary Search 6 | public int search(int[] nums, int target) { 7 | int left = 0; 8 | int right = nums.length - 1; 9 | while (left <= right) { 10 | int mid = left + (right - left) / 2; 11 | if (target == nums[mid]) { 12 | return mid; 13 | } else if (nums[left] <= nums[mid]) { 14 | if (nums[left] <= target && target < nums[mid]) { 15 | right = mid - 1; 16 | } else { 17 | left = mid + 1; 18 | } 19 | } else { 20 | if (target >= nums[right] && target > nums[mid]) { 21 | left = mid + 1; 22 | } else { 23 | right = mid - 1; 24 | } 25 | } 26 | } 27 | return -1; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/SumOfTwoInteger_371.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import java.util.Random; 4 | 5 | public class SumOfTwoInteger_371 { 6 | 7 | /* 8 | * Half Adder 9 | * bit -> b ^ a 10 | * carry -> b & a 11 | * */ 12 | 13 | public int getSum(int a, int b) { 14 | // sum without +, - 15 | // b => carry 16 | // a => bit 17 | return new Random().nextInt(2) != 0 ? iterative(a, b) : recursive(a, b); 18 | } 19 | 20 | private int iterative(int a, int b) { 21 | if (b == 0) { 22 | return a; 23 | } 24 | while (b != 0) { 25 | int carry = a & b; 26 | a = a ^ b; 27 | b = carry << 1; 28 | } 29 | return a; 30 | } 31 | 32 | private int recursive(int a, int b) { 33 | if (b == 0) { 34 | return a; 35 | } 36 | return recursive(b ^ a, (b & a) << 1); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/TopKFrequentElement_347.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import java.util.Comparator; 4 | import java.util.HashMap; 5 | import java.util.Map; 6 | import java.util.Map.Entry; 7 | import java.util.PriorityQueue; 8 | 9 | public class TopKFrequentElement_347 { 10 | 11 | public int[] topKFrequent(int[] nums, int k) { 12 | Map freqMap = new HashMap<>(); 13 | for (int n : nums) { 14 | freqMap.put(n, freqMap.getOrDefault(n, 0) + 1); 15 | } 16 | PriorityQueue> minHeap = new PriorityQueue<>( 17 | Comparator.comparingInt(Entry::getValue)); 18 | for (var entry : freqMap.entrySet()) { 19 | minHeap.add(entry); 20 | if (minHeap.size() > k) { 21 | minHeap.poll(); 22 | } 23 | } 24 | int[] result = new int[k]; 25 | // min heap => min coming first 26 | for (int i = 0; i < k; i++) { 27 | result[i] = minHeap.poll().getKey(); 28 | } 29 | return result; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/UniquePaths_62.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import utility.GenerateExample; 4 | 5 | public class UniquePaths_62 implements GenerateExample { 6 | 7 | public int uniquePaths(int m, int n) { 8 | int[][] dp = new int[m][n]; 9 | for (int r = 0; r < m; r++) { 10 | dp[r][0] = 1; 11 | } 12 | for (int c = 0; c < n; c++) { 13 | dp[0][c] = 1; 14 | } 15 | for (int r = 1; r < m; r++) { 16 | for (int c = 1; c < n; c++) { 17 | // dp[r][c] = dp[r - 1][c] + dp[r][c - 1] 18 | dp[r][c] += dp[r - 1][c]; 19 | dp[r][c] += dp[r][c - 1]; 20 | } 21 | } 22 | return dp[m - 1][n - 1]; 23 | } 24 | 25 | @Override 26 | public void example() { 27 | System.out.println("UniquePaths_62 Result: " + uniquePaths(3, 7)); // 28 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/ValidateBST_98.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import common.TreeNode; 4 | 5 | public class ValidateBST_98 { 6 | 7 | public boolean isValidBST(TreeNode root) { 8 | return isValidBST(root, null, null); 9 | } 10 | 11 | private boolean isValidBST(TreeNode node, Integer min, Integer max) { 12 | if (node == null) { 13 | return true; // Leaf node will combine left/right as true 14 | } 15 | if (min != null && node.val <= min) { 16 | return false; 17 | } 18 | if (max != null && node.val >= max) { 19 | return false; 20 | } 21 | return isValidBST(node.left, min, node.val) && 22 | isValidBST(node.right, node.val, max); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/lc/blind75/medium/WordBreak_139.java: -------------------------------------------------------------------------------- 1 | package lc.blind75.medium; 2 | 3 | import java.util.List; 4 | 5 | public class WordBreak_139 { 6 | 7 | public boolean wordBreak(String s, List wordDict) { 8 | boolean[] table = new boolean[s.length() + 1]; 9 | table[0] = true; 10 | for (int i = 0; i <= table.length; i++) { 11 | if (table[i]) { 12 | for (String word : wordDict) { 13 | int maxIndex = i + word.length(); 14 | if (maxIndex <= s.length() && s.substring(i, maxIndex).equals(word)) { 15 | table[maxIndex] = true; 16 | } 17 | } 18 | } 19 | } 20 | return table[s.length()]; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/lc/general/DesignHitCounter_362.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import java.util.LinkedList; 4 | import java.util.Queue; 5 | 6 | public class DesignHitCounter_362 { 7 | 8 | private static class HitCounter { 9 | 10 | Queue queue; 11 | 12 | public HitCounter() { 13 | queue = new LinkedList<>(); 14 | } 15 | 16 | public void hit(int timestamp) { 17 | queue.add(timestamp); 18 | } 19 | 20 | public int getHits(int timestamp) { 21 | int start = timestamp - 300; 22 | while (!queue.isEmpty() && queue.peek() <= start) { 23 | queue.poll(); 24 | } 25 | return queue.size(); 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/lc/general/DesignTicTacToe_348.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class DesignTicTacToe_348 { 4 | 5 | private static class TicTacToe { 6 | 7 | public int[] rows; 8 | public int[] cols; 9 | public int diagonal = 0; 10 | public int antiDiagonal = 0; 11 | 12 | public int n; 13 | 14 | public TicTacToe(int n) { 15 | this.n = n; 16 | this.rows = new int[n]; 17 | this.cols = new int[n]; 18 | } 19 | 20 | public int move(int row, int col, int player) { 21 | int score = player == 0 ? 1 : -1; 22 | rows[row] += score; 23 | cols[col] += score; 24 | if (row == col) { 25 | diagonal += score; 26 | } 27 | if (col == (cols.length - row - 1)) { 28 | antiDiagonal += score; 29 | } 30 | if (Math.abs(rows[row]) == n || Math.abs(cols[col]) == n 31 | || Math.abs(diagonal) == n || Math.abs(antiDiagonal) == n) { 32 | return player; 33 | } 34 | return 0; 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/lc/general/DetermineIfTwoStringsAreClose_1657.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import java.util.Arrays; 4 | 5 | public class DetermineIfTwoStringsAreClose_1657 { 6 | 7 | public boolean closeStrings(String word1, String word2) { 8 | if (word1 == null || word2 == null || word1.length() != word2.length()) { 9 | return false; 10 | } 11 | int[] count1 = new int[26]; 12 | int[] count2 = new int[26]; 13 | for (char c : word1.toCharArray()) { 14 | count1[c - 'a']++; 15 | } 16 | for (char c : word2.toCharArray()) { 17 | count2[c - 'a']++; 18 | } 19 | if (Arrays.equals(count1, count2)) { 20 | return true; 21 | } 22 | return checkOccurrence(count1, count2); 23 | } 24 | 25 | private boolean checkOccurrence(int[] count1, int[] count2) { 26 | for (char c = 'a'; c <= 'z'; c++) { 27 | if (count1[c - 'a'] != 0 && count2[c - 'a'] == 0) { 28 | return false; 29 | } 30 | } 31 | Arrays.sort(count1); 32 | Arrays.sort(count2); 33 | return Arrays.equals(count1, count2); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /src/lc/general/EqualRowAndColumnPairs_2352.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import java.util.Arrays; 4 | 5 | public class EqualRowAndColumnPairs_2352 { 6 | 7 | public int equalPairs(int[][] grid) { 8 | int n = grid.length; 9 | int[][] cols = new int[n][n]; 10 | 11 | for (int r = 0; r < n; r++) { 12 | for (int c = 0; c < n; c++) { 13 | cols[c][r] = grid[r][c]; 14 | } 15 | } 16 | 17 | int count = 0; 18 | for (int r = 0; r < n; r++) { 19 | for (int c = 0; c < n; c++) { 20 | if (Arrays.equals(grid[r], cols[c])) { 21 | count++; 22 | } 23 | } 24 | } 25 | return count; 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /src/lc/general/FindNUniqueIntegersSumUpToZero_1304.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class FindNUniqueIntegersSumUpToZero_1304 { 4 | 5 | public int[] sumZero(int n) { 6 | int left = 0; 7 | int right = n - 1; // if only one element => 1 - 1 => 0 => result is new int[] { 0 }; 8 | int[] result = new int[n]; 9 | int value = 1; 10 | 11 | while (left < right) { 12 | result[left++] = value; 13 | result[right--] = -value; 14 | value++; 15 | } 16 | 17 | return result; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/lc/general/FindPivotIndex_724.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import utility.Util; 4 | 5 | public class FindPivotIndex_724 { 6 | 7 | public int pivotIndex(int[] nums) { 8 | int leftSum = 0; 9 | int rightSum = Util.sum(nums); 10 | for (int i = 0; i < nums.length; i++) { 11 | leftSum += nums[i]; 12 | if (leftSum == rightSum) { 13 | return i; 14 | } 15 | rightSum -= nums[i]; 16 | } 17 | return -1; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/lc/general/FindTheDifferenceOfTwoArrays_2215.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import java.util.ArrayList; 4 | import java.util.HashSet; 5 | import java.util.List; 6 | 7 | public class FindTheDifferenceOfTwoArrays_2215 { 8 | 9 | public List> findDifference(int[] nums1, int[] nums2) { 10 | var set1 = new HashSet(); 11 | for (int n : nums1) { 12 | set1.add(n); 13 | } 14 | var set2 = new HashSet(); 15 | for (int n : nums2) { 16 | set2.add(n); 17 | } 18 | 19 | for (int n : nums1) { 20 | if (set1.contains(n) && set2.contains(n)) { 21 | set1.remove(n); 22 | set2.remove(n); 23 | } 24 | } 25 | 26 | return List.of( 27 | new ArrayList<>(set1), 28 | new ArrayList<>(set2)); 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /src/lc/general/FindWinnerOfTicTacToeGame_1275.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class FindWinnerOfTicTacToeGame_1275 { 4 | 5 | public String tictactoe(int[][] moves) { 6 | // rule: 3 x 3 7 | int[] rows = new int[3]; 8 | int[] cols = new int[3]; 9 | int diagonal = 0; 10 | int antiDiagonal = 0; 11 | int turn = 0; // A == 0 && B == 1 12 | 13 | for (int[] m : moves) { 14 | int score = turn == 0 ? 1 : -1; 15 | int targetRow = m[0]; 16 | int targetCol = m[1]; 17 | 18 | // Straight 19 | rows[targetRow] += score; 20 | cols[targetCol] += score; 21 | // Diagonal 22 | if (targetRow == targetCol) { 23 | diagonal += score; 24 | } 25 | // Anti-Diagonal 26 | if (targetCol == (3 - targetRow - 1)) { 27 | antiDiagonal += score; 28 | } 29 | if (Math.abs(rows[targetRow]) == 3 || Math.abs(cols[targetCol]) == 3 30 | || Math.abs(diagonal) == 3 || Math.abs(antiDiagonal) == 3) { 31 | return turn == 0 ? "A" : "B"; 32 | } 33 | turn ^= 1; 34 | } 35 | 36 | return moves.length == 9 ? "DRAW" : "Pending"; 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/lc/general/IncreasingTripletSubsequence_334.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class IncreasingTripletSubsequence_334 { 4 | 5 | // O(n^3) 6 | public boolean naiveSolution(int[] nums) { 7 | for (int i = 0; i < nums.length; i++) { 8 | for (int j = i + 1; j < nums.length; j++) { 9 | for (int k = j + 1; k < nums.length; k++) { 10 | if (nums[i] < nums[j] && nums[j] < nums[k]) { 11 | return true; 12 | } 13 | } 14 | } 15 | } 16 | return false; 17 | } 18 | 19 | // O(n) - WTF moment 20 | public boolean increasingTriplet(int[] nums) { 21 | int first = Integer.MAX_VALUE; 22 | int second = Integer.MAX_VALUE; 23 | for (int n : nums) { 24 | if (n <= first) { 25 | first = n; 26 | } else if (n <= second) { 27 | second = n; 28 | } else { 29 | return true; 30 | } 31 | } 32 | return false; 33 | } 34 | } 35 | 36 | -------------------------------------------------------------------------------- /src/lc/general/Integer2Roman_12.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class Integer2Roman_12 { 4 | 5 | private static final String[] thousands = {"", "M", "MM", "MMM"}; // 3999 max 6 | private static final String[] hundreds = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", 7 | "CM"}; 8 | private static final String[] tens = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"}; 9 | private static final String[] ones = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"}; 10 | 11 | public String intToRoman(int num) { 12 | return thousands[num / 1000] + 13 | hundreds[num % 1000 / 100] + 14 | tens[num % 100 / 10] + 15 | ones[num % 10]; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/lc/general/IsSubsequence_392.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class IsSubsequence_392 { 4 | 5 | public boolean isSubsequence(String s, String t) { 6 | if (t.length() < s.length()) { 7 | return false; 8 | } 9 | int si = 0; 10 | int ti = 0; 11 | while (si < s.length() && ti < t.length()) { 12 | if (s.charAt(si) == t.charAt(ti)) { 13 | si++; 14 | } 15 | ti++; 16 | } 17 | return si == s.length(); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /src/lc/general/KidsWithTheGreatestNumberOfCandies_1431.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class KidsWithTheGreatestNumberOfCandies_1431 { 7 | 8 | public List kidsWithCandies(int[] candies, int extraCandies) { 9 | int max = 0; 10 | for (int c : candies) { 11 | max = Integer.max(c, max); 12 | } 13 | List result = new ArrayList<>(); 14 | for (int c : candies) { 15 | result.add((c + extraCandies) >= max); 16 | } 17 | return result; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/lc/general/LeastNumberOfUniqueIntegersAfterKRemovals_1481.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Collections; 5 | import java.util.HashMap; 6 | import java.util.List; 7 | import java.util.Map; 8 | 9 | public class LeastNumberOfUniqueIntegersAfterKRemovals_1481 { 10 | 11 | public int findLeastNumOfUniqueInts(int[] arr, int k) { 12 | Map map = new HashMap<>(); 13 | for (int a : arr) { 14 | map.put(a, map.getOrDefault(a, 0) + 1); 15 | } 16 | List list = new ArrayList<>(map.values()); 17 | Collections.sort(list); 18 | int counter = 0; 19 | // Remove with make least remaining number in array 20 | // so that's mean, we focus on lowest frequency (that's why we sort) 21 | for (int freq : list) { 22 | k -= freq; 23 | if (k < 0) { 24 | break; 25 | } 26 | counter++; 27 | } 28 | // key size represent number members in array 29 | return map.size() - counter; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/lc/general/LongestCommonPrefix_14.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class LongestCommonPrefix_14 { 4 | 5 | public String longestCommonPrefix(String[] strs) { 6 | if (strs.length == 1) { 7 | return strs[0]; 8 | } 9 | String firstWord = strs[0]; 10 | for (int i = 0; i < firstWord.length(); i++) { 11 | char c = firstWord.charAt(i); 12 | for (int j = 1; j < strs.length; j++) { 13 | if (strs[j].length() <= i || strs[j].charAt(i) != c) { 14 | return firstWord.substring(0, i); 15 | } 16 | } 17 | } 18 | return firstWord; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/lc/general/LongestSubarrayOf1sAfterDeletingOneElement_1493.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class LongestSubarrayOf1sAfterDeletingOneElement_1493 { 4 | public int longestSubarray(int[] nums) { 5 | int left = 0; 6 | int right = 0; 7 | int longest = 0; 8 | boolean isDelete = false; 9 | boolean isFoundZero = false; 10 | while (right < nums.length) { 11 | int rn = nums[right++]; 12 | if (rn == 0) { 13 | isFoundZero = true; 14 | while (isDelete) { 15 | int ln = nums[left]; 16 | if (ln == 0) { 17 | isDelete = false; 18 | } 19 | left++; 20 | } 21 | isDelete = true; 22 | } 23 | longest = Integer.max(longest, right - left); 24 | } 25 | return longest - 1; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/lc/general/MaxConsecutiveOnesIII_1004.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class MaxConsecutiveOnesIII_1004 { 4 | public int longestOnes(int[] nums, int k) { 5 | int left = 0; 6 | int right = 0; 7 | int longest = 0; 8 | int zero = k; 9 | while (right < nums.length) { 10 | int current = nums[right++]; 11 | if (current == 0) { 12 | zero--; 13 | while (left < nums.length && zero < 0) { 14 | int ln = nums[left]; 15 | if (ln == 0) { 16 | zero++; 17 | } 18 | left++; 19 | } 20 | } 21 | longest = Integer.max(longest, right - left); 22 | } 23 | return longest; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/lc/general/MaxDiffBetweenIncreasingElement_2016.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class MaxDiffBetweenIncreasingElement_2016 { 4 | 5 | public int maximumDifference(int[] nums) { 6 | int max = -1; 7 | int i = 0; 8 | int j = 0; 9 | while (j < nums.length) { 10 | if (nums[i] >= nums[j]) { 11 | i = j; 12 | } 13 | if (nums[j] > nums[i]) { 14 | max = Integer.max(max, Math.abs(nums[j] - nums[i])); 15 | } 16 | j++; 17 | } 18 | return max; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/lc/general/MaximumLevelSumOfABinaryTree_1161.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import common.TreeNode; 4 | 5 | import java.util.LinkedList; 6 | 7 | public class MaximumLevelSumOfABinaryTree_1161 { 8 | 9 | public int maxLevelSum(TreeNode root) { 10 | LinkedList queue = new LinkedList<>(); 11 | queue.add(root); 12 | int max = Integer.MIN_VALUE; 13 | int currentLevel = 1; 14 | int result = currentLevel; 15 | while (!queue.isEmpty()) { 16 | int levelSize = queue.size(); 17 | int sum = 0; 18 | for (int i = 0; i < levelSize; i++) { 19 | var current = queue.poll(); 20 | sum += current.val; 21 | if (current.left != null) { 22 | queue.add(current.left); 23 | } 24 | if (current.right != null) { 25 | queue.add(current.right); 26 | } 27 | } 28 | if (sum > max) { 29 | max = sum; 30 | result = currentLevel; 31 | } 32 | currentLevel++; 33 | } 34 | return result; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/lc/general/MaximumNumberOfVowelsInASubstringOfGivenLength_1456.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class MaximumNumberOfVowelsInASubstringOfGivenLength_1456 { 4 | 5 | public int maxVowels(String s, int k) { 6 | int left = 0; 7 | int right = 0; 8 | int maxVowelsInLength = 0; 9 | int[] counter = new int[26]; 10 | while (right < s.length()) { 11 | char rc = s.charAt(right++); 12 | counter[rc - 'a']++; 13 | if (right - left == k) { 14 | maxVowelsInLength = Integer.max( 15 | maxVowelsInLength, 16 | countVowels(counter) 17 | ); 18 | char lc = s.charAt(left++); 19 | counter[lc - 'a']--; 20 | } 21 | } 22 | return maxVowelsInLength; 23 | } 24 | 25 | private int countVowels(int[] counter) { 26 | return counter['a' - 'a'] + 27 | counter['e' - 'a'] + 28 | counter['i' - 'a'] + 29 | counter['o' - 'a'] + 30 | counter['u' - 'a']; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/lc/general/MaximumSubsequenceScore_2542.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import java.util.Arrays; 4 | import java.util.PriorityQueue; 5 | 6 | public class MaximumSubsequenceScore_2542 { 7 | 8 | public long maxScore(int[] nums1, int[] nums2, int k) { 9 | int n = nums1.length; 10 | int[][] pairs = new int[n][2]; 11 | for (int i = 0; i < n; i++) { 12 | pairs[i] = new int[]{nums2[i], nums1[i]}; 13 | } 14 | 15 | Arrays.sort(pairs, (a, b) -> Integer.compare(b[0], a[0])); 16 | PriorityQueue pq = new PriorityQueue<>(); 17 | long maximumScore = 0; 18 | long sum = 0; 19 | 20 | for (int[] pair : pairs) { 21 | pq.add(pair[1]); 22 | sum += pair[1]; 23 | if (pq.size() > k) { 24 | sum -= pq.poll(); 25 | } 26 | if (pq.size() == k) { 27 | maximumScore = Math.max(maximumScore, sum * pair[0]); 28 | } 29 | } 30 | 31 | return maximumScore; 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /src/lc/general/MaximumTwinSumOfALinkedList_2130.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import common.ListNode; 4 | 5 | public class MaximumTwinSumOfALinkedList_2130 { 6 | 7 | public int pairSum(ListNode head) { 8 | int max = 0; 9 | int n = 0; 10 | ListNode curr = head; 11 | while (curr != null) { 12 | n++; 13 | curr = curr.next; 14 | } 15 | int expectedSize = n / 2; 16 | 17 | int[] result = new int[expectedSize]; 18 | curr = head; 19 | for (int left = 0; left < expectedSize; left++) { 20 | result[left] += curr.val; 21 | curr = curr.next; 22 | } 23 | for (int right = expectedSize - 1; right >= 0; right--) { 24 | result[right] += curr.val; 25 | max = Integer.max(max, result[right]); 26 | curr = curr.next; 27 | } 28 | 29 | return max; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/lc/general/MergeSortedArray_88.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class MergeSortedArray_88 { 4 | public void merge(int[] nums1, int m, int[] nums2, int n) { 5 | int writeIndex = nums1.length - 1; 6 | int mPtr = m - 1; 7 | int nPtr = n - 1; 8 | 9 | while (writeIndex >= 0) { 10 | if (mPtr >= 0 && nPtr >= 0) { 11 | if (nums1[mPtr] > nums2[nPtr]) { 12 | nums1[writeIndex] = nums1[mPtr--]; 13 | } else { 14 | nums1[writeIndex] = nums2[nPtr--]; 15 | } 16 | } else if (mPtr >= 0) { 17 | nums1[writeIndex] = nums1[mPtr--]; 18 | } else { 19 | nums1[writeIndex] = nums2[nPtr--]; 20 | } 21 | writeIndex--; 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/lc/general/MinimumDeletionsToMakeCharacterFrequenciesUnique_1647.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import constant.StringConstant; 4 | import java.util.HashSet; 5 | import java.util.Set; 6 | import utility.Util; 7 | 8 | public class MinimumDeletionsToMakeCharacterFrequenciesUnique_1647 { 9 | 10 | public int minDeletions(String s) { 11 | if (s == null || s.isEmpty()) { 12 | return 0; 13 | } 14 | int[] freq = new int[StringConstant.LOWERCASE_AMOUNT]; 15 | for (char c : s.toCharArray()) { 16 | freq[Util.getLowercaseIndex(c)]++; 17 | } 18 | 19 | Set countSet = new HashSet<>(); 20 | int result = 0; 21 | for (int n : freq) { 22 | int curr = n; 23 | while (curr > 0 && !countSet.add(curr)) { 24 | curr--; 25 | result++; 26 | } 27 | } 28 | return result; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/lc/general/MinimumFlipsToMakeAORBEqualToC_1318.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class MinimumFlipsToMakeAORBEqualToC_1318 { 4 | public int minFlips(int a, int b, int c) { 5 | int count = 0; 6 | // 32 bits => function need int? 7 | for (int i = 0; i < 32; i++) { 8 | // Get bit technique 9 | int bitA = (a >> i) & 1; 10 | int bitB = (b >> i) & 1; 11 | int bitC = (c >> i) & 1; 12 | if ((bitA | bitB) != bitC) { 13 | // Since it's OR => if c == 0 and it's false from previous condition 14 | // bitA, bitB need to flip if they're 1 15 | // count will add by 1 for set bit 16 | // otherwise, add nothing 17 | if (bitC == 0) { 18 | count += bitA + bitB; 19 | } else { 20 | // Either flip a or b, required at least one of them 21 | count++; 22 | } 23 | } 24 | } 25 | return count; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/lc/general/NumberDifferentIntegersInString_1805.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import java.util.Arrays; 4 | 5 | public class NumberDifferentIntegersInString_1805 { 6 | 7 | public int numDifferentInteger(String word) { 8 | String[] wordSplit = word.replaceAll("[a-z]+", " ") 9 | .split("\\s+"); 10 | return (int) Arrays.stream(wordSplit) 11 | .filter(t -> !t.isEmpty()) 12 | // replace prefix zero with empty string 13 | .map(t -> t.replaceFirst("^0+", "")) 14 | .distinct() 15 | .count(); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/lc/general/OneEditDistance_161.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class OneEditDistance_161 { 4 | 5 | public boolean isOneEditDistance(String s, String t) { 6 | if (s.length() == t.length()) { 7 | return oneEditReplace(s, t); 8 | } else if (s.length() + 1 == t.length()) { 9 | return oneEditInsert(s, t); 10 | } else if (s.length() - 1 == t.length()) { 11 | return oneEditInsert(t, s); 12 | } 13 | return false; 14 | } 15 | 16 | private boolean oneEditReplace(String s1, String s2) { 17 | boolean isOneDiff = false; 18 | for (int i = 0; i < s1.length(); i++) { 19 | if (s1.charAt(i) != s2.charAt(i)) { 20 | if (isOneDiff) { 21 | return false; 22 | } 23 | isOneDiff = true; 24 | } 25 | } 26 | return isOneDiff; 27 | } 28 | 29 | boolean oneEditInsert(String s1, String s2) { 30 | int i1 = 0; 31 | int i2 = 0; 32 | while (i1 < s1.length() && i2 < s2.length()) { 33 | if (s1.charAt(i1) != s2.charAt(i2)) { 34 | if (i1 != i2) { 35 | return false; 36 | } 37 | } else { 38 | i1++; 39 | } 40 | i2++; 41 | } 42 | return true; 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/lc/general/RansomNote_383.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import static constant.StringConstant.LOWERCASE_AMOUNT; 4 | 5 | public class RansomNote_383 { 6 | 7 | public boolean canConstruct(String ransomNote, String magazine) { 8 | int[] count = new int[LOWERCASE_AMOUNT]; 9 | for (char c : magazine.toCharArray()) { 10 | count[c - 'a']++; 11 | } 12 | for (char c : ransomNote.toCharArray()) { 13 | if (count[c - 'a'] == 0) { 14 | return false; 15 | } 16 | count[c - 'a']--; 17 | } 18 | return true; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/lc/general/ReverseWordsInString_151.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import java.util.Arrays; 4 | import java.util.Collections; 5 | import java.util.List; 6 | 7 | public class ReverseWordsInString_151 { 8 | 9 | public String reverseWords(String s) { 10 | s = s.trim(); 11 | List list = Arrays.asList(s.split("\\s+")); 12 | Collections.reverse(list); 13 | return String.join(" ", list); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/lc/general/Roman2Integer_13.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | import java.util.Map; 4 | 5 | public class Roman2Integer_13 { 6 | 7 | private static final Map SYMBOL = Map.of( 8 | 'I', 1, 9 | 'V', 5, 10 | 'X', 10, 11 | 'L', 50, 12 | 'C', 100, 13 | 'D', 500, 14 | 'M', 1000 15 | ); 16 | 17 | public int romanToInt(String s) { 18 | int value = 0; 19 | int i = s.length() - 1; 20 | value += SYMBOL.get(s.charAt(i--)); 21 | while (i >= 0) { 22 | if (SYMBOL.get(s.charAt(i)) < SYMBOL.get(s.charAt(i + 1))) { 23 | value -= SYMBOL.get(s.charAt(i)); 24 | } else { 25 | value += SYMBOL.get(s.charAt(i)); 26 | } 27 | i--; 28 | } 29 | return value; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/lc/general/ScoreOfAString_3110.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class ScoreOfAString_3110 { 4 | public int scoreOfString(String s) { 5 | int sum = 0; 6 | for (int i = 1; i < s.length(); i++) { 7 | sum += Math.abs((int) s.charAt(i) - (int) s.charAt(i - 1)); 8 | } 9 | return sum; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/lc/general/SignOfTheProductOfArray_1822.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class SignOfTheProductOfArray_1822 { 4 | 5 | public int arraySign(int[] nums) { 6 | int sign = 1; 7 | for (int n : nums) { 8 | if (n == 0) { 9 | return 0; 10 | } 11 | if (n < 0) { 12 | sign = -sign; 13 | } 14 | } 15 | return sign; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/lc/general/StringCompression_443.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class StringCompression_443 { 4 | 5 | public int compress(char[] chars) { 6 | if (chars == null || chars.length == 0) { 7 | return 0; 8 | } 9 | int writeIndex = 0; 10 | int counter = 1; 11 | for (int i = 0; i < chars.length; i++) { 12 | while (i + 1 < chars.length && chars[i] == chars[i + 1]) { 13 | counter++; 14 | i++; 15 | } 16 | // drop to this zone when next element not match, or we on last element 17 | chars[writeIndex++] = chars[i]; 18 | if (counter != 1) { 19 | String numTxt = String.valueOf(counter); 20 | for (char c : numTxt.toCharArray()) { 21 | chars[writeIndex++] = c; 22 | } 23 | } 24 | // Reset 25 | counter = 1; 26 | } 27 | return writeIndex; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/lc/general/TheKthFactorOfN_1492.java: -------------------------------------------------------------------------------- 1 | package lc.general; 2 | 3 | public class TheKthFactorOfN_1492 { 4 | 5 | public int kthFactor(int n, int k) { 6 | for (int i = 1; i <= n; i++) { 7 | // Factor หรือตัวประกอบ 8 | // คือตัวที่มันจะหารลงตัว (n % factor == 0) 9 | if (n % i == 0) { 10 | k--; 11 | if (k == 0) { 12 | return i; 13 | } 14 | } 15 | } 16 | return -1; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/lc/general/easy/ApplyOperationsToAnArray_2460.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | public class ApplyOperationsToAnArray_2460 { 4 | 5 | public int[] applyOperations(int[] nums) { 6 | for (int i = 1; i < nums.length; i++) { 7 | if (nums[i] == nums[i - 1]) { 8 | nums[i - 1] = nums[i - 1] * 2; 9 | nums[i] = 0; 10 | } 11 | } 12 | shiftZero(nums); 13 | return nums; 14 | } 15 | 16 | public void shiftZero(int[] nums) { 17 | int read = 0; 18 | int write = 0; 19 | while (read < nums.length) { 20 | if (nums[read] != 0) { 21 | nums[write++] = nums[read]; 22 | } 23 | read++; 24 | } 25 | while (write < nums.length) { 26 | nums[write++] = 0; 27 | } 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /src/lc/general/easy/CheckIfArrayIsSortedAndRotated_1752.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | public class CheckIfArrayIsSortedAndRotated_1752 { 4 | public boolean check(int[] nums) { 5 | int count = 0; 6 | int n = nums.length; 7 | for (int i = 0; i < n; i++) { 8 | // Check if sorted and rotated => Module to check on first element 9 | if (nums[i] > nums[(i + 1) % n]) { 10 | count++; 11 | } 12 | } 13 | return count <= 1; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/lc/general/easy/ClearDigits_3174.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | public class ClearDigits_3174 { 4 | public String clearDigits(String s) { 5 | StringBuilder sb = new StringBuilder(); 6 | for (char c : s.toCharArray()) { 7 | if (Character.isDigit(c) && !sb.isEmpty()) { 8 | sb.deleteCharAt(sb.length() - 1); 9 | } else { 10 | sb.append(c); 11 | } 12 | } 13 | return sb.toString(); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/lc/general/easy/ConfusingNumber_1056.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | import java.util.Map; 4 | 5 | public class ConfusingNumber_1056 { 6 | 7 | public boolean confusingNumber(int n) { 8 | if (n == 0) { 9 | return false; 10 | } 11 | int input = n; 12 | while (n % 10 == 0) { 13 | n /= 10; 14 | } 15 | Map rotateMap = Map.of( 16 | 0, 0, 17 | 1, 1, 18 | 6, 9, 19 | 8, 8, 20 | 9, 6 21 | ); 22 | int rotate = 0; 23 | while (n != 0) { 24 | int digit = n % 10; 25 | if (!rotateMap.containsKey(digit)) { 26 | return false; 27 | } 28 | rotate = rotate * 10 + rotateMap.get(digit); 29 | n /= 10; 30 | } 31 | return rotate != input; 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /src/lc/general/easy/CountingElements_1426.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | public class CountingElements_1426 { 4 | public int countElements(int[] arr) { 5 | int[] count = new int[1001]; 6 | for (int a : arr) { 7 | count[a]++; 8 | } 9 | int result = 0; 10 | for (int i = 0; i < 1000; i++) { 11 | if (count[i] != 0 && count[i + 1] != 0) { 12 | result += count[i]; 13 | } 14 | } 15 | return result; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/lc/general/easy/DegreeOfArray_697.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class DegreeOfArray_697 { 7 | 8 | public int findShortestSubArray(int[] nums) { 9 | Map startMap = new HashMap<>(); 10 | Map freqMap = new HashMap<>(); 11 | int maxDegree = 0; 12 | int maxLength = 0; 13 | for (int i = 0; i < nums.length; i++) { 14 | int num = nums[i]; 15 | // Place first met of this number 16 | startMap.putIfAbsent(num, i); 17 | freqMap.put(num, freqMap.getOrDefault(num, 0) + 1); 18 | // in case same index => the result would be length == 1 19 | int currentLength = i - startMap.get(num) + 1; 20 | if (maxDegree < freqMap.get(num)) { 21 | maxDegree = freqMap.get(num); 22 | maxLength = currentLength; 23 | } else if (maxDegree == freqMap.get(num)) { 24 | maxLength = Integer.max(maxLength, currentLength); 25 | } 26 | } 27 | return maxLength; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/lc/general/easy/DiameterOfBinaryTree_543.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | import common.TreeNode; 4 | 5 | public class DiameterOfBinaryTree_543 { 6 | public int diameterOfBinaryTree(TreeNode root) { 7 | if (root == null) { 8 | return 0; 9 | } 10 | int[] result = {0}; 11 | findDiameter(root, result); 12 | return result[0]; 13 | } 14 | 15 | public int findDiameter(TreeNode node, int[] result) { 16 | if (node == null) { 17 | return 0; 18 | } 19 | int left = findDiameter(node.left, result); 20 | int right = findDiameter(node.right, result); 21 | int currentDiameter = left + right; 22 | result[0] = Integer.max(result[0], currentDiameter); 23 | return 1 + Integer.max(left, right); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/lc/general/easy/FindAnagramMappings_760.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class FindAnagramMappings_760 { 7 | public int[] anagramMappings(int[] nums1, int[] nums2) { 8 | Map valToIdx = new HashMap<>(); 9 | for (int i = 0; i < nums2.length; i++) { 10 | valToIdx.put(nums2[i], i); 11 | } 12 | int[] result = new int[nums1.length]; 13 | for (int i = 0; i < nums2.length; i++) { 14 | result[i] = valToIdx.get(nums1[i]); 15 | } 16 | return result; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/lc/general/easy/FindMissingAndRepeatedValues_2965.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | public class FindMissingAndRepeatedValues_2965 { 4 | public int[] findMissingAndRepeatedValues(int[][] grid) { 5 | int n = grid.length; 6 | int size = n * n; 7 | int[] count = new int[size + 1]; 8 | for (var row : grid) { 9 | for (var num : row) { 10 | count[num]++; 11 | } 12 | } 13 | 14 | int[] result = {0, 0}; 15 | for (int i = 1; i <= size; i++) { 16 | if (count[i] == 0) { 17 | result[1] = i; 18 | } else if (count[i] > 1) { 19 | result[0] = i; 20 | } 21 | } 22 | return result; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/lc/general/easy/LargestUniqueNumber_1133.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | public class LargestUniqueNumber_1133 { 4 | public int largestUniqueNumber(int[] nums) { 5 | int[] count = new int[2001]; 6 | for (int n : nums) { 7 | count[n]++; 8 | } 9 | for (int i = 2000; i >= 0; i--) { 10 | if (count[i] == 1) { 11 | return i; 12 | } 13 | } 14 | return -1; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/lc/general/easy/LongestPalindrome_409.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class LongestPalindrome_409 { 7 | 8 | public int longestPalindrome(String s) { 9 | int length = 0; 10 | int addition = 0; 11 | 12 | Map countMap = new HashMap<>(); 13 | for (char c : s.toCharArray()) { 14 | countMap.put(c, countMap.getOrDefault(c, 0) + 1); 15 | } 16 | for (var entry : countMap.entrySet()) { 17 | if (entry.getValue() % 2 == 0) { 18 | length += entry.getValue(); 19 | } else { 20 | length += entry.getValue() - 1; 21 | addition = 1; 22 | } 23 | } 24 | return length + addition; 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /src/lc/general/easy/LongestStrictlyIncreasingOrStrictlyDecreasingSubarray_3105.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | public class LongestStrictlyIncreasingOrStrictlyDecreasingSubarray_3105 { 4 | 5 | public int longestMonotonicSubarray(int[] nums) { 6 | int n = nums.length; 7 | int longest = 1; 8 | for (int i = 0; i < n; i++) { 9 | for (int j = i + 1; j < n; j++) { 10 | if (nums[j - 1] >= nums[j]) { 11 | break; 12 | } 13 | longest = Integer.max(longest, j - i + 1); 14 | } 15 | } 16 | for (int i = 0; i < n; i++) { 17 | for (int j = i + 1; j < n; j++) { 18 | if (nums[j - 1] <= nums[j]) { 19 | break; 20 | } 21 | longest = Integer.max(longest, j - i + 1); 22 | } 23 | } 24 | return longest; 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /src/lc/general/easy/MajorityElement_169.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | public class MajorityElement_169 { 4 | public int majorityElement(int[] nums) { 5 | int count = 0; 6 | int candidate = Integer.MIN_VALUE; 7 | for (int n : nums) { 8 | if (count == 0) { 9 | candidate = n; 10 | } 11 | count += (n == candidate) ? 1 : -1; 12 | } 13 | return candidate; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/lc/general/easy/MaximumCountOfPositiveIntegerAndNegativeInteger_2529.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | public class MaximumCountOfPositiveIntegerAndNegativeInteger_2529 { 4 | public int maximumCount(int[] nums) { 5 | int pos = 0; 6 | int neg = 0; 7 | for (int n : nums) { 8 | if (n > 0) { 9 | pos++; 10 | } else if (n < 0) { 11 | neg++; 12 | } 13 | } 14 | return Integer.max(pos, neg); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/lc/general/easy/MovingAverageFromDataStream_346.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | import java.util.LinkedList; 4 | import java.util.Queue; 5 | 6 | public class MovingAverageFromDataStream_346 { 7 | 8 | static class MovingAverage { 9 | 10 | private final int size; 11 | private int sum; 12 | private final Queue queue; 13 | 14 | public MovingAverage(int size) { 15 | this.size = size; 16 | this.sum = 0; 17 | this.queue = new LinkedList<>(); 18 | } 19 | 20 | public double next(int val) { 21 | sum += val; 22 | queue.offer(val); 23 | if (queue.size() > size) { 24 | int removedNum = queue.poll(); 25 | sum -= removedNum; 26 | } 27 | return (double) sum / queue.size(); 28 | } 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /src/lc/general/easy/PalindromePermutation_266.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | public class PalindromePermutation_266 { 4 | 5 | public boolean canPermutePalindrome(String s) { 6 | int[] count = new int[26]; 7 | for (char c : s.toCharArray()) { 8 | count[c - 'a']++; 9 | } 10 | boolean isFoundOdd = false; 11 | for (int n : count) { 12 | if (n % 2 != 0 && isFoundOdd) { 13 | return false; 14 | } else if (n % 2 != 0) { 15 | isFoundOdd = true; 16 | } 17 | } 18 | return true; 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /src/lc/general/easy/PerformStringShifts_1427.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | public class PerformStringShifts_1427 { 4 | 5 | public String stringShift(String s, int[][] shift) { 6 | // Left shift => right 7 | // Right shift => left 8 | // sub str1 + sub str 2 9 | int length = s.length(); 10 | int index = 0; 11 | for (var command : shift) { 12 | index += command[0] == 0 ? command[1] : -command[1]; 13 | } 14 | index %= length; 15 | if (index < 0) { 16 | index += length; 17 | } 18 | return s.substring(index) + s.substring(0, index); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /src/lc/general/easy/SingleRowKeyboard_1165.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | public class SingleRowKeyboard_1165 { 4 | public int calculateTime(String keyboard, String word) { 5 | int[] index = new int[26]; 6 | for (int i = 0; i < keyboard.length(); i++) { 7 | char c = keyboard.charAt(i); 8 | index[c - 'a'] = i; 9 | } 10 | int move = 0; 11 | int current = 0; 12 | for (char c : word.toCharArray()) { 13 | move += Math.abs(index[c - 'a'] - current); 14 | current = index[c - 'a']; 15 | } 16 | return move; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/lc/general/easy/SpecialArrayI_3151.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | public class SpecialArrayI_3151 { 4 | 5 | public boolean isArraySpecial(int[] nums) { 6 | if (nums.length == 1) { 7 | return true; 8 | } 9 | for (int i = 1; i < nums.length; i++) { 10 | boolean isCurrEven = nums[i] % 2 == 0; 11 | if ((isCurrEven && nums[i - 1] % 2 == 0) || (!isCurrEven && nums[i - 1] % 2 != 0)) { 12 | return false; 13 | } 14 | } 15 | return true; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/lc/general/easy/ValidWordSquare_422.java: -------------------------------------------------------------------------------- 1 | package lc.general.easy; 2 | 3 | import java.util.List; 4 | 5 | public class ValidWordSquare_422 { 6 | public boolean validWordSquare(List words) { 7 | if (words.isEmpty()) { 8 | return true; 9 | } 10 | 11 | int n = words.size(); 12 | for (int i = 0; i < n; i++) { 13 | for (int j = 0; j < words.get(i).length(); j++) { 14 | if (j >= n || 15 | i >= words.get(j).length() || 16 | words.get(i).charAt(j) != words.get(j).charAt(i) 17 | ) { 18 | return false; 19 | } 20 | } 21 | } 22 | 23 | return true; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/lc/general/medium/AlternatingGroupsII_3208.java: -------------------------------------------------------------------------------- 1 | package lc.general.medium; 2 | 3 | public class AlternatingGroupsII_3208 { 4 | 5 | public int numberOfAlternatingGroups(int[] colors, int k) { 6 | int n = colors.length; 7 | int[] temp = new int[n + k - 1]; 8 | 9 | System.arraycopy(colors, 0, temp, 0, n); 10 | System.arraycopy(colors, 0, temp, n, k - 1); 11 | 12 | int count = 0; 13 | int left = 0; 14 | int right = 0; 15 | 16 | while (right < temp.length) { 17 | if (right > 0 && temp[right] == temp[right - 1]) { 18 | left = right; 19 | } 20 | 21 | if (right - left + 1 >= k) { 22 | count++; 23 | } 24 | 25 | right++; 26 | } 27 | 28 | return count; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/lc/general/medium/CheckIfNumberIsASumOfPowersOfThree_1780.java: -------------------------------------------------------------------------------- 1 | package lc.general.medium; 2 | 3 | public class CheckIfNumberIsASumOfPowersOfThree_1780 { 4 | public boolean checkPowersOfThree(int n) { 5 | while (n != 0) { 6 | if (n % 3 == 2) { 7 | return false; 8 | } 9 | n /= 3; 10 | } 11 | return true; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/lc/general/medium/CountNumberOfBadPairs_2364.java: -------------------------------------------------------------------------------- 1 | package lc.general.medium; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class CountNumberOfBadPairs_2364 { 7 | 8 | public long countBadPairs(int[] nums) { 9 | Map map = new HashMap<>(); 10 | long count = 0; 11 | int n = nums.length; 12 | 13 | for (int i = 0; i < n; i++) { 14 | int key = nums[i] - i; 15 | map.put(key, map.getOrDefault(key, 0) + 1); 16 | } 17 | 18 | for (int i = 0; i < n; i++) { 19 | int key = nums[i] - i; 20 | // Reduce usage 21 | map.put(key, map.get(key) - 1); 22 | count += n - i - 1 - map.getOrDefault(key, 0); 23 | } 24 | 25 | return count; 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /src/lc/general/medium/DesignMostRecentlyUsedQueue_1756.java: -------------------------------------------------------------------------------- 1 | package lc.general.medium; 2 | 3 | public class DesignMostRecentlyUsedQueue_1756 { 4 | 5 | class MRUQueue { 6 | private int[] nums; 7 | private int size; 8 | 9 | public MRUQueue(int n) { 10 | nums = new int[n]; 11 | size = n; 12 | for (int i = 0; i < n; i++) { 13 | nums[i] = i + 1; 14 | } 15 | } 16 | 17 | public int fetch(int k) { 18 | k--; // Convert to 0-based index 19 | int val = nums[k]; 20 | 21 | // Shift elements in bulk using System.arraycopy 22 | System.arraycopy(nums, k + 1, nums, k, size - k - 1); 23 | nums[size - 1] = val; 24 | 25 | return val; 26 | } 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /src/lc/general/medium/Dota2Senate_649.java: -------------------------------------------------------------------------------- 1 | package lc.general.medium; 2 | 3 | import java.util.LinkedList; 4 | import java.util.Queue; 5 | 6 | public class Dota2Senate_649 { 7 | 8 | public String predictPartyVictory(String senate) { 9 | int n = senate.length(); 10 | Queue radiantQueue = new LinkedList<>(); 11 | Queue direQueue = new LinkedList<>(); 12 | for (int i = 0; i < n; i++) { 13 | char c = senate.charAt(i); 14 | if (c == 'R') { 15 | radiantQueue.add(i); 16 | } else { 17 | direQueue.add(i); 18 | } 19 | } 20 | while (!radiantQueue.isEmpty() && !direQueue.isEmpty()) { 21 | var r = radiantQueue.poll(); 22 | var d = direQueue.poll(); 23 | if (r < d) { 24 | // Ban D => Put itself to queue 25 | // But want to ignore next compare as well 26 | radiantQueue.add(r + n); 27 | } else { 28 | direQueue.add(d + n); 29 | } 30 | } 31 | return !radiantQueue.isEmpty() ? "Radiant" : "Dire"; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/lc/general/medium/FirstUniqueNumber_1429.java: -------------------------------------------------------------------------------- 1 | package lc.general.medium; 2 | 3 | import java.util.HashSet; 4 | import java.util.LinkedHashSet; 5 | import java.util.Set; 6 | 7 | public class FirstUniqueNumber_1429 { 8 | 9 | class FirstUnique { 10 | 11 | private Set queue; 12 | private Set seen; 13 | 14 | public FirstUnique(int[] nums) { 15 | queue = new LinkedHashSet<>(); 16 | seen = new HashSet<>(); 17 | for (int n : nums) { 18 | add(n); 19 | } 20 | } 21 | 22 | public int showFirstUnique() { 23 | return queue.isEmpty() ? -1 : queue.iterator().next(); 24 | } 25 | 26 | public void add(int value) { 27 | if (!seen.add(value)) { 28 | queue.remove(value); 29 | } else { 30 | queue.add(value); 31 | } 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/lc/general/medium/MakeThePrefixSumNonNegative_2599.java: -------------------------------------------------------------------------------- 1 | package lc.general.medium; 2 | 3 | import java.util.PriorityQueue; 4 | 5 | public class MakeThePrefixSumNonNegative_2599 { 6 | 7 | public int makePrefSumNonNegative(int[] nums) { 8 | int prefixSum = 0; 9 | PriorityQueue minHeap = new PriorityQueue<>(); 10 | int count = 0; 11 | for (int n : nums) { 12 | prefixSum += n; 13 | if (n < 0) { 14 | minHeap.add(n); 15 | } 16 | while (prefixSum < 0 && !minHeap.isEmpty()) { 17 | int lowestInHeap = minHeap.poll(); 18 | prefixSum -= lowestInHeap; 19 | count++; 20 | } 21 | } 22 | return count; 23 | } 24 | } -------------------------------------------------------------------------------- /src/lc/general/medium/MaximumAbsoluteSumOfAnySubarray_1749.java: -------------------------------------------------------------------------------- 1 | package lc.general.medium; 2 | 3 | public class MaximumAbsoluteSumOfAnySubarray_1749 { 4 | 5 | public int maxAbsoluteSum(int[] nums) { 6 | int currentMin = 0; 7 | int minSoFar = 0; 8 | int currentMax = 0; 9 | int maxSoFar = 0; 10 | 11 | for (int n : nums) { 12 | currentMin = Math.min(0, currentMin + n); 13 | minSoFar = Math.min(minSoFar, currentMin); 14 | 15 | currentMax = Math.max(0, currentMax + n); 16 | maxSoFar = Math.max(maxSoFar, currentMax); 17 | } 18 | 19 | return Math.max(maxSoFar, Math.abs(minSoFar)); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/lc/general/medium/MaximumDistanceInArrays_624.java: -------------------------------------------------------------------------------- 1 | package lc.general.medium; 2 | 3 | import java.util.List; 4 | 5 | public class MaximumDistanceInArrays_624 { 6 | 7 | public int maxDistance(List> arrays) { 8 | int result = 0; 9 | int min = arrays.get(0).getFirst(); 10 | int max = arrays.get(0).getLast(); 11 | for (int i = 1; i < arrays.size(); i++) { 12 | int nextMin = arrays.get(i).getFirst(); 13 | int nextMax = arrays.get(i).getLast(); 14 | result = Integer.max(result, Math.abs(min - nextMax)); 15 | result = Integer.max(result, Math.abs(max - nextMin)); 16 | min = Integer.min(min, nextMin); 17 | max = Integer.max(max, nextMax); 18 | } 19 | return result; 20 | } 21 | } -------------------------------------------------------------------------------- /src/lc/general/medium/NumberOfSubarraysWithOddSum_1524.java: -------------------------------------------------------------------------------- 1 | package lc.general.medium; 2 | 3 | public class NumberOfSubarraysWithOddSum_1524 { 4 | public int numOfSubarrays(int[] arr) { 5 | final int MOD = 1_000_000_007; 6 | int oddCount = 0; 7 | int evenCount = 1; // Start with 1 for empty subarray (sum = 0 is even) 8 | int sum = 0; 9 | int result = 0; 10 | 11 | for (int num : arr) { 12 | sum += num; 13 | if (sum % 2 == 1) { 14 | result = (result + evenCount) % MOD; 15 | oddCount++; 16 | } else { 17 | result = (result + oddCount) % MOD; 18 | evenCount++; 19 | } 20 | } 21 | 22 | return result; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/lc/general/medium/RemoveAllOccurrencesOfASubstring_1910.java: -------------------------------------------------------------------------------- 1 | package lc.general.medium; 2 | 3 | public class RemoveAllOccurrencesOfASubstring_1910 { 4 | public String removeOccurrences(String s, String part) { 5 | String result = s; 6 | int indexOfPart = s.indexOf(part); 7 | while (indexOfPart != -1) { 8 | int length = part.length(); 9 | result = result.substring(0, indexOfPart) + 10 | result.substring(indexOfPart + length); 11 | indexOfPart = result.indexOf(part); 12 | } 13 | return result; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/lc/general/medium/TupleWithSameProduct_1726.java: -------------------------------------------------------------------------------- 1 | package lc.general.medium; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class TupleWithSameProduct_1726 { 7 | 8 | public int tupleSameProduct(int[] nums) { 9 | int count = 0; 10 | Map valueFreq = new HashMap<>(); 11 | for (int i = 0; i < nums.length; i++) { 12 | for (int j = i + 1; j < nums.length; j++) { 13 | long productValue = nums[i] * nums[j]; 14 | valueFreq.put(productValue, valueFreq.getOrDefault(productValue, 0) + 1); 15 | } 16 | } 17 | for (var freq : valueFreq.values()) { 18 | if (freq > 1) { 19 | // 8 combination of a,b,c,d 20 | count += freq * (freq - 1) / 2 * 8; 21 | } 22 | } 23 | return count; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/lc/pattern/backtracking/FindThePunishmentNumberOfAnInteger_2698.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.backtracking; 2 | 3 | public class FindThePunishmentNumberOfAnInteger_2698 { 4 | 5 | public int punishmentNumber(int n) { 6 | int result = 0; 7 | for (int num = 1; num <= n; num++) { 8 | int square = num * num; 9 | if (canPartition(String.valueOf(square), num)) { 10 | result += square; 11 | } 12 | } 13 | return result; 14 | } 15 | 16 | private boolean canPartition(String numText, int target) { 17 | return canPartition(numText, 0, target); 18 | } 19 | 20 | private boolean canPartition(String numText, int currentIndex, int target) { 21 | if (currentIndex == numText.length()) { 22 | return target == 0; 23 | } 24 | for (int index = currentIndex + 1; index <= numText.length(); index++) { 25 | int partitionedNum = Integer.parseInt(numText.substring(currentIndex, index)); 26 | if (canPartition(numText, index, target - partitionedNum)) { 27 | return true; 28 | } 29 | } 30 | return false; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/lc/pattern/backtracking/FindUniqueBinaryString_1980.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.backtracking; 2 | 3 | import java.util.Arrays; 4 | import java.util.HashSet; 5 | import java.util.Set; 6 | 7 | public class FindUniqueBinaryString_1980 { 8 | public String findDifferentBinaryString(String[] nums) { 9 | Set numsSet = new HashSet<>(Arrays.asList(nums)); 10 | int n = nums.length; 11 | Set generateResult = new HashSet<>(); 12 | backtracking(new StringBuilder(), n, generateResult); 13 | for (String s : generateResult) { 14 | if (!numsSet.contains(s)) { 15 | return s; 16 | } 17 | } 18 | return ""; 19 | } 20 | 21 | private void backtracking(StringBuilder curr, int n, Set result) { 22 | if (curr.length() == n) { 23 | result.add(curr.toString()); 24 | return; 25 | } 26 | curr.append('0'); 27 | backtracking(curr, n, result); 28 | curr.deleteCharAt(curr.length() - 1); 29 | 30 | curr.append('1'); 31 | backtracking(curr, n, result); 32 | curr.deleteCharAt(curr.length() - 1); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/lc/pattern/backtracking/LetterTilePossibilities_1079.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.backtracking; 2 | 3 | import java.util.HashSet; 4 | import java.util.Set; 5 | 6 | public class LetterTilePossibilities_1079 { 7 | 8 | public int numTilePossibilities(String tiles) { 9 | Set result = new HashSet<>(); 10 | boolean[] isUsed = new boolean[tiles.length()]; 11 | StringBuilder sb = new StringBuilder(); 12 | calculatePossibilities(tiles, sb, isUsed, result); 13 | return result.size(); 14 | } 15 | 16 | public void calculatePossibilities( 17 | String tiles, 18 | StringBuilder sb, 19 | boolean[] isUsed, 20 | Set result 21 | ) { 22 | if (!sb.isEmpty()) { 23 | result.add(sb.toString()); 24 | } 25 | for (int i = 0; i < tiles.length(); i++) { 26 | if (!isUsed[i]) { 27 | isUsed[i] = true; 28 | sb.append(tiles.charAt(i)); 29 | calculatePossibilities(tiles, sb, isUsed, result); 30 | sb.deleteCharAt(sb.length() - 1); 31 | isUsed[i] = false; 32 | } 33 | } 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /src/lc/pattern/backtracking/Permutation_46.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.backtracking; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.LinkedList; 6 | import java.util.List; 7 | 8 | public class Permutation_46 { 9 | public List> permute(int[] nums) { 10 | Arrays.sort(nums); 11 | List> result = new ArrayList<>(); 12 | boolean[] isUsed = new boolean[nums.length]; 13 | backtracking(nums, new LinkedList<>(), result, isUsed); 14 | return result; 15 | } 16 | 17 | private void backtracking(int[] nums, LinkedList tmpList, 18 | List> result, boolean[] isUsed) { 19 | if (tmpList.size() == nums.length) { 20 | result.add(new ArrayList<>(tmpList)); 21 | return; 22 | } 23 | for (int i = 0; i < nums.length; i++) { 24 | if (isUsed[i]) { 25 | continue; 26 | } 27 | isUsed[i] = true; 28 | tmpList.add(nums[i]); 29 | backtracking(nums, tmpList, result, isUsed); 30 | isUsed[i] = false; 31 | tmpList.pollLast(); 32 | } 33 | } 34 | } -------------------------------------------------------------------------------- /src/lc/pattern/backtracking/Subsets_78.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.backtracking; 2 | 3 | import java.util.ArrayList; 4 | import java.util.LinkedList; 5 | import java.util.List; 6 | 7 | public class Subsets_78 { 8 | public List> subsets(int[] nums) { 9 | List> result = new ArrayList<>(); 10 | backtracking(nums, 0, new LinkedList<>(), result); 11 | return result; 12 | } 13 | 14 | private void backtracking(int[] nums, int currIndex, 15 | LinkedList tmpList, List> result) { 16 | result.add(new ArrayList<>(tmpList)); 17 | for (int i = currIndex; i < nums.length; i++) { 18 | tmpList.add(nums[i]); 19 | backtracking(nums, i + 1, tmpList, result); 20 | tmpList.pollLast(); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/lc/pattern/cyclicsort/FirstMissingPositive_41.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.cyclicsort; 2 | 3 | import utility.Util; 4 | 5 | public class FirstMissingPositive_41 { 6 | 7 | public int firstMissingPositive(int[] nums) { 8 | // Input include negative and zero 9 | // But we focus on positive value, so focus on that first 10 | // If negative or zero, ignore them 11 | int n = nums.length; 12 | int index = 0; 13 | // Cyclic Sort 14 | while (index < n) { 15 | int targetIndex = nums[index] - 1; 16 | // Only POSITIVE!! 17 | boolean isValidRange = targetIndex >= 0 && targetIndex < n; 18 | if (isValidRange && nums[targetIndex] != nums[index]) { 19 | Util.swap(nums, index, targetIndex); 20 | } else { 21 | index++; 22 | } 23 | } 24 | 25 | for (int i = 0; i < n; i++) { 26 | int expectedValue = i + 1; 27 | if (nums[i] != expectedValue) { 28 | return expectedValue; 29 | } 30 | } 31 | 32 | // Default one => if they have all positive within range 33 | return n + 1; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/lc/pattern/dp/BestTimeToBuyAndSellStockWithTransactionFee_714.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.dp; 2 | 3 | public class BestTimeToBuyAndSellStockWithTransactionFee_714 { 4 | public int maxProfit(int[] prices, int fee) { 5 | int n = prices.length; 6 | int[] hold = new int[n]; 7 | int[] free = new int[n]; 8 | hold[0] = -prices[0]; 9 | 10 | for (int i = 1; i < n; i++) { 11 | hold[i] = Integer.max(hold[i - 1], free[i - 1] - prices[i]); 12 | free[i] = Integer.max(free[i - 1], hold[i - 1] + prices[i] - fee); 13 | } 14 | 15 | return free[n - 1]; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/lc/pattern/dp/fibonacci/DominoAndTrominoTiling_790.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.dp.fibonacci; 2 | 3 | public class DominoAndTrominoTiling_790 { 4 | 5 | public int numTilings(int n) { 6 | int mod = ((int) 1e9) + 7; 7 | // 0 - State where empty both 8 | // 1 - Miss bottom 9 | // 2 - Miss top 10 | // 3 - Full 11 | long[] dp = {0, 0, 0, 1}; 12 | for (int i = 1; i <= n; i++) { 13 | long[] newDp = new long[4]; 14 | // Empty state => came from prev full state 15 | newDp[0] = dp[3]; 16 | // Miss Bottom => Fullfill with bottom 17 | newDp[1] = (dp[2] + dp[0]) % mod; 18 | // Miss top => Fullfill with top 19 | newDp[2] = (dp[1] + dp[0]) % mod; 20 | // Full state can come up from any state 21 | newDp[3] = (dp[0] + dp[1] + dp[2] + dp[3]) % mod; 22 | dp = newDp; 23 | } 24 | return (int) dp[3]; 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /src/lc/pattern/dp/fibonacci/MinCostClimbingStairs_746.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.dp.fibonacci; 2 | 3 | public class MinCostClimbingStairs_746 { 4 | public int minCostClimbingStairs(int[] cost) { 5 | int n = cost.length; 6 | int[] dp = new int[n + 1]; 7 | dp[0] = cost[0]; 8 | dp[1] = cost[1]; 9 | for (int i = 2; i <= n; i++) { 10 | if (i < n) { 11 | dp[i] = cost[i]; 12 | } 13 | dp[i] += Integer.min(dp[i - 1], dp[i - 2]); 14 | } 15 | return dp[n]; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/lc/pattern/dp/fibonacci/MinimumCostForTickets_983.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.dp.fibonacci; 2 | 3 | public class MinimumCostForTickets_983 { 4 | 5 | public int mincostTickets(int[] days, int[] costs) { 6 | int lastDay = days[days.length - 1]; 7 | int[] dp = new int[lastDay + 1]; 8 | boolean[] isTravelDay = new boolean[lastDay + 1]; 9 | for (int d : days) { 10 | isTravelDay[d] = true; 11 | } 12 | 13 | for (int i = 1; i <= lastDay; i++) { 14 | if (isTravelDay[i]) { 15 | // Take 1-Day pass 16 | dp[i] = costs[0] + dp[i - 1]; 17 | // Take 7-Day Pass (compare with current day that compute before) 18 | dp[i] = Math.min(dp[i], costs[1] + dp[Math.max(i - 7, 0)]); 19 | // Take 30-Day Pass 20 | dp[i] = Math.min(dp[i], costs[2] + dp[Math.max(i - 30, 0)]); 21 | } else { 22 | dp[i] = dp[i - 1]; 23 | } 24 | } 25 | 26 | return dp[lastDay]; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/lc/pattern/dp/lcs/MinDeleteInsertToTransformToAnotherString.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.dp.lcs; 2 | 3 | import java.util.List; 4 | 5 | public class MinDeleteInsertToTransformToAnotherString { 6 | 7 | public List findMDI(String s1, String s2) { 8 | int longestCommonSubsequenceResult = new LongestCommonSubsequence 9 | .BottomUp() 10 | .findLCSLength(s1, s2); 11 | int s1To2 = s1.length() - longestCommonSubsequenceResult; 12 | int s2To1 = s2.length() - longestCommonSubsequenceResult; 13 | return List.of(s1To2, s2To1); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/lc/pattern/dp/palindromicsubseq/CountOfPalindromeSubstring.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.dp.palindromicsubseq; 2 | 3 | public class CountOfPalindromeSubstring { 4 | 5 | public static class BottomUp { 6 | 7 | public int findCPS(String st) { 8 | int size = st.length(); 9 | boolean[][] dp = new boolean[size][size]; 10 | int count = 0; 11 | for (int i = 0; i < size; i++) { 12 | dp[i][i] = true; 13 | count++; 14 | } 15 | for (int startIndex = size - 1; startIndex >= 0; startIndex--) { 16 | for (int endIndex = startIndex + 1; endIndex < size; endIndex++) { 17 | if (endIndex - startIndex == 1 || dp[startIndex + 1][endIndex - 1]) { 18 | dp[startIndex][endIndex] = true; 19 | count++; 20 | } 21 | } 22 | } 23 | return count; 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/lc/pattern/dp/palindromicsubseq/MinimumDeletionInStringToMakePalindrome.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.dp.palindromicsubseq; 2 | 3 | public class MinimumDeletionInStringToMakePalindrome { 4 | 5 | public int findMinimumDeletions(String st) { 6 | int longestPalindromeSubsequenceResult = new LongestPalindromicSubsequence 7 | .BottomUp() 8 | .findLPSLength(st); 9 | return st.length() - longestPalindromeSubsequenceResult; 10 | } 11 | 12 | public boolean isAlmostPalindrome(String st, int limitation) { 13 | int longestPalindromeSubsequenceResult = new LongestPalindromicSubsequence 14 | .BottomUp() 15 | .findLPSLength(st); 16 | int diff = st.length() - longestPalindromeSubsequenceResult; 17 | return diff <= limitation; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/lc/pattern/fastnslowpointer/DeleteTheMiddleNodeOfALinkedList_2095.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.fastnslowpointer; 2 | 3 | import common.ListNode; 4 | 5 | public class DeleteTheMiddleNodeOfALinkedList_2095 { 6 | 7 | public ListNode deleteMiddle(ListNode head) { 8 | if (head == null || head.next == null) { 9 | return null; 10 | } 11 | ListNode fast = head; 12 | ListNode slow = head; 13 | ListNode prev = slow; 14 | while (fast != null && fast.next != null) { 15 | fast = fast.next.next; 16 | prev = slow; 17 | slow = slow.next; 18 | } 19 | // slow is in the middle 20 | prev.next = slow.next; 21 | slow.next = null; 22 | return head; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/lc/pattern/graphtraversal/KeysAndRooms_841.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.graphtraversal; 2 | 3 | import java.util.HashSet; 4 | import java.util.List; 5 | import java.util.Set; 6 | 7 | public class KeysAndRooms_841 { 8 | 9 | public boolean canVisitAllRooms(List> rooms) { 10 | Set visited = new HashSet<>(); 11 | dfs(rooms, visited, 0); 12 | return visited.size() == rooms.size(); 13 | } 14 | 15 | private void dfs(List> rooms, Set visited, int key) { 16 | if (!visited.contains(key)) { 17 | visited.add(key); 18 | for (int nextRoom : rooms.get(key)) { 19 | dfs(rooms, visited, nextRoom); 20 | } 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/lc/pattern/heap/HighFive_1086.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.heap; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | import java.util.PriorityQueue; 6 | 7 | public class HighFive_1086 { 8 | 9 | public int[][] highFive(int[][] items) { 10 | Map> scores = new HashMap<>(); 11 | for (var score : items) { 12 | scores.putIfAbsent(score[0], new PriorityQueue<>()); 13 | scores.get(score[0]).add(score[1]); 14 | if (scores.get(score[0]).size() > 5) { 15 | scores.get(score[0]).poll(); 16 | } 17 | } 18 | int size = scores.size(); 19 | int[][] result = new int[size][2]; 20 | int i = 0; 21 | for (var entry : scores.entrySet()) { 22 | int sum = 0; 23 | while (!entry.getValue().isEmpty()) { 24 | sum += entry.getValue().poll(); 25 | } 26 | result[i][0] = entry.getKey(); 27 | result[i][1] = sum / 5; 28 | i++; 29 | } 30 | return result; 31 | } 32 | 33 | } 34 | -------------------------------------------------------------------------------- /src/lc/pattern/heap/MinimumCostToConnectSticks_1167.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.heap; 2 | 3 | import java.util.PriorityQueue; 4 | 5 | public class MinimumCostToConnectSticks_1167 { 6 | public int connectSticks(int[] sticks) { 7 | PriorityQueue minHeap = new PriorityQueue<>(); 8 | for (int s : sticks) { 9 | minHeap.add(s); 10 | } 11 | int cost = 0; 12 | while (minHeap.size() != 1) { 13 | int newStick = minHeap.poll() + minHeap.poll(); 14 | cost += newStick; 15 | minHeap.add(newStick); 16 | } 17 | return cost; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/lc/pattern/heap/MinimumOperationsToExceedThresholdValueII_3066.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.heap; 2 | 3 | import java.util.PriorityQueue; 4 | 5 | public class MinimumOperationsToExceedThresholdValueII_3066 { 6 | 7 | public int minOperations(int[] nums, int k) { 8 | PriorityQueue minHeap = new PriorityQueue<>(); 9 | for (int n : nums) { 10 | minHeap.add((long) n); 11 | } 12 | int operationCount = 0; 13 | while (!minHeap.isEmpty() && minHeap.peek() < k && minHeap.size() >= 2) { 14 | operationCount++; 15 | long x = minHeap.poll(); 16 | long y = minHeap.poll(); 17 | long result = Math.min(x, y) * 2 + Math.max(x, y); 18 | minHeap.add(result); 19 | } 20 | return operationCount; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/lc/pattern/inplacelinkedlist/DeleteNNodesAfterMNodesOfALinkedList_1474.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.inplacelinkedlist; 2 | 3 | import common.ListNode; 4 | 5 | public class DeleteNNodesAfterMNodesOfALinkedList_1474 { 6 | 7 | public ListNode deleteNodes(ListNode head, int m, int n) { 8 | ListNode dummy = new ListNode(); 9 | dummy.next = head; 10 | 11 | ListNode curr = head; 12 | ListNode prev = dummy; 13 | while (curr != null) { 14 | int move = m; 15 | while (curr != null && move-- > 0) { 16 | prev = curr; 17 | curr = curr.next; 18 | } 19 | int delete = n; 20 | while (curr != null && delete-- > 0) { 21 | curr = curr.next; 22 | } 23 | prev.next = curr; 24 | } 25 | 26 | return dummy.next; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/lc/pattern/inplacelinkedlist/OddEvenLinkedList_328.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.inplacelinkedlist; 2 | 3 | import common.ListNode; 4 | 5 | public class OddEvenLinkedList_328 { 6 | 7 | public ListNode oddEvenList(ListNode head) { 8 | ListNode[] slots = new ListNode[2]; 9 | // Put dummy node 10 | slots[0] = new ListNode(0); 11 | slots[1] = new ListNode(0); 12 | 13 | ListNode odd = slots[0]; 14 | ListNode even = slots[1]; 15 | ListNode curr = head; 16 | 17 | int flag = 1; 18 | 19 | while (curr != null) { 20 | if (flag == 1) { 21 | odd.next = curr; 22 | odd = odd.next; 23 | } else { 24 | even.next = curr; 25 | even = even.next; 26 | } 27 | flag ^= 1; 28 | curr = curr.next; 29 | } 30 | 31 | // Set next to null on both 32 | odd.next = null; 33 | even.next = null; 34 | // Connect odd to head of even 35 | odd.next = slots[1].next; 36 | // Return head of odd 37 | return slots[0].next; 38 | } 39 | 40 | } 41 | -------------------------------------------------------------------------------- /src/lc/pattern/inplacelinkedlist/PlusOneLinkedList_369.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.inplacelinkedlist; 2 | 3 | import common.ListNode; 4 | 5 | public class PlusOneLinkedList_369 { 6 | 7 | public ListNode plusOne(ListNode head) { 8 | ListNode reversed = reverse(head); 9 | int carry = 1; 10 | ListNode curr = reversed; 11 | while (curr != null) { 12 | int sum = curr.val + carry; 13 | int digit = sum % 10; 14 | curr.val = digit; 15 | carry = sum / 10; 16 | curr = curr.next; 17 | } 18 | if (carry != 0) { 19 | head.next = new ListNode(carry); 20 | } 21 | return reverse(reversed); 22 | } 23 | 24 | public ListNode reverse(ListNode head) { 25 | ListNode prev = null; 26 | ListNode curr = head; 27 | 28 | while (curr != null) { 29 | ListNode next = curr.next; 30 | curr.next = prev; 31 | prev = curr; 32 | curr = next; 33 | } 34 | 35 | return prev; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/lc/pattern/inplacelinkedlist/PrintImmutableLinkedListInReverse_1265.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.inplacelinkedlist; 2 | 3 | import common.ImmutableListNode; 4 | 5 | import java.util.ArrayDeque; 6 | import java.util.Deque; 7 | 8 | public class PrintImmutableLinkedListInReverse_1265 { 9 | 10 | class Solution1 { 11 | public void printLinkedListInReverse(ImmutableListNode head) { 12 | Deque stack = new ArrayDeque<>(); 13 | ImmutableListNode curr = head; 14 | while (curr != null) { 15 | stack.push(curr); 16 | curr = curr.getNext(); 17 | } 18 | while (!stack.isEmpty()) { 19 | stack.pop().printValue(); 20 | } 21 | } 22 | } 23 | 24 | class Solution2 { 25 | public void printLinkedListInReverse(ImmutableListNode head) { 26 | if (head == null) { 27 | return; 28 | } 29 | printLinkedListInReverse(head.getNext()); 30 | head.printValue(); 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/lc/pattern/kwaymerge/.gitkeep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/src/lc/pattern/kwaymerge/.gitkeep -------------------------------------------------------------------------------- /src/lc/pattern/mergeinterval/MeetingRooms_252.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.mergeinterval; 2 | 3 | import java.util.Arrays; 4 | import java.util.Comparator; 5 | 6 | public class MeetingRooms_252 { 7 | 8 | public boolean canAttendMeetings(int[][] intervals) { 9 | if (intervals.length <= 1) { 10 | return true; 11 | } 12 | Arrays.sort(intervals, Comparator.comparingInt(a -> a[0])); 13 | for (int i = 1; i < intervals.length; i++) { 14 | if (intervals[i - 1][1] > intervals[i][0]) { 15 | return false; 16 | } 17 | } 18 | return true; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/lc/pattern/mergeinterval/MinimumNumberOfArrowsToBurstBalloons_452.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.mergeinterval; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.List; 6 | 7 | public class MinimumNumberOfArrowsToBurstBalloons_452 { 8 | 9 | public int findMinArrowShots(int[][] points) { 10 | int n = points.length; 11 | Arrays.sort(points, (a, b) -> Integer.compare(a[1], b[1])); 12 | List overlap = new ArrayList<>(); 13 | overlap.add(points[0]); 14 | for (int i = 1; i < n; i++) { 15 | int[] last = overlap.getLast(); 16 | if (last[1] < points[i][0]) { 17 | overlap.add(points[i]); 18 | } 19 | } 20 | return overlap.size(); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/lc/pattern/mergeinterval/MissingRanges_163.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.mergeinterval; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class MissingRanges_163 { 7 | 8 | public List> findMissingRanges(int[] nums, int lower, int upper) { 9 | List> result = new ArrayList<>(); 10 | if (nums == null || nums.length == 0) { 11 | result.add(List.of(lower, upper)); 12 | return result; 13 | } 14 | int n = nums.length; 15 | for (int i = 0; i < n; i++) { 16 | if (i > 0 && Math.abs(nums[i] - nums[i - 1]) > 1) { 17 | result.add(List.of(nums[i - 1] + 1, nums[i] - 1)); 18 | } 19 | } 20 | if (nums[0] > lower) { 21 | result.add(0, List.of(lower, nums[0] - 1)); 22 | } 23 | if (nums[n - 1] < upper) { 24 | result.add(List.of(nums[n - 1] + 1, upper)); 25 | } 26 | return result; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/lc/pattern/mergeinterval/RemoveInterval_1272.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.mergeinterval; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class RemoveInterval_1272 { 7 | public List> removeInterval(int[][] intervals, int[] toBeRemoved) { 8 | List> result = new ArrayList<>(); 9 | 10 | for (int[] interval : intervals) { 11 | if (interval[1] <= toBeRemoved[0] || interval[0] >= toBeRemoved[1]) { 12 | result.add(List.of(interval[0], interval[1])); 13 | } else { 14 | if (interval[0] < toBeRemoved[0]) { 15 | result.add(List.of(interval[0], toBeRemoved[0])); 16 | } 17 | if (interval[1] > toBeRemoved[1]) { 18 | result.add(List.of(toBeRemoved[1], interval[1])); 19 | } 20 | } 21 | } 22 | 23 | return result; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/lc/pattern/modifiedbinarysearch/FindPeakElement_162.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.modifiedbinarysearch; 2 | 3 | public class FindPeakElement_162 { 4 | 5 | public int findPeakElement(int[] nums) { 6 | int left = 0; 7 | int right = nums.length - 1; 8 | while (left < right) { 9 | int mid = left + (right - left) / 2; 10 | if (nums[mid] < nums[mid + 1]) { 11 | left = mid + 1; 12 | } else { 13 | right = mid; 14 | } 15 | } 16 | return left; 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /src/lc/pattern/modifiedbinarysearch/MissingNumberInArithmeticProgression_1228.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.modifiedbinarysearch; 2 | 3 | public class MissingNumberInArithmeticProgression_1228 { 4 | public int missingNumber(int[] arr) { 5 | if (arr.length == 3) { 6 | int diff = arr[2] - arr[1]; 7 | return arr[0] + diff; 8 | } 9 | int n = arr.length; 10 | int diff = (arr[n - 1] - arr[0]) / n; 11 | int left = 0; 12 | int right = n - 1; 13 | while(left < right) { 14 | int mid = left + (right - left) / 2; 15 | if(arr[mid] == arr[0] + mid * diff) { 16 | left = mid + 1; 17 | } else { 18 | right = mid; 19 | } 20 | } 21 | return arr[0] + diff * left; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/lc/pattern/modifiedbinarysearch/SuccessfulPairsOfSpellsAndPotions_2300.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.modifiedbinarysearch; 2 | 3 | import java.util.Arrays; 4 | 5 | public class SuccessfulPairsOfSpellsAndPotions_2300 { 6 | 7 | public int[] successfulPairs(int[] spells, int[] potions, long success) { 8 | int n = spells.length; 9 | int m = potions.length; 10 | int[] result = new int[n]; 11 | Arrays.sort(potions); 12 | 13 | for (int i = 0; i < n; i++) { 14 | int left = 0; 15 | int right = m - 1; 16 | while (left <= right) { 17 | long spell = spells[i]; 18 | int mid = left + (right - left) / 2; 19 | if (spell * potions[mid] < success) { 20 | left = mid + 1; 21 | } else { 22 | right = mid - 1; 23 | } 24 | } 25 | int length = m - left; 26 | result[i] = length; 27 | } 28 | return result; 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /src/lc/pattern/monotonicstack/DailyTemperature_739.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.monotonicstack; 2 | 3 | import java.util.ArrayDeque; 4 | import java.util.Deque; 5 | 6 | public class DailyTemperature_739 { 7 | 8 | public int[] dailyTemperatures(int[] temperatures) { 9 | if (temperatures == null || temperatures.length == 0) { 10 | return new int[0]; 11 | } 12 | int[] answer = new int[temperatures.length]; 13 | Deque stack = new ArrayDeque<>(); 14 | for (int i = 0; i < temperatures.length; i++) { 15 | while (!stack.isEmpty() && temperatures[stack.peekFirst()] < temperatures[i]) { 16 | int prevIndex = stack.removeFirst(); 17 | answer[i] = i - prevIndex; 18 | } 19 | stack.addFirst(i); 20 | } 21 | return answer; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/lc/pattern/monotonicstack/NextGreaterElementI_496.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.monotonicstack; 2 | 3 | import java.util.ArrayDeque; 4 | import java.util.Deque; 5 | import java.util.HashMap; 6 | import java.util.Map; 7 | 8 | public class NextGreaterElementI_496 { 9 | 10 | // where num1 is subset of num2 11 | public int[] nextGreaterElement(int[] nums1, int[] nums2) { 12 | Map indexMap = new HashMap<>(); 13 | Deque stack = new ArrayDeque<>(); 14 | for (int i = 0; i < nums2.length; i++) { 15 | indexMap.put(nums2[i], -1); 16 | while (!stack.isEmpty() && nums2[stack.peekFirst()] < nums2[i]) { 17 | int prev = stack.removeFirst(); 18 | indexMap.put(nums2[prev], nums2[i]); 19 | } 20 | stack.addFirst(i); 21 | } 22 | int[] result = new int[nums1.length]; 23 | for (int i = 0; i < nums1.length; i++) { 24 | result[i] = indexMap.get(nums1[i]); 25 | } 26 | return result; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/lc/pattern/monotonicstack/OnlineStockSpan_901.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.monotonicstack; 2 | 3 | import java.util.ArrayDeque; 4 | import java.util.Deque; 5 | 6 | public class OnlineStockSpan_901 { 7 | 8 | private static class StockSpanner { 9 | 10 | Deque stack; 11 | 12 | public StockSpanner() { 13 | this.stack = new ArrayDeque<>(); 14 | } 15 | 16 | public int next(int price) { 17 | int span = 1; 18 | while (!this.stack.isEmpty() && this.stack.peekFirst().price <= price) { 19 | span += stack.removeFirst().span; 20 | } 21 | // If we push new one, so that's mean we already sum of the span into this price 22 | this.stack.addFirst(new Stock(price, span)); 23 | return span; 24 | } 25 | } 26 | 27 | private static class Stock { 28 | 29 | int price; 30 | int span; 31 | 32 | public Stock(int price, int span) { 33 | this.price = price; 34 | this.span = span; 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/lc/pattern/prefixsum/SubarraySumEqualK_560.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.prefixsum; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class SubarraySumEqualK_560 { 7 | 8 | public int subarraySum(int[] nums, int k) { 9 | if (nums == null || nums.length == 0) { 10 | return 0; 11 | } 12 | Map map = new HashMap<>(); 13 | int sum = 0; 14 | int counter = 0; 15 | map.put(0, 1); 16 | for (int n : nums) { 17 | sum += n; 18 | if (map.containsKey(sum - k)) { 19 | counter += map.get(sum - k); 20 | } 21 | map.put(n, map.getOrDefault(n, 0) + 1); 22 | } 23 | return counter; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/lc/pattern/slidingwindow/FindKLengthSubstringsWithNoRepeatedCharacters_1100.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.slidingwindow; 2 | 3 | import java.util.HashSet; 4 | import java.util.Set; 5 | 6 | public class FindKLengthSubstringsWithNoRepeatedCharacters_1100 { 7 | 8 | public int numKLenSubstrNoRepeats(String s, int k) { 9 | int count = 0; 10 | int left = 0; 11 | int right = 0; 12 | Set set = new HashSet<>(); 13 | while (right < s.length()) { 14 | char cr = s.charAt(right++); 15 | while (!set.isEmpty() && set.contains(cr)) { 16 | char cl = s.charAt(left++); 17 | set.remove(cl); 18 | } 19 | set.add(cr); 20 | if (right - left >= k) { 21 | count++; 22 | } 23 | } 24 | return count; 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /src/lc/pattern/slidingwindow/LongestSubstringWithAtMostKDistinctCharacters_340.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.slidingwindow; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class LongestSubstringWithAtMostKDistinctCharacters_340 { 7 | 8 | public int lengthOfLongestSubstringKDistinct(String s, int k) { 9 | int left = 0; 10 | int right = 0; 11 | int longest = 0; 12 | Map map = new HashMap<>(); 13 | while (right < s.length()) { 14 | char rc = s.charAt(right++); 15 | map.put(rc, map.getOrDefault(rc, 0) + 1); 16 | while (left < right && map.size() > k) { 17 | char lc = s.charAt(left++); 18 | map.put(lc, map.get(lc) - 1); 19 | if (map.get(lc) == 0) { 20 | map.remove(lc); 21 | } 22 | } 23 | longest = Integer.max(longest, right - left); 24 | } 25 | return longest; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/lc/pattern/slidingwindow/LongestSubstringWithAtMostTwoDistinctCharacters_159.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.slidingwindow; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class LongestSubstringWithAtMostTwoDistinctCharacters_159 { 7 | 8 | public int lengthOfLongestSubstringTwoDistinct(String s) { 9 | int left = 0; 10 | int right = 0; 11 | int longest = 0; 12 | Map map = new HashMap<>(); 13 | while (right < s.length()) { 14 | char rc = s.charAt(right++); 15 | map.put(rc, map.getOrDefault(rc, 0) + 1); 16 | while (left < right && map.size() > 2) { 17 | char lc = s.charAt(left++); 18 | map.put(lc, map.get(lc) - 1); 19 | if (map.get(lc) == 0) { 20 | map.remove(lc); 21 | } 22 | } 23 | longest = Integer.max(longest, right - left); 24 | } 25 | return longest; 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /src/lc/pattern/slidingwindow/MaxConsecutiveOnesII_487.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.slidingwindow; 2 | 3 | public class MaxConsecutiveOnesII_487 { 4 | public int findMaxConsecutiveOnes(int[] nums) { 5 | int left = 0; 6 | int right = 0; 7 | int longest = 0; 8 | int zeroCount = 0; 9 | while (right < nums.length) { 10 | int rn = nums[right++]; 11 | zeroCount += rn == 0 ? 1 : 0; 12 | while (zeroCount > 1) { 13 | int ln = nums[left++]; 14 | zeroCount -= ln == 0 ? 1 : 0; 15 | } 16 | longest = Integer.max(longest, right - left); 17 | } 18 | return longest; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/lc/pattern/slidingwindow/MaximumAscendingSubarraySum_1800.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.slidingwindow; 2 | 3 | public class MaximumAscendingSubarraySum_1800 { 4 | 5 | public int maxAscendingSum(int[] nums) { 6 | if (nums.length == 1) { 7 | return nums[0]; 8 | } 9 | int left = 0; 10 | int right = 1; 11 | int maxSum = nums[0]; 12 | int sum = nums[0]; 13 | while (right < nums.length) { 14 | sum += nums[right]; 15 | while (left < right && nums[right] <= nums[right - 1]) { 16 | sum -= nums[left++]; 17 | } 18 | right++; 19 | maxSum = Integer.max(maxSum, sum); 20 | } 21 | return maxSum; 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /src/lc/pattern/slidingwindow/MinimumRecolorsToGetKConsecutiveBlackBlocks_2379.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.slidingwindow; 2 | 3 | public class MinimumRecolorsToGetKConsecutiveBlackBlocks_2379 { 4 | public int minimumRecolors(String blocks, int k) { 5 | char[] chars = blocks.toCharArray(); 6 | int left = 0; 7 | int right = 0; 8 | int result = Integer.MAX_VALUE; 9 | int whiteCount = 0; 10 | while (right < blocks.length()) { 11 | char cr = chars[right++]; 12 | if (right - left > k) { 13 | result = Integer.min(result, whiteCount); 14 | char cl = chars[left++]; 15 | whiteCount -= cl == 'W' ? 1 : 0; 16 | } 17 | whiteCount += cr == 'W' ? 1 : 0; 18 | } 19 | return Integer.min(result, whiteCount); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/lc/pattern/slidingwindow/SubarrayProductLessThanK_713.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.slidingwindow; 2 | 3 | public class SubarrayProductLessThanK_713 { 4 | 5 | public int numSubarrayProductLessThanK(int[] nums, int k) { 6 | if (k == 0) { 7 | return 0; 8 | } 9 | int counter = 0; 10 | int start = 0; 11 | int end = 0; 12 | int product = 1; 13 | while (end < nums.length) { 14 | product *= nums[end]; 15 | while (start <= end && product >= k) { 16 | product /= nums[start++]; 17 | } 18 | counter += end - start + 1; 19 | end++; 20 | } 21 | return counter; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/lc/pattern/topkelement/KClosestPointsToOrigin_973.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.topkelement; 2 | 3 | import java.util.PriorityQueue; 4 | import common.Point; 5 | 6 | public class KClosestPointsToOrigin_973 { 7 | 8 | public int[][] kClosest(int[][] points, int k) { 9 | PriorityQueue maxHeap = new PriorityQueue<>( 10 | (e1, e2) -> Double.compare(e2.distance, e1.distance) 11 | ); 12 | for (int[] p : points) { 13 | maxHeap.add(new CoordinatePoint(p[0], p[1])); 14 | if (maxHeap.size() > k) { 15 | maxHeap.poll(); 16 | } 17 | } 18 | int[][] result = new int[maxHeap.size()][2]; 19 | int writeIndex = 0; 20 | while (!maxHeap.isEmpty()) { 21 | var point = maxHeap.poll(); 22 | result[writeIndex][0] = point.x; 23 | result[writeIndex][1] = point.y; 24 | writeIndex++; 25 | } 26 | return result; 27 | } 28 | 29 | private static class CoordinatePoint extends Point { 30 | 31 | public double distance; 32 | 33 | public CoordinatePoint(int x, int y) { 34 | super(x, y); 35 | this.distance = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)); 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/lc/pattern/topkelement/KthLargestElementInArray_215.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.topkelement; 2 | 3 | import java.util.PriorityQueue; 4 | 5 | public class KthLargestElementInArray_215 { 6 | 7 | public int findKthLargest(int[] nums, int k) { 8 | PriorityQueue minHeap = new PriorityQueue<>(); 9 | for (int n : nums) { 10 | minHeap.add(n); 11 | if (minHeap.size() > k) { 12 | minHeap.poll(); 13 | } 14 | } 15 | return minHeap.peek(); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/lc/pattern/topkelement/ReorganizeString_767.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.topkelement; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | import java.util.PriorityQueue; 6 | 7 | public class ReorganizeString_767 { 8 | 9 | public String reorganizeString(String s) { 10 | Map freqMap = new HashMap<>(); 11 | for (char c : s.toCharArray()) { 12 | freqMap.put(c, freqMap.getOrDefault(c, 0) + 1); 13 | } 14 | PriorityQueue> pq = new PriorityQueue<>( 15 | (e1, e2) -> Integer.compare(e2.getValue(), e1.getValue()) 16 | ); 17 | pq.addAll(freqMap.entrySet()); 18 | 19 | Map.Entry prev = null; 20 | StringBuilder sb = new StringBuilder(); 21 | while (!pq.isEmpty()) { 22 | var curr = pq.poll(); 23 | if (prev != null && prev.getValue() > 0) { 24 | pq.add(prev); 25 | } 26 | sb.append(curr.getKey()); 27 | curr.setValue(curr.getValue() - 1); 28 | prev = curr; 29 | } 30 | 31 | return sb.length() == s.length() ? sb.toString() : ""; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/lc/pattern/topkelement/SortCharactersByFrequency_451.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.topkelement; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | import java.util.Map.Entry; 6 | import java.util.PriorityQueue; 7 | 8 | public class SortCharactersByFrequency_451 { 9 | 10 | public String frequencySort(String s) { 11 | if (s == null || s.length() == 0) { 12 | return ""; 13 | } 14 | Map freqMap = new HashMap<>(); 15 | for (char c : s.toCharArray()) { 16 | freqMap.put(c, freqMap.getOrDefault(c, 0) + 1); 17 | } 18 | PriorityQueue> pq = new PriorityQueue<>( 19 | (e1, e2) -> Integer.compare(e2.getValue(), e1.getValue()) 20 | ); 21 | pq.addAll(freqMap.entrySet()); 22 | 23 | StringBuilder sb = new StringBuilder(); 24 | while (!pq.isEmpty()) { 25 | var curr = pq.poll(); 26 | sb.append(String.valueOf(curr.getKey()).repeat(curr.getValue())); 27 | } 28 | return sb.toString(); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/lc/pattern/topkelement/TopKFrequentWords_692.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.topkelement; 2 | 3 | import java.util.ArrayList; 4 | import java.util.HashMap; 5 | import java.util.List; 6 | import java.util.Map; 7 | import java.util.Map.Entry; 8 | import java.util.PriorityQueue; 9 | 10 | public class TopKFrequentWords_692 { 11 | 12 | public List topKFrequent(String[] words, int k) { 13 | Map freqWordMap = new HashMap<>(); 14 | for (String w : words) { 15 | freqWordMap.put(w, freqWordMap.getOrDefault(w, 0) + 1); 16 | } 17 | PriorityQueue> pq = new PriorityQueue<>( 18 | (a, b) -> { 19 | int result = Integer.compare(a.getValue(), b.getValue()); 20 | return result != 0 ? result : b.getKey().compareTo(a.getKey()); 21 | }); 22 | List result = new ArrayList<>(); 23 | for (Map.Entry entry : freqWordMap.entrySet()) { 24 | pq.add(entry); 25 | if (pq.size() > k) { 26 | pq.poll(); 27 | } 28 | } 29 | while (!pq.isEmpty()) { 30 | result.add(0, pq.poll().getKey()); 31 | } 32 | return result; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/lc/pattern/topologicalsort/TopologicalSort_DFS.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.topologicalsort; 2 | 3 | import java.util.ArrayDeque; 4 | import java.util.List; 5 | 6 | public class TopologicalSort_DFS { 7 | void topologicalSort(int n, List[] adjacencyList, boolean[] visited, ArrayDeque stack) { 8 | for (int i = 0; i < n; i++) { 9 | if (!visited[i]) { 10 | topologicalSortUtil(i, visited, stack, adjacencyList); 11 | } 12 | } 13 | while (!stack.isEmpty()) { 14 | System.out.println(stack.removeFirst()); 15 | } 16 | } 17 | 18 | void topologicalSortUtil(int v, boolean[] visited, ArrayDeque stack, List[] adjacencyList) { 19 | visited[v] = true; 20 | for (int neighbor : adjacencyList[v]) { 21 | if (!visited[neighbor]) { 22 | topologicalSortUtil(neighbor, visited, stack, adjacencyList); 23 | } 24 | } 25 | stack.addFirst(v); 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /src/lc/pattern/treebfs/AvgOfLevelsInBinaryTree_637.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.treebfs; 2 | 3 | import java.util.ArrayList; 4 | import java.util.LinkedList; 5 | import java.util.List; 6 | import java.util.Queue; 7 | import common.TreeNode; 8 | 9 | public class AvgOfLevelsInBinaryTree_637 { 10 | 11 | public List averageOfLevels(TreeNode root) { 12 | List result = new ArrayList<>(); 13 | if (root == null) { 14 | return result; 15 | } 16 | Queue q = new LinkedList<>(); 17 | q.add(root); 18 | while (!q.isEmpty()) { 19 | int size = q.size(); 20 | double sum = 0; 21 | while (size-- > 0) { 22 | var currNode = q.poll(); 23 | sum += currNode.val; 24 | if (currNode.left != null) { 25 | q.add(currNode.left); 26 | } 27 | if (currNode.right != null) { 28 | q.add(currNode.right); 29 | } 30 | } 31 | result.add(sum / size); 32 | } 33 | return result; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/lc/pattern/treebfs/BinaryTreeLevelOrderTraversalII_107.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.treebfs; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Collections; 5 | import java.util.LinkedList; 6 | import java.util.List; 7 | import java.util.Queue; 8 | import common.TreeNode; 9 | 10 | public class BinaryTreeLevelOrderTraversalII_107 { 11 | 12 | public List> levelOrderBottom(TreeNode root) { 13 | if (root == null) { 14 | return Collections.emptyList(); 15 | } 16 | List> result = new ArrayList<>(); 17 | Queue q = new LinkedList<>(); 18 | q.add(root); 19 | while (!q.isEmpty()) { 20 | int size = q.size(); 21 | List currentLevel = new ArrayList<>(); 22 | while (size-- > 0) { 23 | var node = q.poll(); 24 | currentLevel.add(node.val); 25 | if (node.left != null) { 26 | q.add(node.left); 27 | } 28 | if (node.right != null) { 29 | q.add(node.right); 30 | } 31 | } 32 | result.add(0, currentLevel); 33 | } 34 | return result; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/lc/pattern/treebfs/BinaryTreeLevelOrderTraversal_102.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.treebfs; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Collections; 5 | import java.util.LinkedList; 6 | import java.util.List; 7 | import java.util.Queue; 8 | import common.TreeNode; 9 | 10 | public class BinaryTreeLevelOrderTraversal_102 { 11 | 12 | public List> levelOrder(TreeNode root) { 13 | if (root == null) { 14 | return Collections.emptyList(); 15 | } 16 | List> result = new ArrayList<>(); 17 | Queue q = new LinkedList<>(); 18 | q.add(root); 19 | while (!q.isEmpty()) { 20 | int size = q.size(); 21 | List currentLevel = new ArrayList<>(); 22 | while (size-- > 0) { 23 | var node = q.poll(); 24 | currentLevel.add(node.val); 25 | if (node.left != null) { 26 | q.add(node.left); 27 | } 28 | if (node.right != null) { 29 | q.add(node.right); 30 | } 31 | } 32 | result.add(currentLevel); 33 | } 34 | return result; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/lc/pattern/treebfs/BinaryTreeRightSideView_199.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.treebfs; 2 | 3 | import common.TreeNode; 4 | import java.util.ArrayList; 5 | import java.util.LinkedList; 6 | import java.util.List; 7 | 8 | public class BinaryTreeRightSideView_199 { 9 | 10 | public List rightSideView(TreeNode root) { 11 | List result = new ArrayList<>(); 12 | if (root == null) { 13 | return result; 14 | } 15 | LinkedList queue = new LinkedList<>(); 16 | queue.add(root); 17 | while (!queue.isEmpty()) { 18 | int size = queue.size(); 19 | for (int i = 0; i < size; i++) { 20 | TreeNode node = queue.poll(); 21 | // Last element of that level 22 | if (i + 1 == size) { 23 | result.add(node.val); 24 | } 25 | if (node.left != null) { 26 | queue.add(node.left); 27 | } 28 | if (node.right != null) { 29 | queue.add(node.right); 30 | } 31 | } 32 | } 33 | return result; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/lc/pattern/treebfs/MinimumDepthOfBinaryTree_111.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.treebfs; 2 | 3 | import java.util.LinkedList; 4 | import java.util.Queue; 5 | import common.TreeNode; 6 | 7 | public class MinimumDepthOfBinaryTree_111 { 8 | 9 | public int minDepth(TreeNode root) { 10 | if (root == null) { 11 | return 0; 12 | } 13 | Queue q = new LinkedList<>(); 14 | int level = 0; 15 | q.add(root); 16 | while (!q.isEmpty()) { 17 | int size = q.size(); 18 | while (size-- > 0) { 19 | var node = q.poll(); 20 | if (node.left != null) { 21 | q.add(node.left); 22 | } 23 | if (node.right != null) { 24 | q.add(node.right); 25 | } 26 | } 27 | level++; 28 | } 29 | return level; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/lc/pattern/treebfs/PopulatingNextRightPointersEachNode_116.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.treebfs; 2 | 3 | import common.TreeNodeWithNext; 4 | import java.util.LinkedList; 5 | 6 | public class PopulatingNextRightPointersEachNode_116 { 7 | 8 | public TreeNodeWithNext connect(TreeNodeWithNext root) { 9 | if (root == null) { 10 | return root; 11 | } 12 | LinkedList queue = new LinkedList<>(); 13 | queue.add(root); 14 | while (!queue.isEmpty()) { 15 | int size = queue.size(); 16 | for (int i = 0; i < size; i++) { 17 | TreeNodeWithNext node = queue.poll(); 18 | if (i != size - 1) { 19 | node.next = queue.peek(); 20 | } 21 | if (node.left != null) { 22 | queue.add(node.left); 23 | } 24 | if (node.right != null) { 25 | queue.add(node.right); 26 | } 27 | } 28 | } 29 | return root; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/lc/pattern/treedfs/BalancedBinaryTree_110.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.treedfs; 2 | 3 | import common.TreeNode; 4 | 5 | public class BalancedBinaryTree_110 { 6 | 7 | public boolean isBalanced(TreeNode node) { 8 | if (node == null) { 9 | return true; 10 | } 11 | int leftHeight = getHeight(node.left); 12 | int rightHeight = getHeight(node.right); 13 | int diff = Math.abs(leftHeight - rightHeight); 14 | return diff < 2 && isBalanced(node.left) && isBalanced(node.right); 15 | } 16 | 17 | public int getHeight(TreeNode node) { 18 | if (node == null) { 19 | return 0; 20 | } 21 | return 1 + Integer.max( 22 | getHeight(node.left), 23 | getHeight(node.right) 24 | ); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/lc/pattern/treedfs/BinaryTreeLongestConsecutiveSequence_298.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.treedfs; 2 | 3 | import common.TreeNode; 4 | 5 | public class BinaryTreeLongestConsecutiveSequence_298 { 6 | 7 | public int longestConsecutive(TreeNode root) { 8 | int[] longest = {1}; 9 | dfs(root, 1, longest); 10 | return longest[0]; 11 | } 12 | 13 | public void dfs(TreeNode node, int current, int[] longest) { 14 | if (node == null) { 15 | return; 16 | } 17 | longest[0] = Integer.max(longest[0], current); 18 | if (node.left != null && node.left.val == node.val + 1) { 19 | dfs(node.left, current + 1, longest); 20 | } else { 21 | longest[0] = Integer.max(longest[0], longestConsecutive(node.left)); 22 | } 23 | if (node.right != null && node.right.val == node.val + 1) { 24 | dfs(node.right, current + 1, longest); 25 | } else { 26 | longest[0] = Integer.max(longest[0], longestConsecutive(node.right)); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/lc/pattern/treedfs/CountGoodNodesInBinaryTree_1448.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.treedfs; 2 | 3 | import common.TreeNode; 4 | 5 | public class CountGoodNodesInBinaryTree_1448 { 6 | public int goodNodes(TreeNode root) { 7 | if (root == null) { 8 | return 0; 9 | } 10 | return dfs(root, root.val); 11 | } 12 | 13 | private int dfs(TreeNode node, int maxSoFar) { 14 | if (node == null) { 15 | return 0; 16 | } 17 | int count = node.val >= maxSoFar ? 1 : 0; 18 | maxSoFar = Integer.max(node.val, maxSoFar); 19 | return count + dfs(node.left, maxSoFar) + dfs(node.right, maxSoFar); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/lc/pattern/treedfs/DeleteNodeInABST_450.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.treedfs; 2 | 3 | import common.TreeNode; 4 | 5 | public class DeleteNodeInABST_450 { 6 | 7 | public TreeNode deleteNode(TreeNode root, int key) { 8 | if (root == null) { 9 | return null; 10 | } 11 | if (key < root.val) { 12 | root.left = deleteNode(root.left, key); 13 | } else if (key > root.val) { 14 | root.right = deleteNode(root.right, key); 15 | } else { 16 | if (root.left == null) { 17 | return root.right; 18 | } else if (root.right == null) { 19 | return root.left; 20 | } else { 21 | TreeNode minNode = findMinNode(root.right); 22 | root.val = minNode.val; 23 | root.right = deleteNode(root.right, minNode.val); 24 | } 25 | } 26 | return root; 27 | } 28 | 29 | private TreeNode findMinNode(TreeNode node) { 30 | TreeNode curr = node; 31 | while (curr.left != null) { 32 | curr = curr.left; 33 | } 34 | return curr; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/lc/pattern/treedfs/FindElementsInAContaminatedBinaryTree_1261.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.treedfs; 2 | 3 | import common.TreeNode; 4 | 5 | import java.util.HashSet; 6 | import java.util.Set; 7 | 8 | public class FindElementsInAContaminatedBinaryTree_1261 { 9 | class FindElements { 10 | 11 | private TreeNode root; 12 | private Set storedValue; 13 | 14 | public FindElements(TreeNode root) { 15 | storedValue = new HashSet<>(); 16 | cleanTree(root, 0); 17 | } 18 | 19 | private void cleanTree(TreeNode node, int value) { 20 | node.val = value; 21 | storedValue.add(value); 22 | if (node.left != null) { 23 | cleanTree(node.left, 2 * node.val + 1); 24 | } 25 | if (node.right != null) { 26 | cleanTree(node.right, 2 * node.val + 2); 27 | } 28 | } 29 | 30 | public boolean find(int target) { 31 | return storedValue.contains(target); 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/lc/pattern/treedfs/LongestZigZagPathInABinaryTree_1372.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.treedfs; 2 | 3 | import common.TreeNode; 4 | 5 | public class LongestZigZagPathInABinaryTree_1372 { 6 | 7 | public int longestZigZag(TreeNode root) { 8 | if (root == null) { 9 | return 0; 10 | } 11 | int[] longestValue = {0}; 12 | longestZigZag(root, 0, 0, longestValue); 13 | longestZigZag(root, 1, 0, longestValue); 14 | return longestValue[0]; 15 | } 16 | 17 | public void longestZigZag( 18 | TreeNode node, 19 | int direction, 20 | int count, 21 | int[] longestValue 22 | ) { 23 | if (node == null) { 24 | return; 25 | } 26 | longestValue[0] = Math.max(longestValue[0], count); 27 | if (direction == 0) { 28 | longestZigZag(node.right, 1, count + 1, longestValue); 29 | longestZigZag(node.left, 0, 1, longestValue); 30 | } else { 31 | longestZigZag(node.left, 0, count + 1, longestValue); 32 | longestZigZag(node.right, 1, 1, longestValue); 33 | } 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/lc/pattern/treedfs/SearchInBST_700.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.treedfs; 2 | 3 | import common.TreeNode; 4 | 5 | public class SearchInBST_700 { 6 | 7 | public TreeNode searchBST(TreeNode root, int val) { 8 | if (root == null) { 9 | return null; 10 | } 11 | if (root.val == val) { 12 | return root; 13 | } else if (root.val > val) { 14 | return searchBST(root.left, val); 15 | } else { 16 | return searchBST(root.right, val); 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/lc/pattern/twopointers/AddBinary_67.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.twopointers; 2 | 3 | public class AddBinary_67 { 4 | public String addBinary(String a, String b) { 5 | StringBuilder sb = new StringBuilder(); 6 | int carry = 0; 7 | int ai = a.length() - 1; 8 | int bi = b.length() - 1; 9 | while (ai >= 0 || bi >= 0) { 10 | int aNumber = ai >= 0 ? Character.getNumericValue(a.charAt(ai--)) : 0; 11 | int bNumber = bi >= 0 ? Character.getNumericValue(b.charAt(bi--)) : 0; 12 | int sum = aNumber + bNumber + carry; 13 | carry = sum / 2; 14 | sum = sum % 2; 15 | sb.insert(0, sum); 16 | } 17 | if (carry == 1) { 18 | sb.insert(0, 1); 19 | } 20 | return sb.toString(); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/lc/pattern/twopointers/MoveZeroes_283.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.twopointers; 2 | 3 | public class MoveZeroes_283 { 4 | 5 | public void moveZeroes(int[] nums) { 6 | int writeIndex = 0; 7 | for (int i = 0; i < nums.length; i++) { 8 | if (nums[i] != 0) { 9 | nums[writeIndex++] = nums[i]; 10 | } 11 | } 12 | while (writeIndex < nums.length) { 13 | nums[writeIndex++] = 0; 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/lc/pattern/twopointers/NumberOfSubstringsContainingAllThreeCharacters_1358.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.twopointers; 2 | 3 | public class NumberOfSubstringsContainingAllThreeCharacters_1358 { 4 | 5 | public int numberOfSubstrings(String s) { 6 | char[] chars = s.toCharArray(); 7 | int result = 0; 8 | int left = 0; 9 | int right = 0; 10 | int[] count = new int[3]; 11 | while (right < chars.length) { 12 | char cr = chars[right++]; 13 | count[cr - 'a']++; 14 | while (hasAllThreeChars(count)) { 15 | char cl = chars[left++]; 16 | count[cl - 'a']--; 17 | } 18 | result += left; 19 | } 20 | return result; 21 | } 22 | 23 | private boolean hasAllThreeChars(int[] count) { 24 | return count[0] > 0 && count[1] > 0 && count[2] > 0; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/lc/pattern/twopointers/PalindromeNumber_9.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.twopointers; 2 | 3 | public class PalindromeNumber_9 { 4 | 5 | public boolean isPalindrome1(int x) { 6 | String num = String.valueOf(x); 7 | int left = 0; 8 | int right = num.length() - 1; 9 | while (left <= right) { 10 | if (num.charAt(left) != num.charAt(right)) { 11 | return false; 12 | } 13 | left++; 14 | right--; 15 | } 16 | return true; 17 | } 18 | 19 | public boolean isPalindrome(int x) { 20 | if (x < 0) { 21 | return false; 22 | } 23 | int num = x; 24 | int newValue = 0; 25 | while (num != 0) { 26 | int digit = num % 10; 27 | newValue = newValue * 10 + digit; 28 | num /= 10; 29 | } 30 | return newValue == x; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/lc/pattern/twopointers/ReverseVowelsOfAString_345.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.twopointers; 2 | 3 | public class ReverseVowelsOfAString_345 { 4 | 5 | public String reverseVowels(String s) { 6 | char[] chars = s.toCharArray(); 7 | int left = 0; 8 | int right = chars.length - 1; 9 | while (left < right) { 10 | while (left < right && !isVowel(chars[left])) { 11 | left++; 12 | } 13 | while (left < right && !isVowel(chars[right])) { 14 | right--; 15 | } 16 | if (isVowel(chars[left]) && isVowel(chars[right])) { 17 | char tmp = chars[left]; 18 | chars[left++] = chars[right]; 19 | chars[right--] = tmp; 20 | } 21 | } 22 | return String.valueOf(chars); 23 | } 24 | 25 | private boolean isVowel(char c) { 26 | return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || 27 | c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U'; 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /src/lc/pattern/twopointers/ReverseWordsInStringII_186.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.twopointers; 2 | 3 | import utility.Util; 4 | 5 | public class ReverseWordsInStringII_186 { 6 | 7 | public void reverseWords(char[] s) { 8 | int n = s.length; 9 | Util.reverse(s, 0, n - 1); 10 | int start = 0; 11 | int end = 0; 12 | while (end < n) { 13 | while (start < n && (start < end || Character.isWhitespace(s[start]))) { 14 | start++; 15 | } 16 | while (end < n && (end < start || !Character.isWhitespace(s[end]))) { 17 | end++; 18 | } 19 | Util.reverse(s, start, end - 1); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/lc/pattern/twopointers/SortColors_75.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.twopointers; 2 | 3 | import utility.Util; 4 | 5 | public class SortColors_75 { 6 | // Only have 3 kind of numbers (0, 1, 2) 7 | 8 | private static final int RED = 0; 9 | private static final int WHITE = 1; 10 | private static final int BLUE = 2; 11 | 12 | public void sortColor(int[] nums) { 13 | // Write index for red 14 | int redIndex = 0; 15 | // Write index for white 16 | // Main pointer to move 17 | int whiteIndex = 0; 18 | // Write index for blue 19 | int blueIndex = nums.length - 1; 20 | while (whiteIndex <= blueIndex) { 21 | if (nums[whiteIndex] == RED) { 22 | Util.swap(nums, redIndex++, whiteIndex++); 23 | } else if (nums[whiteIndex] == BLUE) { 24 | Util.swap(nums, whiteIndex, blueIndex--); 25 | } else { 26 | whiteIndex++; 27 | } 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/lc/pattern/unionfind/NumberOfProvinces_547.java: -------------------------------------------------------------------------------- 1 | package lc.pattern.unionfind; 2 | 3 | import common.unionfind.UnionFindNumArr; 4 | 5 | import java.util.HashSet; 6 | import java.util.Set; 7 | 8 | public class NumberOfProvinces_547 { 9 | public int findCircleNum(int[][] isConnected) { 10 | int size = isConnected.length; 11 | UnionFindNumArr uf = new UnionFindNumArr(size); 12 | for (int a = 0; a < size; a++) { 13 | for (int b = 0; b < size; b++) { 14 | if (isConnected[a][b] == 1) { 15 | uf.union(a, b); 16 | } 17 | } 18 | } 19 | Set provinces = new HashSet<>(); 20 | for (int i = 0; i < size; i++) { 21 | provinces.add(uf.find(i)); 22 | } 23 | return provinces.size(); 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /src/utility/GenerateExample.java: -------------------------------------------------------------------------------- 1 | package utility; 2 | 3 | public interface GenerateExample { 4 | 5 | void example(); 6 | } 7 | -------------------------------------------------------------------------------- /src/utility/MathUtil.java: -------------------------------------------------------------------------------- 1 | package utility; 2 | 3 | public class MathUtil { 4 | 5 | public static long manhattanDistance(int x1, int x2, int y1, int y2) { 6 | return Math.abs(x1 - x2) + Math.abs(y1 - y2); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /technicalknowledge/db_schema_design.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/db_schema_design.md -------------------------------------------------------------------------------- /technicalknowledge/high_level_design.md: -------------------------------------------------------------------------------- 1 | # Back to back high level design 2 | 3 | ## Strategies of System Design 4 | 5 | - Design For Failure 6 | - Keep Things Simple And Robust 7 | - Redundancy And Fault Recovery 8 | - Multi-tenancy 9 | - Service Health Check 10 | - Development similar to Production 11 | - Zero Trust 12 | - DRY 13 | - Independent workload/cluster 14 | - Autonomous with allow emergency human intervention 15 | -------------------------------------------------------------------------------- /technicalknowledge/img/collections/collections-framework.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/collections/collections-framework.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/collections/hashmap.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/collections/hashmap.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/collections/hashset.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/collections/hashset.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/collections/list.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/collections/list.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/db/example-icon-db-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/db/example-icon-db-1.png -------------------------------------------------------------------------------- /technicalknowledge/img/db/example-table-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/db/example-table-1.png -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/14-hash-table-concept-2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/14-hash-table-concept-2.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/14-hash-table-concept-3.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/14-hash-table-concept-3.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/5-pointer.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/5-pointer.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/bellman-ford-dry-run.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/bellman-ford-dry-run.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/bellman-ford-negative-cycle.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/bellman-ford-negative-cycle.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/bellman-ford-pseudocode.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/bellman-ford-pseudocode.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/dijsktra-graph-example-pseudocode.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/dijsktra-graph-example-pseudocode.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/dijsktra-graph-example.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/dijsktra-graph-example.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/dijsktra-graph-negative-example.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/dijsktra-graph-negative-example.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/linkedlist/10-range-based-linkedlist.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/linkedlist/10-range-based-linkedlist.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/linkedlist/11-fast-n-slow-pointer-1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/linkedlist/11-fast-n-slow-pointer-1.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/linkedlist/11-fast-n-slow-pointer-2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/linkedlist/11-fast-n-slow-pointer-2.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/linkedlist/6-1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/linkedlist/6-1.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/linkedlist/6-2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/linkedlist/6-2.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/linkedlist/6-3.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/linkedlist/6-3.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/linkedlist/6-4.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/linkedlist/6-4.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/linkedlist/6-5.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/linkedlist/6-5.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/minimum-spanning-tree.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/minimum-spanning-tree.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/sorting/18-bubble-sort.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/sorting/18-bubble-sort.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/sorting/18-insertion-sort.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/sorting/18-insertion-sort.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/sorting/18-merge-sort.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/sorting/18-merge-sort.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/sorting/18-quick-sort.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/sorting/18-quick-sort.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/sorting/18-selection-sort.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/sorting/18-selection-sort.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/sorting/18-sorting-1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/sorting/18-sorting-1.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/dsa/topological-sort.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/dsa/topological-sort.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/multithread/concurrency-vs-parallelism.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/multithread/concurrency-vs-parallelism.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/multithread/process-thread.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/multithread/process-thread.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/multithread/race-condition.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/multithread/race-condition.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/multithread/thread-life-cycle.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/multithread/thread-life-cycle.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/multithread/thread-platform-thread.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/multithread/thread-platform-thread.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/multithread/thread-virtual-thread.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/multithread/thread-virtual-thread.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/network/computer-network-diagram.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/network/computer-network-diagram.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/network/full-duplex.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/network/full-duplex.png -------------------------------------------------------------------------------- /technicalknowledge/img/network/half-duplex.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/network/half-duplex.png -------------------------------------------------------------------------------- /technicalknowledge/img/network/lan.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/network/lan.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/network/osi-model.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/network/osi-model.png -------------------------------------------------------------------------------- /technicalknowledge/img/network/pan.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/network/pan.png -------------------------------------------------------------------------------- /technicalknowledge/img/network/simplex.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/network/simplex.png -------------------------------------------------------------------------------- /technicalknowledge/img/network/wan.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/network/wan.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/oop/0-intro.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/oop/0-intro.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/oop/1-object.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/oop/1-object.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/oop/2-class.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/oop/2-class.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/oop/3-encapsulation.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/oop/3-encapsulation.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/oop/4-abstraction.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/oop/4-abstraction.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/oop/5-inheritance.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/oop/5-inheritance.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/oop/6-polymorphism.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/oop/6-polymorphism.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/oop/7-association.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/oop/7-association.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/oop/8-aggregation.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/oop/8-aggregation.jpg -------------------------------------------------------------------------------- /technicalknowledge/img/oop/9-composition.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/img/oop/9-composition.jpg -------------------------------------------------------------------------------- /technicalknowledge/ood.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/ood.md -------------------------------------------------------------------------------- /technicalknowledge/testing.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marttp/java-tech-interviews-prep/3710b264dffca078d65b660a30ccbb916216b3ec/technicalknowledge/testing.md --------------------------------------------------------------------------------