Solving N-Queens Puzzle with Backtracking and Recursion

🚀 DSA Challenge – Day 86 Problem: Minimum Operations to Make Array Elements Zero ⚙️💥 This problem was a simple yet insightful exercise in greedy thinking and recognizing that we only need to count distinct positive values to reach the goal efficiently. 🧠 Problem Summary: You are given a non-negative integer array nums. In one operation, you can choose an integer x (≤ smallest non-zero element) and subtract it from all positive numbers. Your task: Find the minimum number of operations to make all elements 0. ⚙️ My Approach: 1️⃣ Sort the array to process numbers in ascending order. 2️⃣ Maintain a running subtraction value curr to track how much has already been subtracted. 3️⃣ For each new smallest element, if it’s still positive after prior subtractions, perform one operation and update curr. 4️⃣ Each operation corresponds to discovering a new distinct positive number. 📈 Complexity: Time: O(n log n) → Sorting dominates the time complexity. Space: O(1) → Only a few extra variables used. ✨ Key Takeaway: Every distinct positive number in a sorted array represents a new operation — a clean and intuitive greedy solution that avoids overcomplication. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #GreedyAlgorithm #Sorting #CodingChallenge #Python #Algorithms #EfficientCode #Optimization #TechCommunity #InterviewPrep #CodeEveryday #LearningByBuilding

💡 Day 17 of 30 – LeetCode Challenge: Word Search (Backtracking) Today’s problem tested my understanding of DFS (Depth-First Search) and Backtracking — a key algorithmic concept used in exploring possible paths or configurations in grids, trees, and graphs. 🧩 Problem Summary We are given an m x n character grid (board) and a string word. We must determine if the word exists in the grid by moving horizontally or vertically through adjacent cells. Each cell can be used only once per word construction. ⚙️ Example Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]] word = "ABCCED" Output: true 📖 Explanation: The path A → B → C → C → E → D forms the word “ABCCED” through valid adjacent cells. 🧠 Approach 1. Traverse every cell in the grid. 2. If the character matches the first letter of word, start a DFS. 3. Explore all 4 directions — up, down, left, right — recursively. 4. Mark cells as visited (temporarily) to prevent reuse. 5. Backtrack after exploring each path (restore cell value). 6. Return True as soon as the word is found. ⏱ Complexity Analysis Time Complexity O(m * n * 4^L) → where L = length of word Space Complexity O(L) (Recursion stack) 🧩 Key Learnings ✨ Learned how DFS + Backtracking can explore all potential paths efficiently. ✨ Importance of restoring state (backtracking) after recursive exploration. ✨ Strengthened my problem-solving in grid-based traversal problems. Backtracking is like exploring a maze — you move forward when possible and step back when you hit a dead end. #Day17 #LeetCode #Backtracking #DFS #WordSearch #CodingChallenge #Python #DSA #WomenWhoCode #ProblemSolving #MTech #LearningJourney

🚀 DSA Challenge – Day 85 Problem: Check if All Integers in a Range Are Covered ✅📏 This problem was an elegant use of the Prefix Sum technique, where I used range updates to efficiently check coverage over an interval. 🧠 Problem Summary: You are given several inclusive integer intervals and a target range [left, right]. You must verify if every integer within [left, right] is covered by at least one of the given intervals. ⚙️ My Approach: 1️⃣ Initialize an array line to track coverage at each integer position. 2️⃣ For every range [a, b], increment line[a] and decrement line[b + 1] — this marks the start and end of coverage. 3️⃣ Convert line into a prefix sum array, so each position reflects how many intervals cover that number. 4️⃣ Finally, iterate through [left, right] to ensure each integer has coverage (> 0). 📈 Complexity: Time: O(n + 52) → Linear scan and prefix sum computation. Space: O(52) → Fixed-size array since ranges are small. ✨ Key Takeaway: Prefix sum is not just for subarray sums — it’s a powerful trick for range marking and coverage problems, offering O(1) updates and O(n) verification. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #PrefixSum #RangeUpdate #ProblemSolving #Algorithms #CodingChallenge #Python #EfficientCode #Optimization #TechCommunity #InterviewPrep #CodeEveryday #LearningByBuilding

🚀 DSA Challenge – Day 96 Problem: String to Integer (atoi) 🔢➡️💻 This is a classic implementation problem that tests careful handling of edge cases, parsing logic, and boundary conditions. 🧠 Problem Summary: Implement the function myAtoi(string s) that converts a string into a 32-bit signed integer following specific parsing rules. Steps to follow: 1️⃣ Ignore leading whitespaces. 2️⃣ Check the sign (+ or -). 3️⃣ Read digits until a non-digit character is found. 4️⃣ Handle overflow/underflow by clamping the number within the 32-bit signed integer range: Range = [−2³¹, 2³¹ − 1] 5️⃣ Return the final integer. ⚙️ My Approach: Trim leading spaces using lstrip(). Identify the sign based on the first non-space character. Iterate through the string and build the number digit by digit. Multiply by the sign and ensure the result stays within integer limits using max() and min(). 📈 Complexity Analysis: Time: O(n) — traverse each character once. Space: O(1) — only a few variables used. ✨ Key Takeaway: This problem is a great example of careful boundary handling and parsing logic — it’s not just about coding, but about thinking through every possible input case. 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #Python #CodingChallenge #myAtoi #StringParsing #AlgorithmDesign #InterviewPrep #TechCommunity #LearningEveryday

🚀 DSA Challenge – Day 84 Problem: Reachable Nodes in a Restricted Tree 🌲🚫 This problem was a perfect blend of graph traversal and constraint handling, where we must carefully explore a tree while avoiding restricted nodes. 🧠 Problem Summary: You are given a tree with n nodes (0-indexed) and a list of edges that describe the connections between them. Some nodes are restricted, meaning you cannot visit or pass through them. Starting from node 0, the goal is to determine how many nodes are reachable without visiting any restricted ones. ⚙️ My Approach: 1️⃣ Build an adjacency list representation of the tree. 2️⃣ Store all restricted nodes in a set for quick lookup. 3️⃣ Use Depth-First Search (DFS) to traverse the graph, skipping restricted or already visited nodes. 4️⃣ Accumulate a count of all valid reachable nodes. 📈 Complexity: Time: O(n) → Each node and edge is processed once. Space: O(n) → For adjacency list, recursion stack, and visited set. ✨ Key Takeaway: Even simple DFS problems become interesting when constraints are introduced. Efficient use of sets and recursion can elegantly handle conditions like restricted traversal in trees or graphs. 🌿 🔖 #DSA #100DaysOfCode #LeetCode #GraphTheory #TreeTraversal #DFS #Python #ProblemSolving #CodingChallenge #InterviewPrep #Algorithms #EfficientCode #TechCommunity #CodeEveryday #LearningByBuilding

🚀 Day 29 DSA Challenge – Problem 704: Binary Search A timeless classic — the foundation of efficient searching algorithms 🔍 🎯 Problem Statement: Given a sorted array nums and an integer target, find the index of target using an algorithm with O(log n) time complexity. If target doesn’t exist, return -1. 🧩 How I Solved It: Used the Binary Search technique — repeatedly dividing the search space in half. Initialized two pointers, left and right, representing the current search range. Found the middle index mid, compared nums[mid] with target: If equal → returned mid. If smaller → shifted the left boundary rightward. If greater → moved the right boundary leftward. Continued until left > right, meaning the element isn’t found. ⚙️ Performance Stats: ⏱ Runtime: 0ms (⚡ beats 100%) 💾 Memory: 13.48MB (beats 31.70%) ✅ Testcases Passed: 47 / 47 ✨ Insight: Binary Search perfectly demonstrates divide-and-conquer at its best — turning linear scans into logarithmic efficiency 🚀 #LeetCode #Problem704 #BinarySearch #Algorithm #DSA #DivideAndConquer #Python #100DaysOfCode #CodingChallenge

💼 LeetCode Daily Challenge: 3354. Make Array Elements Equal to Zero Today I worked on an interesting simulation based problem that combines logical movement with mathematical reasoning. 🔍 Problem Overview: - You are given an integer array containing non-negative elements. - The task is to determine the number of valid starting positions (and directions) such that all elements become zero after performing a series of operations. - The movement involves direction reversals and decrements, making direct simulation tricky. 💡 Key Observations: - Instead of brute force simulation, prefix sum analysis helps determine valid balance points. - Each zero acts as a potential pivot; by analyzing prefix and total sums, we can efficiently identify valid selections. - The solution leverages mathematical balance conditions to avoid unnecessary computation. 📊 Complexity: Time Complexity: O(n) Space Complexity: O(1) 🎯 Takeaways: - Simulation problems often hide elegant mathematical patterns. - Prefix sums are powerful tools for deriving insights without explicit iteration over all possibilities. #LeetCode #ProblemSolving #Python #DSA #Algorithm #CodingChallenge #PrefixSum #DataStructures #LearningEveryday #Efficiency

🚀 DSA Challenge – Day 80 Problem: Maximum Distance Between Valid Pairs 🌊📏 Today’s problem tested the combination of binary search and array monotonicity — finding the farthest valid pair between two non-increasing arrays! 🧠 Problem Summary: We’re given two non-increasing arrays, nums1 and nums2. A pair (i, j) is valid if: i ≤ j, and nums1[i] ≤ nums2[j]. The goal is to find the maximum distance (j - i) among all valid pairs. ⚙️ My Approach: 1️⃣ Iterate through each element in nums1. 2️⃣ Use binary search on nums2 to find the farthest valid index satisfying the condition. 3️⃣ Keep track of the maximum j - i distance encountered. This solution leverages the sorted (non-increasing) property of arrays for logarithmic efficiency. 📈 Complexity: Time: O(n log m) → For each element in nums1, a binary search on nums2. Space: O(1) → Only a few variables used. ✨ Key Takeaway: Sometimes, monotonic properties allow you to blend binary search with iteration — turning what looks like a brute-force problem into a clean and efficient search-based solution. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #Algorithms #BinarySearch #TwoPointers #CodingChallenge #Python #InterviewPrep #TechCommunity #Optimization #EfficientCode #CodeEveryday

⚡ Day 87 of #100DaysOfDSA – 3Sum Closest 🔍 📌 Problem. no 16: Given an integer array nums and an integer target, find the sum of three integers in nums such that the sum is closest to the target. Implemented an optimized Two-Pointer Approach after sorting the array. ⚡ Runtime: 431 ms – Beats 75.40% of submissions 💾 Memory: 12.59 MB – Beats 39.70% of solutions 💻 Language Used: Python ✅ Status: Accepted – All 106 test cases passed successfully! This problem helped me strengthen my skills in pointer manipulation, array traversal, and optimization of nested loops. It was a great exercise in precision and efficiency under constraints. 🔑 Key Learnings: ✔️ Learned to balance between accuracy and performance ✔️ Gained deeper understanding of sorting and two-pointer techniques ✔️ Improved debugging and edge-case analysis for numerical problems 🎯 Day 87 — A logical yet challenging problem that sharpened my optimization mindset and coding discipline! 💪🔥 #100DaysOfCode #100DaysOfDSA #LeetCode #PythonProgramming #DataStructures #AlgorithmPractice #CodeNewbie #DailyCoding #ProblemSolving #TechJourney #WomenWhoCode #CodeLife #CodingChallenge #DSAChallenge #DeveloperLife #PythonDeveloper #LearnToCode #CodingCommunity #CodeEveryday #SoftwareEngineering #KathirCollegeOfEngineering #KathirCollege #BTechLife #AIDS #FutureEngineer #CodingMotivation #ProgrammingSkills

🚀 DSA Progress – Day 114 ✅ Problem #228: Summary Ranges 🧠 Difficulty: Easy | Topics: Array, Two-Pointers, Iteration 🔍 Approach: Today I worked on summarizing consecutive sequences in a sorted array. Step 1 (Scan): Iterate through the list from left to right. Step 2 (Mark Start): Treat the current number as the start of a potential range. Step 3 (Expand Range): Continue while the next number is exactly +1 from the current number. Step 4 (Record Result): If the start and end differ → push "start->end" If only one number → push "start" This cleanly compresses consecutive sequences into readable ranges. 🕒 Time & Space Complexity: Time: O(n) — single pass through the array Space: O(1) extra — only the output list uses additional space 📁 File: https://lnkd.in/gaHdwyHc 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem reinforced how to identify and compress consecutive patterns efficiently. The idea of scanning once while controlling a moving pointer is a core technique used in data grouping, run-length encoding, and sequence compression problems. A simple yet elegant problem that improves intuition for range detection in numeric data! 🔢➡️📦 ✅ Day 114 complete — compressed life’s sequences into neat little summaries! 😄📦✨ #LeetCode #DSA #Python #TwoPointers #Arrays #SummaryRanges #DailyCoding #InterviewPrep #GitHubJourney