Solved Set Mismatch problem in 80 days of LeetCode

✅Day 62 of #100DaysOfLeetCode 📌Problem: You are given a sorted array consisting of only integers where every element appears exactly twice, except for one element which appears exactly once. 🟠 Difficulty: Medium 📍Topic: Array, Binary Search 🎯 Goal: Return the single element that appears only once in O(log n) time and O(1) space. 🧠key idea: Approach 1: The problem can be efficiently solved using a modified binary search. The core logic relies on the properties of the sorted array. If we are at an even index, its duplicate pair should be at the next (odd) index. If we are at an odd index, its pair should be at the previous (even) index. By examining the middle element and its neighbor, we can determine if the single, non-duplicated element lies in the left or right half of the array, allowing us to discard one half in each step and achieve a logarithmic time complexity. #100DaysOfCode #LeetCode #CodingChallenge #Java #DataStructures #Algorithms #BinarySearch #ProblemSolving #SoftwareDeveloper #TechJobs #DeveloperLife #CodeNewbie #Programming #LearnToCode #JobSeekers

✅Day 74 of #100DaysOfLeetCode 1.📌Problem: Reverse Vowels of a String 2.🟩 Difficulty: Easy 3.📍Topic: Two Pointers 4.🎯 Goal: Given a string, reverse only the vowels in the string and return the modified string. Vowels include 'a', 'e', 'i', 'o', 'u' in both lower and upper cases. 5.🧠key idea: Approach 1: Use two pointers, one starting from the beginning and one from the end. Move towards each other, swap the vowels found at each pointer, and continue until all vowels are reversed. #LeetCode #CodingChallenge #100DaysOfCode #Algorithms #TechCareers #CodeNewbie #WomenWhoCode #Java #Programming #DailyCoding #Developer #InterviewPrep #TwoPointers #DataStructures #LearnToCode #ProblemSolving

📌 Day 3/100 - Remove Duplicates from Sorted Array (LeetCode 26) 🔹 Problem: Given a sorted array, remove the duplicates in-place so that each element appears only once and return the new length. You must modify the array without using extra space for another array. 🔹 Approach: I used a simple counting-based approach: Iterate through the array using a single loop. If the current element is the same as the next, skip it. Otherwise, place it at the current count index and increment count. Finally, return count as the number of unique elements. 🔹 Key Learning: Practiced in-place array modification efficiently without extra space. Improved understanding of loop-based filtering logic. Realized that sometimes the simplest linear approach works best! Consistency compounds — each problem adds a new layer of confidence! 🚀#100DaysOfCode #LeetCode #Java #ProblemSolving #Array #DSA #TwoPointers

💻 Day 69 of #LeetCode100DaysChallenge Solved LeetCode 264: Ugly Number II a dynamic programming problem that improves sequence generation and pointer-based optimization skills. 🧩 Problem: An ugly number is a positive integer whose prime factors are limited to 2, 3, and 5. Given an integer n, return the n-th ugly number. 💡 Approach — Dynamic Programming with Three Pointers: 1️⃣ Maintain an array dp where dp[i] stores the i-th ugly number. 2️⃣ Use three pointers p2, p3, and p5 to track multiples of 2, 3, and 5 respectively. 3️⃣ At each step, choose the smallest of dp[p2]*2, dp[p3]*3, and dp[p5]*5 as the next ugly number. 4️⃣ Increment the corresponding pointer(s) to avoid duplicates. 5️⃣ Continue until the nth ugly number is found. ⚙️ Complexity: Time: O(N) — one pass to generate all ugly numbers Space: O(N) — for storing the sequence ✨ Key Takeaways: ✅ Strengthened understanding of pointer-based DP techniques. ✅ Learned how to efficiently generate sorted multiplicative sequences. ✅ Practiced optimization over brute-force factor checking. #LeetCode #100DaysOfCode #Java #DynamicProgramming #TwoPointers #Math #DSA #ProblemSolving #CodingJourney #WomenInTech

✅ Day 120: Shortest Common Supersequence Today’s #nationskillup challenge was a beautiful Dynamic Programming problem 🔗 — focused on finding the length of the smallest string that has both given strings as subsequences. ⚡ Problem Statement: Given two strings s1 and s2, find the length of the shortest string which has both s1 and s2 as its subsequences. 🧠 Example: Input: s1 = "geek", s2 = "eke" Output: 5 Explanation: "geeke" has both "geek" and "eke" as subsequences. 💡 Approach Summary: This problem is based on the Longest Common Subsequence (LCS) concept. If we know the length of LCS, we can derive the length of the Shortest Common Supersequence (SCS) as: SCS=m+n−LCS where: m = length of s1 n = length of s2 We compute LCS using DP with space optimization by maintaining only two arrays — prev and curr. 🔹 Recurrence Relation: if (s1[i-1] == s2[j-1])   curr[j] = 1 + prev[j-1]; else   curr[j] = Math.max(prev[j], curr[j-1]); 🔹 Time Complexity: O(m × n) 🔹 Space Complexity: O(n) 🤝 Thanks to GeeksforGeeks and Sandeep Jain Sir for such elegant problems that strengthen core DP skills! 🙌 Shoutout to Jagan Mohan Jangam for keeping the #nationskillup streak alive 🚀 📚 Course Link: https://lnkd.in/gyueNByH #skillupwithgfg #nationskillup #DynamicProgramming #Java #GeeksforGeeks #CodingChallenge #CodeEveryday

✅Day 83 of #100DaysOfLeetCode 📌Problem: Given a binary array and an integer k, return true if all 1's are at least k places away from each other, otherwise return false. 🟢 Difficulty: Easy 📍Topic: Array 🎯 Goal: Check if all 1's in the array are at least k positions apart. 🧠 Key idea: Approach 1: Iterate through the array, track the position of the previous 1, and for each new 1, calculate the distance from the previous 1. If the distance is less than k at any point, return false. Otherwise, return true after the loop ends. #LeetCode #CodingChallenge #100DaysOfCode #DataStructures #Algorithms #Array #Java #CodingInterview #Programmers #DailyCoding #CodeNewbie #TechCareers #ProblemSolving #CodeChallenge

📌 Day 18/100 - Valid Palindrome (LeetCode 125) 🔹 Problem: Determine whether a string reads the same forward and backward, ignoring case and non-alphanumeric characters. 🔹 Approach: Implemented a two-pointer technique. Skipped all non-alphanumeric characters. Compared characters from both ends in lowercase. Returned true if all matched, otherwise false. 🔹 Key Learning: Two-pointer method keeps logic clean and efficient. Character handling is key when data isn’t uniform. Time complexity: O(n), Space complexity: O(1). Sometimes, solving elegantly is better than solving fast. ✨ #100DaysOfCode #LeetCode #Java #ProblemSolving #DSA #CodingJourney

🔥 Day 84 of #100DaysDSAChallenge 📌 Topic: Array — Squares of a Sorted Array ✅ Problem Solved on #LeetCode: 977. Squares of a Sorted Array (🟢 Easy) 💡 Key Learnings: • Strengthened understanding of the two-pointer technique for sorted array manipulation. • Learned to efficiently handle both negative and positive numbers when squaring values. • Optimized time complexity from O(n²) to O(n) by eliminating nested loops. • Enhanced focus on writing clean, readable, and efficient Java code. 🚀 Consistency Builds Clarity: Every problem you solve sharpens your logical thinking and builds confidence. Keep learning, improving, and moving forward — one problem at a time 💪 🏷️ #Day84 #100DaysChallenge #100DaysDSAChallenge #LeetCode #Java #CodingChallenge #ProblemSolving #DataStructures #Algorithms #Arrays #Programming #LearningJourney #10kCoders #10000Coders #Consistency #LogicBuilding

28/30days✅ #2427 Number of Common Factors The logic behind the Number of Common Factors problem is simple yet efficient. The goal is to find how many numbers can divide both given integers a and b without leaving a remainder. To achieve this, I first identify the smaller of the two numbers using Math.min(a, b) since no common factor can be greater than the smaller value. Then, I use a loop that runs from 1 up to that number and check for each value whether it divides both a and b completely (a % i == 0 && b % i == 0). If it does, it’s counted as a common factor. Finally, the program returns the total count of such numbers. For example, if a = 12 and b = 6, the common factors are 1, 2, 3, and 6, giving the output 4. This approach is easy to implement, logically clear, and works efficiently for all valid inputs. #LeetCode #Java #Coding #ProblemSolving

✅Day 71 of #100DaysOfLeetCode 1.📌Problem: Number of 1 Bits Given a positive integer n, write a function that returns the number of set bits in its binary representation (also known as the Hamming weight). 2.🟢 Difficulty: Easy 3.📍Topic: Bit Manipulation 4.🎯 Goal: Find the number of '1' bits present in the binary representation of the given integer n. 5.🧠 Key idea: Approach 1: Keep dividing n by 2 and count if the remainder is 1. This counts the number of 1's in binary form by repeatedly checking and incrementing a counter. A simple while-loop approach that efficiently solves the problem for any positive integer n.image.jpg #100DaysOfCode #LeetCode #CodingChallenge #BitManipulation #DataStructures #Algorithms #Java #Programming #Tech #CodeNewbie #InterviewPrep #LeetCodeEasy #ProblemSolving #LearnToCode #Developer