Arrays and DP: Efficiency with Foresight

📌 Day 28/100 – Intersection of Two Linked Lists (LeetCode 160) 🔹 Problem: Given two singly linked lists, find the node at which they intersect. If they don’t intersect, return null, without modifying their structure. 🔹 Approach: I used the classic two-pointer technique: Pointer p traverses List A, pointer q traverses List B. When a pointer reaches the end, it switches to the other list. Both eventually traverse equal lengths, meeting at the intersection or both becoming null. This method avoids extra space and keeps the code extremely simple. 🔹 Key Learning: Two-pointer syncing is powerful for linked list problems. No extra memory needed (O(1) space). Simple logic can outperform complex hashing approaches. Sometimes, taking the “longer way” (switching lists) leads to the optimal solution!

🔥 Day 69 — “Strings, Structure & Strategy.” 🧩💡 Theme: Strings × Dynamic Programming Today’s challenges tested precision in pairing logic with layers — where every substring, sequence, and selection demanded careful calculation. Dynamic Programming once again became the art of 'balancing time, value, and possibility.' 💻 What I Solved: 🔹 Count Repetitions — (Hard) ✅ 150/150 — finding hidden rhythm within repeated patterns. 🔹 Optimized Washing — (Hard) ✅ 150/150 — time and efficiency woven through clean DP logic. 🔹 Removal of String — (Hard) ⏳ 38/150 — untangling overlaps one substring at a time. 🔹 Maximum Number of Events That Can Be Attended II — (Hard) ⏳ 113/150 — strategizing choices with weighted intervals. 🎯 Key Learnings: * Every DP decision carries a cost — 'choose wisely, gain maximally.' * In Strings, removing one character can change the entire state. * Optimization isn’t speed alone — it’s clarity in constraint. 📊 Leaderboard Update: 🏆 Points: 31,183+ 🏅 Rank: 122 💬 From the coder’s desk: > “Where strings connect and choices collide, > logic finds its rhythm — and patterns come alive.” 🎶💻 Join me on Unstop 👉 https://lnkd.in/gRFmWUyA #100DaysOfCode #Day69 #CodingJourney #Unstop

🔗 Day 75 of #100DaysOfCode 🔗 🌳 Problem: Binary Tree Postorder Traversal – LeetCode ✨ Approach: Implemented a recursive depth-first traversal that processes the left subtree, then right subtree, and finally the root node — perfectly matching the postorder pattern (Left → Right → Root). The solution is clean, intuitive, and highlights the elegance of recursion in tree traversal! 🌿 📊 Complexity Analysis: ⏱ Time Complexity: O(n) — each node is visited exactly once 💾 Space Complexity: O(n) — recursion stack in the worst case (skewed tree) ✅ Runtime: 0 ms (Beats 100% 🚀) ✅ Memory: 43.07 MB 💡 Key Insight: Recursion beautifully mirrors the natural hierarchy of trees — by trusting the call stack, we achieve simplicity and clarity in solving even complex traversal problems. 🌱 #LeetCode #100DaysOfCode #ProblemSolving #DSA #BinaryTree #Recursion #AlgorithmDesign #CodeJourney #ProgrammingChallenge #LogicBuilding #Efficiency #CodingDaily

🚀 Problem Solving Update Today’s problem-solving session was all about optimizing thought processes and tackling both classic and hard-level challenges 💪 🟩 GFG POTD – Get Minimum Squares Approach: Used Dynamic Programming to compute the minimum number of perfect squares that sum up to a given integer n. Built a DP array where dp[i] represents the minimum number of squares required to form i. For every i, iterated over all possible squares j*j ≤ i and updated dp[i] = min(dp[i], dp[i - j*j] + 1). Final answer is dp[n]. A neat and efficient bottom-up approach to a fundamental DP problem! ⚙️ 🟥 LeetCode Daily Challenge – Find X-Sum of All K-Long Subarrays II (Hard) Approach: Implemented an advanced sliding window combined with frequency tracking using two multisets — one maintaining the top x most significant (frequency × value) elements, and another storing the rest. Used custom comparators to dynamically manage transitions between the sets. Maintained a running sum of the top elements (sumTop) to efficiently update answers as the window slides. Smart rebalancing ensured that insertions/removals kept the sets valid for every window. This one was quite intense 🔥 — required careful balancing of logic, data structures, and optimization to achieve efficiency. #ProblemSolving #LeetCode #GeeksforGeeks

Day 9 of #30DaysOfCode 📐 From Brute Force to Ultra-Optimized: Maximum Rectangle Area Problem Just cracked an interesting geometric problem that taught me the power of micro-optimizations in competitive programming! The Challenge: Find the largest axis-aligned rectangle from a set of points where no other points lie inside or on the borders. The Journey: Started with O(n⁴) brute force approach Optimized to O(n³) using diagonal-pair strategy Applied competitive programming micro-optimizations Key Optimizations That Made the Difference: - unordered_set with reserve() → 3-5x faster lookups vs set - Bit packing coordinates → (x,y) into single 64-bit integer for faster hashing - Const references → Reduced array access overhead - Early break/continue → Eliminated wasted iterations - Direct comparison → Avoided max() function overhead The Results: ⚡ 6-8x performance improvement 💾 Same O(n) space complexity 🎯 Runs in ~100-200 operations for n ≤ 10 Key Takeaway: For small constraints, the right data structure + micro-optimizations matter more than asymptotic complexity. Sometimes it's not about changing the algorithm, but making every operation count! #CompetitiveProgramming #CPP #AlgorithmOptimization #DSA #ProblemSolving #SoftwareEngineering #CodingInterview #PerformanceOptimization Educative #educative

🔹 Day 83 of #100DaysOfLeetCodeChallenge 🔹 🚀 Problem: Divide Two Integers 🔑 Topic: Bit Manipulation + Binary Search Approach 🧠 Approach: We need to divide two integers without using /, *, or %. The trick is to simulate division using bit shifting (doubling) — which is basically fast subtraction. Here’s the logic 👇 1️⃣ Handle edge cases: INT_MIN / -1 → overflow, return INT_MAX. If both numbers are equal → result is 1. 2️⃣ Determine the sign of result. 3️⃣ Convert both numbers to positive using long for safety. 4️⃣ Repeatedly subtract the largest doubled divisor from dividend: Keep left-shifting divisor (temp <<= 1) until it exceeds dividend. Add corresponding power-of-two (multiple) to answer. 5️⃣ Apply sign and clamp to 32-bit integer limits. ⏳ Time Complexity: O(log n) 💾 Space Complexity: O(1) 📌 Example: Input: 7 / -3 Output: -2 (since truncation toward zero) 🎯 Takeaway: This problem teaches how bit-level doubling can replace multiplication and how binary logic can optimize even basic math operations. ⚡ #LeetCode #DSA #BitManipulation #BinaryMath #ProblemSolving #CodingJourney #100DaysOfLeetCodeChallenge 🚀

🎯 Day 83 of #100DaysOfCode 🔹 Problem: Count the Digits That Divide a Number – LeetCode ✨ Approach: A simple yet elegant digit-based problem! I extracted each digit of the number using modulo and division, then checked whether the digit cleanly divides the original number. Every valid digit increases the count — a perfect use-case for number breakdown and modular arithmetic. 🔢⚡ 📊 Complexity Analysis: ⏱ Time Complexity: O(d) — where d is the number of digits 💾 Space Complexity: O(1) — no extra data structures used ✅ Runtime: 0 ms (Beats 100% 🚀) ✅ Memory: 42.29 MB 🔑 Key Insight: Even basic problems sharpen precision — breaking numbers digit-by-digit reinforces strong logical thinking and clean coding habits. Sometimes the simplest loops teach the most. ✨ #LeetCode #100DaysOfCode #DSA #NumberTheory #ModularArithmetic #CleanCode #EfficientCoding #LogicBuilding #TechJourney #ProgrammingChallenge #CodingDaily

🚀 Day 61 of #100DaysOfLeetCodeHard — LeetCode 1320: Minimum Distance to Type a Word Using Two Fingers (Hard) My Submission:https://lnkd.in/gdAy6ski Today’s problem was a 5D Dynamic Programming challenge that tested both spatial intuition and state management in recursion. The task was to minimize the total distance required to type a given string on a 2D keyboard using two fingers. Each key has a coordinate on a 6-column grid, and each finger can independently move across the board. 💡 Approach: I defined the state as: dp[ind][x1][y1][x2][y2] → the minimum cost to type from index ind when first finger is at (x1, y1) second finger is at (x2, y2) At each step, I explored both possibilities: Typing the next letter with the first finger, Typing it with the second finger, and recursively computed the minimal total cost. 📘 Key Concepts: Multi-dimensional DP with recursion + memoization Manhattan distance calculation Handling base conditions and free initial finger placement ⏱️ Time Complexity: ~O(n × 6⁴) (optimized with memoization) 💾 Space Complexity: O(n × 6⁴) This problem was one of the most state-heavy DP problems I’ve done so far — but once the transitions clicked, it turned out to be a very elegant solution! 💪 #LeetCode #DynamicProgramming #Recursion #ProblemSolving #C++ #100DaysOfCode #LearningEveryday #CodingChallenge

📌 Day 44/150 – String to Integer (atoi) (LeetCode #8) Today’s challenge was a deep dive into the world of string parsing and data conversion — a problem that demands precision, logic, and attention to detail! ✨🧠 The task? Implement a function that converts a string into a 32-bit signed integer, just like the classic C atoi() function. Sounds simple, right? But here’s the twist — You must handle whitespaces, signs, non-digit characters, and integer overflow — all while ensuring that your implementation works exactly as expected! ⚙️ 🔹 Step-by-Step Breakdown 1️⃣ Ignore leading whitespaces 2️⃣ Check for sign (‘+’ or ‘–’) 3️⃣ Extract valid digits 4️⃣ Stop when a non-digit appears 5️⃣ Clamp the result within the 32-bit signed integer range [-2^31, 2^31 - 1] 💡 Example Walkthrough Input: " -042" Process: → Ignore spaces → detect sign → read “042” → result = -42 ✅ Output: -42 ⚙️ Time & Space Complexity ComplexityValueTimeO(n) — Linear scan through the stringSpaceO(1) — No extra data structures used 🚀 Key Learnings This problem isn’t just about converting strings — it’s about robust input handling and building safe conversions used in real-world systems like compilers, interpreters, and data parsers. It helped me sharpen: 🔧 Careful condition checking 📏 Edge case handling (like overflow and invalid input) 🧩 Logical implementation flow 💬 Takeaway Sometimes, the simplest problems teach you the power of precision. 🧮 "Attention to every condition is what makes logic rock-solid!" 💪 #150DaysOfCode #LeetCode #StringParsing #ProblemSolving #CodingJourney #SoftwareEngineering #ProgrammingLogic #Atoi #DataStructures #Algorithms #TechLearning 💻🚀

🎯 LeetCode Daily – Triangle (Day 113) Today’s problem deepened my understanding of Dynamic Programming on Triangular Grids, focusing on minimizing path sums efficiently. ✅ My Approach: 🔹 Problem – Triangle: • The goal was to find the minimum path sum from the top to the bottom of a triangle array. • Used Memoization (Top-Down DP) to recursively explore all paths while storing intermediate results to avoid redundant computations. • Implemented Tabulation (Bottom-Up DP) to build the solution iteratively starting from the last row and moving upward, computing the minimum path for each position using values from the row below. 🧠 Key Insight: This problem beautifully demonstrates the power of Dynamic Programming in optimizing recursive solutions. By transitioning from memoization to tabulation, the problem transforms from exponential recursion to an elegant linear-time solution. Recognizing overlapping subproblems and optimal substructure patterns is key to mastering DP on grids and triangles. 📊 Time Complexity: O(N²) 📦 Space Complexity: O(N²) #LeetCode #DSA #DynamicProgramming #ProblemSolving #DailyCoding #LearningInPublic #Day113