Lalit Kumar Bodana’s Post

📌 Day 39/150 – Rotate List (LeetCode #61) Today’s problem was a brilliant exploration of how subtle linked list operations can completely change the shape of a data structure! 🔁✨ The task? Given a linked list, rotate it to the right by k positions. Instead of shifting values, we must carefully adjust the links — no cheating with arrays! 😄 This problem reinforces how pointer manipulation and structural thinking work hand-in-hand in linked list questions. 🧠 🔹 Brute Force Idea A naive thought would be: 👉 Rotate one step at a time 👉 Move the last node to the front Repeat this k times. ✅ Easy to visualize ❌ Too slow (k rotations × n operations = inefficient!) ❌ Not scalable for large k 🔹 Optimal Approach – Smart Pointer Manipulation The elegant approach lies in understanding patterns: 👉 First, compute the length of the list. 👉 Connect the tail to the head — forming a temporary circle! 🔄 👉 Reduce k using modulo (k = k % length) 👉 Traverse to the correct breaking point. 👉 Break the circle to form the rotated list. You handle: 🔸 Circular linked list logic 🔸 Tail–head reattachment 🔸 Precise pointer breaking Very clean, very efficient! ✨ 🧠 Example Visualization Input: 1 → 2 → 3 → 4 → 5, k = 2 After rotation: 4 → 5 → 1 → 2 → 3 Only the links change — the magic of pointers! 🔧 ⏱️ Time & Space Complexity ComplexityValueTimeO(n) — just one traversalSpaceO(1) — done in-place 💡 Key Learning: This problem helps build confidence in: ✅ Recognizing patterns ✅ Using circular logic ✅ Efficient pointer manipulation ✅ Avoiding unnecessary extra space It’s one of those linked list questions that feels intimidating at first, but becomes satisfying once you see the strategy. Solving this opens the door to related problems like: 📍 Rotate Array 📍 Reverse Nodes in K-Group 📍 Swap Nodes in Pairs Linked lists may bend… but they don't break your confidence anymore. 💪😄 #150DaysOfCode #LeetCode #RotateList #LinkedLists #Pointers #DSA #CodingChallenge #SoftwareEngineering #LearningJourney #ProblemSolving 🚀🔥

🚀 Day 2 of My #120DaysLeetCode Challenge – Add Two Numbers (Medium) Problem: You are given two non-empty linked lists representing two non-negative integers. Each node contains a single digit, and the digits are stored in reverse order — meaning the 1’s digit is at the head of the list. Your task is to add the two numbers and return the sum as a linked list (also in reverse order). 💡 Approach & Thought Process: To solve this problem, I broke it down into simple, logical steps: Initialize a dummy node to store the result list and use a current pointer to traverse. Keep track of the carry (since adding two digits can be more than 9). Traverse both linked lists simultaneously: Add corresponding digits from both lists along with the carry. Compute sum = val1 + val2 + carry. Update carry = sum / 10 and store sum % 10 as the new node value. Move to the next nodes in both lists until all nodes and carry are processed. Finally, return the linked list starting from the dummy’s next node. ⚙️ Key Concepts Used: Linked List traversal Carry management in addition Handling different lengths of linked lists 🧠 Learning Outcome: This problem helped me strengthen my understanding of linked list manipulation and how to simulate arithmetic operations through data structures. It was a great way to practice pointer handling and iterative problem-solving logic. #LeetCode #CProgramming #LinkedList #DataStructures #100DaysOfCode #CodingChallenge #ProblemSolving

🚀 Day 53 of LeetCode150DaysChallenge 🧩 Problem: Min Stack #150DaysOfCode #LeetCode #DSA #CPlusPlus #CodingChallenge #ProblemSolving #LearnByDoing #SoftwareEngineering Today’s problem is all about designing a special stack that can not only perform regular stack operations but also retrieve the minimum element efficiently at any time. 🧠 Problem Statement: Design a stack that supports the following operations: push(x) → Add element x to the stack pop() → Remove the top element top() → Get the top element getMin() → Retrieve the minimum element in the stack 💡 Intuition: A normal stack supports push and pop, but it doesn’t directly track the minimum value. The simplest approach is to store all elements and, whenever getMin() is called, scan the stack to find the smallest element. 🧩 Approach (Simple Version): Use a vector<int> to store stack elements. push(val) → insert element at the end. pop() → remove the last element. top() → return the last element. getMin() → loop through all elements to find the smallest one. Time Complexity: push(), pop(), top() → O(1) getMin() → O(n) Space Complexity: O(n) 🔍 Optimized Hint: You can improve getMin() to O(1) by keeping track of the minimum at every push using an additional stack or by pairing each value with its current minimum. 💬 Key Takeaway: Start with simple logic → understand the flow → then optimize! Understanding how stacks behave internally helps a lot when designing custom data structures.

🔥 Day 89 of My LeetCode Journey — Problem 237: Delete Node in a Linked List 💡 Problem Insight: Today’s challenge focused on deleting a node from a singly linked list, but here’s the twist — we’re not given the head node, only the node to be deleted! The task was to modify the list in place without full traversal. 🧠 Concept Highlight: The clever trick is to copy the next node’s value into the current node and then bypass the next node. This way, the target node is effectively removed without needing access to the head — a brilliant example of in-place manipulation in linked lists. 💪 Key Takeaway: Not every problem needs a direct approach — sometimes, rethinking what “deletion” means opens up an elegant shortcut. ⚙️ Learning Boost: Linked list problems consistently sharpen logical thinking and pointer management — one step closer to mastering data structures! #Day89 #LeetCode #100DaysOfCode #LinkedList #ProblemSolving #InPlaceAlgorithm #CodingJourney #DSA #LearnByDoing #SoftwareEngineering

🧩 LeetCode Challenge – Day 73 ✅ Worked on a linked list problem today — clean logic, but plenty of room for optimization. 🔗 LeetCode 3217 – Delete Nodes From Linked List Present in Array The goal was to remove nodes whose values appear in a given array. Instead of using hashing for lookups, I applied binary search after sorting the reference array — keeping the approach elegant and efficient. It was a great reminder that data structure choice can completely change a problem’s flow and clarity. 💡 Key Takeaways: • Binary search isn’t just for arrays — it enhances linked list problems too. • Efficiency through structure — sorted data can replace extra space usage. • Exploring alternatives deepens understanding far beyond standard templates. #Day73 #LeetCodeChallenge #100DaysOfCode #DSA #CodingJourney #ProblemSolving #LinkedList #BinarySearch #Pointers #DataStructures

🚀 Day 184 of solving 365 medium questions on LeetCode! Continuing my journey of solving one LeetCode problem every day to sharpen my problem-solving and data structure skills. 🔥 Today's challenge: "Find Closest Node to Given Two Nodes" ✅ Problem: You’re given a directed graph represented by an array edges, where edges[i] points to another node or -1 if none. Given two nodes node1 and node2, find the node reachable from both such that the maximum distance from each starting node is minimized. ✅ Approach: Use BFS (or DFS) from both nodes to compute distances to every other node. Iterate through all nodes, checking which are reachable from both. Choose the node with the smallest max(distance from node1, distance from node2); if tie, pick smaller index. ✅ Key Insight: Precomputing distances separately avoids recomputation — a clean use of graph traversal + distance comparison. ✅ Complexity: Time: O(n) — since each node is visited at most twice. Space: O(n) — for distance arrays. 🔍 Check out my solution approach in the attached slides! 🔥 Flexing my coding skills until recruiters notice! #LeetCode365 #Graph #BFS #DFS #ProblemSolving #Algorithms #DataStructures

🚀 Day 180 of solving 365 medium questions on LeetCode! Continuing my journey of solving one LeetCode problem every day to sharpen my problem-solving and data structure skills. 🔥 Today's challenge: "Path with Maximum Gold" ✅ Problem: You are given a grid where each cell represents the amount of gold in that cell. You can start and stop at any gold cell and move in 4 directions (up, down, left, right) — but you cannot visit the same cell more than once or enter a cell with 0 gold. Find the maximum amount of gold you can collect. ✅ Approach: Use DFS (Depth-First Search) with backtracking. For every cell with nonzero gold: Start a DFS to explore all possible paths. Mark the current cell as visited during traversal. Recurse in all 4 directions and track the total gold collected. Backtrack (unmark the cell) before returning. Track the maximum sum obtained from all starting positions. ✅ Key Insight: This is a perfect example of grid traversal + backtracking — exploring all paths while restoring the grid state for future paths. ✅ Complexity: Time: O(m × n × 4^(m×n)) in the worst case (exploring all possible paths). Space: O(m × n) for recursion stack and visited tracking. 🔍 Check out my solution approach in the attached slides! 🔥 Flexing my coding skills until recruiters notice! #LeetCode365 #Backtracking #DFS #GridTraversal #ProblemSolving #Algorithms #LeetCode

One of our engineers shared this story last week, and I loved it because it perfectly captures what building Datachecks really feels like. They were writing a simple Python script — nothing too fancy. The goal was to automate column mapping for table comparisons. Usually, when you compare two tables with 100+ columns, it takes 10–15 minutes just to map them manually (user_id → id, email → email_address, and so on). This script read those mappings directly from an Excel sheet and created the comparisons in seconds. Easy idea. Smart implementation. And it worked beautifully… until it didn’t. The issue wasn’t the code. It was the Excel file. We had shared a template with headers like table_name and column_name. But every time the team ran it, someone renamed headers — “Dataset Name” here, “Field” there — and the script broke. It was such a simple thing. But it’s always these small inconsistencies that trip up even the best automation. The best part? That quick internal fix has now evolved into a new feature inside our Reconciliation Agent — automating column mapping for users directly in the platform. I love moments like this — where a small friction point sparks a real product improvement. That’s the kind of problem-solving mindset that quietly changes how data teams work. #datamigration #columnmapping #BTS #internalwins

📌 Day 40/150 – Min Stack (LeetCode #155) Today’s problem was a fascinating dive into designing efficient data structures that offer more than just basic push and pop operations! 📦⚡ The challenge? We must build a stack that can: ✅ Push elements ✅ Pop elements ✅ Fetch the top element ✅ Retrieve the minimum element — all in constant time! ⏱️ What makes this interesting is that we cannot scan or sort the elements when asked for the minimum. We have to maintain it intelligently throughout the operations. 🔹 Brute Force Idea A quick thought would be: 👉 Keep all elements in the normal stack 👉 Whenever getMin() is called, scan the entire stack ✅ Simple to implement ❌ Very slow for repeated queries ❌ O(n) time for every getMin() Not suitable for real-time scenarios. 🔹 Optimal Approach — Track the Minimum Smartly The key insight lies in using an auxiliary stack to keep track of minimums: 👉 Push the incoming value onto the main stack 👉 Update the minimum stack with the smallest seen so far 👉 Pop from both stacks simultaneously 👉 The top of the min-stack always reflects the current minimum ✅ No extra traversal, no delay — pure constant time magic! ✨ 🧠 Example Walkthrough Push sequence: [-2, 0, -3] Current minimum after each operation: After -2: -2 After 0: -2 After -3: -3 Pop -3, new minimum becomes -2 again! Two stacks, working hand-in-hand. 🤝 ⏱️ Time & Space Complexity ComplexityValueTimeO(1) for all operationsSpaceO(n) for tracking minimum history 💡 Key Learnings This problem is an excellent lesson in: ✅ Data structure augmentation ✅ Tracking historical minimums ✅ Optimizing real-time queries ✅ Thinking beyond straightforward stacks It’s a beautiful example of how adding a bit of extra structure can unlock powerful capabilities — without sacrificing performance. After solving this, similar problems become approachable: 📍 Max Stack 📍 Queue with min operations 📍 Sliding window minimum Designing smart data structures builds both intuition and confidence. 🚀😄 #150DaysOfCode #LeetCode #MinStack #DataStructures #Stack #AlgorithmDesign #Optimization #CodingChallenge #LearningJourney #ProblemSolving 🔥

🚀 Day 183 of solving 365 medium questions on LeetCode! Continuing my journey of solving one LeetCode problem every day to sharpen my problem-solving and data structure skills. 🔥 Today's challenge: "Random Pick with Weight" ✅ Problem: You are given an array of positive integers w, where w[i] describes the weight of index i. Implement the function pickIndex() that randomly returns an index i with probability proportional to its weight. ✅ Approach: Build a prefix sum array where each element represents cumulative weight. Generate a random number in the range [1, total_weight]. Use binary search to find the index where this random number fits in the prefix array. ✅ Key Insight: By mapping weights to ranges within the prefix sum, each index gets chosen with probability proportional to its weight — an elegant combination of prefix sums + binary search. ✅ Complexity: Time (init): O(n) — to build prefix sum. Time (pick): O(log n) — binary search on prefix sums. Space: O(n) — for prefix array. 🔍 Check out my solution approach in the attached slides! 🔥 Flexing my coding skills until recruiters notice! #LeetCode365 #PrefixSum #BinarySearch #Randomization #Probability #ProblemSolving #Algorithms