Solved LeetCode 1614: Maximum Nesting Depth of Parentheses

📅 Day 32 of #100DaysOfCode Problem: Design HashSet (LeetCode 705) Approach: 1️⃣ Used a boolean vector of fixed size (1,000,001) to represent presence or absence of elements directly by index. 2️⃣ add(key) marks the key as true, meaning it’s present in the set. 3️⃣ remove(key) simply resets the value to false. 4️⃣ contains(key) checks presence in O(1) time using direct indexing — super efficient and clean! #100DaysOfCode #LeetCode #DSA #ProblemSolving #Cplusplus #CodingChallenge #HashSet #DataStructures #Algorithms #CodeNewbie #Programming #DeveloperLife #SoftwareEngineering #LearningInPublic #TechCommunity #KeepLearning #CodingJourney #Motivation #Efficiency

📅 Day 33 of #100DaysOfCode Problem: Basic Calculator (LeetCode 224) Approach: 1️⃣ Parsed the string character by character, keeping track of current number, sign, and result. 2️⃣ When encountering '+' or '-', added the previous number to the result and reset the current number. 3️⃣ Used a stack to handle parentheses — pushed the current result and sign when '(' was found, then restored them after ')'. 4️⃣ Carefully computed the final result by adding the last pending number after traversal. #100DaysOfCode #LeetCode #DSA #ProblemSolving #Stack #Cplusplus #CodingChallenge #Algorithms #Math #CodeNewbie #Programming #SoftwareEngineering #CodingJourney #TechCommunity #DeveloperLife #KeepLearning #LearningInPublic #Motivation

🚀 Day 46 of #100DaysOfCode 📌 LeetCode 844 — Backspace String Compare Today I tackled a problem that looks simple but exposes whether you can simulate string editing efficiently. 🧠 My Intuition Instead of building and modifying strings directly (which is messy and inefficient), I treated the input like a real typing scenario: Use a stack to simulate typing. Push normal characters. Pop when a # appears (acting as backspace). Build the final strings for both inputs and compare them. This makes the whole process clean and avoids unnecessary edge-case headaches. 🔥 Takeaway: When dealing with “string editors,” stacks simplify life. You avoid messy manual string manipulation and let the stack handle the backtracking for you. #leetcode #dsa #javacoding #codingjourney #100daysofcode #leetcode844 #programming

🚀 Day 62 of LeetCode150DaysChallenge Problem: Rotate a Linked List Right #DSA #LeetCode #CodingChallenge #LinkedList #C++ #Programming #150DaysOfCode #LearnDSA #SDEJourney Topic: Linked List Given the head of a linked list, we need to rotate it to the right by k places. Similar to rotate an array by k elements For example: Input: 1 → 2 → 3 → 4 → 5, k = 2 Output: 4 → 5 → 1 → 2 → 3 🔍 Intuition: Rotating a linked list is basically bringing the last k nodes to the front. To do that efficiently, we need to understand: The length (n) of the list. The point of split (at position n - k). Reconnect the parts properly. 🧠 Step-by-Step Approach: Find the length of the list. Compute k = k % n to handle rotations larger than the list size. Break the list at the (n - k)th node. Reverse both halves for easier concatenation. Join them, and finally reverse the whole list back to get the rotated version. This clever use of the reverse operation avoids complex pointer adjustments! ⏱️ Time Complexity: O(n) – one traversal to find length, and a few reversals. 💾 Space Complexity: O(1) – in-place manipulation. 💡 Key Takeaway: This problem beautifully shows how reversing sublists can simplify complex pointer operations. Mastering linked list manipulations like these builds strong problem-solving intuition! 💪

🔥 Day 83 of My LeetCode Journey – Problem 242: Valid Anagram Today’s problem focused on one of the most classic string challenges — determining whether two strings are anagrams of each other. An anagram means both strings contain the same characters with the same frequency, just arranged differently. 💡 Concept: If two strings have identical character counts for every letter, they’re anagrams. Common approaches include: Using a frequency counter (hash map or array) Sorting both strings and comparing them directly ✅ Key Takeaways: Strengthened logic around hash maps and string frequency counting Learned efficient ways to compare large datasets of characters Reinforced time-space optimization techniques for string problems Small problems like this one help sharpen attention to detail and analytical accuracy, key skills for every programmer 🚀 #LeetCode #ProblemSolving #100DaysOfCode #DSA #Cplusplus #CodingChallenge #Anagram #Programming #LogicBuilding #LearningEveryday

🌟 Day 82 of My LeetCode Journey – Problem 796: Rotate String Today’s challenge was quite interesting — checking if one string can become another through rotation! In this problem, we determine whether rotating a string s by any number of positions can produce another string goal. 💡 Concept: If s and goal are of the same length, then goal must be a substring of s + s. Example: s = "abcde" and goal = "cdeab" 👉 s + s = "abcdeabcde" — and since "cdeab" is inside, it’s a valid rotation! ✅ Key Takeaways: Reinforced string manipulation and substring search logic. Understood how concatenation can simplify complex rotation checks. A great reminder that sometimes the simplest ideas lead to elegant solutions. Every problem adds one more step to mastering logic and pattern recognition 💪 #LeetCode #ProblemSolving #100DaysOfCode #DSA #CodingJourney #Cplusplus #Programming #StringManipulation #LearningEveryday

In this program, I used a while loop to print numbers from 1 to 5 and calculate their total sum at the same time. 🔁 It’s a great example of how loops can perform multiple tasks — displaying numbers and performing calculations in one go! 🚀 ✨ Concepts Used: ➡️ Variable initialization (c = 1, sum = 0) ➡️ While loop condition (c <= 5) ➡️ Increment operators (c = c + 1, sum = sum + 1) ➡️ Output using printf() This simple logic builds the foundation for more complex algorithms in programming! 💪 #CProgramming #WhileLoop #CodingPractice #LearnToCode #ProgrammingBasics #CodeJourney #ProblemSolving 💻

🔥 Day 70 of #100DaysOfCode 🔥 💡 Problem: Number of Steps to Reduce a Number to Zero – LeetCode ✨ Approach: A simple while loop logic — divide the number by 2 if it’s even, else subtract 1. Repeated until it hits zero. Clean, elegant, and lightning fast! ⚡ 📊 Complexity Analysis: Time Complexity: O(log n) – each division by 2 halves the number Space Complexity: O(1) – constant space ✅ Runtime: 0 ms (Beats 100%🔥) ✅ Memory: 41.95 MB 🚀 Key Takeaway: Sometimes, brilliance lies in simplicity — clear logic, powerful performance! #LeetCode #100DaysOfCode #ProblemSolving #CodingChallenge #Programming #DSA #LogicBuilding #Efficiency #CodeDaily #DeveloperJourney

From Arrays and Linked Lists to Graphs and Tries, each structure organizes data differently and serves unique real-world purposes — from managing browser history and social networks to building file systems and dictionaries. Whether you’re coding algorithms or optimizing applications, knowing when to use the right structure makes all the difference. Start small, visualize often, and build your foundation strong. 💡 #DataStructures #Programming #SoftwareEngineering #LearnToCode #TechEducation

📅 Day 51 of #100DaysOfCode Problem: Number of Substrings That Satisfy (LeetCode 3280) Approach: 1️⃣ Precomputed cumulative counts of 1s using a prefix sum array. 2️⃣ For each substring [i...j], calculated both the number of 0s and 1s. 3️⃣ Used a smart optimization: If (zero² > one), skip forward — those substrings can’t satisfy the condition. If (zero² == one) or (zero² < one), count and move ahead efficiently. 4️⃣ This drastically reduced redundant iterations compared to a naïve O(n³) brute force. #100DaysOfCode #LeetCode #DSA #ProblemSolving #Cplusplus #CodingChallenge #Algorithms #MathLogic #BinaryString #Programming #DeveloperLife #CodingJourney #CodeNewbie #DailyDSA #SoftwareEngineering #KeepLearning #GrowthMindset #Motivation #TechCommunity