Madhana Gopal Thirunavukkarasu’s Post

Everyone believes that the technical aspects of data structures and algorithms are the most challenging. Determining which algorithm to use could be the problem. Choosing the appropriate data structure could be the solution... Choosing the ideal programming language could be the answer... or perhaps recognizing edge cases and having a thorough understanding of the issue. But in all honesty, it's not any of those. After all that, the real challenge starts when you actually sit down to write code based on your idea. That instant when you have a clear solution in mind but find it challenging to turn it into something accurate, error-free, and effective. Every little error counts. Every little thing matters. Thought-simple logic becomes complicated when put into practice. #DSA #DataStructures #Algorithms #Coding #Programming #ProblemSolving #LearnToCode #CodingJourney #DeveloperLife #CodeDaily #TechLearning

Mastering array manipulation is fundamental for any developer. The seemingly simple task of finding the largest element in an array presents an excellent opportunity to optimize for efficiency. While sorting the array (O(n log n) time complexity) is one approach, a more performant solution involves a single traversal. By initializing a 'max' variable and iterating once through the array, we can find the largest element in optimal O(n) time and O(1) space. This highlights the importance of choosing the right algorithm for the job. Dive deeper into the implementation details and critical ideas to think about: https://lnkd.in/eBQGgE5w #DSA #Algorithms #DataStructures #Programming #Coding

Now DP is new the stage 😁 Solved the classic problem Climbing Stairs using Dynamic Programming. The problem is simple: Given n steps, you can climb either 1 or 2 steps at a time. Find the total number of distinct ways to reach the top. At first, I thought of solving it using recursion, but it leads to repeated calculations and becomes inefficient. Then I moved to memoization (top-down DP) to store already computed results and avoid recomputation. Finally, I implemented a bottom-up approach, which builds the solution iteratively. Key Idea: To reach step i: • You can come from (i-1) • Or from (i-2) So, ways[i] = ways[i-1] + ways[i-2] This makes the problem similar to the Fibonacci sequence. Time Complexity: O(N) Space Complexity: O(N) What I liked about this problem is how it clearly shows the transition from a simple recursive solution to an optimized dynamic programming approach. It’s a great example of understanding overlapping subproblems and optimizing step by step. #DSA #DynamicProgramming #Algorithms #Coding #ProblemSolving

📌 What is Time Complexity in Programming? Time Complexity is a concept used to measure how efficiently an algorithm runs as the input size increases. Instead of measuring exact time, we focus on how the execution time grows with larger inputs. Common Time Complexities: ✔ O(1) – Constant Time The operation takes the same time regardless of input size ✔ O(n) – Linear Time Time increases proportionally with input size ✔ O(log n) – Logarithmic Time Very efficient, often seen in binary search ✔ O(n²) – Quadratic Time Time increases rapidly with larger inputs Why is Time Complexity important? • Helps in writing efficient code • Improves performance of applications • Important for coding interviews and problem solving Understanding time complexity allows developers to choose better approaches and optimize their solutions. #TimeComplexity #Programming #DataStructures #Algorithms #ComputerScience #TechKnowledge

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

Day 65 on LeetCode Sort Characters By Frequency 🔤📊✅ Today’s problem focused on combining hash maps with custom sorting. 🔹 Approach Used in My Solution The goal was to sort characters in a string based on their frequency in descending order. Key idea in the solution: • Use a hash map to count frequency of each character • Store (character, frequency) pairs in a vector • Apply custom sorting based on frequency (descending order) • Build the result string by repeating characters according to their frequency This approach efficiently organizes characters by importance (frequency). ⚡ Complexity: • Time Complexity: O(n log n) (due to sorting) • Space Complexity: O(n) 💡 Key Takeaways: • Practiced frequency counting using hash maps • Learned how to apply custom comparators in sorting • Reinforced building results based on frequency-driven logic #LeetCode #DSA #Algorithms #DataStructures #HashMap #Sorting #Strings #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

Solved today’s LeetCode Daily and it made me pause 👇 “XOR After Range Multiplication Queries I” At first glance, it looks like: Segment Tree? Lazy Propagation? Some heavy optimization? 🤯 But the reality? Sometimes… brute force wins. --- Given constraints were small. And that completely changes the game. So instead of overengineering: ✔️ Just simulate each query ✔️ Jump with k steps ✔️ Apply multiplication (mod 1e9+7) ✔️ Take final XOR And that’s it. --- The interesting part 👇 As developers, we are trained to think: “Optimize first” But problems like this remind us: 👉 Understand constraints before choosing approach Because honestly, A simple O(n * q) solution can beat an overcomplicated design any day. --- What I learned today: • Not every problem needs advanced DS • Constraints are part of the problem statement for a reason • Simplicity is underrated --- Consistency check ✅ One more problem done. --- Curious 👇 Comment your approach. #LeetCode #DSA #Programming #Coding #Developers #ProblemSolving #Rust

Today, I tackled a classic dynamic programming problem — Minimum Difficulty of a Job Schedule. This challenge really tested my understanding of: - Breaking problems into subproblems (partitioning jobs across days) - Optimizing brute force recursion using memoization - Thinking carefully about state definition (index, days left) Initially, I made a common mistake by trying to accumulate results greedily instead of exploring all valid partitions. Once I corrected that and properly defined the recurrence: 👉 current_day_max + solve(remaining_jobs, remaining_days) things started to click. Key takeaways include: - Always validate your recurrence before optimizing - DP is all about choosing the right state and transitions - Small indexing mistakes (i+1 vs ind+1) can completely break logic This was a valuable exercise in debugging and refining my dynamic programming approach. #LeetCode #DataStructures #Algorithms #DynamicProgramming #ProblemSolving

Solved a great DP problem today: Count Binary Strings Without Consecutive 1’s. Given a length n, the task is to count all distinct binary strings such that no two 1s are adjacent. Example: n = 3 → 000, 001, 010, 100, 101 → 5 n = 2 → 00, 01, 10 → 3 The key insight: 1. Strings ending with 0 can be formed by appending 0 to all valid strings of previous length. 2. Strings ending with 1 can only be formed by appending 1 to strings that previously ended with 0. This leads to a simple DP relation: 1. zero[i] = zero[i-1] + one[i-1] 2. one[i] = zero[i-1] So the pattern follows a Fibonacci-style sequence, and the problem can be solved in: O(n) time and O(1) space I enjoy how problems like this look simple at first, but the right state definition makes them very elegant. #DataStructures #Algorithms #DynamicProgramming #Coding #ProblemSolving #Cpp #Programming #SoftwareDevelopment

#Day58 Solved: Longest Substring Without Repeating Characters(Leetcode 3) Worked on one of the most asked string problems that really tests problem-solving and optimization skills. Problem: Find the length of the longest substring without repeating characters. Approach: Used the sliding window technique to efficiently track a valid substring. Instead of checking all possible substrings (which is slow), I dynamically adjusted the window: Expanded when characters were unique Shrunk when a duplicate appeared Key Learning: The biggest takeaway was understanding how to maintain a valid window rather than restarting every time a duplicate is found. Complexity: Optimized the solution from O(n²) to O(n) using the right approach. This problem strengthened my understanding of: Sliding Window Two Pointer Technique Optimizing brute force solutions #leetcode #dsa #programming #coding #slidingwindow #problemSolving