Removing Methods from Project Without Breaking Dependencies

🧠 Day 192 — Cycle Detection in Directed Graph 🔄➡️ Today solved an important graph problem: Detect Cycle in a Directed Graph. 📌 Problem Goal Given a directed graph: ✔️ Determine if there exists a cycle ✔️ Return true if a cycle is present, else false 🔹 Core Idea Use DFS with path tracking. 👉 Maintain two arrays: • Visited → tracks nodes that are already explored • Path Visited → tracks nodes in the current DFS path 🔹 Cycle Detection Logic While traversing: 1️⃣ If a node is unvisited → continue DFS 2️⃣ If a node is already visited and also in current path → 👉 Cycle detected This indicates a back edge, which forms a cycle in directed graphs. 🔹 Why Path Tracking Works In directed graphs: 👉 A cycle exists if we revisit a node within the same DFS path That’s exactly what pathVisited helps detect. 🔹 Approach 1️⃣ Build adjacency list from edges 2️⃣ Traverse all components 3️⃣ Use DFS with: • visited array • pathVisited array 4️⃣ Backtrack by removing node from path after DFS completes 🧠 Key Learning ✔️ Directed graph cycle detection requires path tracking ✔️ Backtracking is essential to maintain correct DFS path ✔️ Difference from undirected graph → no parent check, use pathVisited 💡 Big Realization Whenever you see: 👉 “Cycle in directed graph” Think: 👉 DFS + Path Visited (Recursion Stack) 🚀 Momentum Status: Graph theory fundamentals getting sharper now. On to Day 193. #DSA #Graphs #DFS #CycleDetection #Java #CodingJourney #LeetCode #ProblemSolving #ConsistencyWins

 𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐃𝐚𝐢𝐥𝐲 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞 – 𝐃𝐞𝐜𝐨𝐝𝐞 𝐭𝐡𝐞 𝐒𝐥𝐚𝐧𝐭𝐞𝐝 𝐂𝐢𝐩𝐡𝐞𝐫𝐭𝐞𝐱𝐭 (𝐌𝐞𝐝𝐢𝐮𝐦) Today’s problem was a 𝐟𝐮𝐧 𝐦𝐚𝐭𝐫𝐢𝐱 𝐭𝐫𝐚𝐯𝐞𝐫𝐬𝐚𝐥 + 𝐬𝐢𝐦𝐮𝐥𝐚𝐭𝐢𝐨𝐧 𝐜𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐋𝐢𝐧𝐤 : https://lnkd.in/gsSCrJbr 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧 𝐋𝐢𝐧𝐤 : https://lnkd.in/gMhqhD6M The idea behind the encoding process: The original text is written 𝐝𝐢𝐚𝐠𝐨𝐧𝐚𝐥𝐥𝐲 𝐢𝐧 𝐚 𝐦𝐚𝐭𝐫𝐢𝐱 with a fixed number of rows. The matrix is then read row by row to produce the encoded string. To decode it, we reverse the process: 🔹 𝐊𝐞𝐲 𝐎𝐛𝐬𝐞𝐫𝐯𝐚𝐭𝐢𝐨𝐧𝐬 If n = encodedText.length() and we know rows, then cols = n / rows Characters of the original text lie on diagonals starting from each column in the first row. Traverse diagonally (row++, col++) from each starting column. 🔹 𝐒𝐭𝐞𝐩𝐬 Compute the number of columns. For every column c, traverse diagonally down-right. Map the matrix index using r * cols + c. Build the result string. Remove trailing spaces at the end. 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 Time: O(n) Space: O(n) 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲: Whenever you see a matrix encoding problem, think about how the data was written and reverse the traversal pattern. #LeetCode #CodingInterview #DataStructures #Algorithms #Java #ProblemSolving #DailyCodingChallenge

Day 11/60 This graph illustrates how different algorithms perform as the input size (n) increases. The x-axis represents input size, and the y-axis represents time (or operations). 💡 Explanation of Each Complexity: 🔹 O(1) — Constant Time Execution time remains the same regardless of input size. ➡️ Example: Accessing an element in an array 🔹 O(log n) — Logarithmic Time Time increases slowly as input grows. ➡️ Example: Binary Search 🔹 O(n) — Linear Time Execution time grows proportionally with input size. ➡️ Example: Iterating through a list 🔹 O(n log n) — Linearithmic Time Efficient for sorting large datasets. ➡️ Example: Merge Sort, Quick Sort 🔹 O(n²) — Quadratic Time Time increases rapidly due to nested operations. ➡️ Example: Nested loops (Bubble Sort) 🔹 O(2ⁿ) — Exponential Time Time doubles with each additional input. ➡️ Example: Recursive problems (subsets, Fibonacci) 🔹 O(n!) — Factorial Time Extremely slow growth; impractical for large inputs. ➡️ Example: Generating all permutations ⚠️ Key Insight As input size increases: Lower complexity algorithms scale efficiently Higher complexity algorithms become impractical 📌 Summary Order (Best → Worst) O(1) → O(log n) → O(n) → O(n log n) → O(n²) → O(2ⁿ) → O(n!) #DataStructures #Algorithms #BigO #TimeComplexity #Java #Programming #SoftwareEngineering #BackendDevelopment #DSA #Coding

Day 76/100 | #100DaysOfDSA 🧩🚀 Today’s problem: Lowest Common Ancestor of a Binary Tree A fundamental tree problem that builds strong recursion intuition. Problem idea: Find the lowest node in the tree that has both given nodes as descendants. Key idea: DFS + recursion (bottom-up approach). Why? • Each subtree can independently tell if it contains p or q • Combine results while backtracking • First node where both sides return non-null → answer How it works: • If current node is null / p / q → return it • Recursively search left and right subtree • If both left & right are non-null → current node is LCA • Else return the non-null side Time Complexity: O(n) Space Complexity: O(h) (recursion stack) Big takeaway: Tree problems often rely on post-order traversal + combining child results. Understanding this pattern unlocks many binary tree problems. 🔥 Day 76 done. 🚀 #100DaysOfCode #LeetCode #DSA #Algorithms #BinaryTree #Recursion #DFS #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity

📚 Trees View Algorithms | Mastering Visibility in Trees 🌳🚀 Completed a deep dive into Tree View Algorithms, understanding how different perspectives reveal different nodes in a tree. 🔹 Left View – First node of each level (leftmost visible) 🔹 Right View – Last node of each level (rightmost visible) 🔹 Top View – First node at each horizontal distance (topmost) 🔹 Bottom View – Last node at each horizontal distance (deepest) 💡 Key Takeaways: • Left = first node per level • Right = last node per level • Top = first node per horizontal distance • Bottom = last node per horizontal distance • BFS (Queue) is the most common approach • Horizontal Distance (HD) is key for Top & Bottom views Understanding tree views helps in: ✔ Solving advanced tree problems ✔ Building strong logic for BFS & DFS ✔ Handling real-world visualization problems ✔ Cracking coding interviews with confidence Mastering trees is a game-changer in DSA — it sharpens problem-solving and builds strong system thinking 💪 #Java #DSA #Trees #BinaryTree #TreeTraversal #Algorithms #CodingInterview #BackendDevelopment #JavaDeveloper #ProblemSolving #CodesInTransit #JavaDeveloper

The High Cost of the Wrong Initial Choice I have seen complex computation logic for over a million records take hours to run simply because of inefficient, row-by-row processing that is offered by database stored procedures and traditional java/python code. It is slow, impossible to scale, and eventually kills your product's edge in the market. By moving to vectorized logic with tools like NumPy or Polars, you can turn those hours of computation into milliseconds. This is not just about using newer tools, it is about leveraging modern execution like #SIMD (Single Instruction Multiple Data) and #multithreading to gain a massive competitive advantage. If your backend is computation heavy and you're still stuck in legacy loops, you are leaving performance, market edge and money on the table. References: https://lnkd.in/g8j3A5Bn https://lnkd.in/gaPnFUQm https://lnkd.in/gWt9WHnp #DataEngineering #SystemDesign #NumPy #PerformanceOptimization #Scalability #PythonProgramming #TechStrategy #Vectorization #TechToolChoice

First Missing Positive — Not as Simple as It Looks At first glance, this problem looks simple. A natural instinct is to solve it using a hashmap or a set to track elements. But that approach won’t work here. The problem strictly requires: O(n) Time Complexity O(1) Space Complexity So we need a different way of thinking. The key idea is to use the input array itself as a marker instead of extra space. Approach: Clean the array Replace all negative numbers, zeros, and values greater than n with n + 1 Because the answer will always lie in the range [1, n+1] Mark presence using indices For every number num, mark the index num - 1 as negative This indicates that the number exists in the array Identify the missing number The first index that has a positive value gives the answer (index + 1) Edge case If all indices are marked, then the answer is n + 1 Why this works: We reuse the given array, so no extra space is needed. Each element is processed a constant number of times, ensuring linear time. Insight: This problem shows how constraints change your approach. A hashmap solution is straightforward, but it violates the space requirement. Sometimes the optimal solution comes from rethinking how to use the existing data instead of adding new structures. #DataStructures #Algorithms #Java #CodingInterview #ProblemSolving

𝗜 𝗰𝘂𝘁 𝗮𝗻 𝗘𝗧𝗟 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲'𝘀 𝗽𝗿𝗲𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴 𝗹𝗮𝘁𝗲𝗻𝗰𝘆 𝗯𝘆 𝟳𝟬%. Three things worked. Only one of them was the one I expected. The context: we were processing 𝟱𝟬𝟬𝗞+ (𝗶𝗻𝘃𝗼𝗶𝗰𝗲𝘀) 𝗿𝗲𝗰𝗼𝗿𝗱𝘀 𝗮 𝘄𝗲𝗲𝗸. The pipeline was quietly becoming the bottleneck for every downstream dashboard. Management wanted more data ingested, not less — so optimization wasn't optional. 𝗛𝗲𝗿𝗲'𝘀 𝘄𝗵𝗮𝘁 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗺𝗼𝘃𝗲𝗱 𝘁𝗵𝗲 𝗻𝗲𝗲𝗱𝗹𝗲: 𝟭. 𝗣𝗿𝗼𝗳𝗶𝗹𝗲 𝗯𝗲𝗳𝗼𝗿𝗲 𝘆𝗼𝘂 𝗼𝗽𝘁𝗶𝗺𝗶𝘇𝗲. My instinct was to parallelize first. The profiler told me 60% of the time was spent in a single nested loop doing membership checks against a list. Swapping the list for a set closed most of the gap before I wrote a single worker. 𝟮. 𝗜/𝗢-𝗯𝗼𝘂𝗻𝗱 𝘄𝗼𝗿𝗸 𝗱𝗼𝗲𝘀𝗻'𝘁 𝗰𝗮𝗿𝗲 𝗮𝗯𝗼𝘂𝘁 𝗰𝗼𝗿𝗲𝘀. I assumed multiprocessing would win. The CPU-bound transforms benefited less than expected. The biggest jump came from batching database writes and running them concurrently against the sink — not from parallelizing the Python code. 𝟯. 𝗕𝗼𝗿𝗶𝗻𝗴 𝗯𝗲𝗮𝘁𝘀 𝗰𝗹𝗲𝘃𝗲𝗿, 𝗮𝗹𝗺𝗼𝘀𝘁 𝗮𝗹𝘄𝗮𝘆𝘀. A weekly-batch analysis showed ~50% of our records didn't actually change week-over-week. A simple content-hash cache skipped all of that redundant work. Five lines of code. Bigger impact than the parallelism refactor. The takeaway I keep coming back to: measure first, then pick the cheapest fix that matches the real bottleneck. Engineers (me included) love the interesting solutions. The boring ones usually win. So tell me :— What's the most embarrassingly simple fix that ever saved you a week? #softwareengineering #python #backend #dataengineering #learninginpublic

Understanding Grid Ways using Recursion 🚀 Recently, I explored an interesting DSA problem — finding the number of ways to move from the top-left corner (0,0) to the bottom-right (n-1, m-1) in a grid. 👉 Allowed moves: • Right ➡ • Down ⬇ 💡 Key Idea: From any cell (i, j), we have 2 choices: → Move Right → (i, j+1) → Move Down → (i+1, j) So the recurrence becomes: f (i , j) = f (i + 1, j) + f (i, j + 1) ⚡ Insight: • Time Complexity: O(2^(n+m)) • Optimized using combinatorics: Total ways = (n+m-2)! / ((n-1)! (m-1)!) This problem helped me understand how recursion explores all possible paths and how we can optimize it further mathematically. Next step: diving deeper into optimization techniques🚀 #DSA #Java #Recursion #Backtracking #ProblemSolving #LearningJourney

✳️Day 35 of #100DaysOfCode✳️ 📌 Cracking the "Redundant Connection" Problem with DSU! 🛠️ My Approach: The DSU Strategy The Disjoint Set Union (or Union-Find) algorithm is perfect here because it allows us to track connected components efficiently as we iterate through the edges. ✨The Steps in my Code: 1️⃣Initialization: Created a parent array where every node is initially its own parent (representing n independent sets). 2️⃣Iterative Union: For every edge (u, v) in the input: Find the root (representative) of u. Find the root (representative) of v. Cycle Detection: * If find(u) == find(v), it means u and v are already part of the same connected component. Adding this edge would create a cycle. 🚩 Since the problem asks for the last edge that causes the cycle, I return this edge immediately. 3️⃣Union: If they are in different sets, I perform a union by setting the parent of one root to the other. 4️⃣Optimization: I used Path Compression in the find function to keep the tree flat, ensuring almost constant time complexity. 💡 When should you use DSU? 🔅DSU is a powerhouse for specific graph scenarios. Reach for it when: Cycle Detection: You need to check if adding an edge creates a cycle in an undirected graph. 🔅Connected Components: You need to count or manage groups of connected nodes dynamically. 🔅Minimum Spanning Trees: It’s the backbone of Kruskal’s Algorithm. Grid Problems: Identifying "islands" or connected regions in a 2D matrix. #DataStructures #Algorithms #LeetCode #Java #GraphTheory #CodingLife #SoftwareEngineering