Mastering Array Manipulation with Optimized Approach

61 of #100DaysOfCode 🚀 Solved LeetCode 907 – Sum of Subarray Minimums using an optimized Monotonic Stack + Contribution Technique 🔥 🔍 Approach: Instead of generating all subarrays, I focused on how each element contributes as the minimum in different subarrays. 👉 For every element: • Find how far it can extend to the left (Previous Smaller Element) • Find how far it can extend to the right (Next Smaller Element) 📌 Using a monotonic increasing stack: • Left array stores distance to previous smaller element • Right array stores distance to next smaller element 💡 Formula Used: Each element contributes: arr[i] * left[i] * right[i] ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(n) #LeetCode #Stack #Algorithms #DataStructures #CodingJourney #ProblemSolving #100DaysOfCode

🚀 From Problem to Pattern: My Approach to “Rotate Image” (LeetCode) Instead of memorizing solutions, I focused on understanding the pattern behind the problem — and that made all the difference. 💡 Step 1: Transpose the Matrix Swap elements across the diagonal → converting rows into columns. 💡 Step 2: Reverse Each Row This transforms the transposed matrix into a 90° rotated matrix. ✨ Simple. Efficient. Elegant. 🔥 Key Takeaways: Break complex problems into smaller transformations Look for patterns, not just answers Optimize thinking, not just code 📈 Result? ✔️ 0 ms runtime ✔️ 100% performance ✔️ Clean, in-place solution This is what I love about problem-solving — it’s not about grinding endlessly, it’s about thinking smartly. What’s your go-to strategy for matrix problems? 👇 #DataStructures #Algorithms #CodingJourney #LeetCode #ProblemSolving #WomenInTech #TechGrowth #100DaysOfCode #DeveloperMindset

Day 109 Solved: 1855. Maximum Distance Between a Pair of Values (Medium) Today’s problem was a solid exercise in two-pointer technique on non-increasing arrays. 🔍 Key Idea: Since both arrays are non-increasing, we can avoid brute force and use a greedy two-pointer approach: Start with i = 0, j = 0 If nums1[i] <= nums2[j], update max distance and move j forward Otherwise, move i forward ⚡ Why it works: We leverage the sorted nature (non-increasing) to ensure we never revisit unnecessary pairs → O(n + m) time complexity. 💡 Learning: Understanding array properties (like sorted order) can completely change your approach—from brute force to optimal. 📈 Progress: Day 109 of consistency. Still learning, still improving. #LeetCode #DataStructures #Algorithms #CodingJourney #100DaysOfCode #TwoPointers

💡 LeetCode Daily — Problem Solved: Rotate Function (Medium). Today’s problem looked mathematical at first glance… but the real trick was pattern recognition + optimization. At face value, rotating the array and recalculating the function every time feels natural. But that leads straight into an O(n²) trap — not scalable. So I stepped back and asked: 👉 What actually changes when we rotate the array? 🔍 Key Insight (Simple Visualization). Instead of recomputing everything: Each rotation shifts elements, but the total sum stays constant. Only the weight contribution of elements changes. That leads to a powerful relation: Next rotation value can be derived from the previous one using a formula — no need to rebuild from scratch. ⚙️ My Approach Compute initial value F(0) using a loop. Use accumulate() (STL) to get total sum efficiently. Derive next values using a rolling formula. Track maximum along the way. This reduces complexity to O(n) — clean and efficient. 📊 Consistency Snapshot Total active days on LeetCode: 75 Max streak: 68 days 🧠 What I Took Away This problem wasn’t about rotations. It was about: Breaking brute-force thinking. Finding relationships between consecutive states. Trusting math over simulation. Sometimes, optimization isn’t about writing better code — it’s about seeing the problem differently. Still learning. Still refining how I think. #LeetCode #DSA #ProblemSolving #CPP #STL #DailyCoding #Consistency

Day 58 of solving LeetCode problems. Today’s focus: Range Sum Query – Mutable At first glance, it looks simple. But the moment updates enter the picture, brute force collapses. This problem pushes you toward Segment Trees / Fenwick Trees — where preprocessing and smart updates turn inefficiency into precision. Key takeaway: Speed isn’t about doing things faster. It’s about avoiding unnecessary work entirely. Still consistent. Still refining. There’s always a structure behind the surface. 3 → 6 → 9 #LeetCode #Algorithms #DataStructures #CodingJourney #DSA #SegmentTree #FenwickTree #ProblemSolving #SoftwareEngineering #Consistency #KeepBuilding #DeveloperMindset

🚀 Day 89/100 – Permutations II 🧠 Problem: Given an array that may contain duplicates, return all unique permutations ✔️ No duplicate permutations ✔️ Order doesn’t matter 💡 Core Idea 🔥 Classic Backtracking + Duplicate Handling 👉 Sort the array first 👉 Use a used[] array 👉 Skip duplicates using condition: if(i > 0 && nums[i] == nums[i-1] && !used[i-1]) continue; ⚡ This ensures only unique permutations are generated 📚 Key Learnings Backtracking with pruning Handling duplicates efficiently Importance of sorting before recursion ⏱️ Complexity Time Complexity: O(n! ) Space Complexity: O(n) #100DaysOfCode #Day89 #LeetCode #DSA #Backtracking #Algorithms #ProblemSolving #CodingJourney #Consistency

🚀 Day 87 of #100DaysOfCode 🧠 Problem Solved: 1855. Maximum Distance Between a Pair of Values Today’s problem tested my understanding of two-pointer technique on sorted (non-increasing) arrays. 💡 Key Insight: Instead of checking all pairs (which would be slow), we can efficiently move pointers to maximize the distance while maintaining the condition: 👉 nums1[i] ≤ nums2[j] ⚡ Approach Used: - Start with two pointers at the beginning - Expand the right pointer to maximize distance - Adjust the left pointer only when the condition breaks - Track the maximum distance throughout 📈 Result: - Optimized from brute force O(n²) → O(n) - Efficient and clean logic 🔥 What I Learned: - How sorted properties help reduce complexity - Smart pointer movement is key to greedy problems - Avoid brute force when patterns exist Consistency > Motivation 💯 #Day87 #LeetCode #DataStructures #Algorithms #CodingJourney #100DaysOfCode

🚀 Today’s LeetCode Solve: 3Sum Closest Today I solved the “3Sum Closest” problem on LeetCode — a great variation of the classic 3Sum problem. 🔍 Problem summary: Given an array and a target value, find three integers such that the sum is closest to the target. 💡 Approach used: --> Sort the array first --> Fix one element and use the two-pointer technique for the remaining --> elements --> Calculate the sum and compare it with the target --> Update the closest sum whenever a better match is found Move pointers based on whether the current sum is less or greater than the target ⚡ Efficiency: --> Time Complexity: O(n²) --> Space Complexity: O(1) 📌 Key takeaway: Small variations in problems (like “closest” instead of exact match) require careful thinking but often reuse the same core pattern. Consistent practice is making patterns clearer day by day 💪 #LeetCode #DSA #TwoPointers #ProblemSolving #Algorithms #CodingPractice #LearningInPublic

5 days ago I published a teardown of Claude Code's leaked source and found something buried in the codebase: An unreleased model family codenamed "Capybara" — internally called Mythos. I wrote: "Step-change reasoning and cybersecurity capabilities. Enterprise security teams first." Today Anthropic made it official. Project Glasswing — powered by Claude Mythos Preview — found thousands of zero-day vulnerabilities across every major OS and browser before it was even announced publicly. The leaked source told the whole story:  - Mythos was the brain behind KAIROS (the autonomous daemon)  - The false-claims data showed v8 at 29-30% FC rate — more capable but less reliable  - The deployment gates (build-time, runtime, behavioral) explained why it wasn't shipped yet  - The cybersecurity focus was written into the architecture The developers who read the source code didn't just find bugs — they found a roadmap. My full technical teardown from before the announcement: https://lnkd.in/g9in3_Kx Previous post with the original KAIROS analysis: https://lnkd.in/gm3Mu_2d  #AI #ClaudeCode #Anthropic #Cybersecurity #ClaudeMythos #ProjectGlasswing #AgenticAI #SoftwareEngineering #DevTools #FutureOfCoding

🚀 Day 72/100 – Combinations 🧠 Problem: Given two integers n and k, return all possible combinations of k numbers from 1 to n. 💡 Core Idea Classic Backtracking / Recursion problem 🔥 1️⃣ Start from number 1 2️⃣ Choose current element → move forward 3️⃣ Reduce k (remaining elements to pick) 4️⃣ Backtrack (remove element & explore next options) 👉 Build combinations step-by-step 📚 Key Learnings 1. Backtracking fundamentals 2. Decision tree exploration 3. Include / Exclude pattern 3. Generating all possible combinations ⏱️ Complexity Time Complexity: O(C(n, k)) Space Complexity: O(k) (recursion stack) #100DaysOfCode #Day73 #LeetCode #DSA #Backtracking #Recursion #Algorithms #ProblemSolving #CodingJourney #Consistency