Divide Array into Subarrays with Min Cost

🚀 Day 13 – LeetCode 60 Days Challenge   Problem Solved: 4 Sum Today I solved the classic 4Sum problem using Sorting + Two Pointer technique. 🔹 Problem: Given an array of integers, return all unique quadruplets such that: nums[i] + nums[j] + nums[left] + nums[right] == target 🔹 Approach I Used: 1️⃣ First, sort the array. 2️⃣ Fix the first element using loop (i). 3️⃣ Fix the second element using loop (j). 4️⃣ Use two pointers (left & right) for remaining two elements. 5️⃣ Carefully skip duplicates to avoid repeated quadruplets. 6️⃣ Used long for sum to avoid integer overflow. This reduces the brute force O(n^4) solution to: ⏱ Time Complexity: O(n^3) 📦 Space Complexity: O(1) (excluding result list) 🔹 Key Learning: - Two pointer technique becomes powerful after sorting. - Duplicate handling is VERY important in combination problems. - Always consider overflow when dealing with large integers. - Pattern recognition: 4Sum is an extension of 3Sum. 💡 Interview Insight: Most interviewers expect you to: ✔ First explain brute force ✔ Then optimize step by step ✔ Handle duplicates properly ✔ Think about overflow edge cases Consistency > Motivation 🔥 Day 13 Done ✅   On to Day 14 🚀 #LeetCode #Java #DSA #ProblemSolving #CodingJourney #InterviewPreparation

15/100 🧠 “building focus, strengthening logical thinking, and staying consistent with problem solving.” Today I worked on a string-based problem where I analyzed each character and categorized it as a vowel, consonant, digit, or space. The focus was on iterating through the string using a loop and applying clear conditional logic to handle different cases properly. This exercise helped reinforce how important attention to detail is when working with characters and conditions. Small mistakes in logic can change the output completely, so being precise matters. Strengthening fundamentals one problem at a time and improving clarity in how I approach string handling. #Java #Strings #ProblemSolving #LogicalThinking #LearningInPublic #CodingJourney #ConsistencyChallenge

Day38 - LeetCode Journey Solved LeetCode 434: Number of Segments in a String using Java ✅ Simple problem, sharp thinking. This one reinforces how much attention to detail matters in string-based questions. Instead of relying on split methods, scanning the string and detecting valid word boundaries made the solution both clean and efficient. What stood out today was handling edge cases like extra spaces and string boundaries correctly. Small logic, big clarity. Key takeaways: • Stronger understanding of string traversal • Better handling of edge cases • Writing efficient, single-pass solutions • Building solid fundamentals for interviews Progress isn’t always loud. Sometimes it’s these small wins that build real confidence. On to the next 🚀 #LeetCode #DSA #Java #StringManipulation #ProblemSolving #Algorithms #CodingJourney #InterviewPrep #Consistency #DailyPractice

Daily Coding Update – Day 23 Today’s challenge: Find the Index of the First Occurrence in a String What I Learned How substring searching works internally Difference between brute force and optimized comparison Why avoiding unnecessary string creation improves performance Approaches Explored Brute force using substring comparison Character-by-character matching (more optimized) Learned about an advanced algorithm: KMP for interview-level optimization Key Takeaway Good developers don’t just solve problems — they analyze time complexity and optimize solutions. Every day I understand DSA a little deeper, and that confidence keeps growing. #Java #DSA #CodingJourney #ProblemSolving #DeveloperGrowth

🚀 Day 5 – LeetCode Practice Today, I solved the Reverse Nodes in k-Group problem on LeetCode: 🎯 Difficulty: Hard 💻 Language Used: Java 💡 Approach: • Given a linked list and an integer k, the task was to reverse every group of k nodes. • I used pointer manipulation and a dummy node to handle group reversals cleanly. • Moved through the list in blocks of k, reversing each sub-group by re-wiring next pointers. • Ensured that if the final group had fewer than k nodes, it was kept as-is. • This approach ensured in-place reversal without extra space. ⏱ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 📚 Key Takeaway: This problem deepened my understanding of in-place linked list manipulation, group operations, and edge-case handling when list length isn’t a multiple of k. Solving pattern-rich, hard problems like this consistently improves my algorithmic thinking and implementation precision. 💪 #LeetCode #Java #DSA #LinkedList #ProblemSolving #Algorithms #CodingPractice #100DaysOfCode #SoftwareDeveloper

Day 2/100 – LeetCode Challenge 🚀 Problem: #48 Rotate Image   Difficulty: Medium   Language: Java   Approach: In-Place Rotation using Transpose + Row Reversal   Time Complexity: O(n²)   Space Complexity: O(1) 🔍 Key Insight: To rotate a matrix 90° clockwise without extra space: 1️⃣ First transpose the matrix (swap across diagonal). 2️⃣ Then reverse each row. This avoids creating a new matrix and satisfies the in-place constraint. 🧠 Solution Brief: Used nested loops to transpose the matrix by swapping arr[i][j] and arr[j][i]. Then reversed each row using two pointers (start and end). Combined both operations inside a rotate() method. Achieved full rotation with constant extra space. 📌 What I Learned: Matrix problems are more about pattern recognition than brute force. Understanding transformations (transpose + reverse) makes complex problems simple. Starting my 100 Days of LeetCode journey today 💪 Consistency > Motivation. #LeetCode #Day2 #100DaysOfCode #Java #DSA #Matrix #ProblemSolving #CodingJourney #MediumProblem

🚀 Day 24 – LeetCode 1358 | Mastering Sliding Window for Substring Counting Solved LeetCode 1358: Number of Substrings Containing All Three Characters today. At first glance, this problem looks like a brute-force substring question. But checking every substring leads to O(n²) or O(n³) time, which is unacceptable for interviews. The correct approach is using the Sliding Window (Two Pointers) technique. Instead of generating all substrings: Expand the window Track counts of a, b, and c Once all three are present, count all valid substrings at once Shrink the window and repeat This reduces the complexity to O(n). Today’s focus: • Efficient substring counting • Two-pointer logic • Thinking in patterns instead of brute force Improving problem-solving skills one day at a time. #LeetCode #DSA #SlidingWindow #TwoPointers #Java #ProblemSolving #CodingInterview #SoftwareDeveloper #100DaysOfCode #TechGrowth

⚡ Day 4 — Merge Intervals (Greedy + Sorting) Consistency is slowly turning confusion into clarity. Today’s problem was Merge Intervals — a classic example where the real difficulty isn’t coding, but recognizing the pattern. 🧩 Problem solved: Merge Intervals 🔢 LeetCode: 56 At first glance, the problem looks messy because overlapping ranges create too many comparison possibilities. The turning point was realizing that trying to merge randomly is inefficient — sorting the intervals by start time simplifies everything. Once sorted, the logic becomes straightforward: • Compare the current interval with the last merged interval • If they overlap → extend the boundary • If they don’t → push a new interval No unnecessary comparisons. Just one clean pass. 🔍 Key learnings: • Sorting often converts complex interval problems into linear scans • Greedy decisions work when local choices don’t break global correctness • Tracking only the “last merged interval” avoids redundant checks • Pattern recognition matters more than code length Slowly building the instinct to see patterns before writing loops. Solutions are available here: https://lnkd.in/gW8atfqw More tomorrow. #DSA #Java #LeetCode #GreedyAlgorithm #CodingJourney #StudentDeveloper #LearningInPublic

🚀 Day 14 – LeetCode 60 Days Challenge   Problem Solved: Search Insert Position Today I solved the classic Binary Search problem – Search Insert Position. 🔹 Problem: Given a sorted array and a target value, return the index if the target exists.   If not, return the index where it should be inserted to maintain sorted order. 🔹 Approach I Used: 1️⃣ Applied Binary Search (O(log n))   2️⃣ Used while(start <= end) template   3️⃣ Carefully adjusted boundaries:   - If nums[mid] < target → move start = mid + 1   - If nums[mid] > target → move end = mid - 1 4️⃣ If target is not found, return start as the correct insert position. 🔹 Key Insight: When the loop ends, start automatically points to the smallest index where the target can be placed without breaking sorted order. No extra condition needed. Binary Search naturally gives the insertion point. ⏱ Time Complexity: O(log n)   📦 Space Complexity: O(1) 🔹 Learning: - Never mix different binary search templates. - Choose one pattern and stick to it. - Boundary movement (mid - 1 vs mid) is VERY important. - Understanding loop termination is more important than memorizing code. Binary Search looks simple, but small boundary mistakes can break everything. Day 14 Done ✅   On to mastering Lower Bound & Upper Bound next 🚀 #LeetCode #BinarySearch #Java #DSA #InterviewPreparation #CodingJourney