"Day 77: LeetCode Challenge - Find and Replace Pattern"

A script executes. An application decides. #ZeroToFullStackAI Day 6/135: The Principle of Control Flow. For the past five days, our code has been a simple, top-to-bottom script. It executes one line after another, no matter what. The ValueError from our Day 5 challenge proved this is not enough. We need a way to handle different conditions. Today, we build the "brain" of our application. This is Control Flow. It’s the mechanism that allows our code to analyze a situation and make a decision. Our tool for this is the if/elif/else structure: if: The primary gate. It asks a True/False question. elif: The secondary gate. It only asks its question if the if was False. else: The "catch-all." It runs only if all preceding conditions were False. This is the first and most fundamental tool for writing non-linear, intelligent logic. We can now create different paths for our program to follow. We've taught our code to make logical decisions. But we still haven't built the "safety net" for when it receives bad data (like the ValueError). That is the final piece of our foundation. Tomorrow, we build the safety net: Error Handling. #Python #DataScience #SoftwareEngineering #AI #Developer #Logic

💡 Day 41 / 100 – Rotate Image (LeetCode #48) Today’s challenge was a matrix manipulation classic — rotating a square matrix by 90 degrees in place. At first glance, it might look like a simple transformation, but the real trick lies in performing it without using extra space. The solution requires two steps: Transpose the matrix (convert rows to columns). Reverse each row to achieve a 90° rotation. It’s a perfect exercise in visualizing 2D arrays and understanding how in-place operations affect data structure integrity. 🔍 Key Learnings Transposing a matrix is an elegant way to swap coordinates (i, j) → (j, i). Reversing rows after transposition completes the 90° rotation efficiently. Visualization before coding often leads to cleaner, bug-free logic. 💭 Thought of the Day This problem taught me that complex transformations can often be broken into smaller, intuitive steps. When faced with a tough problem, simplify — understand what each move represents before you code it. Smart thinking always beats brute force. 🔗 Problem Link: https://lnkd.in/ggYm37q6 #100DaysOfCode #Day41 #LeetCode #Python #Matrix #DataStructures #ProblemSolving #CodingChallenge #Algorithms #CleanCode #CodingJourney #KeepLearning #TechGrowth #CodeEveryday #PythonProgramming

A script executes. An application decides. #ZeroToFullStackAI Day 6/135: The Principle of Control Flow. For the past five days, our code has been a simple, top-to-bottom script. It executes one line after another, no matter what. The `ValueError` from our Day 5 challenge proved this is not enough. We need a way to handle different conditions. Today, we build the "brain" of our application. This is "Control Flow". It’s the mechanism that allows our code to analyze a situation and make a decision. Our tool for this is the `if/elif/else` structure: 1. 'if' : The primary gate. It asks a `True/False` question. 2. 'elif' : The secondary gate. It *only* asks its question if the `if` was `False`. 3. 'else': The "catch-all." It runs *only* if all preceding conditions were `False`. This is the first and most fundamental tool for writing non-linear, intelligent logic. We can now create different paths for our program to follow. We've taught our code to make logical decisions. But we still haven't built the "safety net" for when it receives bad data (like the `ValueError`). That is the final piece of our foundation. Tomorrow, we build the safety net: **Error Handling**. #Python #DataScience #SoftwareEngineering #AI #Developer #Logic

🚀 𝗗𝗮𝘆 𝟲𝟳 𝗼𝗳 𝟯𝟲𝟱 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲! Today's daily leetcode challenge: Count how many valid selections (starting points) can transform an array to all zeroes following a specific process. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: 3163. Make Array Elements Equal to Zero 🔗 𝐋𝐢𝐧𝐤: https://lnkd.in/gzW2pytw ✔️ 𝗠𝘆 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵: - For each index where the value is zero, try starting a “zeroing process” from both the left and the right. * If at index with nums[idx] > 0, decrement and change direction. * Continue until moving off either array end; check if all elements become zero. - Count all valid initial choices. ⏱️ Time Complexity: O(n²)  📦 Space Complexity: O(n) 📝 Shared handwritten notes & code as well for deeper reference. A simulation-heavy approach that checks all possible starting points to find every successful zeroing path! #LeetCode365 #Day67 #ZeroingArray #ArraySimulation #DailyQuestion #ProblemSolving #Python #AI #ML #DL #AgenticAI #GenAI

🔍 Day 66 of #100DaysOfCode 🔍 🔹 Problem: Binary Search – LeetCode ✨ Approach: Implemented an iterative binary search to efficiently locate the target element within a sorted array. By halving the search range each time — adjusting low and high around the mid-point — the algorithm achieves blazing-fast lookups! ⚡ 📊 Complexity Analysis: Time Complexity: O(log n) — array size halves with each iteration Space Complexity: O(1) — constant extra space ✅ Runtime: 0 ms (Beats 100.00%) ✅ Memory: 46.02 MB 🔑 Key Insight: Binary Search is proof that efficiency isn’t about doing more — it’s about eliminating what’s unnecessary. 🚀 #LeetCode #100DaysOfCode #ProblemSolving #DSA #AlgorithmDesign #BinarySearch #LogicBuilding #Efficiency #ProgrammingChallenge #CodeJourney #CodingDaily

✨ Day 50 of 50 Days Challenge ✨ Solved LeetCode 154: Find Minimum in Rotated Sorted Array II (Hard) 👉 Problem Statement: Given a sorted array that has been rotated between 1 and n times and may contain duplicate elements, find the minimum element in the array. The goal is to minimize operations (preferably better than O(n)). 📌 Examples: Input: nums = [1,3,5] Output: 1 Input: nums = [2,2,2,0,1] Output: 0 🔎 Approach Used: ➡️ Modified Binary Search (Handles Duplicates) 1. Initialize two pointers — start and end. 2. If elements at start, mid, and end are equal, shrink the range (start++, end--). 3. If the left half is sorted, update minEle with nums[start] and move to the right. 4. Otherwise, update minEle with nums[mid] and move to the left. 5. Continue until the minimum element is found. ✅ Complexity Analysis: Time Complexity: O(log n) on average, can degrade to O(n) (due to duplicates). Space Complexity: O(1) → Constant extra space. #50DaysChallenge #LeetCode #C++ #BinarySearch #RotatedArray #Duplicates #DSA #CodingChallenge #Algorithms

🔹 Day 65 of #100DaysOfLeetCodeChallenge 🔹 Problem: Generate Parentheses Focus: Recursion + Backtracking 💡 The Challenge: Generate all valid combinations of n pairs of parentheses. Sounds simple? The trick is ensuring every string remains valid throughout construction! 🧠 My Approach: Used backtracking to build strings intelligently: Add '(' when we haven't used all n opening brackets Add ')' only when it won't break validity (close < open) Base case: Both counts reach n → valid combination found! ✅ 📊 Complexity Analysis: ⏳ Time: O(2ⁿ) — exploring possible combinations 💾 Space: O(n) — recursion stack depth 📌 Example: Input: n = 3 Output: ["((()))","(()())","(())()","()(())","()()()"] 🎯 Key Takeaway: Backtracking shines when you need to explore all possibilities while intelligently pruning invalid paths. This problem perfectly illustrates the power of constraint-based recursion! What's your favorite backtracking problem? Drop it in the comments! 👇 Day 65/100 complete. Onwards to mastering DSA, one problem at a time! 💪 #LeetCode #Algorithms #DataStructures #BacktrackingAlgorithms #TechCareers #SoftwareEngineering #CodingJourney #LearnInPublic

🚀Day 67 of #120_Days_LeetCode Challenge !! 🌳 Problem-Solving with Binary Trees: Constructing from Inorder & Postorder Traversals 🌳 Today, I worked on an interesting tree reconstruction problem where the goal was to build a binary tree from its inorder and postorder traversals. 🧩 Problem Statement: Given two integer arrays — inorder: the inorder traversal of a binary tree postorder: the postorder traversal of the same tree Reconstruct and return the binary tree. 💡 Key Insight: In postorder traversal, the last element is always the root of the tree. Using a hash map for quick index lookups in the inorder sequence helps efficiently locate the root position and divide the tree into left and right subtrees. ⚙️ Approach: Build a hash map to store inorder indices for O(1) lookups. Start from the end of the postorder array (root node). Recursively construct the right subtree first, then the left subtree, since postorder processes left → right → root. 🧠 Time Complexity: O(N) 📦 Space Complexity: O(N) (for recursion + hash map) 🔗 This problem sharpened my understanding of tree traversal relationships and recursion-based construction logic — a vital concept for many tree-based algorithms in interviews and real-world parsing systems. #Coding #DSA #BinaryTree #CPlusPlus #ProblemSolving #LeetCode #TechLearning #Algorithms #ProgrammingJourney

🚀Day 68 of #120_Days_LeetCode Challenge !! 🌳 Problem-Solving with Binary Trees: Constructing from Inorder & Postorder Traversals 🌳 Today, I worked on an interesting tree reconstruction problem where the goal was to build a binary tree from its inorder and postorder traversals. 🧩 Problem Statement: Given two integer arrays — inorder: the inorder traversal of a binary tree postorder: the postorder traversal of the same tree Reconstruct and return the binary tree. 💡 Key Insight: In postorder traversal, the last element is always the root of the tree. Using a hash map for quick index lookups in the inorder sequence helps efficiently locate the root position and divide the tree into left and right subtrees. ⚙️ Approach: Build a hash map to store inorder indices for O(1) lookups. Start from the end of the postorder array (root node). Recursively construct the right subtree first, then the left subtree, since postorder processes left → right → root. 🧠 Time Complexity: O(N) 📦 Space Complexity: O(N) (for recursion + hash map) 🔗 This problem sharpened my understanding of tree traversal relationships and recursion-based construction logic — a vital concept for many tree-based algorithms in interviews and real-world parsing systems. #Coding #DSA #BinaryTree #ProblemSolving #LeetCode #TechLearning #Algorithms #ProgrammingJourney