100 Days LeetCode Challenge: Matrix Similarity After Cyclic Shifts

🚀 Day 22 of 100 Days LeetCode Challenge Problem: Determine Whether Matrix Can Be Obtained By Rotation Day 22 is a classic matrix rotation + simulation problem 🔥 💡 Key Insight: We can rotate the matrix in 90° steps (up to 4 times): 90° 180° 270° 360° (back to original) 👉 If at any step mat == target → ✅ True 🔍 Core Approach: 1️⃣ Rotate Matrix (90° Clockwise) Transpose the matrix Reverse each row 👉 This gives one 90° rotation 2️⃣ Repeat Rotation 4 Times After each rotation: Compare with target 👉 If match found → return true 👉 Else after 4 rotations → false 💡 Optimization: Early exit when match is found Avoid unnecessary rotations 🔥 What I Learned Today: Matrix rotation is a standard pattern Simulation problems require step-by-step accuracy Reusing logic reduces complexity 📈 Challenge Progress: Day 22/100 ✅ Staying consistent & sharp! LeetCode, Matrix, Rotation, Simulation, Arrays, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #Matrix #Rotation #Simulation #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

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

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

🚀 Day 214 of #300DaysOfCoding Today I solved a Hard-level problem on LeetCode: 👉 Minimum Total Distance Traveled This problem really tested my understanding of Dynamic Programming + Greedy Thinking. 💡 Key Learnings: Sorting plays a crucial role in optimizing 1D distance problems Converting real-world constraints into DP states makes complex problems manageable Handling capacity constraints (factories limit) using iterative assignment 🧠 Approach: Sorted robots and factories based on position Used DP + Memoization to assign robots to factories efficiently Tried multiple assignments per factory within capacity limits ⚡ Why this problem is interesting? It combines: Greedy intuition (nearest assignment) Dynamic Programming (optimal substructure) Real-world modeling (capacity constraints) 📊 Complexity: Time: O(n × m × limit) Space: O(n × m) 🔥 Problems like this improve problem-solving depth and prepare you for top product-based companies. #LeetCode #DSA #DynamicProgramming #CodingJourney #ProblemSolving #SoftwareEngineering #MCA #GATEPreparation

Hi LinkedIn Fam, Started learning System Design – Day 6 Moving ahead with Structural + Behavioral Design Patterns. Covered: Bridge, Strategy Bridge Pattern: Use case: When you want to separate abstraction from implementation so both can change independently. Decouples interface and implementation Improves flexibility and scalability Avoids tight coupling Key idea: Separate “what” from “how”. Strategy Pattern: Use case: When multiple algorithms exist and you want to choose one at runtime. Encapsulates different behaviors Makes algorithms interchangeable Removes complex if-else conditions Key idea: Define a family of algorithms and switch between them easily. Quick Summary Bridge → Decouples abstraction and implementation Strategy → Switch algorithms at runtime Learning step by step. Strong fundamentals lead to better system design. #SystemDesign #DesignPatterns #StructuralPatterns #BehavioralPatterns #LearningJourney #Day6 #SoftwareEngineering

𝐃𝐚𝐲 𝟕𝟖/𝟑𝟔𝟓 🚀 📌 𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐏𝐎𝐓𝐃: 𝐖𝐚𝐥𝐤𝐢𝐧𝐠 𝐑𝐨𝐛𝐨𝐭 𝐒𝐢𝐦𝐮𝐥𝐚𝐭𝐢𝐨𝐧 Continuing my 𝟑𝟔𝟓 𝐃𝐚𝐲𝐬 𝐨𝐟 𝐂𝐨𝐝𝐞 journey with a focus on 𝐩𝐫𝐨𝐛𝐥𝐞𝐦-𝐬𝐨𝐥𝐯𝐢𝐧𝐠, 𝐃𝐒𝐀, 𝐚𝐧𝐝 𝐜𝐨𝐧𝐬𝐢𝐬𝐭𝐞𝐧𝐜𝐲. 💪 🔎 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Track robot movement using (x, y) coordinates. Maintain direction using an index (North, East, South, West). Store obstacles in a HashSet for fast lookup. Move step-by-step and stop if an obstacle is encountered. Track maximum Euclidean distance squared from origin. 🔍 𝐀𝐥𝐠𝐨𝐫𝐢𝐭𝐡𝐦 𝐮𝐬𝐞𝐝: Simulation + HashSet for obstacle detection. ⏱ 𝐓𝐢𝐦𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: 𝐎(𝐧 × 𝐦) (worst case step simulation) 🧠 𝐒𝐩𝐚𝐜𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: 𝐎(𝐤) (for storing obstacles) 📈 𝐊𝐞𝐲 𝐭𝐚𝐤𝐞𝐚𝐰𝐚𝐲: Using HashSet for obstacle detection converts costly lookups into O(1), making simulation efficient. #LeetCode #LeetCodeDaily #365DaysOfCode #DSA #Java #Simulation #Hashing #ProblemSolving #LearningInPublic 👨💻 🔗 Problem link in comments 👇

🚀 Day 36 of 100 Days LeetCode Challenge Problem: Robot Return to Origin Day 36 is a simple but important simulation + counting problem 🔥 💡 Key Insight: To return to origin (0,0): Total moves Right = Left Total moves Up = Down 👉 If both conditions satisfy → ✅ robot returns to origin 🔍 Core Approach: 1️⃣ Initialize Counters x = 0, y = 0 2️⃣ Process Each Move 'R' → x++ 'L' → x-- 'U' → y++ 'D' → y-- 3️⃣ Final Check If (x == 0 && y == 0) → true Else → false 💡 Alternative Approach: Count occurrences: count('R') == count('L') count('U') == count('D') 🔥 What I Learned Today: Simple problems test basic logic clarity Simulation problems are about correct tracking Don’t overcomplicate—keep it clean 📈 Challenge Progress: Day 36/100 ✅ Consistency still going strong! LeetCode, Simulation, Strings, Counting, Coordinates, Arrays, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #Simulation #Strings #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 Day 16 of 100 Days LeetCode Challenge Problem: Get Biggest Three Rhombus Sums in a Grid Today’s problem was a matrix + geometry + prefix sum optimization challenge 🔥 💡 Key Insight: A rhombus is basically a rotated square, and we only need the border sum, not the entire area. 👉 Brute force works, but it’s slow. So we optimize using diagonal prefix sums. 🔍 Core Approach: 1️⃣ Understand Rhombus Shape Defined by a center and a “radius” Four edges → top, right, bottom, left 2️⃣ Efficient Border Sum Use diagonal prefix sums to quickly calculate edges Avoid recomputing each cell repeatedly 3️⃣ Track Top 3 Unique Sums Use a set or priority structure Keep only the largest 3 distinct values 🔥 What I Learned Today: Geometry-based problems require visual thinking Prefix sums are powerful beyond simple arrays Optimization matters when dealing with nested loops 📈 Challenge Progress: Day 16/100 ✅ Still consistent, still growing! LeetCode, Matrix, Prefix Sum, Geometry, Optimization, Arrays, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #Matrix #PrefixSum #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 Day 1 of Consistent Problem Solving Today I solved a problem that perfectly combines Sliding Window + Circular Array concepts. At first glance, it looked simple… but the circular nature made it tricky. 📌 Problem: Given a circular array, replace each element with the sum of: next k elements (if k > 0) previous k elements (if k < 0) 0 (if k == 0) 🧪 My Initial Approach (Brute Force): I tried iterating for every index and summing k elements manually. Time Complexity: O(n * k) It works, but recalculates the same values again and again ❌ ⚡ Key Insight: The size of the window (k elements) is fixed. Instead of recomputing every time, I can reuse the previous sum and just: ➖ remove one element ➕ add one element This is exactly a Sliding Window pattern 🔥 💡 Optimized Approach: Use a sliding window of size k Handle circular behavior using modulo (% n) Shift window for each index Time Complexity: O(n) ✅ Space Complexity: O(n) 🧩 Key Learning: Fixed-size neighbor problems → think Sliding Window Circular arrays can be handled cleanly using modulo Brute force isn’t wrong — it helps discover patterns Consistency + reflection = real improvement 📈 Have you solved similar circular array problems? Drop them below 👇 #LeetCode #SlidingWindow #Algorithms #CodingJourney #ProblemSolving #100DaysOfCode

Your system may seem efficient… But have you ever actually seen how memory is managed inside an operating system? We often study concepts like paging, segmentation, and virtual memory in theory, but rarely get to visualize how they actually work in real time. So instead of just learning them, we built something to show them. 💡 Introducing: Dynamic Memory Management Visualizer As part of our Operating Systems project, me and my teammate SV Adithiyaa and SHAIK AASIF developed an interactive framework that transforms complex memory management concepts into live simulations, allowing you to visualize memory allocation, page replacement, and system behavior step by step. 🔍 What it demonstrates: • Paging simulation using FIFO page replacement • Step-by-step visualization of page hits and page faults • Dynamic memory frame allocation • Segmentation using logical memory division (Code, Stack, Heap, Data) • Virtual Memory simulation showing RAM vs disk usage • Graphical representation using charts for better understanding What started as a classroom concept turned into something much more meaningful — a way to truly understand how operating systems manage memory behind the scenes. Special Thanks Special thanks to Mr. Arjun Saini for his constant guidance and support throughout this journey. Under the academic supervision of Dr. Neeraj Sharma (HOD). And sincere thanks to Lovely Professional University for providing the platform to explore and build this project. Tech Stack: HTML • CSS • JavaScript • Chart.js Live Demo: https://lnkd.in/gv_FfuwM #OperatingSystems #TechProjects #LPU #WebDevelopment #BuildInPublic #LearningByDoing