Day 152 of #1000DaysOfCode: Transpose Matrix on LeetCode

🚀 LeetCode Daily Challenge – Day 51 🧩 Problem: LeetCode 3289 – The Two Sneaky Numbers of Digitville 🔗 Problem Link: https://lnkd.in/gsaJMm8J 🧠 Intuition: Today’s challenge takes us into the realm of frequency counting and pattern detection 🔢🔍. We’re asked to find the “sneaky” numbers — the ones that appear more than once in a given array. It’s a simple yet elegant problem that highlights how crucial data tracking is — whether it’s in code or in real-world analytics. ⚙️ Approach (Counting Technique): 1️⃣ Initialize a frequency array count[] to keep track of occurrences. 2️⃣ Traverse through the input nums — increment the count for each number. 3️⃣ After the pass, any number with a count greater than 1 is a sneaky number 👀. 4️⃣ Collect these numbers and return them. 💡 Key Insight: This problem emphasizes the importance of frequency mapping — a foundational concept for problems like duplicates, anagrams, and data analysis. Sometimes, solving efficiently is about counting smartly rather than searching repeatedly. ⏱️ Time Complexity: O(n) 💾 Space Complexity: O(1) (since the number range is fixed to <100) 📈 Learning from Day 51: Even the simplest algorithms teach big lessons — tracking, observation, and attention to detail. Whether it’s arrays, logs, or life — what you measure, you can master. 📊✨ 🌟 Motivation: Don’t underestimate the power of small problems — they build the intuition that drives big solutions. Keep counting your progress, not your setbacks. Every line of code adds up. 💪💻 #️⃣ Hashtags: #Day51 #LeetCode #CodingChallenge #Java #DSA #ProblemSolving #FrequencyCount #LogicBuilding #100DaysOfCode #Consistency #GrowthMindset #KeepCoding #LearnByDoing

💻 Day 71 of #LeetCode100DaysChallenge Solved LeetCode 50: Pow(x, n) — a classic math-based problem that enhances recursion, divide and conquer, and optimization thinking. 🧩 Problem: Implement a function to calculate xⁿ (x raised to the power n). Handle both positive and negative exponents efficiently without using built-in library functions. 💡 Approach — Fast Exponentiation (Binary Exponentiation): 1️⃣ If n is 0 → return 1 (base case). 2️⃣ If n is negative → compute 1 / pow(x, -n). 3️⃣ For even n, compute pow(x * x, n / 2). 4️⃣ For odd n, multiply once more by x. 5️⃣ This recursive or iterative approach reduces repeated multiplications. ⚙️ Complexity: Time: O(log N) — each step halves the exponent. Space: O(1) (iterative) or O(log N) (recursive). ✨ Key Takeaways: ✅ Strengthened understanding of binary exponentiation and recursion optimization. ✅ Learned how to handle negative powers and edge cases gracefully. ✅ Practiced a pattern used widely in modular arithmetic and scientific computing. #LeetCode #100DaysOfCode #Java #Math #Recursion #BinaryExponentiation #Optimization #ProblemSolving #CodingJourney #WomenInTech

🔥🔥 Day #51 of #100DaysOfDP When “#simple” problems teach you the most! Recently tackled a binary string problem on #Codeforces that looked deceptively straightforward: turn any binary string into its non-decreasing version with the least operations. Easy, right? 🚦 Here’s what actually happened… 🔸 Phase 1: The Indexing Mistake I dove in, started coding, and quickly realized my approach was totally off. I was using zero-based indexing, but the problem expected one-based! Small misunderstanding, huge confusion. 🔸 Phase 2: Brute Force Struggles Once I fixed indexing, I coded up the most straightforward brute-force recursive solution I could think of. It worked on sample tests… but promptly blew up with Time Limit Exceeded (TLE) on hidden cases! 🔸 Phase 3: Memoization (Hello, Memory Errors) Determined to make it work, I threw memoization at the recursion thinking, “This has to do it!” Instead, my program ate up all available memory almost instantly. Bye-bye, hope (and hello, MLE errors)! 🔸 Phase 4: The “Aha!” Moment After revisiting the problem, I realized the key wasn’t simulating every combination or caching every state. The real trick? Count only the segment transitions—specifically, the points where the string moves from 1 to 0, managing state with a simple flag. Elegant, efficient, and passed in a snap. ✨✨Key Takeaway: Sometimes the “optimal” approach means not simulating every possibility but understanding the underlying pattern and optimizing for it. Debugging and running into both TLE and MLE wasn’t a setback, it was part of the journey to deeper insight! #programming #learning #Codeforces #problemsolving #growthmindset

🚀 Just Completed a Deep Dive into Claude Code Here are my biggest takeaways: 💡 Smart Context Management Claude uses three-layer CLAUDE.md files (machine / project / local) to keep the right context at the right time — nothing more, nothing less. ⚙️ Plan Mode vs Thinking Mode Plan Mode → breadth: multi-step tasks across the codebase Thinking Mode → depth: complex logic and debugging Knowing when to use each is a real game-changer. 🔍 Hooks for Code Quality Automatic TypeScript or Python checks and duplicate code detection run after every edit — it’s like having a senior engineer reviewing changes in real time. 🧩 Extensibility MCP servers (like Playwright) and GitHub integration (e.g. @mentions in PRs) open up powerful automation workflows I’m still exploring. #AI #DeveloperTools #SoftwareEngineering #ClaudeCode #Productivity

🚩 Problem: 238. Product of Array Except Self 🔥 Day 46 of #100DaysOfLeetCode 🔍 Problem Summary: Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i]. You must solve it without using division and in O(n) time. 🧠 Intuition: Instead of recalculating products repeatedly, we can compute prefix and suffix products: prefix[i] → product of all elements before index i. suffix[i] → product of all elements after index i. Then, answer[i] = prefix[i] * suffix[i] But to optimize space, we can do this in one pass using constant extra space (excluding the output array). ✅ Optimized Approach (Prefix & Suffix Multiplication): Traverse from left to right, building prefix products in the answer array. Traverse from right to left, multiplying suffix products into the existing answer. 📊 Complexity: Time Complexity: O(n) Space Complexity: O(1) (excluding output array) ✨ Key Takeaway: This problem highlights the power of prefix-suffix techniques — optimizing from O(n²) to O(n) by reusing partial computations. A great demonstration of how small mathematical insights can lead to highly efficient solutions. Link:[https://lnkd.in/g_Wxm9rc] #100DaysOfLeetCode #Day46 #Problem238 #ProductOfArrayExceptSelf #PrefixSum #SuffixProduct #Java #Algorithms #DSA #LeetCode #ProblemSolving #CodingChallenge #InterviewPreparation #CrackingTheCodingInterview #CodingCommunity #DataStructures #SoftwareEngineering #DeveloperJourney #ArjunInfoSolution #CodeNewbie #Programming #LearnToCode #TechCareers #CareerGrowth #ComputerScience #CodeEveryday #ZeroToHero #CodeLife #CodingIsFun #GeeksForGeeks #GameDeveloper #Unity #JavaDeveloper #AI #MachineLearning

⚙️ 𝗖𝗿𝗮𝗳𝘁𝗶𝗻𝗴 𝗖𝗹𝗮𝗿𝗶𝘁𝘆 𝘄𝗶𝘁𝗵 𝗙𝗹𝗮𝘀𝗸 In software, there’s a quiet power in simplicity. Frameworks come and go — each promising speed, structure, and scale. But at the heart of great engineering lies one timeless question: “𝘿𝙤 𝙄 𝙘𝙤𝙣𝙩𝙧𝙤𝙡 𝙩𝙝𝙚 𝙨𝙮𝙨𝙩𝙚𝙢, 𝙤𝙧 𝙙𝙤𝙚𝙨 𝙩𝙝𝙚 𝙨𝙮𝙨𝙩𝙚𝙢 𝙘𝙤𝙣𝙩𝙧𝙤𝙡 𝙢𝙚?” That question defined my choice. And that choice was Flask. Flask doesn’t try to impress with noise. It gives you space — to architect your logic, to shape your flow, to own your performance. It’s not just a microframework; it’s a philosophy of clarity, precision, and freedom. I’ve built APIs where every route has intent, every response has meaning, and every decision feels deliberate — not dictated. Through Flask, I learned that scalability isn’t born from complexity — it’s born from understanding. Because in the end, true craftsmanship in code is not about frameworks. It’s about the mind behind them. #Flask #Python #APIDesign #Microservices #SoftwareArchitecture #EngineeringPhilosophy #CleanCode #LeadershipInTech

💻 Day 3 of My #120DaysOfLeetCode Challenge 🚀 🧩 Problem: Longest Substring Without Repeating Characters Difficulty: Medium | Language Used: C 🔍 What’s the Problem About? The task is to find the length of the longest substring in a given string that contains no repeating characters. For example: Input: "abcabcbb" → Output: 3 (Longest substring: "abc") Input: "pwwkew" → Output: 3 (Longest substring: "wke") Input: "bbbbb" → Output: 1 (Longest substring: "b") This problem is a classic example of how we can optimize brute force logic using sliding window and two-pointer techniques. ⚙️ Approach I Used – Sliding Window Technique Instead of checking every possible substring (which would be very slow), I used a sliding window approach with two pointers (left and right) and a frequency array to track visited characters. Here’s the step-by-step thought process: Start both pointers at the beginning of the string. Move the right pointer one step at a time, adding characters to the window. If a character repeats, move the left pointer ahead until all characters in the window are unique again. Keep track of the maximum window size during the process. This ensures each character is processed only once → giving an efficient O(n) solution. 💡 Key Takeaways Learned how two-pointer and sliding window techniques can simplify substring problems. Understood how to use frequency arrays to track duplicates efficiently. Strengthened logical reasoning and window-based problem-solving skills in C. Every new problem is an opportunity to refine logic, enhance efficiency, and get one step closer to mastering Data Structures and Algorithms. Day 3 completed ✅ | 117 more to go 💪 #LeetCode #CProgramming #DSA #ProblemSolving #CodingChallenge #100DaysOfCode #LearningJourney #SlidingWindow

🧠 Day 37 / 100 – Implement Queue using Stacks (LeetCode #232) Today’s challenge was about building a Queue using two Stacks, and it really made me appreciate the power of thinking creatively with basic data structures. A queue works in FIFO (First In, First Out) order, while a stack follows LIFO (Last In, First Out) — but by using two stacks, I could recreate queue behavior perfectly. This problem taught me how sometimes you don’t need a new data structure — just a new perspective. By transferring elements only when necessary, I learned how to make operations both efficient and intuitive. 🔍 Key Learnings Two stacks can together simulate queue behavior efficiently. Use one stack for incoming elements and the other for outgoing ones. Always transfer only when needed to maintain time efficiency. 💭 Thought of the Day Creativity in coding often comes from repurposing what you already know. This challenge reminded me that mastering fundamentals allows you to solve complex problems with simple logic. 🔗 Problem Link:https://lnkd.in/g7my77rr #100DaysOfCode #Day37 #LeetCode #Python #Queue #Stack #DataStructures #ProblemSolving #AlgorithmPractice #CodingJourney #LearnByDoing #TechGrowth #CleanCode #PythonProgramming

💻 Day 54 of #LeetCode100DaysChallenge Solved LeetCode 202: Happy Number — a problem that beautifully combines mathematics and cycle detection concepts. 🧩 Problem: Determine if a number is a “happy number.” A number is happy if repeatedly replacing it with the sum of the squares of its digits eventually equals 1. If the process loops endlessly (without reaching 1), it’s not a happy number. Example: 19 → 1² + 9² = 82 82 → 8² + 2² = 68 68 → 6² + 8² = 100 100 → 1² + 0² + 0² = 1 ✅ (Happy Number) 💡 Approach — Floyd’s Cycle Detection: 1️⃣ Define a helper function to compute the sum of squares of digits. 2️⃣ Use two pointers (slow and fast): slow moves one step (sum of squares once). fast moves two steps (sum of squares twice). 3️⃣ If they meet at 1 → happy number. 4️⃣ If they meet at another number → cycle detected → not happy. ⚙️ Complexity: Time: O(log N) — each iteration reduces digits. Space: O(1) — constant extra space. ✨ Key Takeaways: ✅ Strengthened understanding of Floyd’s cycle detection beyond linked lists. ✅ Gained insight into mathematical pattern-based problems. ✅ Practiced writing clean helper functions for iterative digit operations. #LeetCode #100DaysOfCode #Java #Math #CycleDetection #Hashing #DSA #CodingJourney #WomenInTech #HappyNumber

🔥 Day 109 of My DSA Challenge – Intersection of Two Arrays 🔷 Problem : 349. Intersection of Two Arrays 🔷 Goal : Return the unique intersection of two integer arrays. Order doesn’t matter, but duplicates should not appear in the result. 🔷 Key Insight : This is a set / hashmap based lookup problem. We store elements from the first array, then check if elements from the second array exist in it. To ensure uniqueness, we remove the element once counted, so duplicates don't appear. 🔷 Approach : 1️⃣ Add all elements of nums1 to a HashMap 2️⃣ Traverse nums2 3️⃣ If the element exists in the map → add to result & remove from map 4️⃣ Convert list to array and return Time Complexity: O(n + m) Space Complexity: O(n) Sometimes the simplest tools — like HashMaps/Sets — give the cleanest solutions. Learning to choose the right data structure = faster logic + cleaner code 💪 #Day109 #100DaysOfCode #LeetCode #DSA #Java #HashMap #DataStructures #CodingChallenge #Algorithm #ProblemSolving #Programming #SoftwareEngineering #TechJourney #DeveloperJourney #CodeEveryday #LearnDSA #LogicBuilding #GrowthMindset #EngineerMindset