Solved Word Search without DFS or Recursion using Index Tracking

Tackling a Quick LeetCode Challenge: Final Value of Variable After Performing Operations (2011) It's amazing how a simple iteration can solve a coding problem! This one is a perfect example of keeping it simple: tracking a variable's state change based on a list of defined operations. The Problem: We start with x=0 and are given an array of string operations (like ++X, X++, --X, X--). We need to calculate the final value of x. My C++ Approach: I noticed that regardless of whether the increment/decrement is pre (++X, −−X) or post (X++, X−−), the effect is the same for the final value. Therefore, I only need to check what the operation is, not where the X is. I iterate through the operations array. Inside the loop, I check if the string contains two plus signs ("++"). An even simpler check, as shown in the code, is checking if the operation string equals "++X" or "X++" or even just checking for the presence of a '+'. If it's an increment operation, I use x++. If it's a decrement operation, I use x--. A neat little problem to practice basic array iteration and conditionals! Full code is accepted and running in the screenshot. Have you solved this one? What was your approach? #DataStructures #Algorithms #CodingInterviewPrep #SoftwareDevelopment #DailyCoding #C++

🚀 Day 19/50 | LeetCode Coding Challenge Today's problem: Maximum Frequency After Operations - A challenging medium-level problem that tested my optimization skills! 💡 The Challenge: Given an array and k operations, we can add values in range [-k, k] to selected indices. The goal? Maximize the frequency of any element. 🎯 Key Learnings: 1️⃣ Binary Search Optimization: Replaced O(n²) nested loops with binary search using lower_bound/upper_bound - reduced complexity from O(n²) to O(n log n) 2️⃣ Two-Pointer Technique: Implemented sliding window to efficiently find valid ranges where elements can be transformed 3️⃣ Integer Overflow Awareness: Used long long for calculations with values up to 10⁹ to prevent overflow errors 4️⃣ Multiple Strategies: Combined two approaches: Keeping existing values unchanged Transforming all elements to a new target value ⚡ The Result: ✅ 633/633 test cases passed ✅ Time complexity: O(n log n) ✅ Optimized from TLE to accepted solution 🔥 Biggest Takeaway: When you hit Time Limit Exceeded, don't give up! Analyze your bottlenecks: Identify nested loops → Consider binary search or two pointers Watch for repeated computations → Use preprocessing Always handle edge cases (overflow, boundary conditions) The journey from brute force to optimal solution taught me more than just getting it right the first time ever could. Day 19 ✅ | 31 more days to go 💪 Shishir chaurasiya and PrepInsta #100DaysOfCode #CodingChallenge #LeetCode #DSA #ProblemSolving #SoftwareEngineering #CPlusPlus #Algorithms #TechJourney #LearningInPublic

🚀 Day 8 of #120DaysOfCode — String to Integer (atoi) 🧩 Today’s challenge was LeetCode Problem 8: “String to Integer (atoi)”, a classic string parsing problem that teaches how to handle input conversion safely and efficiently — something we often take for granted in programming. 🧠 Problem Summary: We need to implement the myAtoi(string s) function that converts a string into a 32-bit signed integer. The function must: Ignore leading whitespaces Handle optional + or - signs Extract the number until a non-digit is found Clamp (limit) the value within the 32-bit integer range Return the final integer result 📘 Example: Input → " -042" Output → -42 ⚙️ Approach I Used: I solved this problem using a step-by-step parsing approach: Trim spaces: Move through the string to skip leading whitespaces. Check the sign: If the next character is '-', mark the sign as negative, otherwise positive. Convert characters to digits: Loop through the characters while they are digits and build the result (result = result * 10 + digit). Handle overflow: Before updating the result, check if adding another digit would exceed the 32-bit integer range ([-2³¹, 2³¹ - 1]). Return the final value: Apply the sign and return the integer. This approach ensures correctness, prevents overflow, and follows a clean linear-time logic with O(n) complexity and O(1) space. 💡 Key Learning: Even a simple-looking task like string-to-integer conversion involves careful consideration of edge cases, boundaries, and input validation — all critical in real-world software systems. 💬 Next Goal: Continue improving my problem-solving skills with more logic-building and string manipulation challenges! #100DaysOfCode #120DaysOfCode #LeetCode #CProgramming #ProblemSolving #CodingChallenge #DeveloperJourney #LearningEveryday

🔹 DSA Daily | Check for Balanced Parentheses (C++) Balanced parentheses problems are a classic way to test your understanding of **stacks** and **logical thinking**. Today, I solved one such problem — checking if a string of parentheses, braces, and brackets is balanced. 💡 Problem Statement: Given a string containing '(', ')', '{', '}', '[' and ']', determine if the string is **balanced**. A string is balanced if every opening bracket has a corresponding closing bracket in the correct order. Approach: I used a **stack** to keep track of opening brackets.   - Push every opening bracket onto the stack.   - For closing brackets, check if the top of the stack has the matching opening bracket.   - If it does, pop it; otherwise, the string is unbalanced.   - At the end, if the stack is empty, the string is balanced. Time Complexity: O(n) — traversing the string once   Space Complexity: O(n) — for the stack  This problem highlights how **stacks make bracket-matching elegant and efficient**. 🚀 #DSA #CPlusPlus #Coding #ProblemSolving #Stack #BalancedParentheses #CodeEveryday #GeeksforGeeks #LeetCode #ProgrammingJourney #DataStructures #Algorithms #InterviewPrep #CodingCommunity #LogicBuilding #EfficientCode #LearnToCode #TechJourney

📌 Day 35/150 – Remove Nth Node From End of List (LeetCode #19) Today’s problem was a classic linked list challenge that tested my understanding of two-pointer techniques — a powerful pattern for solving traversal-based problems efficiently. ⚙️ The task? Given the head of a linked list, remove the n-th node from the end and return the updated list. At first glance, it seems simple — just find the node from the end and delete it. But the twist lies in doing it in a single pass for optimal performance. 🚀 🔹 Brute Force Idea Traverse the list once to count total nodes, then again to remove the (length–n)th node. ✅ Easy to implement ❌ Requires two passes → not optimal 🔹 Optimal Approach – Two Pointer Technique To achieve this in one pass, we use two pointers: fast and slow. 👉 Move the fast pointer n steps ahead. 👉 Then move both fast and slow together until fast reaches the end. 👉 The slow pointer will be just before the target node — remove it cleanly. This elegant trick ensures we traverse the list only once! 🧠 Example: Input: head = [1, 2, 3, 4, 5], n = 2 Output: [1, 2, 3, 5] Here, the 2nd node from the end (4) is removed using the one-pass logic. ⏱️ Time Complexity: O(L) 📦 Space Complexity: O(1) 💡 Learning: Linked list problems often look tricky because of pointer manipulation, but patterns like slow & fast pointers simplify them beautifully. Recognizing and reusing such patterns across problems is a major step in mastering DSA. 💪 #150DaysOfCode #LeetCode #ProblemSolving #LinkedList #TwoPointer #CodingChallenge #SoftwareEngineering #DSA #Cplusplus #Developers #TechCommunity #LearningJourney 🚀

Solved LeetCode Problem #22: Generate Parentheses, a classic example of using backtracking and recursion to generate valid combinations. The problem reinforced how powerful state tracking can be — deciding when to add an opening or closing parenthesis based on previous choices ensures every combination remains valid. What I really enjoyed about this problem is how it visually represents the beauty of recursion — every path explores a new possibility, but only valid paths make it to the final answer. 🔍 Key Takeaways: Backtracking is not about brute force, but smart exploration. Maintaining the right balance between open and close parentheses is the core idea. Visualizing recursion as a decision tree really helps in understanding the flow. It’s one of those problems that looks simple on the surface but beautifully demonstrates how clean logic can solve complex combinations. #LeetCode #Cplusplus #Backtracking #Recursion #ProblemSolving #DSA #CodingJourney #LogicBuilding

LeetCode 217: Contains duplicate ⁇ Suppose you have a list of numbers, and you want to know if any number appears more than once. It’s like making sure everyone in class has a unique roll number! Approach 1: Set - Go through each number. - If it’s not in your set, add it. - If you ever see a number already in your set, you’ve got a duplicate! Approach 2: Hash Table (Counter) - Use a Counter to count how often each number appears in the list. - If any number appears more than once, return True (there’s a duplicate). Complexity: - Time Complexity: O(n) — One pass through all numbers. - Space Complexity: O(n) — Storing seen numbers or counts. Both approaches are fast and effective for catching duplicates quickly! Let’s check our numbers and make sure everyone’s unique! Check out the problem here: https://lnkd.in/g-JgRTEn Keep going, keep revising, and keep building confidence! 💪🔥 #DSA #Coding #ProblemSolving #Learning

🚀 Day 17 of #100DaysofCode Challenge! 🚀 🔍 What is Dynamic Programming (DP), and why does it matter? I recently watched Aditya Verma’s introductory video on DP and here are the highlights: • DP is an optimization over naïve recursion — it’s about identifying when you’re solving the same sub-problem repeatedly, and instead reuse those results (overlapping sub-problems + optimal substructure). • The typical workflow: start with a recursive solution, notice repeated work → switch to memoization (top-down) → then possibly convert to tabulation (bottom-up). • The key mindset shift: Think in terms of subproblem states and transitions/choices — that’s what lets you build from smaller results to the full solution. • Use DP when brute force recursion is too slow and when the problem naturally splits into smaller pieces whose optimal solutions combine. • Base cases, initialization, and correct ordering (especially in bottom-up) are crucial — you can’t just “DP-ify” any recursion without thinking about these. #Day17 #DynamicProgramming #Algorithms #ProblemSolving #CodingMindset #SoftwareEngineering #AdityaVerma #CodingJourney