System Design: Bridge & Strategy Patterns Explained

🚀 Day 27 of 100 Days LeetCode Challenge Problem: Matrix Similarity After Cyclic Shifts Day 27 brings a neat simulation + modular arithmetic problem 🔥 💡 Key Insight: Shifting happens k times, but instead of simulating k steps: 👉 We can reduce it using modulo Effective shifts = k % n (where n = number of columns) 🔍 Core Approach: 1️⃣ Understand Row Behavior Even rows → shift left Odd rows → shift right 2️⃣ Apply Optimized Shift For each row: Calculate effective shift using modulo Perform one optimized shift instead of k times 3️⃣ Compare with Original Matrix If all rows match → ✅ true Else → ❌ false 💡 Why Modulo Works: After n shifts, row returns to original state → avoids unnecessary computation 🚀 🔥 What I Learned Today: Repeated operations → think modulo optimization Simulation problems can often be simplified Understanding patterns saves time 📈 Challenge Progress: Day 27/100 ✅ Closing in on 30! LeetCode, Matrix, Simulation, Cyclic Shift, Modular Arithmetic, Arrays, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #Matrix #Simulation #ModularArithmetic #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

Some problems look simple — until you try solving them without shortcuts. Day 44 — Daily Engineering Practice Solved: Product of Array Except Self At first, the idea seems straightforward: Multiply all elements except the current one. But there’s a constraint: 👉 No division allowed --- The solution? Use prefix and suffix products: • Prefix → product of elements before index • Suffix → product of elements after index Multiply both → get the result for each position. --- Key Insight: Instead of recomputing everything, reuse previously computed values efficiently. --- Also: • Time → O(n) • Space → optimized to O(1) (excluding output) --- What I’m learning: Many problems aren’t about complexity — they’re about seeing the pattern clearly. --- Day 44. Still building consistency. Let’s stay consistent. 🤝 #DSA #LeetCode #Algorithms #ProblemSolving #LearningInPublic

🚀 Time Complexity ≠ Execution Time (Common Misconception!) Many of us think that time complexity means the actual time a program takes to run. But that’s not true. 👉 Time complexity is NOT about seconds or milliseconds. 👉 It is about how the execution time grows as input size increases. Let’s understand with a simple example: 👨💻 Person A runs their code → takes 0.4 seconds 👨💻 Person B runs their code → takes 0.3 seconds At first glance, we might say Person B’s code is better. But is that really fair? 🤔 What if: - Person A is using an older system - Person B is using a high-performance laptop Now imagine running Person A’s code on Person B’s machine — it might run in 0.2 seconds! ⚠️ So can we really judge efficiency based on execution time alone? No. --- 💡 Another example: Linear Search We know that linear search has a worst-case time complexity of O(n). 👉 This remains O(n) on every system (whether it's a low-end machine or a high-end laptop) But: - On a modern laptop → it may run faster - On an older system → it may run slower ⚠️ Still, the time complexity does not change — only execution time does. --- ✅ That’s why we use time complexity — it gives us a machine-independent measure of efficiency. It focuses on growth rate, not exact runtime. 📌 Key takeaway: "Execution time depends on hardware, environment, and implementation. Time complexity depends on the algorithm itself." 💡 Always analyze algorithms using Big-O, not just runtime. #DataStructures #Algorithms #Coding #Programming #ComputerScience #InterviewPrep

Hi LinkedIn Fam, Started learning System Design – Day 7 Continuing with Behavioral Design Patterns. Covered: Observer, Command Observer Pattern: Use case: When multiple objects need to be notified automatically about changes in another object. Defines one-to-many dependency When one object changes state, all dependents are notified Promotes loose coupling Key idea: One change → many updates. Command Pattern: Use case: When you want to encapsulate a request as an object. Decouples sender and receiver Supports undo/redo operations Useful for queues and task scheduling Key idea: Turn actions into objects. Quick Summary Observer → Notify multiple objects on change Command → Encapsulate requests as objects Learning step by step. Consistency is the key to mastering system design. #SystemDesign #DesignPatterns #BehavioralPatterns

🚀 Day 50/90 – Construct Target Array | Reverse Thinking + Heap | DSA Pattern. Halfway through the journey. Today’s problem was a reminder that sometimes the right approach is not forward thinking, but thinking in reverse. 🔴 Problem — Construct Target Array With Multiple Sums (LeetCode 1354) Given a target array, → Determine whether it can be constructed from an initial array of ones → At each step, one element is replaced by the sum of the entire array 💡 Core Approach — Reverse + Greedy + Max Heap → Instead of building forward, simulate the process backwards → Always pick the largest element → Replace it with its previous value using: → previous = largest % remainingSum → Repeat until all elements become 1 ⏱️ Time Complexity: O(n log n) 📦 Space Complexity: O(n) 🔑 Key Insight Forward simulation leads to exponential growth. Reverse simulation simplifies the problem. This shift in perspective turns a complex problem into a manageable one. 🧠 What I Learned → Not every problem should be solved in the forward direction → Identifying the “inverse process” can reduce complexity drastically → Heaps help in efficiently tracking extreme values 📌 Pattern Takeaway → Reverse thinking + Greedy + Heap → Optimize using mathematical observation (modulo) Day 50 complete. Halfway done — consistency continues. On to Day 51 🚀 #Day50of90 #LeetCode1354 #GreedyAlgorithm #Heap #PriorityQueue #DSAPatterns #CodingInterview #ProblemSolving #JavaDSA #PlacementPrep

🚀 Day 7 of Consistent Problem Solving Today I solved a problem that reinforces one of the most important patterns in DSA — Sliding Window. 📌 Problem: Given an array, count the number of subarrays of size k whose average is greater than or equal to a threshold. 🧪 My Initial Approach (Brute Force): Check every subarray of size k and compute its sum. Time Complexity: O(n × k) Inefficient due to repeated calculations ❌ ⚡ Key Insight: The condition: (sum / k) ≥ threshold can be rewritten as: sum ≥ k × threshold 👉 This removes division and simplifies comparisons. 💡 Optimized Approach (Sliding Window): Compute sum of first window of size k Slide the window: Add next element Remove previous element Check condition at each step Time Complexity: O(n) ✅ Space Complexity: O(1) 🧩 Key Learning: Fixed-size subarray problems → think Sliding Window Avoid recomputation — reuse previous results Transform conditions (like removing division) to simplify logic ⚠️ Common Pitfall: Incorrect window update (forgetting to subtract the outgoing element). 🔗 Follow-up Insight: This pattern extends to more advanced problems like: Subarray Sum Equals K Longest Substring Without Repeating Characters Minimum Size Subarray Sum 📚 Prerequisites: Basic array traversal Understanding of window-based techniques Prefix sum intuition (for advanced variations) Consistency + pattern recognition = real growth 📈 What’s your favorite sliding window problem? 👇 #LeetCode #SlidingWindow #Algorithms #ProblemSolving #CodingJourney #DataStructures

💡 “In DSA, the smartest solutions often come from transforming the problem into something you already know.” 🚀 #geekstreak60 — Day 46 Day 46 of the streak! Today’s problem was a perfect example of how problem transformation can turn a tricky question into a familiar one. 📌 Problem Statement Given an array, we can assign + or - before each element and form an expression. Goal: ➡️ Count the number of ways to reach a given target sum 🧠 My Thought Process At first, this looked like a brute-force recursion problem: 👉 Try all combinations of + and - → exponential complexity (2ⁿ) But then came the key transformation: Let: S1 = sum of elements with + S2 = sum of elements with - We know: S1 - S2 = target S1 + S2 = totalSum Solving: 👉 S1 = (totalSum + target) / 2 🛠️ Optimized Approach The problem reduces to: ✅ Count number of subsets with sum = S1 Applied Dynamic Programming (subset sum counting) to efficiently compute the answer. ⚡ Complexity Analysis Time Complexity: O(n × sum) Space Complexity: O(sum) Efficient for given constraints. 💡 Key Learning Transforming a problem is often more powerful than solving it directly. Today strengthened my understanding of: ✅ Problem transformation techniques ✅ Subset sum DP ✅ Counting-based dynamic programming ✅ Optimizing exponential problems Consistency continues strong 💪🔥 #geekstreak60 #npci #DSA #CPP #DynamicProgramming #ProblemSolving #CodingJourney #ContinuousLearning

Was solving a tree problem on a whiteboard today. On the board, the solution felt almost obvious. You can see the nodes, the branches, the flow — everything at once. But the moment you switch to code, it becomes step-by-step again. Traversal. Recursion. Iteration. It made me think… What if we had something like “third dimensional programing”? one program enough to solve problems Not writing instructions line by line, but a system that can see the entire structure at once — nodes, connections, states — from a higher-level view. Like how we look at a tree on a whiteboard and instantly understand the shape. For example, problems like: • Lowest Common Ancestor — you just “see” where paths meet • Number of Islands — components become visually obvious • BFS shortest path — layers are clear instantly • Cycle detection in graphs — loops are visible • Tree height / depth — structure speaks for itself These feel almost trivial when visualized… but take time when written step by step. Would problem solving become faster than traditional DSA? Would we move from “executing logic” to “perceiving structure”? Just a thought — curious how others think about this. #DSA #Algorithms #SystemDesign #Coding #SoftwareEngineering #Backend #ProblemSolving #GraphTheory #Trees #ComputerScience #QuantumComputing #QuantumScience

🚀 Deadlock Detection & Recovery Toolkit — Simulation Project Excited to share a project I’ve been working on that dives deep into one of the most critical concepts in Operating Systems — deadlocks. This toolkit simulates how processes compete for resources, how deadlocks are formed, and most importantly, how a system can intelligently detect and recover from them. 🔍 What the project demonstrates: • Dynamic resource allocation between multiple processes • Real-time detection of deadlock conditions using system state analysis • Visualization of Resource Allocation Graph (RAG) for better understanding • Implementation of recovery strategies like process termination and resource preemption • Step-by-step execution flow to clearly track how the system reaches and resolves a deadlock 📽️ In this screen recording: You’ll see the simulation running live — how processes get blocked, how the system identifies the deadlock, and the actions taken to restore normal execution. (No voiceover — focused purely on the logic and behavior) 🌐 Try it yourself: 👉 https://lnkd.in/gUxPhEii 💡 Why I built this: I wanted to go beyond theory and actually see deadlocks happen and resolve them programmatically, which helped me understand OS concepts at a much deeper level. Open to feedback, suggestions, or ideas to extend this further (maybe adding Banker’s Algorithm or distributed system scenarios next 👀) #OperatingSystems #Deadlock #SystemDesign #ComputerScience #Simulation #SoftwareEngineering #DeveloperJourney #Coding #TechProject #BuildInPublic #LearningByDoing #CSStudents #OpenToOpportunities Lovely Professional University Lovely Professional University (LPU)

A little divergence from what I usually do. So, in the era of LLMs, while teaching at the University (as a TA), I have noticed an increasing dependence on LLMs to learn things about different subjects. Sometimes this can be really useful if the querying is really well-curated. But many a times it can deviate the learner from the very basics to superficial learning, which hurts them later in their careers. So, I started building a few basic tools that could be interactive for students to understand the basics first. So, with all the hype around large models, I believe, having a strong base for the fundamentals of machine learning is THE MOST important thing at the moment. I started playing around optimization algorithms to start with and built this interactive interface. Hope this helps some learners. And I welcome your suggestions for addition of newer ways to explain to this interface: https://lnkd.in/grVP4jnU (I'll keep adding more with time, and there are some other stuff too in the comment section.)