Solved LeetCode 282 with backtracking and recursion

🚀 Day 7 of #120DaysOfCode Challenge 💡 Problem: Reverse Integer (LeetCode #7 | Medium) 📄 Problem Statement: Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes it to go outside the signed 32-bit integer range [-2³¹, 2³¹ - 1], then return 0. 🧩 My Approach: Extract the last digit of x using % 10. Build the reversed number step by step using rev = rev * 10 + digit. Carefully check for overflow before multiplying or adding — using INT_MAX and INT_MIN limits to ensure the reversed number stays valid. If overflow is detected, return 0. 🔍 Key Learnings: How to handle integer overflow without using 64-bit variables. Importance of edge case testing and boundary conditions. Reinforced understanding of modulus (%) and integer division (/) operations. 🔥 Progress: Day 7 / 120 📚 Language: C 🏁 Problem Solved: Reverse Integer (LeetCode #7) Every problem is a small step toward stronger logic and cleaner code! 💪 #100DaysOfCode #120DaysOfCode #CodingChallenge #LeetCode #CProgramming #ProblemSolving #LearnEveryday #BuildInPublic

I recently tackled LeetCode 2654 – Minimum Number of Operations to Make All Array Elements Equal to 1. Most solutions simulate every operation. The approach that worked for me came from stepping back and thinking mathematically: 1️⃣ If there’s already a 1 in the array, it can be spread to all other elements efficiently. 2️⃣ If no 1 exists, find the shortest subarray whose GCD is 1 – creating a 1 from that subarray is the minimal first step. 3️⃣ Once a 1 exists, the rest follows in a straightforward way. It’s a reminder that sometimes understanding the structure of a problem beats brute-force coding. And here’s a little validation: ✅ Runtime: 1ms, beats 100% of submissions ✅ Memory: 56.1MB, beats 100% of submissions For anyone doing coding challenges or preparing for interviews, focus on insights like these – they often save more time than writing extra lines of code. #ProblemSolving #Algorithms #CodingMindset #LeetCode #SoftwareEngineering

Day 46 — #100DaysOfLeetCode 🚀 Problem: Remove Duplicate Letters (LeetCode 316) ✅ Approach: Used a Stack + Greedy approach to build the smallest lexicographical string with unique letters. ⚡ Complexity: O(n) Learning: Strengthened understanding of stack-based string manipulation and greedy logic 🔠 #LeetCode #100DaysOfCode #DSA #Strings #Stack #GreedyAlgorithm #ProblemSolving #CodingJourney

🌟 Day 93 of My LeetCode Journey — Problem 686: Repeated String Match 💡 Problem Insight: Today’s problem explored how many times string A must be repeated so that string B becomes a substring of it. It’s a fun mix of string repetition and pattern matching — testing both logic and edge-case awareness. 🧠 Concept Highlight: The core idea is to keep repeating A until it’s at least as long as B, then check if B exists within it (or one more repetition). This problem reinforces concepts of string concatenation, searching, and boundary conditions in text processing. 💪 Key Takeaway: Sometimes, solutions aren’t about complexity but about knowing when to stop repeating — in both coding and persistence! ✨ Daily Reflection: Simple problems like these highlight the beauty of algorithmic reasoning — transforming trial-and-error into structured logic. #Day93 #LeetCode #100DaysOfCode #StringMatching #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering #Persistence

🔥 Day 92 of My LeetCode Journey — Problem 28: Find the Index of the First Occurrence in a String 💡 Problem Insight: Today’s problem was about finding the first occurrence of a substring (needle) inside another string (haystack). Essentially, it’s like implementing your own version of the strStr() function — a classic problem in string searching. 🧠 Concept Highlight: This challenge sharpens understanding of string traversal and pattern matching. The intuitive solution uses simple iteration and substring comparison, while the optimized approach can involve algorithms like KMP (Knuth-Morris-Pratt) for efficient searching. 💪 Key Takeaway: Sometimes, even built-in functions hide deep logic beneath simplicity — mastering these fundamentals builds confidence for more advanced string algorithms. ⚙️ Daily Reflection: Every search begins with clarity — whether in code or in life. Precision and patience always lead to the right match. #Day92 #LeetCode #100DaysOfCode #StringSearch #PatternMatching #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering

Day 47 — #100DaysOfLeetCode 🚀 Problem: Reverse Words in a String (LeetCode 151) ✅ Approach: Trim spaces, split the string, reverse the words, and join them back. ⚡ Complexity: O(n) Learning: Improved string handling and manipulation efficiency 🔁 Every line of code adds clarity and confidence 💪 #LeetCode #100DaysOfCode #DSA #Strings #ProblemSolving #CodingJourney

🔹 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 🚀

🚀 LeetCode POTD — 3228. Maximum Number of Operations to Move Ones to the End 🎯 Difficulty: Medium | Topics: Greedy, String Manipulation, Two-Pointer Logic 🔗 Solution Link: https://lnkd.in/gAAxvfFV Today’s #LeetCode Problem of the Day was an interesting greedy + two-pointer problem. We’re given a binary string, and the task is to repeatedly move '1' over blocks of '0' until it reaches either another '1' or the end — and count the maximum operations possible. 🧠 My Approach: The key observation is that every '0' segment contributes operations equal to the number of '1's seen before it. I used a two-pointer technique: l → counts how many '1's we’ve encountered so far r → scans the string Whenever we encounter a '0' block, we add l to the result Every time we see a '1', we increment l This handles all possible valid moves optimally without actually simulating the operations. 💡 Core Idea: 👉 Each '1' can “jump” over every '0' segment that appears after it — the count of such jumps is the total number of operations. 📈 Complexity: Time: O(n) Space: O(1) 💬 Takeaway: Greedy algorithms often work beautifully when you track just the right variables. This problem shows how understanding movement relationships in a sequence can simplify what looks like a complicated operation. #LeetCode #ProblemOfTheDay #StringManipulation #GreedyAlgorithms #TwoPointers #DSA #CodingChallenge #SoftwareEngineering #CodingJourney #TechCommunity #100DaysOfCode

🌿Day 65 LeetCode: Generate Parentheses (22) Approach: Backtracking 🔁 ✨ Used recursion to build all valid combinations of parentheses. At each step, we can add '(' if we still have opens left, and ')' only if it doesn’t make the string invalid (close < open). Backtracking ensures we explore all possible balanced patterns. 📈 Learned how recursive tree exploration helps generate combinations efficiently while maintaining balance and constraints. #LeetCode #100DaysOfCode #Backtracking #Recursion #DSA #CodingJourney #ProblemSolving

🔢 Day 69 of #100DaysOfCode 🔢 🔹 Problem: Maximum Count of Positive and Negative Integers – LeetCode ✨ Approach: A simple yet powerful one-pass solution! Iterated through the array, counting positives and negatives separately — and returned whichever count was greater. Clean, direct, and efficient. ⚡ 📊 Complexity Analysis: Time Complexity: O(n) — single traversal of the array Space Complexity: O(1) — no extra data structures used ✅ Runtime: 1 ms (Beats 12.27%) ✅ Memory: 46.89 MB 🔑 Key Insight: Sometimes, simplicity wins — clarity in logic often outperforms complex tricks. Counting right leads to coding right! 💡 #LeetCode #100DaysOfCode #ProblemSolving #DSA #Array #AlgorithmDesign #LogicBuilding #CodeJourney #ProgrammingChallenge #CodingDaily #Efficiency