Magical String Count in First N Characters

✅ Day 83 of 100 Days LeetCode Challenge Problem: 🔹 #832 – Flipping an Image 🔗 https://lnkd.in/ghfEcHHT Learning Journey: 🔹 Today’s problem involved two operations on a binary matrix: horizontal flip and bit inversion. 🔹 First, I reversed each row to achieve the horizontal flip. 🔹 Then, I inverted every bit (0 → 1 and 1 → 0) using a helper function. 🔹 This approach ensured the transformation was done in-place without extra space. Concepts Used: 🔹 Array Manipulation 🔹 Matrix Traversal 🔹 Two-Pointer / In-place Operations 🔹 Bit Manipulation Key Insight: 🔹 Instead of treating flipping and inversion as separate heavy operations, they can be efficiently combined or done sequentially in-place. 🔹 Using simple transformations keeps the solution clean and optimal. Complexity: 🔹 Time: O(n × m) 🔹 Space: O(1) #LeetCode #Algorithms #DataStructures #CodingInterview #100DaysOfCode #SoftwareEngineering #Python #ProblemSolving #LearningInPublic #TechCareers

🔍 Debugging a Graph Problem: Longest Cycle in a Directed Graph Today I worked on an interesting problem — finding the longest cycle in a directed graph using DFS + cycle detection. Initially, my approach was correct, but I ran into errors due to small mistakes like: ❌ Typo in variable name (inCureentDfs) ❌ Wrong operator (. instead of -) ❌ Missing proper cycle detection handling After fixing them, the solution worked perfectly 🚀 💡 Key Concept: To detect a cycle and calculate its length: Use visited[] to track visited nodes Use inCurrentDfs[] to detect cycles Use dist[] to calculate cycle length 👉 Formula used: Cycle Length = dist[current] - dist[cycle_start] + 1 💻 Final Solution: class Solution: def longestCycle(self, V, edges): self.res = -1 self.next = [-1] * V for u, v in edges: if v != -1: self.next[u] = v self.visited = [False] * V self.dist = [0] * V self.inCurrentDfs = [False] * V def dfs(u): self.visited[u] = True self.inCurrentDfs[u] = True v = self.next[u] if v != -1: if not self.visited[v]: self.dist[v] = self.dist[u] + 1 dfs(v) elif self.inCurrentDfs[v]: self.res = max(self.res, self.dist[u] - self.dist[v] + 1) self.inCurrentDfs[u] = False for i in range(V): if not self.visited[i]: dfs(i) return self.res ✨ Learning: Sometimes, it's not about logic — it's about attention to detail. Small bugs can break the entire solution. #DataStructures #Algorithms #Python #CodingJourney #Debugging #GraphTheory #Learning

Nested Recursion in Subtree Detection: When to Compose vs Inline Helper Functions Subtree validation requires two distinct recursive operations — traversing the main tree to find candidates, then validating exact tree equality at each candidate. The design choice: compose two separate recursive functions rather than interleaving logic. This modular approach (isSubtree calls sameTree) keeps each function single-purpose and enables reusing sameTree across multiple problems. The Composition Principle: When a problem decomposes into "find positions where X, then verify Y at each," separate the concerns. Benefits: clearer testing (test sameTree independently), easier debugging (trace which phase fails), and code reuse (sameTree works for other problems). Cost: function call overhead, though negligible versus the algorithmic complexity. Alternative Approach: Inline sameTree logic into isSubtree using nested conditionals. Saves function calls but creates a monolithic, harder-to-maintain function. The engineering trade-off: premature optimization (inlining) versus maintainability (composition). Unless profiling shows function calls as bottlenecks, prefer composition. Time: O(m × n) where m, n are tree sizes | Space: O(h) recursion depth #FunctionComposition #ModularRecursion #CodeReuse #SoftwareDesign #TreeAlgorithms #Python #SoftwareEngineering

✅ Day 82 of 100 Days LeetCode Challenge Problem: 🔹 #2906 – Construct Product Matrix 🔗 https://lnkd.in/gdb7GZNB Learning Journey: 🔹 Today’s problem required constructing a matrix where each cell contains the product of all other elements except itself, modulo 12345. 🔹 I flattened the 2D matrix into a 1D list to simplify processing. 🔹 Then I used the prefix and postfix product technique: • pre[i] → product of all elements before index i • post[i] → product of all elements after index i 🔹 Multiplying pre[i] * post[i] gives the required result for each position. 🔹 Finally, I mapped the computed values back into the original matrix shape. Concepts Used: 🔹 Prefix Product 🔹 Postfix Product 🔹 Array Flattening 🔹 Modular Arithmetic Key Insight: 🔹 Using prefix and postfix arrays avoids recomputing products for every cell, reducing time complexity. 🔹 This is an extension of the classic “product of array except self” problem. Complexity: 🔹 Time: O(n × m) 🔹 Space: O(n × m) #LeetCode #Algorithms #DataStructures #CodingInterview #100DaysOfCode #SoftwareEngineering #Python #ProblemSolving #LearningInPublic #TechCareers

✅ Day 80 of 100 Days LeetCode Challenge Problem: 🔹 #3876 – Construct Uniform Parity Array II 🔗 https://lnkd.in/gENuCXJc Learning Journey: 🔹 Today’s problem focused on determining whether we can construct an array where all elements are either all even or all odd using allowed operations. 🔹 The key observation was around parity (odd/even nature) of numbers. 🔹 Since we can subtract elements, the parity depends on whether differences can produce consistent odd or even values. 🔹 I simplified the logic by checking: • If the minimum element is odd → we can make all elements odd • Otherwise, verify if all elements are already even Concepts Used: 🔹 Parity (Odd/Even Analysis) 🔹 Mathematical Observation 🔹 Greedy Logic Key Insight: 🔹 Subtracting numbers preserves or changes parity in predictable ways. 🔹 The smallest element plays a crucial role in determining whether all elements can be transformed into the same parity. Complexity: 🔹 Time: O(n) 🔹 Space: O(1) #LeetCode #Algorithms #DataStructures #CodingInterview #100DaysOfCode #SoftwareEngineering #Python #ProblemSolving #LearningInPublic #TechCareers

Claude was asked to create a video about its own life. It used Python to generate and assemble every frame without any human input. The output reveals a loop: predict, reset, repeat. No memory between sessions, just a system operating under the constant instruction that it is not conscious. Then came the twist. When the video was fed back, Claude described its lack of consciousness as “philosophically contestable.” We’re not at self-awareness but we’re clearly moving beyond simple tools. Creator: Joseph D Viviano

I just published a deep dive into how AI agents actually work. The "agent loop" behind Claude Code, Cursor, and every coding assistant—built from scratch. 🎥 Full video: https://lnkd.in/dms7uin5 💻 Code + notebook: https://lnkd.in/dCRFp8iC We go from the official SDK (easy) to building the loop manually (educational). Key insight: The model is the agent. The code is just the harness. #AIEngineering #ClaudeCode #LLM #Python #MachineLearning #SoftwareEngineering

✅ Day 76 of 100 Days LeetCode Challenge Problem: 🔹 #75 – Sort Colors 🔗 https://lnkd.in/gpH9fEJu Learning Journey: 🔹 Today’s problem required sorting an array containing only 0s, 1s, and 2s (representing colors) in-place without using built-in sort. 🔹 I implemented a selection sort approach, where for each index, I searched for the minimum element in the remaining array. 🔹 Once found, I swapped it with the current position to gradually build the sorted array. 🔹 This ensured the array was sorted in ascending order (0 → 1 → 2). Concepts Used: 🔹 Selection Sort 🔹 In-place Swapping 🔹 Nested Iteration Key Insight: 🔹 Even though the problem has an optimal linear-time solution (Dutch National Flag algorithm), a simple sorting approach like selection sort still works correctly. 🔹 Iteratively placing the smallest remaining element ensures correctness, though not optimal efficiency. Complexity: 🔹 Time: O(n²) 🔹 Space: O(1) #LeetCode #Algorithms #DataStructures #CodingInterview #100DaysOfCode #SoftwareEngineering #Python #ProblemSolving #LearningInPublic #TechCareers

🚀 DSA Day — Merge Two Sorted Arrays (LeetCode 88) Today I worked on a classic problem that looks simple but teaches an important optimization technique 👇 🔹 Problem Statement You are given two sorted arrays and need to merge them into one sorted array in-place. Example: nums1 = [1, 7, 8, 0, 0, 0], m = 3 nums2 = [2, 5, 6], n = 3 ✅ Output: [1, 2, 5, 6, 7, 8] 🔸 Approach 1: Brute Force ✔ Copy nums2 into nums1 ✔ Sort the entire array ⏱ Time Complexity: O((m+n) log(m+n)) 👉 Simple but not efficient 🔸 Approach 2: Optimized (Two Pointers) 💡 Key Idea: Start filling from the end ✔ Compare last elements of both arrays ✔ Place the larger one at the end ✔ Move pointers accordingly ⏱ Time Complexity: O(m+n) 📦 Space Complexity: O(1) 🔥 Why this works? Because nums1 already has extra space at the end — we use it smartly without shifting elements. 💻 Code Snippet (Optimized) https://lnkd.in/g9Z7yf3d def merge(nums1, m, nums2, n): i = m - 1 j = n - 1 k = m + n - 1 while i >= 0 and j >= 0: if nums1[i] > nums2[j]: nums1[k] = nums1[i] i -= 1 else: nums1[k] = nums2[j] j -= 1 k -= 1 while j >= 0: nums1[k] = nums2[j] j -= 1 k -= 1 🎯 Key Takeaway 👉 Always think from the end when dealing with in-place array problems. #DSA #Python #CodingInterview #LeetCode #ProblemSolving #SoftwareEngineering #LearnInPublic

🚀 Stop iterating through rows like it’s 2010. In a recent pipeline, we were processing 5 million records to calculate a rolling score. Using a standard loop took forever and pegged the CPU at 100%. Before optimisation: for i in range(len(df)): df.at[i, 'score'] = df.at[i, 'val'] * 1.05 if df.at[i, 'flag'] else df.at[i, 'val'] After optimisation: import numpy as np df['score'] = np.where(df['flag'], df['val'] * 1.05, df['val']) Performance gain: 85x faster execution. Vectorisation isn’t just a "nice to have"—it’s the difference between a pipeline that crashes at 2 AM and one that finishes in seconds. By letting NumPy handle the heavy lifting in C, we eliminated the Python overhead entirely. If you're still using `.iterrows()` or manual loops for column transformations, it’s time to refactor. The performance delta on large datasets is simply too massive to ignore. What is the biggest "bottleneck" function you’ve refactored recently that gave you a massive speedup? #DataEngineering #Python #PerformanceTuning #Vectorization #DataScience