Madhana Gopal Thirunavukkarasu’s Post

𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐇𝐚𝐫𝐝 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐞𝐝: 𝐅𝐢𝐧𝐝 𝐭𝐡𝐞 𝐒𝐭𝐫𝐢𝐧𝐠 𝐰𝐢𝐭𝐡 𝐋𝐂𝐏 𝐐𝐮𝐞𝐬𝐭𝐢𝐨𝐧 𝐋𝐢𝐧𝐤 :https://lnkd.in/gPQ5WExk 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧 𝐋𝐢𝐧𝐤 : https://lnkd.in/gYpvYnaW Today I worked on an interesting 𝐡𝐚𝐫𝐝 𝐩𝐫𝐨𝐛𝐥𝐞𝐦: 𝐅𝐢𝐧𝐝 𝐭𝐡𝐞 𝐒𝐭𝐫𝐢𝐧𝐠 𝐰𝐢𝐭𝐡 𝐋𝐂𝐏. The problem provides an 𝐋𝐂𝐏 (𝐋𝐨𝐧𝐠𝐞𝐬𝐭 𝐂𝐨𝐦𝐦𝐨𝐧 𝐏𝐫𝐞𝐟𝐢𝐱) 𝐦𝐚𝐭𝐫𝐢𝐱 and asks us to construct the lexicographically smallest string that satisfies this matrix.  𝐊𝐞𝐲 𝐈𝐝𝐞𝐚 Instead of constructing substrings directly, the approach is: 1️⃣ Start assigning characters from 'a' onward. 2️⃣ If lcp[i][j] > 0, it means the substrings starting at i and j share the same first character. 3️⃣ Propagate the same character across positions where the LCP value indicates a match. 4️⃣ Finally, validate the entire LCP matrix using the rule: lcp[i][j] = (word[i] == word[j]) ? 1 + lcp[i+1][j+1] : 0 If any condition fails, no valid string exists.  𝐖𝐡𝐚𝐭 𝐈 𝐥𝐞𝐚𝐫𝐧𝐞𝐝 • How LCP matrices represent relationships between substrings • Constructing strings using greedy character assignment • Validating constraints using dynamic programming relations • Importance of verifying generated structures against given matrices Problems like this really sharpen string manipulation + matrix reasoning skills. Always fun pushing through Hard-level challenges! #LeetCode #DataStructures #Algorithms #CodingPractice #Java #ProblemSolving

Solved Reverse Linked List II with optimal in-place pointer manipulation. Key takeaway: You don’t always need extra space—careful pointer rewiring can achieve O(1) space complexity while maintaining linear time. Approach highlights: Traverse to the left position while tracking the previous node Reverse the sublist using iterative pointer reversal Reconnect the reversed segment with the remaining list Performance: Runtime: 0 ms (100th percentile) Space: O(1) This problem is a solid reminder that mastering linked list fundamentals—especially pointer handling—can significantly improve both performance and confidence in low-level problem solving. Consistent practice is paying off. If you want, I can also make a slightly more storytelling-style or recruiter-focused version. #DataStructures #Algorithms #LinkedList #CodingInterview #LeetCode #ProblemSolving #SoftwareEngineering #Programming #JavaScript #CodeNewbie #100DaysOfCode #TechSkills #DeveloperJourney #CodingLife #DSA #TechCareer #LearnToCode #ComputerScience #CodingPractice #Placements

🚀 Mastering Sliding Window Technique in DSA Recently, I worked on an important problem: Maximum Sum Subarray of Size K — a classic example that highlights the power of optimization in problem-solving. 🔍 Approach Breakdown: Started with the brute force approach (O(N × K)), recalculating sums for every subarray. Optimized it using the Sliding Window Technique, reducing the time complexity to O(N). Leveraged the idea of reusing previous computations instead of recalculating from scratch. 💡 Key Insight: Instead of recomputing the sum for every subarray, we subtract the outgoing element and add the incoming element: Efficient thinking leads to efficient coding. 📈 What I Learned: Importance of identifying patterns like fixed-size windows How small optimizations significantly improve performance Writing clean and efficient logic for real-world problem solving This problem strengthened my understanding of array manipulation and optimization techniques commonly asked in coding interviews. #DataStructures #Algorithms #Java #CodingInterview #LeetCode #ProblemSolving #SlidingWindow #100DaysOfCode

🚀 Debugging Journey: Largest BST in a Binary Tree (with Solution) Today I worked on a classic DSA problem — finding the largest BST inside a Binary Tree — and it really tested my debugging + recursion skills. 💡 Key Learnings: 🔹 Use correct boundary values → float('inf'), float('-inf') 🔹 Always track multiple things in recursion (size, min, max, BST status) 🔹 Correct condition is: max(left) < root < min(right) 🔹 Small syntax mistakes can break the whole logic ✅ Approach: For every node, return: Size of BST Minimum value Maximum value Whether it's a BST If subtree is BST → combine left + right Else → take max of left/right subtree 💻 Python Solution: class Solution: def largestBst(self, root): def helper(node): if not node: return 0, float('inf'), float('-inf'), True N1, min1, max1, isBST1 = helper(node.left) N2, min2, max2, isBST2 = helper(node.right) if isBST1 and isBST2 and max1 < node.data < min2: return (N1 + N2 + 1, min(min1, node.data), max(max2, node.data), True) return max(N1, N2), 0, 0, False ans, _, _, _ = helper(root) return ans 📌 Key Takeaway: “Debugging isn’t just fixing code — it’s understanding your logic deeply.” This problem helped me improve: ✔️ Tree Traversal ✔️ Recursion Thinking ✔️ Debugging Mindset #DSA #Python #BinaryTree #CodingJourney #Debugging #LearnInPublic #TechSkills

🚀 Day 2 – DSA Practice Log Today was all about strengthening fundamentals and understanding *why* solutions work, not just coding them. 🔸 Rotate Array Learned how to optimize from brute force to the reversal technique (O(n), O(1)) 🔸Fibonacci Compared iterative vs recursive 👉 Realized why iterative is preferred in interviews 🔸 Kadane’s Algorithm 💡 Game changer! 👉 Logic: Extend or restart the subarray 👉 Helps find maximum subarray sum efficiently 🧠 What I learned today: Understanding the logic > memorizing code 📈 Progress update: Getting more comfortable with patterns and problem-solving Let’s keep going 🔥 #100DaysOfCode #DSAJourney #LeetCode #Java #KeepLearning

🔥 𝗨𝗽𝘀𝗼𝗹𝘃𝗶𝗻𝗴 𝗮 𝗛𝗮𝗿𝗱 𝗖𝗼𝗻𝘁𝗲𝘀𝘁 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗧𝗼𝗱𝗮𝘆 — 𝗔 𝗟𝗲𝘀𝘀𝗼𝗻 𝗶𝗻 𝗔𝗿𝗿𝗮𝘆𝘀 & 𝗥𝗼𝘁𝗮𝘁𝗶𝗼𝗻𝘀 Today I upsolved a hard problem that looked like a simple rotation task but turned into a lesson in 𝗱𝗶𝘃𝗶𝘀𝗼𝗿𝘀, 𝗽𝗲𝗿𝗺𝘂𝘁𝗮𝘁𝗶𝗼𝗻𝘀, and 𝘀𝗺𝗮𝗿𝘁 𝗼𝗯𝘀𝗲𝗿𝘃𝗮𝘁𝗶𝗼𝗻. 🧩 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 Given an array nums of length n, a number k is sortable if: a. k divides n b. Split the array into blocks of size k c. You can cyclically rotate each block d. After rotations, the whole array becomes non-decreasing Return the sum of all such k. 💡 𝗞𝗲𝘆 𝗜𝗻𝘀𝗶𝗴𝗵𝘁 Instead of asking “how to rotate to sort?”, ask: What must be true if sorting by rotations is possible? ⚙️ 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵 1. Only check divisors of n (valid block sizes) 2. Create a sorted copy of the array 3. For each block, check if some rotation can match its sorted segment 4. Use the minimum element as an anchor to test rotation alignment 5. If all blocks pass → add k to the answer 📚 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴𝘀 1. Divisors often appear in partition problems 2. Think from the final state backward 3. Use invariants (like minimum element) as anchors A great reminder that tough problems become simpler when you change perspective. #DSA #Algorithms #ProblemSolving #CompetitiveProgramming #Java #LearningInPublic #DataStructures #Coding #CodingLife #ProgrammerLife #Developers #Tech #InterviewPrep #CodingInterview #LeetCode #CP #Upsolving #DailyCoding #ArrayProblems #MathInCoding #LogicBuilding #AnalyticalThinking

𝗗𝗮𝘆 𝟲𝟴/𝟭𝟬𝟬 — 𝗧𝗶𝗺𝗲 𝗡𝗲𝗲𝗱𝗲𝗱 𝘁𝗼 𝗕𝘂𝘆 𝗧𝗶𝗰𝗸𝗲𝘁𝘀 🎟️ Day 68. Sometimes you don't need to simulate. You just need to think. 𝗧𝗼𝗱𝗮𝘆'𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: ✅ #𝟮𝟬𝟳𝟯: Time Needed to Buy Tickets (Easy) 𝗧𝗵𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: People in a queue buying tickets. Each person needs a certain number of tickets. They buy one at a time and go to the back of the line if they need more. How long until person k finishes buying? 𝗧𝗵𝗲 𝗜𝗻𝘀𝗶𝗴𝗵𝘁: You could simulate the queue. Or you could realize: People before position k contribute min(tickets[i], target) People after position k contribute min(tickets[i], target - 1) Why target - 1 for people after? Because person k finishes before they get another turn. No simulation needed. Just math. 𝗠𝘆 𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻: One loop. For each person: If before or at position k: add min(tickets[i], tickets[k]) If after position k: add min(tickets[i], tickets[k] - 1) Sum it up. Done. Time: O(n), Space: O(1) 𝗪𝗵𝘆 𝗜𝘁 𝗠𝗮𝘁𝘁𝗲𝗿𝘀: The best solutions eliminate unnecessary work. Simulation is O(n × max(tickets)). Math is O(n). 𝗖𝗼𝗱𝗲: https://lnkd.in/gn58Hcf7 𝗗𝗮𝘆 𝟲𝟴/𝟭𝟬𝟬 ✅ 𝟲𝟴 𝗱𝗼𝘄𝗻. 𝟯𝟮 𝘁𝗼 𝗴𝗼. #100DaysOfCode #LeetCode #Queue #Algorithms #MathematicalThinking #CodingInterview #Programming #Java #Optimization #LogicalThinking

A lot of people struggle with DSA… not because it’s hard — but because they miss the pattern. One developer solves 200 problems. Still gets stuck in interviews. Another solves just 20… but recognizes the pattern instantly. The difference? Pattern recognition. Take this problem: 🔥 Count Number of Nice Subarrays At first glance, it feels confusing. Subarrays… odd numbers… count exactly k… Most people try brute force → ❌ O(n²) But the real trick is 👇 💡 Prefix Sum + HashMap pattern 🧠 How it works • Convert problem into: → Count subarrays with sum = k • Treat odd numbers as 1, even as 0 • Use prefix sum to track cumulative count • Use HashMap to store frequency of prefix sums • Check: currentSum - k ⚡ Why this is powerful This same pattern works for: • Subarray sum equals K • Binary arrays • Count problems • Even/odd transformations 📚 Hard truth You don’t need to solve 500 problems. You need to master: → Sliding Window → Two Pointers → Prefix Sum + HashMap → Binary Search That’s where interviews are cracked. #DSA #LeetCode #CodingInterview #SoftwareEngineering #ProblemSolving #DataStructures #Programming #TechLearning

Most developers approach range update problems with brute force and hit performance limits. The Difference Array Technique is a powerful optimization that reduces time complexity from O(n × q) to O(n + q) by shifting how updates are applied. Instead of updating every element in a range, you mark changes and resolve them later using prefix sums. Efficient thinking > brute force execution. If you’re preparing for coding interviews or improving problem-solving skills, this is a must-know pattern. #codefri #datastructures #algorithms #dsa #softwareengineering #codinginterview #programming #developers #codingcommunity #learncoding

DSA series... 🚀 Chapter 3: "Sliding Window Dynamic" LeetCode #3 (Level: Medium) Longest Substring Without Repeating Characters... 🧐 At first glance, this looks like a string problem … Especially substring problem, without any doubts move to Sliding Window (Dynamic) ... 🔥 Sliding Window (Dynamic) ... ⚡ - Just move your right pointer to expand until you hit your goal, then pull your left pointer to shrink and find the optimal size. Explanation ... ✍️ 1⃣ Get the length and check the edge condition. 2⃣ Use two pointers `left` and `right`. Keep a set/map to track characters existence. 3⃣ Move `right` pointer to add characters on the string when the character is not duplicate one. 4⃣ If duplicate found, move `left pointer` to remove characters until duplicate is gone. 5⃣ Track max length during the process. --- Difference between Sliding Window Fixed vs Dynamic Programming ... 👇 ** On Fixed, we decrement 'left' pointer only once when contition met. Use if statement. ** On Dynamic Programming, we decrement 'left' pointer untill reach the condition fully met on the current window. Use while statement. Note: But sometimes it may be differ... You can see that difference from the previous chapter and the current one ... ❗ --- Easy Trigger to Remember for this pattern usage ... 😎 👉 “Longest substring without repeating characters”, 👉 “At most / no duplicate”. --- Key Insights ... 🎯 - Don’t restart the loop when duplicate appears, - Just shrink the window smartly that saves time (O(n)). Just put on your thoughts or suggestions ... 💬 Stay tuned always ... 😎 #LeetCode #SlidingWindow #DSA #CodingInterview #Java #ProblemSolving #Algorithms #TechLearning #SoftwareEngineering