Solved LeetCode 287 with HashSet, learned about optimization and focus

💻 LeetCode Post — Day 3 of Week 2 #Learning_Of_DSA 🚀 Today’s #LeetCode_Problem_1 – Two Sum 💡 Today’s problem reminded me — simple logic can solve powerful challenges. The task? Given an array, find two numbers that add up to a target. At first glance, it looks easy — but efficiency matters when data grows big. ⚡ 🧠 Approach: Used a HashMap to store previously seen numbers and their indices. For every element, checked if (target - current) already exists in the map — if yes, we found our pair! Time complexity: O(n) — lightning-fast compared to the brute force O(n²). 💬 Takeaway: Problem-solving isn’t about memorizing patterns — it’s about thinking logically, efficiently, and scalably. Every question is another step toward writing code that thinks before it runs. 🚀 #LeetCode #DSA #LearnInPublic #ProblemSolving #CodingJourney #100DaysOfCode #SoftwareEngineering #MERNStack #CareerGrowth #TechWithPurpose

Day 5/365 — Tackling Linked Lists & Recursion 🚀 Another milestone on my LeetCode journey! Today, I solved five classic problems that deepened my understanding of linked lists and recursion. Problems Solved Today: 21. Merge Two Sorted Lists 22. Generate Parentheses 23. Merge k Sorted Lists 24. Swap Nodes in Pairs 25. Reverse Nodes in k-Group Today's Stats: 🕒 Time spent: about 3 hours 🧠 Concepts used: linked list manipulation, dummy nodes, recursion, divide and conquer, iterative/pointer techniques ✨ Biggest insight: Attacking complex list problems with both recursion and iterative logic—and using dummy nodes—makes tricky edge cases much easier to handle. 3 Tips Learned: 1. Using a dummy node can simplify pointer management for list merges. 2. Break down recursive problems like parentheses/gen. into base case + valid subparts. 3. For k-group reversal, visualize node connections before coding to avoid pointer mishaps. Why this challenge? Every new pattern mastered compounds into long-term algorithmic confidence. Let's keep grinding! Are you on a similar journey? Drop a 👍 if you're committed too, and share your favorite coding tip! #LeetCode #365DaysOfCode #Algorithms #DataStructures #ProgrammingJourney #ProblemSolving #GrowthMindset #LearningInPublic #DeveloperLife

🚀 LeetCode POTD — 1611. Minimum One Bit Operations to Make Integers Zero 🎯 Difficulty: Hard | Topics: Bit Manipulation, Recursion, Mathematical Patterns 🔗 Solution Link: https://lnkd.in/g4RHfa8h Today’s #LeetCode Problem of the Day was one of those that really make you stop and think. The problem looked simple on the surface — transform a number into 0 using a defined set of bit operations — but understanding how the bits interact recursively was the real challenge. At first, I tried approaching it directly by simulating the operations… but quickly realized that wasn’t scalable. I took a hint, tried to reason it out again, but still couldn’t fully connect the dots. Then I watched Mazhar Imam Khan’s explanation — and everything finally clicked! 🎯 The key insight was understanding that for a number like 1100, you can derive its result by simply calculating: 👉 f(1100) = f(1000) - f(100) That single conceptual shift completely changed how I looked at the problem. 💡 Core Idea: Build an array (holder) representing the number of operations required for each bit position. Traverse from the most significant bit downward. If the current bit is set, adjust the result using a sign-flip mechanism to handle transitions between set bits. 🧠 Key Learnings: Many bit-manipulation problems are built on mathematical symmetry, not just logical operations. Understanding the pattern behind Gray Code transformations helps reveal the structure. Sometimes, one line of conceptual clarity from a great teacher saves hours of debugging. 🕒 Complexity: Time: O(size of binary transformation ) Space: O(size of binary transformation + 1) 💬 Takeaway: Don’t hesitate to seek clarity when stuck — a well-explained insight can bridge the gap between confusion and understanding. #LeetCode #ProblemOfTheDay #BitManipulation #HardProblem #DSA #C++ #CodingJourney #Consistency #ProblemSolving #LearningInPublic #100DaysOfCode #SoftwareEngineering #TechCommunity

#DSAChallenge | #LeetCodeProgress 📌 Problem: 54.Spiral Matrix 📍 Platform: LeetCode Over the past few days, I’ve been exploring some classic yet challenging LeetCode problems — the kind that really test your understanding of logic, edge cases, and clean code design. 🧠 Problem Insight You're given a matrix, and the goal is to return all elements in spiral order — starting from the top-left corner and moving right → down → left → up, repeating this pattern until all elements are covered. ⚙️ Logic Breakdown (Step-by-Step): 1️⃣ Set boundaries: top, bottom, left, right 2️⃣ Traverse in order: → Move left to right (top row) → top++ → Move top to bottom (right column) → right-- → Move right to left (bottom row) → bottom-- → Move bottom to top (left column) → left++ 3️⃣ Continue while top <= bottom and left <= right 🧩 Key Learning Points: ✅ Strengthened my understanding of matrix boundaries and directions. ✅ Improved my ability to handle edge cases cleanly. ✅ Learned how to manage loop conditions efficiently. ⏱️ Time & Space Complexity Time Complexity: O(m × n) → Every element is visited once Space Complexity: O(1) → If output list is excluded 💡 Takeaway: In DSA, consistency beats intensity. Even small daily challenges — when done consistently — compound into stronger problem-solving intuition. 🔥 Next Up: Moving on to Rotate Image & Set Matrix Zeroes to deepen my matrix manipulation skills! #DSA #LeetCode #ProblemSolving #DataStructures #Algorithms #100DaysOfDSA #Matrix #SpiralMatrix #CodeNewbie #GrowthMindset #DailyLearning #NeverGiveUp #KeepCoding #LearningNeverStops

💻 Day 18 of My LeetCode Journey 🚀 Problem: LeetCode 2 — Add Two Numbers (Medium) 📘 Problem Overview: You are given two non-empty linked lists representing two non-negative integers. Each node in the lists contains a single digit, and the digits are stored in reverse order — meaning the 1’s place is at the head of the list. Your task is to add the two numbers and return the sum as a new linked list, also in reverse order. 💡 Key Learnings and Algorithmic Insights: 🔹 Core Concept: This problem is an excellent exercise in linked list traversal, digit-by-digit addition, and carry management, simulating manual addition in code form. 🔹 Approach: 1️⃣ Initialize a dummy node to construct the result list. 2️⃣ Use two pointers to traverse both linked lists simultaneously. 3️⃣ Maintain a carry variable to handle sums that exceed 9. 4️⃣ Continue until all digits and any remaining carry are processed. 🔹 Time Complexity: O(max(m, n)) — both lists are traversed once. 🔹 Space Complexity: O(max(m, n)) — for the resulting linked list. 🎯 Key Takeaway: This problem elegantly demonstrates how data structures can simulate real-world operations. It emphasizes careful pointer manipulation, iteration logic, and understanding of how information flows across linked nodes. Each problem in this journey reinforces the importance of clean logic, structured thinking, and consistency in learning. On to Day 19 💡 #LeetCode #Day18 #CodingChallenge #ProblemSolving #LinkedList #DSA #AlgorithmDesign #SoftwareEngineering #LearningEveryday #100DaysOfCode

⚡ Day 97 of My LeetCode Journey — Problem 328: Odd Even Linked List 💡 Problem Insight: Today’s problem focused on rearranging a singly linked list so that all nodes at odd indices come first, followed by all even-indexed nodes — while maintaining their relative order. A great challenge to test how well you understand pointer manipulation! 🧠 Concept Highlight: The solution revolves around re-linking nodes using two pointers — one tracking odd nodes and another for even nodes. By carefully connecting them, we achieve the rearrangement in-place without extra space. It’s a smart exercise in linked list restructuring and pointer logic. 💪 Key Takeaway: Organizing efficiently — whether in data or in life — often means rearranging, not replacing. A small change in order can create big clarity. ✨ Daily Reflection: Linked lists truly train the mind to think sequentially and structurally — every link counts, just like every day of consistent learning. #Day97 #LeetCode #100DaysOfCode #LinkedList #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering #Pointers

🔹 Day 25 of 50 | 50 Days of LeetCode Challenge Problem: Merge Two Sorted Lists 🧩 Today’s challenge revolved around one of the most fundamental problems in linked list manipulation — merging two sorted lists into one sorted structure. It’s a classic test of understanding both pointer management and algorithmic optimization. The goal was to efficiently merge the nodes from two sorted linked lists without creating new ones — simply by rearranging pointers. The key insight lies in using a dummy node as a placeholder to simplify list construction and eliminate complex edge-case handling at the start. 💡 Approach Overview: Initialize a dummy node to serve as the head of the new list. Maintain a pointer (tail) that tracks the last node in the merged list. Traverse both input lists simultaneously, linking the smaller node each time. Once one list is exhausted, append the remainder of the other list directly. This yields an elegant O(n + m) solution with O(1) extra space — no recursion, no redundant allocations, just clean pointer logic and efficient iteration. 🧠 Core Learnings: Dummy nodes simplify linked list problems by removing special case handling. Always prefer iterative solutions for linked lists in production — recursion risks stack overflow for large datasets. Even the simplest problems reinforce the importance of clarity and structure in thinking. ⚙️ Performance: ✅ Time Complexity: O(n + m) ✅ Space Complexity: O(1) ✅ Runtime beats 95%+ of submissions on LeetCode. Each problem in this challenge is more than code — it’s an exercise in discipline, pattern recognition, and precision. Because in software engineering, mastery isn’t about solving problems quickly; it’s about solving them elegantly and understanding why they work.Shishir chaurasiya and PrepInsta #Day25 #LeetCode #ProblemSolving #DataStructures #Algorithms #LinkedList #CodingChallenge #SoftwareEngineering #ContinuousLearning #CleanCode

🚀 LeetCode Challenge: Sqrt(x) Today’s problem was all about finding the square root of a number without using any built-in functions , sounds simple, but implementing it from scratch really makes you think deeper! After doing some research online, I discovered that this problem can be efficiently solved using Binary Search . Binary Search isn’t just for finding elements in a sorted array , it’s a technique that helps you narrow down a search space efficiently. 👉 Here’s the logic in simple words: The square root of x always lies between 0 and x. Instead of checking every number, we can repeatedly divide this range in half. If mid² is greater than x, the answer lies on the left side. If mid² is smaller, we move right , because we need a larger number. And if it’s equal , that’s our perfect square root. By updating the range step by step, we finally land at the integer part of the square root , with much better efficiency. 💡This problem wasn’t about math at all , it was about thinking efficiently. Sometimes in coding (and in life), we waste time checking every option linearly when we could just “binary search” our way , observe, eliminate, and focus on what matters. P.S. It’s my fourth day of LeetCode problem-solving. Here’s my LeetCode profile 👇 https://lnkd.in/daSxpGmi 🔗 Connect if you are also solving LeetCode problems — I’ll be sharing simple explanations of the problem solutions here. 🔁If you think this could help another learner, share it forward #datastructures #algorithms #LeetCode #squarerootofx #sqrt(x) #leetcodeproblem69

🔹 Day 70 of #100DaysOfLeetCodeChallenge 🔹 🚀 Problem: Combination Sum III 🔑 Topic: Backtracking 🧠 Approach: We need to find all combinations of k distinct numbers (1–9) that sum to n. Here’s how I solved it 👇 Use backtracking to explore all combinations starting from 1 to 9. Add the number and move forward recursively, reducing both k (count) and n (target). Stop when k == 0 and n == 0 → valid combination found! Backtrack by removing the last number and continue exploring. ⏳ Time Complexity: O(2⁹) ≈ O(512) 💾 Space Complexity: O(k) (recursion + temp list) 📌 Example: Input: k = 3, n = 9 Output: [[1,2,6],[1,3,5],[2,3,4]] ✅ 🎯 Takeaway: This problem teaches the power of controlled recursion — when both depth and sum conditions guide the search efficiently. 💡 #LeetCode #DSA #Backtracking #ProblemSolving #CodingChallenge #100DaysOfLeetCodeChallenge 🚀

🔥🔥 Day #51 of #100DaysOfDP When “#simple” problems teach you the most! Recently tackled a binary string problem on #Codeforces that looked deceptively straightforward: turn any binary string into its non-decreasing version with the least operations. Easy, right? 🚦 Here’s what actually happened… 🔸 Phase 1: The Indexing Mistake I dove in, started coding, and quickly realized my approach was totally off. I was using zero-based indexing, but the problem expected one-based! Small misunderstanding, huge confusion. 🔸 Phase 2: Brute Force Struggles Once I fixed indexing, I coded up the most straightforward brute-force recursive solution I could think of. It worked on sample tests… but promptly blew up with Time Limit Exceeded (TLE) on hidden cases! 🔸 Phase 3: Memoization (Hello, Memory Errors) Determined to make it work, I threw memoization at the recursion thinking, “This has to do it!” Instead, my program ate up all available memory almost instantly. Bye-bye, hope (and hello, MLE errors)! 🔸 Phase 4: The “Aha!” Moment After revisiting the problem, I realized the key wasn’t simulating every combination or caching every state. The real trick? Count only the segment transitions—specifically, the points where the string moves from 1 to 0, managing state with a simple flag. Elegant, efficient, and passed in a snap. ✨✨Key Takeaway: Sometimes the “optimal” approach means not simulating every possibility but understanding the underlying pattern and optimizing for it. Debugging and running into both TLE and MLE wasn’t a setback, it was part of the journey to deeper insight! #programming #learning #Codeforces #problemsolving #growthmindset