Subbareddy karri’s Post

After completing my Frontend Developer Roadmap , I decided to give back to the community by starting a new Dev.to series about Algorithms, Data Structures, and Performance. The idea was inspired by NeetCode, but I wanted to create my own free, beginner-friendly version — one that’s more adaptable for frontend developers who want to understand how these concepts apply in real projects. Each article explains one key concept in simple words and ends with real LeetCode examples + pseudocode to make learning practical. Read the first article here: 👉 https://lnkd.in/ejpnBWdH New posts every week — stay tuned 🌱 #frontenddevelopment #learninginpublic #algorithms #datastructures #devcommunity

🧠 If you think design patterns are just fancy names… stop scrolling for a second 😄 Recently, someone asked me — “I’m already writing clean code. Why should I care about naming it Singleton or Strategy?” And honestly… I totally get that. Because I used to think the same way earlier too 😅 Yes, you might write clean code sometimes, but sometimes you may not. The difference is , once you actually learn design patterns, you start thinking before coding every single time. You’ll naturally ask yourself 👉 Is this code scalable? 👉 Will it be easy to maintain later? 👉 Am I violating any design principle? That’s the real power of design patterns. They don’t just give names, they make your design choices intentional, and your thought process structured. 💬 Think of it this way — Design patterns are like grammar for programming. You can speak a language without grammar, but if you understand the rules, you can express complex ideas more clearly, avoid confusion, and build confidence in what you say. Similarly, when you know patterns, you can design complex systems with clarity, reuse, and confidence instead of reinventing structure every time. And I’m sure many people might have the same question in mind, so I just wanted to clear it up here 🙂 Honestly, I’m just happy that more people are showing curiosity about these concepts, that itself keeps me motivated to learn and share whenever I apply something new in real work 🚀 #DesignPatterns #CleanCode #SoftwareEngineering #Developers #Python #CodingJourney #SystemDesign

🚀 Clean Code in OOP Writing clean code isn’t just about syntax — it’s about clarity, structure, and design. Key takeaways: 🧩 Objects vs Data Containers Data containers just hold data. Objects encapsulate behavior. 👉 Use the right one for the right job. ⚙️ SOLID Made Simple S – One class, one responsibility. O – Extend, don’t modify. L – Subclasses should behave like parents. I – Keep interfaces focused. D – Depend on abstractions, not details. 🧠 Law of Demeter Don’t chain internals (a.b.c.d). Expose clean methods instead (getPurchaseDate()). 💡 Final Thought: Clean code = clarity + cohesion + simplicity. Build systems that last, not just work. Clean code is like good writing — the easier it is to read, the better it performs. 📘 Read the full guide here: “Writing Clean Functions & Methods” comment below #CleanCode #SOLID #OOP #SoftwareEngineering #CodeQuality #Javascript #GitBook

Can a tree stay balanced no matter how deep it grows? 🌳 Let’s find out. Hey everyone! Day 299 of my 365-day coding journey was all about trees — LeetCode’s “Balanced Binary Tree.” This is one of those classic problems that truly tests your grasp of recursion and optimization. Let’s dive in! ⚡ 🛠️ The Problem Given a binary tree, the goal is to determine if it’s height-balanced. A tree is height-balanced if, for every node, the height difference between its left and right subtrees is at most 1. 🎯 The Approach I explored two different ways to solve it — one simple but inefficient, and another optimized and elegant. 1️⃣ Brute Force Approach (Top-Down) - For each node, check if both subtrees are balanced. - Compute heights of left and right subtrees separately. - Simple but inefficient — recalculates heights multiple times. - Time Complexity: O(N²) in the worst case. 2️⃣ Optimized Approach (Bottom-Up using DFS) - A smarter way using Depth-First Search. - Calculate height and balance simultaneously in one traversal. - If any subtree is unbalanced, propagate a signal (like -1) upward to stop further computation. - Time Complexity: O(N) 🧠 Key Takeaways - Optimization often comes from rethinking recursion flow — switching from top-down to bottom-up can save massive computation. - The “return height + status” pattern is powerful for many tree problems. - Always analyze if a recursive function can return multiple useful values to avoid redundant work. 💡 Challenge for You! The optimized solution uses a special return value (like -1) to indicate unbalance. How else could you design this logic? Maybe with a helper class or a tuple? Drop your ideas below! 💬 📺 Watch My Walkthrough I’ve explained both approaches (brute force and optimized DFS) in detail here: https://lnkd.in/gyMuFivt 🔥 Join the Conversation If you’re diving deep into recursion and tree problems, let’s connect! Sharing ideas and patterns like these makes the learning journey even better. 🚀 #CodingJourney #365DaysOfCode #LeetCode #DSA #BinaryTree #TreeTraversal #Recursion #DepthFirstSearch #ProblemSolving #Programming #SoftwareEngineering #CodeNewbies #DeveloperLife #TechLearning #LearningEveryDay

What if adding and subtracting numbers could lead to the same target? ➕➖ Let’s decode how. Hey everyone! Day 319 of my 365-day coding journey brought me face-to-face with one of the most interesting dynamic programming problems — LeetCode 494: Target Sum. This problem is a fantastic blend of recursion, logic, and optimization through DP. Let’s dive in. ⚡ 🛠️ The Problem You’re given an integer array nums and a target value.   By assigning either a “+” or “−” sign before each number, the goal is to count how many different expressions can evaluate to the given target. Example: nums = [1, 1, 1, 1, 1], target = 3 → Output = 5   (There are 5 ways to assign symbols to reach 3.) 🎯 The Approach I solved this using two approaches — starting from the basics and optimizing it further. Solution 1: Recursion (Brute Force) I used a recursive function that tries adding and subtracting each element to explore all possible combinations. This clearly demonstrates the problem’s structure but leads to exponential time complexity (O(2^N)). Solution 2: 1D Dynamic Programming To optimize, I transformed the problem into a subset-sum variation. By using a 1D DP array, I tracked how many ways we can achieve each possible sum. This reduced the complexity to O(N * Sum), making it scalable for larger inputs. 🧠 Key Takeaways 💡 Many DP problems start with recursion — identifying overlapping subproblems helps in building optimized solutions.   🧩 Transforming a problem (like Target Sum → Subset Sum) can often reveal a cleaner, more efficient path.   ⚙️ 1D DP arrays save space without compromising clarity or performance.  💬 Challenge for You! How do you usually transition from recursion to dynamic programming? What’s your mental model for identifying patterns like this? 📺 Watch My Full Walkthrough I explain both the recursive and optimized DP solutions step-by-step in my latest video: https://lnkd.in/gE9Ma7uA 🔥 Join the Conversation If you’re exploring dynamic programming or solving LeetCode challenges daily, let’s connect and grow together! 🚀 #CodingJourney #DSA #DynamicProgramming #LeetCode #ProblemSolving #TargetSum #Recursion #Algorithms #CodeNewbies #DeveloperLife #Programming #LearningEveryDay #365DaysOfCode

The Four Pillars of Robust Code. Day 49/60 of my CS Fundamentals roadmap is in the books. ✅ Today was a review day, where I paused to consolidate the four core pillars of Object-Oriented Programming: Encapsulation, Abstraction, Inheritance, and Polymorphism. My key insight 💡: No single pillar works in isolation; their true power lies in how they combine to create elegant software. OOP is a design philosophy that, when fully implemented, manages complexity and minimizes risk at every layer. The simple, collective power is profound: - **Encapsulation** protects the data and the logic. - **Abstraction** simplifies the interface, so you don't need to know the hidden details. - **Inheritance** allows for efficient code reuse and organization. - **Polymorphism** allows code to be flexible and easily extensible for future features. The "hands-on" reflection was seeing how the "Car" analogy relies on all four: Encapsulation hides the engine, Abstraction gives you the simple gas pedal, Inheritance allows a 'Truck' to extend the base 'Vehicle' class, and Polymorphism lets every vehicle respond uniquely to a generic 'drive()' command. For a Full-Stack developer, this is the entire toolkit for writing professional, maintainable code. Now that the foundations are set, I’m ready to dive into the practical application of these rules with SOLID principles and Design Patterns! #AI #MachineLearning #GenAI #FullStackDeveloper #SoftwareEngineering #OOP #ObjectOrientedProgramming #SystemsDesign #Developer #60DayChallenge #DeveloperJourney #Tech #Coding #Programming #SoftwareDevelopment #CareerDevelopment #LearnInPublic #SoftwareArchitecture #CleanCode #Java #Python #OpenToWork

What if generating all subsets wasn’t the hard part — but avoiding duplicates was? ⚡ Hey everyone! Day 306 of my 365-day coding journey took me into an interesting combinatorial challenge — LeetCode 90: Subsets II. This problem is a great test of recursion, backtracking, and handling duplicates efficiently. Let’s break it down 🛠️ The Problem Given an integer array that may contain duplicates, the goal is to return all possible subsets (the power set) — but without any duplicate subsets. Example: Input: [1,2,2] Output: [[], [1], [2], [1,2], [1,2,2]] 🎯 The Approaches Solution 1: Brute Force + Set - Generate all possible subsets using recursion or bitmasking. - Store each subset in a set to automatically remove duplicates. - Simple to implement, but storing all combinations before filtering makes it inefficient in terms of both time and memory. Solution 2: Backtracking (Optimized) - Sort the array first to group duplicates. - During recursion, skip duplicate elements at the same decision level. - This avoids generating duplicate subsets altogether, making it clean and efficient. - It’s a perfect example of pruning unnecessary branches in recursion. 🧠 Key Takeaways 💡 Sorting helps manage duplicates effectively in combination problems.   ⚙️ Using sets removes duplicates but doesn’t scale well for larger inputs.   🚀 Backtracking with skipping logic is both elegant and optimal — generating only unique subsets. 💬 Challenge for You When solving recursion problems, do you prefer brute force first for clarity or jump straight into optimization?   Share your thoughts — I’d love to hear your approach! 💬 📺 Watch My Full Walkthrough I’ve explained both brute force and optimized backtracking solutions step-by-step in my latest video: https://lnkd.in/gAEYMPHu 🔥 Join the Conversation If you’re passionate about DSA and love solving problems that sharpen your logical thinking, let’s connect! Every problem solved is one step closer to mastery. 🚀 #CodingJourney #DSA #LeetCode #Subsets #Backtracking #ProblemSolving #Algorithms #DataStructures #Python #JavaScript #TechLearning #CodeNewbies #DeveloperLife #Programming #365DaysOfCode #LearningEveryDay

💻 Cracking the “String Compression” Problem on LeetCode! 🚀 Today’s challenge was all about optimization, logic, and patience — the String Compression problem from LeetCode. At first glance, it looks simple, but trust me, every detail matters when it comes to in-place modification! 😅 Initially, I tried a few different approaches, but my logic wasn’t aligning perfectly with LeetCode’s “in-place” requirement. After debugging multiple edge cases (especially for repeating characters and multi-digit counts), I finally nailed a clean and efficient solution using C++ and stack-based logic 🔥 Here’s how my journey went: 🧠 Problem Understanding: Given an array of characters, compress it by replacing consecutive repeating characters with the character followed by the count. Example: ["a","a","b","b","c","c","c"] → ["a","2","b","2","c","3"] ⚙️ Approach Used: Used a stack to handle characters dynamically. Counted consecutive occurrences. Converted counts into strings using to_string(count) for digits like “12”. Reversed and stored the final compressed result back into the input array. ✅ Result: All 77/77 test cases passed 🎯 ⏱️ Runtime: 3 ms (beats 13.51%) 💾 Memory: 13.88 MB (beats 43.35%) 🔍 Key Learnings: Every “Wrong Answer” teaches you to recheck your boundary conditions. Understanding in-place modification is crucial in string manipulation problems. Sometimes a small change — like returning ans.size() instead of chars.size() — makes all the difference between ❌ and ✅. 📈 Concepts Involved: Stack String Manipulation Two-pointer technique (for optimized approach) Edge case handling (multi-digit repetition) 💬 Takeaway: Debugging is not just fixing errors; it’s understanding the logic behind every tiny detail. Each failed test case pushes you closer to mastering the art of precision in coding. Feeling great to see that green “Accepted ✅” on LeetCode after carefully analyzing every part of the code! 💪 #LeetCode #C++ #StringCompression #ProblemSolving #DataStructures #Stack #Debugging #100DaysOfCode #CodeNewbie #LearningEveryday #CodingJourney #TechWithWasim #MohdWasim

🔥 𝗠𝗮𝗰𝗵𝗶𝗻𝗲 𝗖𝗼𝗱𝗶𝗻𝗴 — 𝗙𝗶𝗹𝗲 𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 Got inspired after watching Akshay Saini 🚀’s Machine coding series — and decided to take on a fun machine coding challenge: Building a file explorer from scratch. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗦𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁 👇 ✅ Render a tree-structure from JSON (folders/files with expand-collapse) ✅ Add new files or folders dynamically at any level ✅ Keep everything sorted alphabetically — folders first, then files 𝗧𝗲𝗰𝗵𝗻𝗶𝗾𝘂𝗲𝘀 𝗜 𝘂𝘀𝗲𝗱:  1. Recursive function to render nested structures.  2. React Context API to manage shared states (active folder, add mode, etc).  3. Pure immutable state updates using structured cloning for clean re-renders.  4. Smart sorting logic — folders and files handled separately and merged elegantly. 💻 𝗟𝗶𝘃𝗲 𝗱𝗲𝗺𝗼 : https://lnkd.in/gJapscTm 🔗 𝗚𝗶𝘁𝗛𝘂𝗯 (𝗰𝗼𝗱𝗲): https://lnkd.in/gCnpu39P 🎥 𝗔𝗸𝘀𝗵𝗮𝘆'𝘀 𝗬𝗧 𝘃𝗶𝗱𝗲𝗼: https://lnkd.in/gXch9JKE 𝗗𝗿𝗼𝗽 𝘆𝗼𝘂𝗿 𝘁𝗵𝗼𝘂𝗴𝗵𝘁𝘀 👇 — 𝘄𝗼𝘂𝗹𝗱 𝗹𝗼𝘃𝗲 𝘁𝗼 𝗱𝗶𝘀𝗰𝘂𝘀𝘀 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵𝗲𝘀! #ReactJS #MachineCoding #FrontendDevelopment #JavaScript #CleanCode #WebDevelopment #SoftwareEngineering #CodingInterview #Learning

Singleton Pattern — Used It in real work scenario! 💡 A few days back, I shared how I started applying design patterns practically in my codebase. And today — I got to use one in a real work scenario 🙌 While writing unit tests for a class with multiple functions, I created separate test classes to isolate mock data for each function. But that meant reinitializing the same object every time — which was expensive and repetitive 😅 That’s when a thought struck — “Wait… this looks like a Singleton case!” ⚡ So, I created a shared instance using a simple get_instance() method. Now the object is initialized only once and reused across all tests — saving both time and resources 🔁 It’s a small example, but it felt great to naturally apply a design pattern in a real project rather than just reading about it! I’ll keep sharing more such real-world pattern use cases as I encounter them 🚀 💬 Curious to hear from you — ➡️ Have you ever applied a design pattern in your daily work? ➡️ Which one helped you the most? Let’s make design patterns feel real and practical for everyone! 🌱 #DesignPatterns #Singleton #CleanCode #SoftwareEngineering #Python #Developers #CodingJourney