LeetCode Day 5: Prefix Sum Optimization

Day 42 on LeetCode — Merge Sorted Array (Two Pointer Approach) ✅ Today’s problem focused on efficient in-place array manipulation using the two-pointer technique. 🔹 Approach Used in My Solution The key insight was to compare elements from the back of both arrays instead of the front. Since nums1 already has extra space at the end to accommodate elements from nums2, we can fill the array from the last index backwards. Key points in the logic: • Initialize pointers at the end of the valid elements of nums1 and nums2 • Compare the elements and place the larger one at the back of nums1 • Move the pointers accordingly until all elements are merged • This allows the final sorted array to be stored directly in nums1 This strategy avoids unnecessary shifting of elements and keeps the solution efficient. ⚡ Complexity: • Time Complexity: O(m + n) • Space Complexity: O(1) (in-place merge) 💡 Key Takeaways: • Learned how working from the back can simplify in-place merges • Strengthened understanding of the two-pointer technique • Practiced optimizing array operations without using extra space #LeetCode #DSA #Algorithms #DataStructures #TwoPointers #Arrays #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

🚀 Day 6/60 — LeetCode Discipline Problem Solved: Two Sum II – Input Array Is Sorted (Revision) Difficulty: Medium Today’s focus was on leveraging the sorted property of arrays to move from brute-force thinking to an optimal two-pointer approach. Revisiting this pattern helped reinforce how problem constraints can guide us toward more efficient solutions. 💡 Focus Areas: • Strengthened two-pointer technique • Utilized sorted array properties effectively • Improved constant-space optimization thinking • Focused on writing clean and efficient logic ⚡ Performance Highlight: Achieved ~96% runtime efficiency on submission. Steadily refining core patterns, one day at a time. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #TwoPointers #BinarySearch #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #TechCareers #Programming #Developers #CodingLife

Day 43 on LeetCode — Squares of a Sorted Array ✅ Today’s problem focused on two-pointer technique and handling absolute values for efficient array transformation. 🔹 Approach Used in My Solution The goal was to return a sorted array of squares from a non-decreasing sorted input array, which may contain negative numbers. Key points in the logic: • Use two pointers at the start (left) and end (right) of the array • Compare absolute values of elements at both ends • Place the larger square at the current last position in the result array (pos) • Move the pointer of the larger absolute value and fill the result array from back to front • Continue until all elements are squared and placed This ensures a single-pass O(n) solution without extra sorting. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(n) 💡 Key Takeaways: • Practiced the two-pointer technique for array transformations • Learned to handle negative numbers when squaring • Strengthened understanding of in-place logic using a separate result array #LeetCode #DSA #Algorithms #DataStructures #Arrays #TwoPointers #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

🚀 Day 7/60 — LeetCode Discipline Problem Solved: Contiguous Array (Revision) Difficulty: Medium Today’s practice focused on identifying equal 0s and 1s in a binary array using prefix sum and hashmap optimization. Revisiting this problem reinforced how transforming the problem space can unlock efficient linear-time solutions. 💡 Focus Areas: • Strengthened prefix sum transformation technique • Practiced hashmap-based frequency tracking • Improved subarray pattern recognition • Focused on writing clean and efficient logic ⚡ Performance Highlight: Achieved solid runtime performance on submission. Quiet consistency, deeper patterns, sharper intuition. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #PrefixSum #HashMap #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #TechCareers #Programming #Developers #CodingLife

🚀 Day 8/60 — LeetCode Discipline Problem Solved: 3Sum (Revision) Difficulty: Medium Today’s session revisited the classic 3Sum problem, focusing on combining sorting with the two-pointer technique to efficiently identify unique triplets. This problem continues to be a great exercise in careful duplicate handling and pointer movement discipline. 💡 Focus Areas: • Strengthened sorting + two-pointer pattern • Practiced duplicate triplet elimination • Improved nested pointer reasoning • Focused on writing clean and efficient logic ⚡ Performance Highlight: Achieved solid runtime performance on submission. Step by step, the patterns grow clearer and the intuition sharper. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #TwoPointers #ThreeSum #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #TechCareers #Programming #Developers #CodingLife

Day 40 on LeetCode — Longest Consecutive Sequence ✅ Today’s challenge was about finding the longest sequence of consecutive numbers in an unsorted array. 🔹 Approach Used in My Solution In my implementation, I first sorted the array, which makes consecutive numbers appear next to each other. After sorting, I traversed the array once to track the current streak of consecutive numbers. Key points in the logic: • Skip duplicates to avoid breaking the sequence • Increase the counter when the current number is exactly previous + 1 • Reset the counter when the sequence breaks and update the longest streak This approach keeps the implementation simple, readable, and effective. ⚡ Complexity: • Time Complexity: O(n log n) due to sorting • Space Complexity: O(1) (excluding sorting space) 💡 Key Takeaways: • Sorting can simplify many sequence detection problems • Careful handling of duplicates is important in consecutive sequence problems • Reinforces writing clean traversal logic after preprocessing #LeetCode #DSA #Algorithms #DataStructures #Arrays #Sorting #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

🚀 Day 9/60 — LeetCode Discipline Problem Solved: Container With Most Water (Revision) Difficulty: Medium Today’s session focused on revisiting this classic two-pointer optimization problem. The key insight was understanding how intelligently moving pointers can reduce time complexity while still exploring the optimal solution space. 💡 Focus Areas: • Strengthened two-pointer optimization technique • Improved area maximization intuition • Practiced greedy pointer movement logic • Focused on writing clean and efficient implementation ⚡ Performance Highlight: Achieved ~81% runtime efficiency on submission. Steady practice. Sharper instincts. Stronger foundations. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #TwoPointers #Greedy #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #TechCareers #Programming #Developers #CodingLife

Day 47 on LeetCode — Partition Labels ✂️✅ Today’s problem was a great example of greedy strategy with smart indexing. 🔹 Approach Used in My Solution The goal was to split the string into maximum number of partitions such that each character appears in only one part. Key idea in the solution: • First, store the last occurrence of each character in an array • Traverse the string while maintaining a current partition range • Continuously update the end of the partition using the last index of characters encountered • When the current index reaches end, it means the partition is complete • Store the partition size and start a new one This greedy approach ensures each partition is as small as possible while still valid. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 💡 Key Takeaways: • Learned how preprocessing (last occurrence tracking) simplifies problems • Practiced greedy partitioning techniques • Strengthened understanding of interval expansion logic #LeetCode #DSA #Algorithms #DataStructures #GreedyAlgorithm #Strings #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

🚀 Day 17/60 — LeetCode Discipline Problem Solved: 4Sum (Revision) Difficulty: Medium Today’s session revisited the classic k-Sum family problem — 4Sum. After solving 2Sum and 3Sum patterns previously, this problem naturally extends the idea by combining sorting with nested iteration and the two-pointer technique to efficiently identify unique quadruplets. The key challenge lies in managing duplicates carefully while keeping the solution efficient and structured. 💡 Focus Areas: • Strengthened k-Sum pattern understanding • Practiced sorting + two-pointer combination • Improved duplicate handling in multi-pointer problems • Reinforced nested iteration optimization • Focused on writing structured and readable code Problems like these highlight how mastering one pattern allows you to scale the same idea to more complex variations. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #TwoPointers #Arrays #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #Programming #Developers #TechCareers

Practiced an interesting array problem today: Majority Element. What I understood from this problem was that not all meaningful learning comes from complex topics like dynamic programming or backtracking. Sometimes, even simpler problems create room to think more deeply about optimization. This problem has a very straightforward solution using hashing, but it also led me to explore how much the solution could be optimized in terms of space. That’s when I came across the Boyer–Moore Majority Vote Algorithm. The idea behind it is quite intuitive. Instead of explicitly counting every element, we maintain a candidate and a counter . As we iterate through the array, matching elements increase the count, while different elements decrease it. Over time, elements effectively "cancel each other out". Since the majority element appears more than ⌊n/2⌋ times, it ends up being the final candidate after all cancellations. Problems like this are a good reminder that sometimes the real value lies not just in solving a problem, but in exploring how far an idea can be optimized. ⚡ #softwareengineering #leetcode #algorithms #dsa #coding #programming #problemSolving #computerscience