Day 93 of #100DaysofCoding 😊

🔸 Day 55 of #100DaysOfCode & #DrGVishwanathan Challenge! 📌 Today’s Problem: Leetcode 3333. Find the Original Typed String II 🧠 Problem Summary: Alice, while typing a string, might have held down some keys too long, causing some characters to repeat. You're given: A final word that includes these possible repeated characters. An integer k — the minimum length of the original string Alice intended to type. Our task is to count the number of valid original strings of size at least k that could result in word after possibly holding down some keys multiple times. Return the result modulo 10^9 + 7. 🔍 Approach & Insight: ✅ Step 1: Segment into Groups Group consecutive identical characters — e.g., "aaabbc" → [3, 2, 1] Each group contributes to the number of ways we can choose how many times a character was actually typed. If a appears 3 times in a group, the original could have had 1 to 3 as. ✅ Step 2: Total Combinations For each group with length x, we have x options (typed it once, twice...up to x times). Multiply these together for total ways to generate any possible string. ✅ Step 3: Remove Invalid Ones Now, using dynamic programming, we remove the combinations where the total original length is less than k. dp[s] = number of ways to get a string of length s ✅ Final Answer = Total - Invalid (mod MOD) 📦 Time & Space Complexity: Time: O(n * k) where n = number of groups Space: O(k) using DP with rolling arrays 🧠 Tricky Part: Careful handling of modular arithmetic and constraints on minimum original string size. 💡 Takeaway from Today: This problem is a beautiful blend of combinatorics + dynamic programming. The key was to break down what affects valid typing into discrete, countable possibilities, and then eliminate invalid ones using state transitions. Let’s keep this consistency going! 🚀 On to Day 56... #Leetcode #CodingChallenge #100DaysOfCode #DynamicProgramming #Combinatorics #ProblemSolving #Cpp #DailyCode #SoftwareEngineering #TechJourney #LinkedInCodingLogs

Day 10 of my #100DaysOfCode journey I solved a problem today! Problem: "Reverse Integer" – Given a signed 32-bit integer x, reverse its digits and return the result. If the reversed number overflows the 32-bit signed integer range [-2³¹, 2³¹ - 1], return 0. Do not use 64-bit integers. Used Approach: ◾ Extract digits using modulus: digit = x % 10 ◾ Remove last digit using division: x /= 10 ◾ Build reversed number: rev = rev * 10 + digit ◾Check for overflow/underflow before updating rev: 🔸 If rev > INT_MAX/10 or rev == INT_MAX/10 && digit > 7, return 0 🔸 If rev < INT_MIN/10 or rev == INT_MIN/10 && digit < -8, return 0 ◾Return final reversed number if no overflow occurs Complexity Analysis: ⏳ Time: O(log x) ⌛ Space: O(1) #CodingQuints #CodingChallenge #GirlsWhoCode #PlacementPrep #C #Leetcode #BeUnstoppable #100DaysOfCode

🚀 Day 45 of #100DaysOfLeetCode 🎯 Problem: Search in Rotated Sorted Array II (LeetCode 81) 🔍 Problem Statement: You're given a sorted array that may be rotated at an unknown pivot and can contain duplicates. Determine if a target exists in the array in O(log N) time on average. -> nums = [2, 5, 6, 0, 0, 1, 2], target = 0 Output: true 💡 Intuition Behind the Approach: We apply a modified binary search, but need to handle cases where duplicates make it unclear which side is sorted. --> Normal logic: If nums[left] <= nums[mid], the left part is sorted, Else, the right part is sorted. --> BUT when nums[left] == nums[mid] == nums[right] to shrink the search space safely. --> left++, right-- nums = [1, 1, 1, 1, 1, 1, 2, 1, 1] target = 2 In this case, we can’t determine whether the left or right half is sorted, so we shrink the search space #DSA #BinarySearch #LeetCode #RotatedArray #Coding #100DaysOfCode #ProblemSolving #TechJourney #LearningEveryday #Day45

🧠 LeetCode Algorithm - Minimum Window Substring 📌 Problem: Given two strings s and t, return the minimum window in s which contains all the characters in t. 🔍 Approach: Sliding window + character count tracking using ASCII map. 🔍 Algorithm (Sliding Window + ASCII Map) 💡 Step-by-step logic: StepAction 1️⃣Build a frequency map of string t characters using ASCII (map[charCode]++) 2️⃣Use a sliding window with two pointers (left and right) 3️⃣Move right pointer to expand the window, decreasing map[charCode] 4️⃣When all chars from t are covered (count == 0), try to shrink from left 5️⃣Update minLen and start if a smaller window is found 6️⃣Return the substring from start to start + minLen 📈 Performance: ✅ Accepted in 9ms, beating 97.83% on runtime 📉 Memory usage: 59.05 MB, better than 78.93% 🧪 Tested on 268 cases 🔢 Example: s = "ADOBECODEBANC", t = "ABC" 🟢 Output: "BANC" #LeetCode #TypeScript #Coding #ProblemSolving #SoftwareDeveloper #Frontend #100DaysOfCode #KannanCodes #TwoPointers #Algorithms

Day 2 of LeetCode Challenge: Maximum Length of Valid Subsequence! 🚀 Today’s problem was a fascinating one—finding the longest valid subsequence where the sum of every consecutive pair has the same parity (odd or even). Problem Statement Given an array nums, a subsequence is valid if: (sub[i] + sub[i+1]) % 2 is the same for all consecutive pairs. Example: nums = [1,2,1,1,2,1,2] → Longest valid subsequence is [1,2,1,2,1,2] (length 6). Approach All Odd or All Even Subsequence If all elements are odd or all are even, every consecutive pair sum is even (0). Alternating Odd & Even Subsequence If subsequence alternates between odd and even, every consecutive pair sum is odd (1). Key Insight: Track two types of sequences: ☑️Same parity (allOdd, allEven). ☑️Alternating parity (lengthStartOdd, lengthStartEven). Time & Space Complexity Time: O(n) → Single pass through the array. Space: O(1) → Constant extra space. Key Takeaways ✔ Parity matters—odd/even sums determine validity. ✔ Dynamic tracking of sequences simplifies the problem. ✔ Edge cases (all odd/even or alternating) must be considered. #LeetCode #CodingChallenge #Algorithm #Java #DynamicProgramming #ProblemSolving Let me know your thoughts or optimizations! 🔥👇

🚀 Day 48 of #100DaysOfLeetCode 🎯 Problem: Search a 2D Matrix (LeetCode 74) 🔍 Problem Statement: You're given an m x n matrix where: Each row is sorted in non-decreasing order. The first integer of each row is greater than the last integer of the previous row. Return true if the target exists in the matrix, otherwise false. Brute Force --> Traversing in Matrix Time: O(m × n) Optimized Binary Search Approach By treating the 2D matrix as a virtual 1D sorted array, we apply binary search Time: O(log(m × n)) #DSA #100DaysOfCode #Matrix #BinarySearch #ProblemSolving #Coding #Cpp #Leetcode

#LeetCode #19_Remove_Nth_Node_From_End_of_List. 🧠 LeetCode Problem Solved: Remove Nth Node From End of List (Medium) Today, I tackled an important linked list problem using the two-pointer (fast & slow) approach to efficiently remove the N-th node from the end in a single pass. 🔍 Problem: Given the head of a singly linked list, remove the N-th node from the end of the list and return the head. ✅ Key Takeaways: * Utilized a dummy node to handle edge cases (e.g. removing the head). * Leveraged O(n) time and O(1) space complexity. * Reinforced my understanding of pointer manipulation and memory management in C. 💡 This pattern (two-pointer gap technique) is extremely helpful in many real-world scenarios involving singly linked lists. #LeetCode #LinkedList #CProgramming #ProblemSolving #Algorithms #DataStructures #CodingPractice #100DaysOfCode

#24day of #100daychallengecode 🔎 LeetCode 153: Find Minimum in Rotated Sorted Array When a sorted array is rotated at an unknown pivot, how do you efficiently find the minimum element? The catch: You must do it in O(log n) time! 💡 Key Insight: In a rotated sorted array, one half is always sorted. The minimum element will always lie in the unsorted part. --- 🧠 Approach (Binary Search): 1. Use low and high pointers. 2. Find mid. 3. Compare: If nums[mid] > nums[high], the minimum lies to the right → low = mid + 1 Else, the minimum is on the left (or mid) → high = mid 4. Finally, nums[low] is the minimum element. --- 🧪 Example: Input: [3,4,5,1,2] Output: 1 📈 Time Complexity: O(log n) 📦 Space Complexity: O(1) 🔁 This is a perfect twist on traditional binary search and a great example of thinking in halves when working with rotated arrays. --- 🔖 Hashtags: #LeetCode #BinarySearch #DSAwithedslash #CodingChallenge #JavaDeveloper #ProblemSolving #TechInterview #ProgrammingLogic #100DaysOfCode #CodeNewbie #LearnToCode #CodingSkills #DataStructures #InterviewPreparation #edslash edSlash

🔹 LeetCode Challenge – Day 4 🔹 📌 Problem: Valid Perfect Square 🎯 Challenge: Given a positive integer num, determine if it’s a perfect square without using built-in sqrt functions. 🧠 Solution Breakdown: ⚡ Optimized Approach (Binary Search): 1️⃣ Binary Search Setup: Search Space: left = 1, right = num Mid Calculation: Avoid overflow with mid = left + (right - left) / 2 2️⃣ Key Operations: Square Check: Compare mid² with num Adjust Boundaries: Narrow down search space based on comparison 3️⃣ Edge Handling: Early return for num = 0 or 1 Overflow Prevention: Use long for squaring mid 🔍 Key Insights: ✅ Efficiency: O(log n) time complexity → Far faster than brute-force O(√n) No extra space (O(1)) → In-place checks ✅ Binary Search Mastery: Demonstrates how to adapt BS for non-array problems Terminates early if exact square is found ✅ Avoiding Overflow: Critical for large numbers (e.g., num = 2^31 - 1) 📊 Performance: Time: O(log n) Space: O(1) #LeetCode #Algorithms #BinarySearch #Java #Programming #Optimization #DSA #CodingInterview #TechSkills #100DaysOfCode #Day4

#DSAChallenge ✅ Problem 1: Check if a Pair Exists Problem: Given a sorted array and a target value, determine whether there exists a pair of elements whose sum equals the target. Intuition: Start with two pointers — one at the beginning and one at the end. By comparing the sum with the target and adjusting the pointers accordingly (move left if sum is too large, right if too small), you can find the pair in O(n) time — far better than the O(n²) brute-force method! Why it works: The array is sorted, so we can trust that moving pointers inward brings us closer to the right combination. 🔢 Problem 2: Count All Valid Pairs Problem: Given a sorted array and a target, count how many distinct index pairs (i, j) exist such that arr[i] + arr[j] == target and i ≠ j. The Twist: This time, not just finding one pair — we want to count all valid pairs, even with duplicates involved. Key Insight: Still use the two-pointer technique, but now track how many times a value is repeated at the left and right ends. Multiply the counts of those duplicates → to find how many index pairs they form. Bonus: If all values between left and right are the same, use the formula nC2 = n(n-1)/2 to count all pairings in one shot. ✨ What I Learned: Two-pointer is simple yet powerful. Sorted arrays + smart movement = clean and optimized solutions. Knowing when and how to handle duplicates is key! #DSA #Java #TwoPointers #CodingPractice #ProblemSolving #InterviewPrep #Leetcode #WomenInTech#LearningInPublic #InterviewPreparation #CodingJourney #100DaysOfCode #CodeNewbie #DataStructures #Algorithms #SoftwareEngineering #CodeWithMe #DevCommunity #GirlsWhoCode #CodeDaily #ProgrammingTips