Recursion Simplifies Tree Depth Calculation

Handling complex tables and math in RAG pipelines is tricky. Standard text splitters often break the table structure, which leads to LLM hallucinations. I was stuck on this exact issue a few days ago. A special thanks to vishal sharma and Alampally Sainath, I was blocked on this, but your suggestions on layout-aware parsing really helped me figure it out and learn a better approach. Based on those discussions, I built a Table-Aware RAG architecture using Docling and Multi-Vector Retrieval to keep the data structure completely intact. I've put together a quick technical breakdown in the carousel below. I'm always looking to improve, so any feedback or alternative approaches are highly welcome! You can find the GitHub link in the first comment! #RAG #GenerativeAI #LLM #LlamaIndex #AIEngineering #Python #BuildInPublic #Docling

🚀 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

✅ 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

Weekly Challenge 9: TSP With Farthest Insertion. How do you find the shortest route to visit multiple locations without wasting fuel or time. This is known as the Traveling Salesperson Problem (TSP), one of the most famous challenges in computer science and Operations Research. Since finding the "perfect" route by checking every combination takes too long, we use Heuristics to find highly optimized routes in milliseconds. For Week 9 of my Python challenge, I built a spatial heuristic from scratch: > 1️⃣ Generated random nodes (cities) on a 2D plane. > 2️⃣ Calculated their Euclidean distance from the origin. > 3️⃣ Programmed an **Insertion Sort** algorithm to sort the nodes by distance. > 4️⃣ Compared the random route vs. the optimized route. > 📉 The Result: As you can see in the graph below, just by applying this sorting logic, the route distance is drastically reduced (saving over 30% in travel distance in most random scenarios!). Data visualization makes optimization beautiful. Full source code on my GitHub: https://lnkd.in/epZBxUnQ #Python #Optimization #OperationsResearch #DataScience #Matplotlib #Algorithms #CodingChallenge 

Day 8: Cracking the Subarray Sum Logic 🧩 💡 How I solved it: Instead of a slow O(n^2) brute-force approach, I used the Prefix Sum + Hash Map technique to achieve a highly efficient O(n) solution. *Tracked the Running Sum: Maintained a current_sum as I traversed the array. *The Difference Trick: For every element, I checked if (current_sum - k) existed in my hash map. If it did, it meant a subarray summing to k had just been completed. *Frequency Mapping: Used a dictionary to store how many times each prefix sum occurred, ensuring every valid subarray was counted. *Handled the Edge Case: Initialized the map with {0: 1} to correctly catch subarrays that sum to k starting right from index 0. 🧠 Key Takeaway: *Space-Time Optimization: By using O(n) space for the hash map, I eliminated the need for nested loops, drastically speeding up the execution. *Mathematical Insight: Reinforced the logic that Sum(i, j) = PrefixSum(j) - PrefixSum(i-1). This is a powerhouse pattern for any range-sum problem. One step closer to mastering Data Structures and Algorithms! 💻🔥 The logic is getting sharper every day! 📈🤝 #100DaysOfCode #DSA #Python #ProblemSolving #StriverA2ZSheet #CodingJourney

✅ Day 84 of 100 Days LeetCode Challenge Problem: 🔹 #2946 – Matrix Similarity After Cyclic Shifts 🔗 https://lnkd.in/g3uy6WKa Learning Journey: 🔹 Today’s problem was about checking if a matrix remains the same after applying cyclic shifts k times. 🔹 Instead of handling even and odd rows separately, I simplified the logic by focusing on the final shifted state. 🔹 I used modulo (k % n) to reduce unnecessary full rotations. 🔹 For each row, I generated its left cyclic shift using slicing: • row[k % n:] + row[:k % n] 🔹 Then, I directly compared the shifted row with the original row. 🔹 If any row doesn’t match, return False; otherwise, True. Concepts Used: 🔹 Modular Arithmetic 🔹 Array Slicing 🔹 Matrix Traversal Key Insight: 🔹 Full rotations don’t change the array, so reducing k using modulo is critical. 🔹 Direct row comparison after a single computed shift avoids repeated simulation and keeps the solution concise. Complexity: 🔹 Time: O(n × m) 🔹 Space: O(m) #LeetCode #Algorithms #DataStructures #CodingInterview #100DaysOfCode #SoftwareEngineering #Python #ProblemSolving #LearningInPublic #TechCareers

🚀 DSA Challenge – Day 194 Problem: Largest Component Size by Common Factor 🔗🔢 Today’s problem is a powerful application of Union-Find (Disjoint Set Union) combined with number theory (factorization). 🧠 Problem Summary You are given an array of unique positive integers nums. We construct a graph where: 👉 Each number is a node 👉 An edge exists between two numbers if they share a common factor > 1 🎯 Goal: Return the size of the largest connected component in this graph. 💡 Key Insight Instead of explicitly building the graph (which would be expensive), we use: 🔥 Union-Find to group connected numbers Key observation: 👉 If two numbers share a factor, they belong to the same component 👉 So we can connect numbers via their prime factors ⚙️ Approach 1️⃣ For each number, compute its prime factors 2️⃣ Maintain a map: factor → index of number 3️⃣ For every factor of a number: If factor already seen → union current index with previous index Else → store it in the map 4️⃣ After processing all numbers: Find the root parent of each node Count size of each component 5️⃣ Return the maximum component size 📈 Complexity Time Complexity: 👉 Factorization: ~O(n √max(nums)) 👉 Union-Find operations: ~O(n α(n)) Space Complexity: O(n) ✨ Why This Problem Is Important This problem teaches a powerful pattern: 🔥 Connect elements indirectly using shared properties Instead of: ❌ Comparing every pair (O(n²)) We use: ✅ Factor mapping + Union-Find 💡 Key Learnings: ➡️ DSU for grouping problems ➡️ Prime factorization in graph problems ➡️ Avoiding explicit graph construction This pattern appears in: ➡️ Connected components ➡️ Grouping by similarity ➡️ Graph problems with hidden relationships 🔖 #DSA #100DaysOfCode #Day194 #UnionFind #DSU #Graphs #NumberTheory #LeetCode #Algorithms #ProblemSolving #CodingChallenge #InterviewPrep #Python #SoftwareEngineering #DeveloperJourney #TechCommunity #CodingLife

I made a Multi-Document RAG system from the ground up. Here's a full breakdown. Most RAG tutorials only use one PDF. Real production systems can handle hundreds of documents in different formats and fields. Here is how I set mine up: The Ingestion Layer loads PDFs, CSV, and TXT files in chunks, with metadata tagging (source, page, section, timestamp). The Retrieval Layer uses a combination of Dense (semantic embeddings) 🧠 Layer LLM Strict grounded prompting means that answers can only come from the context that was retrieved. No seeing things that aren't there. When there is no context, it returns "Not found." ⚙️ Pipeline: Architecture based on configuration. Change models, chunk sizes, and retriever types without changing the core logic. Here, we used a class-based architecture. Full code is on GitHub: https://lnkd.in/gM68gjUz If this helped you, give it a thumbs up. #RAG #LLM #GenerativeAI #AIEngineering #VectorSearch #Python #MachineLearning #BuildInPublic #OpenSource #GenAI #LangChain #FastAPI #learning

Most teams treat randomness like magic. Then they’re surprised when models behave like lottery tickets in production. Controlling randomness is not academic — it’s reliability engineering. Tiny checklist that saves you weeks: - Pin your RNG across layers: Python, NumPy, PyTorch/TensorFlow, CUDA. - Bake seeds into configs (not code). Change seed => full experiment trace. - Snapshot the environment: deps, CUDA driver, OS. Reproduce locally and in CI. - Log the seed with every run and tie it to artifacts (model, dataset version). - Test determinism: run the same seed 5–10x in CI. Fail fast on divergence. - Use deterministic ops only where latency and throughput allow; document the trade-offs. Tools & repos that actually help: - Hydra — manage experiment configs (include seeds consistently) - DVC — dataset + pipeline versioning so seeds map to dataset snapshots - MLflow — track runs and attach the seed as a searchable parameter - pytorch-lightning/pytorch-lightning — has seed_everything utilities to standardize seeding Quick config snippet idea: - config.yaml: seed: 12345 - bootstrap script: set all RNGs from config.seed, save that seed to run metadata Operational tip: Don’t just set one seed. Use a seed hierarchy: global -> component -> data-loader. It makes partial replay easier. At FlazeTech we once traced a flaky production endpoint to a missing seed in a custom C++ sampler. Fixing that single line cut customer errors by 70%. Determinism costs time. But unpredictability costs customers. What small seeding rule will you add to your next experiment or CI pipeline? #MLops #MachineLearning #Reproducibility #AIEngineering #DevTools #PyTorch #Hydra #DVC

🚀 DSA Challenge – Day 196 Problem: Minimum Number of Vertices to Reach All Nodes 🧭📊 Today’s problem is a clean and powerful application of graph intuition using indegree. 🧠 Problem Summary You are given: 👉 A Directed Acyclic Graph (DAG) with n nodes 👉 A list of directed edges 🎯 Goal: Find the smallest set of vertices from which all nodes are reachable. 💡 Key Insight In a DAG: 👉 If a node has incoming edges, it can be reached from another node 👉 If a node has NO incoming edges (indegree = 0), it must be included in the answer 🔥 Why? Because: ➡️ No other node can reach it ➡️ It has to be a starting point ⚙️ Approach 1️⃣ Initialize an indegree array/map for all nodes 2️⃣ Traverse edges: For each edge (u → v) 👉 Increment indegree[v] 3️⃣ Collect all nodes with: 👉 indegree == 0 4️⃣ Return them as the answer 📈 Complexity Time Complexity: O(n + e) Space Complexity: O(n) ✨ Why This Problem Is Important This problem highlights a fundamental graph concept: 🔥 Nodes with indegree 0 are entry points Key takeaway: ➡️ In DAG problems, always check indegree/outdegree patterns ➡️ Helps in: Topological sorting Dependency resolution Task scheduling 💡 Real-world analogy: Think of tasks: 👉 Tasks with no dependencies must be started manually 👉 Everything else can be reached through them 🔖 #DSA #100DaysOfCode #Day196 #Graphs #DAG #Indegree #LeetCode #Algorithms #ProblemSolving #CodingChallenge #InterviewPrep #Python #SoftwareEngineering #DeveloperJourney #TechCommunity #CodingLife