Max Subarray Sum with Kadane's Algorithm

🚀 LeetCode Challenge 1/50 🔍 Problem: Longest Substring Without Repeating Characters Today, I solved a classic sliding window problem that focuses on optimizing string traversal efficiently. 💡 Approach: Instead of checking all substrings (which would be inefficient), I used the Sliding Window + HashMap technique. - Maintained two pointers to track the current window - Used a HashMap to store the last index of characters - Whenever a duplicate appeared, directly shifted the left pointer to avoid unnecessary iterations ⚡ This helped in reducing time complexity significantly. 📊 Complexity Analysis: Time Complexity: O(n) Space Complexity: O(n) 📚 Key Learning: Efficient use of data structures like HashMap can drastically optimize problems by avoiding redundant computations. The sliding window technique is extremely powerful for substring-related problems. Consistency is key—looking forward to solving more such problems! 💪 #LeetCode #DataStructures #Algorithms #CodingJourney #ProblemSolving #Java #100DaysOfCode #Learning #StudentDeveloper

🚀 Solved LeetCode 215 – Kth Largest Element in an Array Today I worked on a classic and highly important problem that tests understanding of Heap, Sorting, and Quick Select algorithms. 🔍 Problem Insight: Given an unsorted array, the task is to find the kth largest element without fully sorting the array. 💡 Key Learnings: Sorting works but is not the most optimal approach Min Heap (Priority Queue) helps maintain the k largest elements efficiently Quick Select provides an optimal average-case solution Understanding trade-offs between approaches is crucial ⚙️ Approaches Explored: Sorting → Simple but takes O(n log n) Min Heap → Efficient with O(n log k) Quick Select → Best average time complexity O(n) 📈 Complexity: Heap approach: O(n log k) Quick Select: O(n) average, O(n²) worst case 🔥 Takeaway: This problem is a must-know for interviews as it builds a strong foundation in selection algorithms and data structures like heaps. Choosing the right approach based on constraints is the real skill here. #LeetCode #Algorithms #DataStructures #Heap #QuickSelect #CodingJourney #ProblemSolving #Java #CompetitiveProgramming

🚀 LeetCode Challenge 9/50 🔍 Problem: Maximum Subarray Today’s problem introduced one of the most important algorithms in Dynamic Programming — Kadane’s Algorithm. 💡 Approach: Instead of checking all possible subarrays (which would be inefficient), I used Kadane’s Algorithm: At each step, decide whether to start a new subarray or continue the existing one Keep track of the current sum and update the maximum sum accordingly ⚡ This allows solving the problem in a single pass efficiently. 📊 Complexity Analysis: Time Complexity: O(n) Space Complexity: O(1) 📚 Key Learning: Kadane’s Algorithm is a powerful technique for solving subarray problems. It helps optimize brute-force solutions and is a must-know concept for interviews and competitive programming. Consistency + Learning = Growth 🚀 #LeetCode #Algorithms #DataStructures #DynamicProgramming #ProblemSolving #CodingJourney #Java #100DaysOfCode #StudentDeveloper #Learning

🚀 Day 5/100 — #100DaysOfLeetCode Consistency + Concepts = Growth 📈 ✅ Problem Solved: 🔹 LeetCode 53 — Maximum Subarray 💡 Algorithm Used: Kadane’s Algorithm 🧠 What I Learned: Kadane’s Algorithm efficiently finds the maximum subarray sum in O(n) time by following a simple intuition: Keep adding elements to a running sum. If the running sum becomes negative, reset it to 0 because a negative sum can never help future subarrays. Continuously track the maximum sum seen so far. Instead of checking all possible subarrays (which is costly), Kadane’s Algorithm teaches how local decisions lead to a global optimal solution. This problem helped me understand how optimization patterns work in real DSA problems. Day by day, patterns are becoming clearer 🚀 #100DaysOfLeetCode #LeetCode #DSA #KadaneAlgorithm #Java #ProblemSolving #Algorithms #CodingJourney #LearningInPublic

🚀 Solved LeetCode 2515 – Shortest Distance to Target String in a Circular Array Today I tackled an interesting problem that highlights the importance of handling circular data structures efficiently. 🔍 Problem Insight: Given a circular array of words, a target string, and a starting index, the goal is to find the minimum number of steps required to reach the target by moving either left or right. 💡 Key Learnings: Circular arrays require thinking beyond linear traversal Always consider both directions (forward & backward) Optimizing distance using min(distance, n - distance) is the key trick Simple logic + correct observation = optimal solution ⚙️ Approach Used: Traverse the array to find all occurrences of the target Calculate distance from the starting index Take the minimum considering circular movement 📈 Complexity: Efficient O(n) solution with constant space 🔥 Takeaway: This problem reinforced how small tweaks (like circular behavior) can change the entire approach. A great example of combining logic + observation for clean and optimal solutions. #LeetCode #Algorithms #ProblemSolving #CodingJourney #Java #DataStructures #CompetitiveProgramming

Day 22 of my #30DayCodeChallenge: The Art of Backtracking! The Problem: Permutations. Given an array of distinct integers, return all possible arrangements. This is a foundational problem for understanding how to explore a "state space." The Logic: approached this using a Recursive Backtracking strategy with a Frequency Map (boolean array) to keep track of used elements. 1. State Exploration: I used a DFS function to build a permutation one element at a time. For every position, we "decide" which available number to place there. 2. The Visited Array: To ensure we don't reuse the same number in a single permutation, I maintained a bool vis array. This acts as our "memory" of what's already in the current path. 3. Backtracking (The "Undo" Step): This is the magic. After exploring a path (e.g., [1, 2, 3]), we pop the last element and mark it as "unvisited" so it can be used in a different position for the next branch (e.g., [1, 3, 2]). The Goal: By the time the recursion depth equals the array length, we've found a valid permutation and add it to our final list. One step closer to mastery. Onward to Day 23! #Java #Algorithms #DataStructures #Backtracking #Recursion #150DaysOfCode

🚀 LeetCode Challenge 32/50 💡 Approach: Factorial Number System (Math + Greedy) Generating all n! permutations and picking the kᵗʰ one would be O(n! × n) — way too slow! Instead, we use the Factorial Number System to directly compute the kᵗʰ permutation digit by digit in O(n²)! 🔍 Key Insight: → Precompute factorials: fact[i] = i! → Convert k to 0-based index (k--) → For each position, there are (n-1)! permutations starting with each digit → index = k / fact[i-1] tells which digit to pick next → Remove used digit, update k = k % fact[i-1], repeat! 📈 Complexity: ❌ Generate all permutations → O(n! × n) Time ✅ Factorial Number System → O(n²) Time, O(n) Space Sometimes the best algorithm isn’t about searching — it’s about computing the answer directly using pure math! 🧑🔬 #LeetCode #DSA #Math #Greedy #Java #ADA #PBL2 #LeetCodeChallenge #Day32of50 #CodingJourney #ComputerEngineering #AlgorithmDesign #PermutationSequence

🚀 LeetCode Challenge 10/50 🔍 Problem: Merge Sorted Array Today’s problem focused on efficiently merging two sorted arrays without using extra space. 💡 Approach: I used the Two Pointer technique (from the end): Started comparing elements from the back of both arrays Placed the larger element at the end of nums1 Continued this process until all elements were merged ⚡ This approach avoids unnecessary shifting and works in-place. 📊 Complexity Analysis: Time Complexity: O(m + n) Space Complexity: O(1) 📚 Key Learning: Thinking from the end can simplify problems and avoid extra operations. Two-pointer technique is extremely useful for array manipulation problems. Consistency is building confidence 💪 #LeetCode #Algorithms #DataStructures #ProblemSolving #CodingJourney #Java #100DaysOfCode #StudentDeveloper #Learning

🚀 LeetCode Challenge 15/50 💡 Approach: Dutch National Flag Algorithm The problem says no library sort — and even a two-pass counting sort feels like cheating when there's a legendary one-pass algorithm designed exactly for this! Edsger Dijkstra's Dutch National Flag algorithm sorts 3 distinct values in a single traversal! 🔍 Key Insight: → Maintain 3 pointers: low, mid, high → nums[mid] == 0 → swap with low, advance both low & mid → nums[mid] == 1 → already in place, just advance mid → nums[mid] == 2 → swap with high, shrink high only → Stop when mid crosses high 📈 Complexity: ❌ Two-pass Counting Sort → O(n) Time, O(1) Space (2 passes) ✅ Dutch National Flag → O(n) Time, O(1) Space (1 pass only!) Sometimes knowing the right algorithm is the solution itself. Dijkstra didn't just solve sorting — he solved elegance! 🇳🇱 #LeetCode #DSA #DutchNationalFlag #Java #ADA #PBL2 #LeetCodeChallenge #Day15of50 #CodingJourney #ComputerEngineering #AlgorithmDesign #SortColors

🚀 Day 55 of #100DaysOfCode – Rotate Image Today I worked on an interesting matrix problem: Rotate Image (90° clockwise) 🔄 💡 Key Learning: Instead of using extra space, the challenge is to rotate the matrix in-place. 🧠 Approach I used: 1️⃣ Transpose the matrix (convert rows → columns) 2️⃣ Reverse each row This combination effectively rotates the matrix by 90° clockwise without using extra memory. 📌 Example: Input: [[1,2,3], [4,5,6], [7,8,9]] Output: [[7,4,1], [8,5,2], [9,6,3]] ⚡ Complexity: Time: O(n²) Space: O(1) (in-place) 💻 Implemented in Java and successfully passed all test cases ✅ This problem really helped me strengthen my understanding of matrix manipulation and in-place algorithms. #LeetCode #DataStructures #Java #CodingPractice #ProblemSolving #Algorithms #100DaysOfCode