Solved LeetCode problem: Single Element in a Sorted Array

✅Day 80 of #100DaysOfLeetCode 1.📌Problem: Set Mismatch You are given an array that represents a set of integers from 1 1 to n n, but due to an error, one number is duplicated and another is missing. The task is to find the duplicated number and the missing number and return them as an array. 2.🟢 Difficulty: Easy 3.📍Topic: Hashing,Array 4.🎯 Goal: Find the number that occurs twice and the number that is missing, then return them in an array. 5.🧠 key idea: Approach 1: Use a HashMap to count occurrences of each number in the input array. Identify the duplicated number by finding the one which appears twice. Compute the total sum expected (n(n+1)/2 n(n+1)/2) and compare with the actual sum (excluding the duplicate). The missing number equals the difference between the expected total and the corrected actual sum. Return the duplicate and missing numbers as the result array. #LeetCode #100DaysOfCode #CodingChallenge #Java #Programming #InterviewPrep #Algorithms #DataStructures #Hashing #ProblemSolving #Array #SoftwareEngineering #TechCareers #LearnToCode #CodeNewbie #DailyCode #ChallengeYourself

✅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 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

Day 53 of My DSA Challenge Problem: Find the pair in an array whose sum is closest to and less than or equal to a given target. Approach: Instead of checking every possible pair (O(N²)), I optimized the solution using the Two-Pointer Technique. Sort the array. Initialize two pointers — one at the start and one at the end. Move the pointers based on the sum compared to the target: If the sum is less than or equal to the target, record it and move the left pointer forward. If the sum exceeds the target, move the right pointer backward. This ensures that every pair is checked efficiently, and the closest valid sum is captured. Complexity: Time: O(N log N) (due to sorting) Space: O(1) #Day53 #DSAChallenge #TwoPointers #Sorting #Optimization #ProblemSolving #DSA #Java #CodingChallenge #Algorithms #DataStructures #100DaysOfCode #GeeksforGeeks #LeetCode #ProgrammingJourney #CodingCommunity

✅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 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

📌 Day 23/100 – Squares of a Sorted Array (LeetCode 977) 🔹 Problem: Given a sorted integer array (may contain negatives), return a new array of the squares of each number, sorted in non-decreasing order. 🔹 Approach (Two Pointers): Since negative values become positive when squared, the largest values will be at either end of the array. So we: Use left and right pointers Compare squares → place the larger one at the end of result array Move pointers inward and fill result from back to front This avoids sorting again and keeps the solution O(n). 🔹 Time & Space Complexity: ⏱️ Time: O(n) 💾 Space: O(n) (result array) 🔹 Key Learnings: ✅ Two-pointer technique helps avoid extra sorting ✅ Always think about value transformation (like negative → squared) ✅ Filling from the back is a smart trick when maintaining sorted order #100DaysOfCode #LeetCode #Java #DSA #ProblemSolving #CodingJourney #TwoPointers #Programming

Day 48 of #50DaysOfLeetCodeChallenge Problem : Daily Temperatures 💡Approach: Used a monotonic stack to store indices of temperatures. For each day, I checked if the current temperature is higher than the one at the top of the stack. If yes, that means we’ve found a warmer day — so I popped the index and calculated the number of days waited. This gave an efficient O(n) solution instead of checking every pair. 🔥Key Takeaways: Learned how stacks can simplify problems involving “next greater element.” Improved understanding of monotonic structures and how they reduce unnecessary comparisons. Continuing my journey of learning, growing, and coding every day! #LeetCode #50DaysOfCode #Java #DataStructures #Stack #ProblemSolving #CodeToLearn #CharuCodes

💻 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 21 of #100DaysOfLeetCode – Unique Binary Search Trees 🌳 Today’s challenge was all about counting how many structurally unique BSTs can be formed using n distinct numbers. 🧮 This problem beautifully blends dynamic programming and combinatorial logic — where the number of unique trees for each n depends on the possible root positions and their left/right subtree combinations. ⚙️ 💡 Key takeaway: Dynamic programming helps in reusing subproblem results efficiently — making even complex recursive patterns simpler and faster! 🚀 #LeetCode #100DaysChallenge #BinarySearchTree #DynamicProgramming #ProblemSolving #CodingJourney #Java #DataStructures