From 5f55f21da964993403b3d17aaf21bd91fdc893d1 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Sat, 14 Feb 2026 10:31:47 +0530 Subject: [PATCH 01/63] Create TwoSum.java MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implemented the Two Sum problem using a brute-force technique. The solution iterates through all possible pairs using nested loops to identify the indices whose sum equals the target. Time Complexity: O(n²) Space Complexity: O(1) --- TwoSum.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 TwoSum.java diff --git a/TwoSum.java b/TwoSum.java new file mode 100644 index 0000000..fdd3e30 --- /dev/null +++ b/TwoSum.java @@ -0,0 +1,15 @@ +class Solution { + public int[] twoSum(int[] nums, int target) { + int n = nums.length; + + for (int i = 0; i < n; i++) { + for (int j = i + 1; j < n; j++) { + if (nums[i] + nums[j] == target) { + return new int[] {i, j}; + } + } + } + + return new int[] {}; + } +} From e3e2f646a6e13c208a422748906269640e08eaed Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Sat, 14 Feb 2026 10:40:44 +0530 Subject: [PATCH 02/63] Update README.md --- README.md | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 0f362e0..003817b 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,5 @@ -# LeetCode-DSA-Practice -A collection of my LeetCode problem solutions written in Java. This repository documents my journey of practicing Data Structures and Algorithms for coding interviews and competitive programming. Each solution focuses on optimized time and space complexity. +# Two Sum +Problem Link: https://leetcode.com/problems/two-sum/ +Approach: Brute Force +Time Complexity: O(n²) +Space Complexity: O(1) From 9dc8dd05b43a8b314ab552b742848b925d9baa8c Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Sat, 14 Feb 2026 10:44:56 +0530 Subject: [PATCH 03/63] Rename TwoSum.java to TwoSum_BruteForce.java --- TwoSum.java => TwoSum_BruteForce.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename TwoSum.java => TwoSum_BruteForce.java (100%) diff --git a/TwoSum.java b/TwoSum_BruteForce.java similarity index 100% rename from TwoSum.java rename to TwoSum_BruteForce.java From 79c683fbce8e7ae3fdbbc3b44428df0562c7f60e Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Sat, 14 Feb 2026 10:47:38 +0530 Subject: [PATCH 04/63] Create TwoSum_HashMap.java MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Solved the Two Sum problem using an optimized HashMap approach. The solution iterates through the array once while storing previously seen elements in a HashMap. For each element, the complement (target − current value) is calculated and checked in the map to find the required pair efficiently. This reduces the time complexity from O(n²) to O(n). Time Complexity: O(n) Space Complexity: O(n) --- TwoSum_HashMap.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 TwoSum_HashMap.java diff --git a/TwoSum_HashMap.java b/TwoSum_HashMap.java new file mode 100644 index 0000000..691a685 --- /dev/null +++ b/TwoSum_HashMap.java @@ -0,0 +1,17 @@ +class Solution { + public int[] twoSum(int[] nums, int target) { + HashMap map = new HashMap<>(); + + for (int i = 0; i < nums.length; i++) { + int complement = target - nums[i]; + + if (map.containsKey(complement)) { + return new int[] { map.get(complement), i }; + } + + map.put(nums[i], i); + } + + return new int[] {}; + } +} From e9b65e880152fcf0def816ff4e6aa436b79aafc4 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Sat, 14 Feb 2026 10:49:29 +0530 Subject: [PATCH 05/63] Update TwoSum_BruteForce.java MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implemented the Two Sum problem using a brute-force technique. The solution iterates through all possible pairs using nested loops to identify the indices whose sum equals the target. Time Complexity: O(n²) Space Complexity: O(1) --- TwoSum_BruteForce.java | 1 - 1 file changed, 1 deletion(-) diff --git a/TwoSum_BruteForce.java b/TwoSum_BruteForce.java index fdd3e30..0f55635 100644 --- a/TwoSum_BruteForce.java +++ b/TwoSum_BruteForce.java @@ -9,7 +9,6 @@ public int[] twoSum(int[] nums, int target) { } } } - return new int[] {}; } } From 4e91c9fca8c5dd6aa2944baf87e13465fa6d051a Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Sat, 14 Feb 2026 12:59:08 +0530 Subject: [PATCH 06/63] Update README.md --- README.md | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 003817b..b84edfc 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,11 @@ -# Two Sum +# Arrays + +## 1. Two Sum Problem Link: https://leetcode.com/problems/two-sum/ -Approach: Brute Force -Time Complexity: O(n²) -Space Complexity: O(1) +### Approach 1: Brute Force +- Time Complexity: O(n²) +- Space Complexity: O(1) + +### Approach 2: HashMap (Optimized) +- Time Complexity: O(n) +- Space Complexity: O(n) From 87ce22272b33d795b79c4d72d65ba95a89b7eb1f Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 10:18:46 +0530 Subject: [PATCH 07/63] Rename TwoSum_BruteForce.java to 1_TwoSum_BruteForce.java --- TwoSum_BruteForce.java => 1_TwoSum_BruteForce.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename TwoSum_BruteForce.java => 1_TwoSum_BruteForce.java (100%) diff --git a/TwoSum_BruteForce.java b/1_TwoSum_BruteForce.java similarity index 100% rename from TwoSum_BruteForce.java rename to 1_TwoSum_BruteForce.java From 20b202b827a1cf79045f3fba7a236b3f8799e192 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 10:19:13 +0530 Subject: [PATCH 08/63] Rename TwoSum_HashMap.java to 1_TwoSum_HashMap.java --- TwoSum_HashMap.java => 1_TwoSum_HashMap.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename TwoSum_HashMap.java => 1_TwoSum_HashMap.java (100%) diff --git a/TwoSum_HashMap.java b/1_TwoSum_HashMap.java similarity index 100% rename from TwoSum_HashMap.java rename to 1_TwoSum_HashMap.java From df3a4bd6432e97d6815b91224289943884da50b1 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 10:22:02 +0530 Subject: [PATCH 09/63] Create 560_Subarray_Sum_Equals_K.java --- Subarray_Sum_Equals_K.java | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 Subarray_Sum_Equals_K.java diff --git a/Subarray_Sum_Equals_K.java b/Subarray_Sum_Equals_K.java new file mode 100644 index 0000000..1297233 --- /dev/null +++ b/Subarray_Sum_Equals_K.java @@ -0,0 +1,24 @@ +import java.util.HashMap; + +class Solution { + public int subarraySum(int[] nums, int k) { + + HashMap map = new HashMap<>(); + map.put(0, 1); // Important: handles case when subarray starts from index 0 + + int sum = 0; + int count = 0; + + for (int num : nums) { + sum += num; + + if (map.containsKey(sum - k)) { + count += map.get(sum - k); + } + + map.put(sum, map.getOrDefault(sum, 0) + 1); + } + + return count; + } +} From 0e187afc7b90eaaefc14ace70d89acb63901380b Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 10:23:39 +0530 Subject: [PATCH 10/63] Rename Subarray_Sum_Equals_K.java to 560_Subarray_Sum_Equals_K.java --- Subarray_Sum_Equals_K.java => 560_Subarray_Sum_Equals_K.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Subarray_Sum_Equals_K.java => 560_Subarray_Sum_Equals_K.java (100%) diff --git a/Subarray_Sum_Equals_K.java b/560_Subarray_Sum_Equals_K.java similarity index 100% rename from Subarray_Sum_Equals_K.java rename to 560_Subarray_Sum_Equals_K.java From fe2758b91c12f633e4bc8993e970dec789376da7 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 10:44:12 +0530 Subject: [PATCH 11/63] Update README.md --- README.md | 31 +++++++++++++++++++++++++------ 1 file changed, 25 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index b84edfc..a2226d6 100644 --- a/README.md +++ b/README.md @@ -2,10 +2,29 @@ ## 1. Two Sum Problem Link: https://leetcode.com/problems/two-sum/ -### Approach 1: Brute Force -- Time Complexity: O(n²) -- Space Complexity: O(1) +Difficulty: Easy +### Approaches +#### Approach 1: Brute Force +Time Complexity: O(n²) +Space Complexity: O(1) +#### Approach 2: HashMap (Optimized) +Time Complexity: O(n) +Space Complexity: O(n) -### Approach 2: HashMap (Optimized) -- Time Complexity: O(n) -- Space Complexity: O(n) +## 560. Subarray Sum Equals K +Problem Link: https://leetcode.com/problems/subarray-sum-equals-k/ +Difficulty: Medium +### Approach: Prefix Sum + HashMap (Optimized) +Time Complexity: O(n) +Space Complexity: O(n) +### Concepts Used: +Prefix Sum, HashMap, Subarray Pattern + +## 128. Longest Consecutive Sequence +Problem Link: https://leetcode.com/problems/longest-consecutive-sequence/ +Difficulty: Medium +### Approach: HashSet (Optimized) +Time Complexity: O(n) +Space Complexity: O(n) +### Concepts Used: +HashSet, Sequence Pattern, Array Traversal From db738bb0bc50c30cb3cd703a8dfc40dca5e98531 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 10:45:25 +0530 Subject: [PATCH 12/63] Create 128_Longest_Consecutive_Sequence.java --- 128_Longest_Consecutive_Sequence.java | 34 +++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 128_Longest_Consecutive_Sequence.java diff --git a/128_Longest_Consecutive_Sequence.java b/128_Longest_Consecutive_Sequence.java new file mode 100644 index 0000000..65c0494 --- /dev/null +++ b/128_Longest_Consecutive_Sequence.java @@ -0,0 +1,34 @@ +import java.util.HashSet; + +class Solution { + public int longestConsecutive(int[] nums) { + + HashSet set = new HashSet<>(); + + // Add all numbers to set + for (int num : nums) { + set.add(num); + } + + int longest = 0; + + for (int num : set) { + + // Check if it's the start of a sequence + if (!set.contains(num - 1)) { + + int currentNum = num; + int currentStreak = 1; + + while (set.contains(currentNum + 1)) { + currentNum++; + currentStreak++; + } + + longest = Math.max(longest, currentStreak); + } + } + + return longest; + } +} From 6a3efae9d87bab1e44c92f735e079e6599c73074 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 10:48:56 +0530 Subject: [PATCH 13/63] Create 523_ Continuous_Subarray_Sum.java --- 523_ Continuous_Subarray_Sum.java | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 523_ Continuous_Subarray_Sum.java diff --git a/523_ Continuous_Subarray_Sum.java b/523_ Continuous_Subarray_Sum.java new file mode 100644 index 0000000..65e2e70 --- /dev/null +++ b/523_ Continuous_Subarray_Sum.java @@ -0,0 +1,26 @@ +import java.util.HashMap; + +class Solution { + public boolean checkSubarraySum(int[] nums, int k) { + + HashMap map = new HashMap<>(); + map.put(0, -1); // Important: Handles case when subarray starts from index 0 + + int sum = 0; + + for (int i = 0; i < nums.length; i++) { + sum += nums[i]; + + int remainder = sum % k; + + if (map.containsKey(remainder)) { + if (i - map.get(remainder) > 1) { + return true; + } + } else { + map.put(remainder, i); + } + } + + return false; + } From 4c8fd0c52675144e2074799825199eef1152c96b Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 10:57:13 +0530 Subject: [PATCH 14/63] Update README.md --- README.md | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index a2226d6..8384945 100644 --- a/README.md +++ b/README.md @@ -3,13 +3,16 @@ ## 1. Two Sum Problem Link: https://leetcode.com/problems/two-sum/ Difficulty: Easy -### Approaches -#### Approach 1: Brute Force +### Approach 1: Brute Force Time Complexity: O(n²) Space Complexity: O(1) -#### Approach 2: HashMap (Optimized) +### Concepts Used: +Array Traversal,Nested Loops,Pair Checking +### Approach 2: HashMap (Optimized) Time Complexity: O(n) Space Complexity: O(n) +### Concepts Used: +Array Traversal,HashMap,Complement Technique,Single Pass Algorithm,Key-Value Mapping ## 560. Subarray Sum Equals K Problem Link: https://leetcode.com/problems/subarray-sum-equals-k/ @@ -28,3 +31,12 @@ Time Complexity: O(n) Space Complexity: O(n) ### Concepts Used: HashSet, Sequence Pattern, Array Traversal + +## 523. Continuous Subarray Sum +Problem Link: https://leetcode.com/problems/continuous-subarray-sum/ +Difficulty: Medium +### Approach: Prefix Sum + HashMap (Modulo Technique) +Time Complexity: O(n) +Space Complexity: O(n) +### Concepts Used: +Prefix Sum, HashMap, Modulo Arithmetic, Subarray Pattern From e378679a02dd23b63b53a206d8c1794d30dfe737 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 11:04:46 +0530 Subject: [PATCH 15/63] Create 49_Group_Anagrams.java --- 49_Group_Anagrams.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 49_Group_Anagrams.java diff --git a/49_Group_Anagrams.java b/49_Group_Anagrams.java new file mode 100644 index 0000000..62629bc --- /dev/null +++ b/49_Group_Anagrams.java @@ -0,0 +1,19 @@ +import java.util.*; + +class Solution { + public List> groupAnagrams(String[] strs) { + + HashMap> map = new HashMap<>(); + + for (String str : strs) { + char[] chars = str.toCharArray(); + Arrays.sort(chars); + String key = new String(chars); + + map.putIfAbsent(key, new ArrayList<>()); + map.get(key).add(str); + } + + return new ArrayList<>(map.values()); + } +} From 9aaeb036be6aa7833cd118a0f0f476dd2fd2ccf4 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 11:06:23 +0530 Subject: [PATCH 16/63] Rename 1_TwoSum_BruteForce.java to 001_TwoSum_BruteForce.java --- 1_TwoSum_BruteForce.java => 001_TwoSum_BruteForce.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 1_TwoSum_BruteForce.java => 001_TwoSum_BruteForce.java (100%) diff --git a/1_TwoSum_BruteForce.java b/001_TwoSum_BruteForce.java similarity index 100% rename from 1_TwoSum_BruteForce.java rename to 001_TwoSum_BruteForce.java From c6fabc6ee2c834c1e3f91fd226d57236bab8afa3 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 11:06:44 +0530 Subject: [PATCH 17/63] Rename 1_TwoSum_HashMap.java to 001_TwoSum_HashMap.java --- 1_TwoSum_HashMap.java => 001_TwoSum_HashMap.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 1_TwoSum_HashMap.java => 001_TwoSum_HashMap.java (100%) diff --git a/1_TwoSum_HashMap.java b/001_TwoSum_HashMap.java similarity index 100% rename from 1_TwoSum_HashMap.java rename to 001_TwoSum_HashMap.java From 39ecf196cdb9262fa81e716f604640b35165778d Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 11:07:02 +0530 Subject: [PATCH 18/63] Rename 49_Group_Anagrams.java to 049_Group_Anagrams.java --- 49_Group_Anagrams.java => 049_Group_Anagrams.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 49_Group_Anagrams.java => 049_Group_Anagrams.java (100%) diff --git a/49_Group_Anagrams.java b/049_Group_Anagrams.java similarity index 100% rename from 49_Group_Anagrams.java rename to 049_Group_Anagrams.java From a534d9f5ecb434fd134973c50663871fb6631719 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 11:14:39 +0530 Subject: [PATCH 19/63] Update README.md --- README.md | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 8384945..a0011a6 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# Arrays +image# Arrays ## 1. Two Sum Problem Link: https://leetcode.com/problems/two-sum/ @@ -13,15 +13,14 @@ Time Complexity: O(n) Space Complexity: O(n) ### Concepts Used: Array Traversal,HashMap,Complement Technique,Single Pass Algorithm,Key-Value Mapping - -## 560. Subarray Sum Equals K -Problem Link: https://leetcode.com/problems/subarray-sum-equals-k/ +## 49. Group Anagrams +Problem Link: https://leetcode.com/problems/group-anagrams/ Difficulty: Medium -### Approach: Prefix Sum + HashMap (Optimized) -Time Complexity: O(n) -Space Complexity: O(n) +### Approach: Sorting + HashMap +Time Complexity: O(n × k log k) +Space Complexity: O(n × k) ### Concepts Used: -Prefix Sum, HashMap, Subarray Pattern +Array Traversal,String Manipulation,Sorting,HashMap,Grouping Pattern ## 128. Longest Consecutive Sequence Problem Link: https://leetcode.com/problems/longest-consecutive-sequence/ @@ -40,3 +39,12 @@ Time Complexity: O(n) Space Complexity: O(n) ### Concepts Used: Prefix Sum, HashMap, Modulo Arithmetic, Subarray Pattern + +## 560. Subarray Sum Equals K +Problem Link: https://leetcode.com/problems/subarray-sum-equals-k/ +Difficulty: Medium +### Approach: Prefix Sum + HashMap (Optimized) +Time Complexity: O(n) +Space Complexity: O(n) +### Concepts Used: +Prefix Sum, HashMap, Subarray Pattern From 40d3a6e12e0bb2696256cdc8b83d600c8c45814a Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 11:23:45 +0530 Subject: [PATCH 20/63] Update README.md --- README.md | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index a0011a6..d2acccb 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -image# Arrays +# Arrays ## 1. Two Sum Problem Link: https://leetcode.com/problems/two-sum/ @@ -22,6 +22,15 @@ Space Complexity: O(n × k) ### Concepts Used: Array Traversal,String Manipulation,Sorting,HashMap,Grouping Pattern +## 121. Best Time to Buy and Sell Stock +Problem Link: https://leetcode.com/problems/best-time-to-buy-and-sell-stock/ +Difficulty: Easy +### Approach: Greedy (One Pass Optimization) +Time Complexity: O(n) +Space Complexity: O(1) +### Concepts Used: +Array Traversal,Greedy Strategy,Minimum Tracking,Profit Maximization,Single Pass Algorithm + ## 128. Longest Consecutive Sequence Problem Link: https://leetcode.com/problems/longest-consecutive-sequence/ Difficulty: Medium From 3fcbd1e665755b9cb54c9c8893383a7d14aa12c7 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 11:58:45 +0530 Subject: [PATCH 21/63] Create 121_Best_Time_to_Buy_and_Sell_Stock.java --- 121_Best_Time_to_Buy_and_Sell_Stock.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 121_Best_Time_to_Buy_and_Sell_Stock.java diff --git a/121_Best_Time_to_Buy_and_Sell_Stock.java b/121_Best_Time_to_Buy_and_Sell_Stock.java new file mode 100644 index 0000000..f786e6a --- /dev/null +++ b/121_Best_Time_to_Buy_and_Sell_Stock.java @@ -0,0 +1,15 @@ +class Solution { + public int maxProfit(int[] prices) { + + int profit = 0 ; + int n = prices.length; + int min_price = prices[0]; + for(int i = 0; i Date: Tue, 17 Feb 2026 12:02:20 +0530 Subject: [PATCH 22/63] Update README.md --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index d2acccb..d44f64b 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,7 @@ Time Complexity: O(n) Space Complexity: O(n) ### Concepts Used: Array Traversal,HashMap,Complement Technique,Single Pass Algorithm,Key-Value Mapping + ## 49. Group Anagrams Problem Link: https://leetcode.com/problems/group-anagrams/ Difficulty: Medium @@ -57,3 +58,4 @@ Time Complexity: O(n) Space Complexity: O(n) ### Concepts Used: Prefix Sum, HashMap, Subarray Pattern + From 598d9eab977ce61525b97f485ad13aff1a08e555 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 12:04:47 +0530 Subject: [PATCH 23/63] Create 268_Missing_Number.java --- 268_Missing_Number.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 268_Missing_Number.java diff --git a/268_Missing_Number.java b/268_Missing_Number.java new file mode 100644 index 0000000..1b32cd8 --- /dev/null +++ b/268_Missing_Number.java @@ -0,0 +1,14 @@ +class Solution { + public int missingNumber(int[] nums) { + int n = nums.length; + + int expectedSum = n * (n + 1) / 2; + int actualSum = 0; + + for (int num : nums) { + actualSum += num; + } + + return expectedSum - actualSum; + } +} From 1f27b74382839ed81b7773573888820b2351200c Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 12:05:45 +0530 Subject: [PATCH 24/63] Update README.md --- README.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/README.md b/README.md index d44f64b..7527daf 100644 --- a/README.md +++ b/README.md @@ -41,6 +41,15 @@ Space Complexity: O(n) ### Concepts Used: HashSet, Sequence Pattern, Array Traversal +## 268. Missing Number +Problem Link: https://leetcode.com/problems/missing-number/ +Difficulty: Easy +### Approach: Mathematical Formula (Sum Formula) +Time Complexity: O(n) +Space Complexity: O(1) +### Concepts Used: +Mathematical Formula, Arithmetic Series, Array Traversal, Summation Technique + ## 523. Continuous Subarray Sum Problem Link: https://leetcode.com/problems/continuous-subarray-sum/ Difficulty: Medium From 65732fb3d8cf2e9db7dc55ce0bc56717b74baec1 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 12:48:51 +0530 Subject: [PATCH 25/63] Create 704_Binary_Search.java --- 704_Binary_Search.java | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 704_Binary_Search.java diff --git a/704_Binary_Search.java b/704_Binary_Search.java new file mode 100644 index 0000000..9fb8711 --- /dev/null +++ b/704_Binary_Search.java @@ -0,0 +1,24 @@ +class Solution { + public int search(int[] nums, int target) { + + int low = 0; + int high = nums.length - 1; + + while (low <= high) { + + int mid = low + (high - low) / 2; + + if (nums[mid] == target) { + return mid; + } + else if (nums[mid] < target) { + low = mid + 1; + } + else { + high = mid - 1; + } + } + + return -1; // If target not found + } +} From c4d6bcdd3a7f9da111daca589eb08d0582f8e43f Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 12:51:47 +0530 Subject: [PATCH 26/63] Update 704_Binary_Search.java --- 704_Binary_Search.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/704_Binary_Search.java b/704_Binary_Search.java index 9fb8711..761fd2d 100644 --- a/704_Binary_Search.java +++ b/704_Binary_Search.java @@ -19,6 +19,8 @@ else if (nums[mid] < target) { } } - return -1; // If target not found + return -1; } } + + From 78aeca10bb56d3cbbbd376963a8d97e828e0fdad Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 12:54:16 +0530 Subject: [PATCH 27/63] Update README.md --- README.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/README.md b/README.md index 7527daf..40e2600 100644 --- a/README.md +++ b/README.md @@ -68,3 +68,11 @@ Space Complexity: O(n) ### Concepts Used: Prefix Sum, HashMap, Subarray Pattern +## 704. Binary Search +Problem Link: https://leetcode.com/problems/binary-search/ +Difficulty: Easy +### Approach: Binary Search (Optimized) +Time Complexity: O(log n) +Space Complexity: O(1) +### Concepts Used: +Divide and Conquer,Sorted Array Requirement,Two Pointers (Low & High),Mid Calculation,Half Search Space Reduction From d8c34309d59ca897d28a4e68ff07bcb232067110 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 12:56:12 +0530 Subject: [PATCH 28/63] Create 26Remove_Duplicates_from_Sorted_Array.java --- 26Remove_Duplicates_from_Sorted_Array.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 26Remove_Duplicates_from_Sorted_Array.java diff --git a/26Remove_Duplicates_from_Sorted_Array.java b/26Remove_Duplicates_from_Sorted_Array.java new file mode 100644 index 0000000..e3b79ee --- /dev/null +++ b/26Remove_Duplicates_from_Sorted_Array.java @@ -0,0 +1,16 @@ +class Solution { + public int removeDuplicates(int[] nums) { + if (nums.length == 0) return 0; + + int i = 0; // slow pointer + + for (int j = 1; j < nums.length; j++) { + if (nums[j] != nums[i]) { + i++; + nums[i] = nums[j]; + } + } + + return i + 1; // number of unique elements + } +} From 45fd68c957aa9d7ff280291206489128b94793c0 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 12:58:57 +0530 Subject: [PATCH 29/63] Update README.md --- README.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/README.md b/README.md index 40e2600..fac1ceb 100644 --- a/README.md +++ b/README.md @@ -14,6 +14,15 @@ Space Complexity: O(n) ### Concepts Used: Array Traversal,HashMap,Complement Technique,Single Pass Algorithm,Key-Value Mapping +## 26. Remove Duplicates from Sorted Array +Problem Link: https://leetcode.com/problems/remove-duplicates-from-sorted-array/ +Difficulty: Easy +### Approach: Two Pointer Technique (Optimized) +Time Complexity: O(n) +Space Complexity: O(1) +### Concepts Used: +Two Pointer Technique, In-Place Modification, Sorted Array Property, Single Pass Algorithm + ## 49. Group Anagrams Problem Link: https://leetcode.com/problems/group-anagrams/ Difficulty: Medium From 785ae60b27dc77ac40b7d76d386b902d1549524c Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 12:59:21 +0530 Subject: [PATCH 30/63] Rename 26Remove_Duplicates_from_Sorted_Array.java to 026_Remove_Duplicates_from_Sorted_Array.java --- ...ted_Array.java => 026_Remove_Duplicates_from_Sorted_Array.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 26Remove_Duplicates_from_Sorted_Array.java => 026_Remove_Duplicates_from_Sorted_Array.java (100%) diff --git a/26Remove_Duplicates_from_Sorted_Array.java b/026_Remove_Duplicates_from_Sorted_Array.java similarity index 100% rename from 26Remove_Duplicates_from_Sorted_Array.java rename to 026_Remove_Duplicates_from_Sorted_Array.java From 6b5fc607fbd23b226bd86fc5fb6338118c2c2ebd Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:02:45 +0530 Subject: [PATCH 31/63] Create 283_Move_Zeroes.java --- 283_Move_Zeroes.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 283_Move_Zeroes.java diff --git a/283_Move_Zeroes.java b/283_Move_Zeroes.java new file mode 100644 index 0000000..71c940c --- /dev/null +++ b/283_Move_Zeroes.java @@ -0,0 +1,19 @@ +class Solution { + public void moveZeroes(int[] nums) { + int insertPos = 0; // position to place next non-zero + + // Move all non-zero elements to the front + for (int i = 0; i < nums.length; i++) { + if (nums[i] != 0) { + nums[insertPos] = nums[i]; + insertPos++; + } + } + + // Fill the remaining positions with zeros + while (insertPos < nums.length) { + nums[insertPos] = 0; + insertPos++; + } + } +} From 1e7f5f89399916cdc4617335a5b50f4cc63ae0ce Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:07:03 +0530 Subject: [PATCH 32/63] Update README.md --- README.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/README.md b/README.md index fac1ceb..64346ce 100644 --- a/README.md +++ b/README.md @@ -59,6 +59,15 @@ Space Complexity: O(1) ### Concepts Used: Mathematical Formula, Arithmetic Series, Array Traversal, Summation Technique +## 283. Move Zeroes +Problem Link: https://leetcode.com/problems/move-zeroes/ +Difficulty: Easy +### Approach: Two Pointers (In-Place Modification) +Time Complexity: O(n) +Space Complexity: O(1) +### Concepts Used: +Two Pointers, Array Traversal, In-Place Algorithm, Element Shifting, Stable Partitioning + ## 523. Continuous Subarray Sum Problem Link: https://leetcode.com/problems/continuous-subarray-sum/ Difficulty: Medium From ea0cc92d97b161ca7b42e5bbde93308632c0ba3a Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:08:22 +0530 Subject: [PATCH 33/63] Create 2396_Strictly_Palindromic_Number.java --- 2396_Strictly_Palindromic_Number.java | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 2396_Strictly_Palindromic_Number.java diff --git a/2396_Strictly_Palindromic_Number.java b/2396_Strictly_Palindromic_Number.java new file mode 100644 index 0000000..1541955 --- /dev/null +++ b/2396_Strictly_Palindromic_Number.java @@ -0,0 +1,5 @@ +class Solution { + public boolean isStrictlyPalindromic(int n) { + return false; + } +} From 45c6f5ca6f35ef687fcead0cd4ca1ac3798855e2 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:08:39 +0530 Subject: [PATCH 34/63] Rename 001_TwoSum_BruteForce.java to 0001_TwoSum_BruteForce.java --- 001_TwoSum_BruteForce.java => 0001_TwoSum_BruteForce.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 001_TwoSum_BruteForce.java => 0001_TwoSum_BruteForce.java (100%) diff --git a/001_TwoSum_BruteForce.java b/0001_TwoSum_BruteForce.java similarity index 100% rename from 001_TwoSum_BruteForce.java rename to 0001_TwoSum_BruteForce.java From f801a820c19e8eb73d01961799425ffe882d01e2 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:08:56 +0530 Subject: [PATCH 35/63] Rename 001_TwoSum_HashMap.java to 0001_TwoSum_HashMap.java --- 001_TwoSum_HashMap.java => 0001_TwoSum_HashMap.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 001_TwoSum_HashMap.java => 0001_TwoSum_HashMap.java (100%) diff --git a/001_TwoSum_HashMap.java b/0001_TwoSum_HashMap.java similarity index 100% rename from 001_TwoSum_HashMap.java rename to 0001_TwoSum_HashMap.java From fbcb654633d3445bc3748fb3429afc3a07b0e01a Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:09:15 +0530 Subject: [PATCH 36/63] Rename 026_Remove_Duplicates_from_Sorted_Array.java to 00026_Remove_Duplicates_from_Sorted_Array.java --- ...d_Array.java => 00026_Remove_Duplicates_from_Sorted_Array.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 026_Remove_Duplicates_from_Sorted_Array.java => 00026_Remove_Duplicates_from_Sorted_Array.java (100%) diff --git a/026_Remove_Duplicates_from_Sorted_Array.java b/00026_Remove_Duplicates_from_Sorted_Array.java similarity index 100% rename from 026_Remove_Duplicates_from_Sorted_Array.java rename to 00026_Remove_Duplicates_from_Sorted_Array.java From edaf20ef4f8dc840dca60f902d26501a68165587 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:09:33 +0530 Subject: [PATCH 37/63] Rename 00026_Remove_Duplicates_from_Sorted_Array.java to 0026_Remove_Duplicates_from_Sorted_Array.java --- ...ed_Array.java => 0026_Remove_Duplicates_from_Sorted_Array.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 00026_Remove_Duplicates_from_Sorted_Array.java => 0026_Remove_Duplicates_from_Sorted_Array.java (100%) diff --git a/00026_Remove_Duplicates_from_Sorted_Array.java b/0026_Remove_Duplicates_from_Sorted_Array.java similarity index 100% rename from 00026_Remove_Duplicates_from_Sorted_Array.java rename to 0026_Remove_Duplicates_from_Sorted_Array.java From 547c5be1b7ba9230ee9ceb779ac12920a6578a90 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:09:50 +0530 Subject: [PATCH 38/63] Rename 049_Group_Anagrams.java to 0049_Group_Anagrams.java --- 049_Group_Anagrams.java => 0049_Group_Anagrams.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 049_Group_Anagrams.java => 0049_Group_Anagrams.java (100%) diff --git a/049_Group_Anagrams.java b/0049_Group_Anagrams.java similarity index 100% rename from 049_Group_Anagrams.java rename to 0049_Group_Anagrams.java From 7e2f3021478fc2047910d64e8e1a4fb3e909ba73 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:10:02 +0530 Subject: [PATCH 39/63] Rename 121_Best_Time_to_Buy_and_Sell_Stock.java to 0121_Best_Time_to_Buy_and_Sell_Stock.java --- ...d_Sell_Stock.java => 0121_Best_Time_to_Buy_and_Sell_Stock.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 121_Best_Time_to_Buy_and_Sell_Stock.java => 0121_Best_Time_to_Buy_and_Sell_Stock.java (100%) diff --git a/121_Best_Time_to_Buy_and_Sell_Stock.java b/0121_Best_Time_to_Buy_and_Sell_Stock.java similarity index 100% rename from 121_Best_Time_to_Buy_and_Sell_Stock.java rename to 0121_Best_Time_to_Buy_and_Sell_Stock.java From faf7d34a034dbc96bb5c4c45234febd31f74b778 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:10:34 +0530 Subject: [PATCH 40/63] Update and rename 128_Longest_Consecutive_Sequence.java to 0128_Longest_Consecutive_Sequence.java --- ...cutive_Sequence.java => 0128_Longest_Consecutive_Sequence.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 128_Longest_Consecutive_Sequence.java => 0128_Longest_Consecutive_Sequence.java (100%) diff --git a/128_Longest_Consecutive_Sequence.java b/0128_Longest_Consecutive_Sequence.java similarity index 100% rename from 128_Longest_Consecutive_Sequence.java rename to 0128_Longest_Consecutive_Sequence.java From 94ff8fec21eb0c61823d15b63d945d07061ab1c4 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:10:51 +0530 Subject: [PATCH 41/63] Rename 268_Missing_Number.java to 0268_Missing_Number.java --- 268_Missing_Number.java => 0268_Missing_Number.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 268_Missing_Number.java => 0268_Missing_Number.java (100%) diff --git a/268_Missing_Number.java b/0268_Missing_Number.java similarity index 100% rename from 268_Missing_Number.java rename to 0268_Missing_Number.java From e9bd8ac2b73358862b5f1368e2cc3afb61e0adcf Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:11:04 +0530 Subject: [PATCH 42/63] Rename 283_Move_Zeroes.java to 0283_Move_Zeroes.java --- 283_Move_Zeroes.java => 0283_Move_Zeroes.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 283_Move_Zeroes.java => 0283_Move_Zeroes.java (100%) diff --git a/283_Move_Zeroes.java b/0283_Move_Zeroes.java similarity index 100% rename from 283_Move_Zeroes.java rename to 0283_Move_Zeroes.java From 96fbb423b696d1eb732fc04c9cb5cc4d6bb5af17 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:11:19 +0530 Subject: [PATCH 43/63] Rename 523_ Continuous_Subarray_Sum.java to 0523_ Continuous_Subarray_Sum.java --- ...inuous_Subarray_Sum.java => 0523_ Continuous_Subarray_Sum.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 523_ Continuous_Subarray_Sum.java => 0523_ Continuous_Subarray_Sum.java (100%) diff --git a/523_ Continuous_Subarray_Sum.java b/0523_ Continuous_Subarray_Sum.java similarity index 100% rename from 523_ Continuous_Subarray_Sum.java rename to 0523_ Continuous_Subarray_Sum.java From fb20593c3623d27da662062a7ec0a574511cf01c Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:11:34 +0530 Subject: [PATCH 44/63] Rename 560_Subarray_Sum_Equals_K.java to 0560_Subarray_Sum_Equals_K.java --- 560_Subarray_Sum_Equals_K.java => 0560_Subarray_Sum_Equals_K.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 560_Subarray_Sum_Equals_K.java => 0560_Subarray_Sum_Equals_K.java (100%) diff --git a/560_Subarray_Sum_Equals_K.java b/0560_Subarray_Sum_Equals_K.java similarity index 100% rename from 560_Subarray_Sum_Equals_K.java rename to 0560_Subarray_Sum_Equals_K.java From 712c20de58d3498322c2667cfceb15136b0de779 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:11:47 +0530 Subject: [PATCH 45/63] Rename 704_Binary_Search.java to 0704_Binary_Search.java --- 704_Binary_Search.java => 0704_Binary_Search.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 704_Binary_Search.java => 0704_Binary_Search.java (100%) diff --git a/704_Binary_Search.java b/0704_Binary_Search.java similarity index 100% rename from 704_Binary_Search.java rename to 0704_Binary_Search.java From 21c7753c13500118a82f4d1eab626b2c972e0040 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:12:54 +0530 Subject: [PATCH 46/63] Create 0088_Merge_Sorted_Array.java --- 0088_Merge_Sorted_Array.java | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 0088_Merge_Sorted_Array.java diff --git a/0088_Merge_Sorted_Array.java b/0088_Merge_Sorted_Array.java new file mode 100644 index 0000000..45c7d15 --- /dev/null +++ b/0088_Merge_Sorted_Array.java @@ -0,0 +1,27 @@ +class Solution { + public void merge(int[] nums1, int m, int[] nums2, int n) { + + int i = m - 1; // Pointer for nums1 + int j = n - 1; // Pointer for nums2 + int k = m + n - 1; // Pointer for final position + + // Merge from the back + while (i >= 0 && j >= 0) { + if (nums1[i] > nums2[j]) { + nums1[k] = nums1[i]; + i--; + } else { + nums1[k] = nums2[j]; + j--; + } + k--; + } + + // If nums2 still has elements left + while (j >= 0) { + nums1[k] = nums2[j]; + j--; + k--; + } + } +} From b102bcef5a26084c83719e8a515bd93c66dba2b1 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:14:18 +0530 Subject: [PATCH 47/63] Update README.md --- README.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/README.md b/README.md index 64346ce..b33ab08 100644 --- a/README.md +++ b/README.md @@ -32,6 +32,15 @@ Space Complexity: O(n × k) ### Concepts Used: Array Traversal,String Manipulation,Sorting,HashMap,Grouping Pattern +## 88. Merge Sorted Array +Problem Link: https://leetcode.com/problems/merge-sorted-array/ +Difficulty: Easy +### Approach: Two Pointers (Backward Merge) +Time Complexity: O(m + n) +Space Complexity: O(1) +### Concepts Used: +Two Pointers, Array Traversal, In-Place Algorithm, Backward Iteration, Merging Technique + ## 121. Best Time to Buy and Sell Stock Problem Link: https://leetcode.com/problems/best-time-to-buy-and-sell-stock/ Difficulty: Easy From ff4e7dfff7ce0389d1e1d3762fd6f78ae42b9b01 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:16:01 +0530 Subject: [PATCH 48/63] Create 0053_Maximum_Subarray.java --- 0053_Maximum_Subarray.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 0053_Maximum_Subarray.java diff --git a/0053_Maximum_Subarray.java b/0053_Maximum_Subarray.java new file mode 100644 index 0000000..4253e6b --- /dev/null +++ b/0053_Maximum_Subarray.java @@ -0,0 +1,13 @@ +class Solution { + public int maxSubArray(int[] nums) { + int max_sum = nums[0]; + int current_sum = nums[0]; + + for (int i = 1; i < nums.length; i++) { + current_sum = Math.max(nums[i], current_sum + nums[i]); + max_sum = Math.max(max_sum, current_sum); + } + + return max_sum; + } +} From 054783c8f341922635b40589e2fe3b490111dc47 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:17:37 +0530 Subject: [PATCH 49/63] Create 75_Sort_Colors.java --- 75_Sort_Colors.java | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 75_Sort_Colors.java diff --git a/75_Sort_Colors.java b/75_Sort_Colors.java new file mode 100644 index 0000000..61140a4 --- /dev/null +++ b/75_Sort_Colors.java @@ -0,0 +1,26 @@ +class Solution { + public void sortColors(int[] nums) { + int low = 0; + int mid = 0; + int high = nums.length - 1; + + while (mid <= high) { + if (nums[mid] == 0) { + int temp = nums[low]; + nums[low] = nums[mid]; + nums[mid] = temp; + low++; + mid++; + } + else if (nums[mid] == 1) { + mid++; + } + else { // nums[mid] == 2 + int temp = nums[high]; + nums[high] = nums[mid]; + nums[mid] = temp; + high--; + } + } + } +} From f0277fa7af3e4456d3a744a47044aa8433effa69 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:17:50 +0530 Subject: [PATCH 50/63] Rename 75_Sort_Colors.java to 0075_Sort_Colors.java --- 75_Sort_Colors.java => 0075_Sort_Colors.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 75_Sort_Colors.java => 0075_Sort_Colors.java (100%) diff --git a/75_Sort_Colors.java b/0075_Sort_Colors.java similarity index 100% rename from 75_Sort_Colors.java rename to 0075_Sort_Colors.java From 2a2f7383becc6484dd300e636d6db50ab2e8c5df Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:21:15 +0530 Subject: [PATCH 51/63] Create 11_Container_With_Most_Water.java --- 11_Container_With_Most_Water.java | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 11_Container_With_Most_Water.java diff --git a/11_Container_With_Most_Water.java b/11_Container_With_Most_Water.java new file mode 100644 index 0000000..342c877 --- /dev/null +++ b/11_Container_With_Most_Water.java @@ -0,0 +1,24 @@ +class Solution { + public int maxArea(int[] height) { + int left = 0; + int right = height.length - 1; + int maxArea = 0; + + while (left < right) { + int width = right - left; + int minHeight = Math.min(height[left], height[right]); + int area = width * minHeight; + + maxArea = Math.max(maxArea, area); + + // Move the pointer with smaller height + if (height[left] < height[right]) { + left++; + } else { + right--; + } + } + + return maxArea; + } +} From e42f9b9d4faf2babc3488776fb508669bae900b7 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:24:09 +0530 Subject: [PATCH 52/63] Update README.md --- README.md | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/README.md b/README.md index b33ab08..b4a542d 100644 --- a/README.md +++ b/README.md @@ -14,6 +14,15 @@ Space Complexity: O(n) ### Concepts Used: Array Traversal,HashMap,Complement Technique,Single Pass Algorithm,Key-Value Mapping +## 11. Container With Most Water +Problem Link: https://leetcode.com/problems/container-with-most-water/ +Difficulty: Medium +### Approach: Two Pointers (Greedy Optimization) +Time Complexity: O(n) +Space Complexity: O(1) +### Concepts Used: +Two Pointers, Greedy Strategy, Area Calculation, Width–Height Optimization, Pointer Movement Logic + ## 26. Remove Duplicates from Sorted Array Problem Link: https://leetcode.com/problems/remove-duplicates-from-sorted-array/ Difficulty: Easy @@ -32,6 +41,24 @@ Space Complexity: O(n × k) ### Concepts Used: Array Traversal,String Manipulation,Sorting,HashMap,Grouping Pattern +## 53. Maximum Subarray +Problem Link: https://leetcode.com/problems/maximum-subarray/ +Difficulty: Medium +### Approach: Kadane’s Algorithm (Dynamic Programming / Greedy) +Time Complexity: O(n) +Space Complexity: O(1) +### Concepts Used: +Kadane’s Algorithm, Dynamic Programming, Greedy Strategy, Running Sum, Maximum Tracking + +## 75. Sort Colors +Problem Link: https://leetcode.com/problems/sort-colors/ +Difficulty: Medium +### Approach: Dutch National Flag Algorithm (Three Pointers) +Time Complexity: O(n) +Space Complexity: O(1) +### Concepts Used: +Three Pointers, Two Pointer Technique, In-Place Sorting, Partitioning Logic, Dutch National Flag Algorithm + ## 88. Merge Sorted Array Problem Link: https://leetcode.com/problems/merge-sorted-array/ Difficulty: Easy From 2cf8406c4b7d06011a9e0b4ae9102d87a45dc572 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:24:57 +0530 Subject: [PATCH 53/63] Rename 11_Container_With_Most_Water.java to 0011_Container_With_Most_Water.java --- ...er_With_Most_Water.java => 0011_Container_With_Most_Water.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 11_Container_With_Most_Water.java => 0011_Container_With_Most_Water.java (100%) diff --git a/11_Container_With_Most_Water.java b/0011_Container_With_Most_Water.java similarity index 100% rename from 11_Container_With_Most_Water.java rename to 0011_Container_With_Most_Water.java From 6ef4d41b2f82ad58e4303e011ebf274459a2a558 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Tue, 17 Feb 2026 13:26:12 +0530 Subject: [PATCH 54/63] Update README.md --- README.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/README.md b/README.md index b4a542d..c36072c 100644 --- a/README.md +++ b/README.md @@ -130,3 +130,12 @@ Time Complexity: O(log n) Space Complexity: O(1) ### Concepts Used: Divide and Conquer,Sorted Array Requirement,Two Pointers (Low & High),Mid Calculation,Half Search Space Reduction + +## 2396. Strictly Palindromic Number +Problem Link: https://leetcode.com/problems/strictly-palindromic-number/ +Difficulty: Medium +### Approach: Mathematical Observation (Trick Problem) +Time Complexity: O(1) +Space Complexity: O(1) +### Concepts Used: +Number Theory, Base Conversion Concept, Mathematical Proof, Logical Deduction From 523c12af70fad3f45d2ac6bf474fc40a9e6a4875 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Sun, 22 Feb 2026 23:45:50 +0530 Subject: [PATCH 55/63] Update README.md --- README.md | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/README.md b/README.md index c36072c..eeccacc 100644 --- a/README.md +++ b/README.md @@ -32,15 +32,6 @@ Space Complexity: O(1) ### Concepts Used: Two Pointer Technique, In-Place Modification, Sorted Array Property, Single Pass Algorithm -## 49. Group Anagrams -Problem Link: https://leetcode.com/problems/group-anagrams/ -Difficulty: Medium -### Approach: Sorting + HashMap -Time Complexity: O(n × k log k) -Space Complexity: O(n × k) -### Concepts Used: -Array Traversal,String Manipulation,Sorting,HashMap,Grouping Pattern - ## 53. Maximum Subarray Problem Link: https://leetcode.com/problems/maximum-subarray/ Difficulty: Medium @@ -130,12 +121,3 @@ Time Complexity: O(log n) Space Complexity: O(1) ### Concepts Used: Divide and Conquer,Sorted Array Requirement,Two Pointers (Low & High),Mid Calculation,Half Search Space Reduction - -## 2396. Strictly Palindromic Number -Problem Link: https://leetcode.com/problems/strictly-palindromic-number/ -Difficulty: Medium -### Approach: Mathematical Observation (Trick Problem) -Time Complexity: O(1) -Space Complexity: O(1) -### Concepts Used: -Number Theory, Base Conversion Concept, Mathematical Proof, Logical Deduction From c0566094b26e5692b054e7648b573843f5e8f793 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Sun, 22 Feb 2026 23:52:10 +0530 Subject: [PATCH 56/63] Update README.md --- README.md | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/README.md b/README.md index eeccacc..93e45b1 100644 --- a/README.md +++ b/README.md @@ -95,24 +95,6 @@ Space Complexity: O(1) ### Concepts Used: Two Pointers, Array Traversal, In-Place Algorithm, Element Shifting, Stable Partitioning -## 523. Continuous Subarray Sum -Problem Link: https://leetcode.com/problems/continuous-subarray-sum/ -Difficulty: Medium -### Approach: Prefix Sum + HashMap (Modulo Technique) -Time Complexity: O(n) -Space Complexity: O(n) -### Concepts Used: -Prefix Sum, HashMap, Modulo Arithmetic, Subarray Pattern - -## 560. Subarray Sum Equals K -Problem Link: https://leetcode.com/problems/subarray-sum-equals-k/ -Difficulty: Medium -### Approach: Prefix Sum + HashMap (Optimized) -Time Complexity: O(n) -Space Complexity: O(n) -### Concepts Used: -Prefix Sum, HashMap, Subarray Pattern - ## 704. Binary Search Problem Link: https://leetcode.com/problems/binary-search/ Difficulty: Easy From 480035a106717f761c12f0cc723e1487d5d2edd9 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Mon, 23 Feb 2026 00:08:30 +0530 Subject: [PATCH 57/63] Update README.md --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 93e45b1..f75fe1c 100644 --- a/README.md +++ b/README.md @@ -3,11 +3,12 @@ ## 1. Two Sum Problem Link: https://leetcode.com/problems/two-sum/ Difficulty: Easy -### Approach 1: Brute Force +### Approach : Brute Force Time Complexity: O(n²) Space Complexity: O(1) ### Concepts Used: Array Traversal,Nested Loops,Pair Checking + ### Approach 2: HashMap (Optimized) Time Complexity: O(n) Space Complexity: O(n) From c672d83dca9daab18e1386e4dfe5a7805d8fe08e Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Mon, 23 Feb 2026 00:12:25 +0530 Subject: [PATCH 58/63] Delete 0049_Group_Anagrams.java --- 0049_Group_Anagrams.java | 19 ------------------- 1 file changed, 19 deletions(-) delete mode 100644 0049_Group_Anagrams.java diff --git a/0049_Group_Anagrams.java b/0049_Group_Anagrams.java deleted file mode 100644 index 62629bc..0000000 --- a/0049_Group_Anagrams.java +++ /dev/null @@ -1,19 +0,0 @@ -import java.util.*; - -class Solution { - public List> groupAnagrams(String[] strs) { - - HashMap> map = new HashMap<>(); - - for (String str : strs) { - char[] chars = str.toCharArray(); - Arrays.sort(chars); - String key = new String(chars); - - map.putIfAbsent(key, new ArrayList<>()); - map.get(key).add(str); - } - - return new ArrayList<>(map.values()); - } -} From 5399b6e5f7799db7e8526bcc4382182e6cfd4105 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Mon, 23 Feb 2026 00:12:47 +0530 Subject: [PATCH 59/63] Delete 2396_Strictly_Palindromic_Number.java --- 2396_Strictly_Palindromic_Number.java | 5 ----- 1 file changed, 5 deletions(-) delete mode 100644 2396_Strictly_Palindromic_Number.java diff --git a/2396_Strictly_Palindromic_Number.java b/2396_Strictly_Palindromic_Number.java deleted file mode 100644 index 1541955..0000000 --- a/2396_Strictly_Palindromic_Number.java +++ /dev/null @@ -1,5 +0,0 @@ -class Solution { - public boolean isStrictlyPalindromic(int n) { - return false; - } -} From 2352170444e8cadd94fbbf02668d09162d001c46 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Mon, 23 Feb 2026 00:13:25 +0530 Subject: [PATCH 60/63] Delete 0001_TwoSum_HashMap.java --- 0001_TwoSum_HashMap.java | 17 ----------------- 1 file changed, 17 deletions(-) delete mode 100644 0001_TwoSum_HashMap.java diff --git a/0001_TwoSum_HashMap.java b/0001_TwoSum_HashMap.java deleted file mode 100644 index 691a685..0000000 --- a/0001_TwoSum_HashMap.java +++ /dev/null @@ -1,17 +0,0 @@ -class Solution { - public int[] twoSum(int[] nums, int target) { - HashMap map = new HashMap<>(); - - for (int i = 0; i < nums.length; i++) { - int complement = target - nums[i]; - - if (map.containsKey(complement)) { - return new int[] { map.get(complement), i }; - } - - map.put(nums[i], i); - } - - return new int[] {}; - } -} From 3e30db3597ae4b3b32d4c94894530f6876fc09f3 Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Mon, 23 Feb 2026 00:13:35 +0530 Subject: [PATCH 61/63] Delete 0128_Longest_Consecutive_Sequence.java --- 0128_Longest_Consecutive_Sequence.java | 34 -------------------------- 1 file changed, 34 deletions(-) delete mode 100644 0128_Longest_Consecutive_Sequence.java diff --git a/0128_Longest_Consecutive_Sequence.java b/0128_Longest_Consecutive_Sequence.java deleted file mode 100644 index 65c0494..0000000 --- a/0128_Longest_Consecutive_Sequence.java +++ /dev/null @@ -1,34 +0,0 @@ -import java.util.HashSet; - -class Solution { - public int longestConsecutive(int[] nums) { - - HashSet set = new HashSet<>(); - - // Add all numbers to set - for (int num : nums) { - set.add(num); - } - - int longest = 0; - - for (int num : set) { - - // Check if it's the start of a sequence - if (!set.contains(num - 1)) { - - int currentNum = num; - int currentStreak = 1; - - while (set.contains(currentNum + 1)) { - currentNum++; - currentStreak++; - } - - longest = Math.max(longest, currentStreak); - } - } - - return longest; - } -} From 8c413ae64684e24c0e4bdac4ff15c6e7ce506c8b Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Mon, 23 Feb 2026 00:13:54 +0530 Subject: [PATCH 62/63] Delete 0523_ Continuous_Subarray_Sum.java --- 0523_ Continuous_Subarray_Sum.java | 26 -------------------------- 1 file changed, 26 deletions(-) delete mode 100644 0523_ Continuous_Subarray_Sum.java diff --git a/0523_ Continuous_Subarray_Sum.java b/0523_ Continuous_Subarray_Sum.java deleted file mode 100644 index 65e2e70..0000000 --- a/0523_ Continuous_Subarray_Sum.java +++ /dev/null @@ -1,26 +0,0 @@ -import java.util.HashMap; - -class Solution { - public boolean checkSubarraySum(int[] nums, int k) { - - HashMap map = new HashMap<>(); - map.put(0, -1); // Important: Handles case when subarray starts from index 0 - - int sum = 0; - - for (int i = 0; i < nums.length; i++) { - sum += nums[i]; - - int remainder = sum % k; - - if (map.containsKey(remainder)) { - if (i - map.get(remainder) > 1) { - return true; - } - } else { - map.put(remainder, i); - } - } - - return false; - } From 7807f09f3caa42f7b0cd08e4c94058ca5176112d Mon Sep 17 00:00:00 2001 From: ISHA AGGARWAL <244146795+IshaAggarwalDev@users.noreply.github.com> Date: Mon, 23 Feb 2026 00:14:03 +0530 Subject: [PATCH 63/63] Delete 0560_Subarray_Sum_Equals_K.java --- 0560_Subarray_Sum_Equals_K.java | 24 ------------------------ 1 file changed, 24 deletions(-) delete mode 100644 0560_Subarray_Sum_Equals_K.java diff --git a/0560_Subarray_Sum_Equals_K.java b/0560_Subarray_Sum_Equals_K.java deleted file mode 100644 index 1297233..0000000 --- a/0560_Subarray_Sum_Equals_K.java +++ /dev/null @@ -1,24 +0,0 @@ -import java.util.HashMap; - -class Solution { - public int subarraySum(int[] nums, int k) { - - HashMap map = new HashMap<>(); - map.put(0, 1); // Important: handles case when subarray starts from index 0 - - int sum = 0; - int count = 0; - - for (int num : nums) { - sum += num; - - if (map.containsKey(sum - k)) { - count += map.get(sum - k); - } - - map.put(sum, map.getOrDefault(sum, 0) + 1); - } - - return count; - } -}