Find All Duplicates in Array with Cyclic Placement Pattern

LeetCode 287: Find the Duplicate Number Solved LeetCode 287 — Find the Duplicate Number. The problem gives an array containing n + 1 integers where each number is in the range [1, n]. Since there are more numbers than the available range, one number must repeat, and the task is to find that duplicate. Approach — Cyclic Placement Idea The key observation is that numbers belong to the range 1 to n, meaning each value ideally belongs at the index value − 1. The idea is: - Take an element and check whether it is already placed at its correct index. - If not, swap it with the element at its correct position. - Continue this process until the correct position already contains the same value. When the element's correct position already holds the same number, that value is the duplicate. This works because: - Every number is supposed to appear only once. - If the correct index already contains the same value, it means another copy of that number exists. Accepted on LeetCode. #leetcode #dsa #algorithms #javaprogramming #problemSolving #learninginpublic

LeetCode 448: Find All Numbers Disappeared in an Array Solved LeetCode 448 — Find All Numbers Disappeared in an Array. The problem gives an array of size n, where each number is in the range [1, n]. Some numbers appear twice, while others are missing. The task is to return all the numbers from the range 1 to n that do not appear in the array. Approach — Cyclic Placement Pattern Since every number belongs to the range 1 to n, each value should ideally be placed at the index value − 1. The process works as follows: - Traverse the array and try placing each element at its correct index. - If the current number is already at the correct position, or the correct position already contains the same value (duplicate case), move forward. - Otherwise, swap the element with the number at its correct index. After this placement phase: - Scan the array once more. - Any index where nums[i] ≠ i + 1 indicates that the number i + 1 is missing. This approach keeps the solution: - O(n) time - O(1) extra space (excluding the result list) Accepted on LeetCode. #leetcode #dsa #algorithms #javaprogramming #problemSolving #learninginpublic

LeetCode 645: Set Mismatch Solved LeetCode 645 — Set Mismatch. Originally, the array should contain numbers from 1 to n, each appearing exactly once. But due to an error, one number appears twice, and one number is missing. The task is to identify both values. Approach — Cyclic Placement Since the numbers belong to the range 1 to n, each value should ideally be placed at index value − 1. The steps are: - Traverse the array and try placing each number at its correct index. - If the current number is not at its correct position and the correct index does not already contain the same number, swap them. - Otherwise move forward. After this placement phase: - Scan the array again. - If an index i does not contain i + 1, then: - nums[i] is the duplicate number - i + 1 is the missing number This works because the duplicate prevents the correct number from occupying its proper position. Accepted on LeetCode. #leetcode #dsa #algorithms #javaprogramming #problemSolving #learninginpublic

🧠 LeetCode 1784 ✅ Check if Binary String Has at Most One Segment of Ones 📊 Difficulty: Easy 💡 Approach: The goal is to check whether the binary string contains more than one segment of consecutive 1s. If the pattern 01 appears anywhere in the string, it means a segment of 1s ended and another segment of 1s started later, which violates the condition. So we simply scan the string and check for the pattern 0 followed by 1. If found → return false, otherwise → true. ⚡ Complexity: • Time: O(n) • Space: O(1) 🏆 Submission Result: 🚀 Runtime: 0 ms (Beats 100%) Consistency in solving small problems helps sharpen pattern recognition in larger algorithmic challenges. #LeetCode #DataStructures #Algorithm #LearningInPublic #ProblemSolving #CodingPractice #Cpp

#100DaysLeetCode Day 32 ✅ Solved LeetCode 169: Majority Element The task is to find the element that appears more than ⌊n/2⌋ times in the array. 🚀 Approach Used the Boyer–Moore Voting Algorithm. Idea: Maintain a candidate (majority element) and a count. If count becomes 0, update the candidate. If current element equals candidate → increase count. Otherwise → decrease count. Because the majority element appears more than half of the time, it will remain the final candidate. Time Complexity: O(n) Space Complexity: O(1) #100DaysLeetCode #Day32 #LeetCode169 #leetcode #cpp #dsa #arrays #algorithm #problemSolving #coding #interviewprep

🚀 Day 7/100 — LeetCode Challenge Solved Search in Rotated Sorted Array II At first, it feels similar to the previous rotated array problem, but duplicates make it harder to decide which half is sorted. 💡 Key idea: 1) Normally, one half is always sorted 2) But with duplicates, we can get stuck when low == mid == high 3) In that case, we shrink the search space from both ends 4) Otherwise, identify the sorted half and proceed like binary search 👉 Small change, but big impact on logic. 🧠 Time Complexity: Average: O(log n) Worst case: O(n) (due to duplicates) 💾 Space Complexity: O(1) Learning that small edge cases can completely change how an algorithm behaves. Staying consistent. #LeetCode #DSA #100DaysOfCode #Cpp #BinarySearch #CodingJourney

🚀 LeetCode Daily Challenge 🧩 Problem: Complement of Base 10 Integer You are given a non-negative integer n. Your task is to return the complement of its binary representation. The complement means: Flip every bit in the binary representation 1 → 0 0 → 1 Important: The complement is applied only up to the most significant bit of n, not the full 32 bits. 🎯 Goal Convert the number to binary, flip all the bits, and return the decimal value of the complemented binary number. Example: n = 5 Binary representation: 5 → 101 Complement: 010 Result: 2 🧠 Key Intuition To compute the complement correctly: Find the highest set bit in the number. Only flip bits within that range. 🛠 Approach 1️⃣ Handle edge case If n == 0, return 1. 2️⃣ Find the number of significant bits using __builtin_clz(). 3️⃣ Traverse each bit of n: If the bit is 1 → append 0 If the bit is 0 → append 1 4️⃣ Reverse the generated binary string. 5️⃣ Convert the complemented binary string back to decimal. 📈 Complexity Analysis Time Complexity: O(log n) Space Complexity: O(log n) 🔗 Problem https://lnkd.in/d9QWqaKw 💻 Solution https://lnkd.in/d654Dvie #LeetCode #Cpp #DSA #BitManipulation #ProblemSolving #CodingChallenge #Algorithms #LeetCodeDailyChallenge #CompetitiveProgramming #CodingJourney 

Day 16 of #30DaysOfLeetCode Solved LeetCode Problem #69 – Sqrt(x) using C. Problem: Given a non-negative integer x, return the square root of x rounded down to the nearest integer. The solution must not use built-in functions like sqrt() or pow(). Approach I used: • Applied Binary Search to find the integer square root • Searched within the range 0 to x • Compared mid * mid with x • If it was smaller → moved right • If it was larger → moved left • Stored the last valid value as the final answer Performance: • Runtime: 0 ms • Memory: 9.06 MB What I learned today: • How binary search can be used for mathematical problems • Importance of choosing the correct data type (long) to avoid overflow • Better understanding of efficient problem-solving techniques • Staying consistent every day is making the problems easier to solve #LeetCode #DSA #Algorithms #BinarySearch #CProgramming #ProblemSolving 

🚀 LeetCode 1758 — Minimum Changes To Make Alternating Binary String Today’s problem focuses on recognizing patterns in binary strings. 🔹 A binary string is alternating if no two adjacent characters are the same. Valid patterns can only be: 010101... 101010... 💡 Key Insight Instead of constructing both patterns, we can compare the string with just one pattern (0101...) and count mismatches. "01"[i & 1] helps generate the expected character at index i. ops → number of changes required to convert the string to 0101... n - ops → changes required to convert it to 1010... The answer is simply the minimum of these two values. ⚡ Time Complexity: O(n) 💾 Space Complexity: O(1) 🧠 Idea: Count mismatches with one alternating pattern and derive the other automatically. #LeetCode #DSA #Algorithms #BinaryString #CodingPractice #ProblemSolving #CompetitiveProgramming

Day 14/90 #90DaysOfDSA 🚀 LeetCode Problem Solved – Two Sum II (Sorted Array) Today I solved the Two Sum II problem using the Two Pointer Technique. 🔹 Key Idea: Since the array is already sorted, we can avoid extra space like hash maps and instead use two pointers. 🔹 Approach: • Place one pointer at the start and another at the end of the array. • Calculate the sum of both elements. • If the sum equals the target → return the indices. • If the sum is smaller → move the left pointer forward. • If the sum is larger → move the right pointer backward. 📌 Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 💡 Insight: Whenever a problem involves a sorted array and pair finding, the two-pointer approach is often the most efficient solution. #LeetCode #DSA #ProblemSolving #CodingPractice #Algorithms #Cpp #SoftwareEngineering