The Goal:

The goal of this problem is often to find the number that appears more than once.

int findDuplicate(vector<int>& nums) {

        sort(nums.begin(),nums.end());


        for(int i = 0 ; i<nums.size()-1 ; i++){
            if(nums[i] == nums[i+1]){
                return nums[i] ; 
            }
            
        }
        return -1 ;
        
}

Step-by-Step Explanation:

1. Initialization:

   int answerIndex = -1;

    
   • answerIndex is initialized to -1. This variable is used to store the index of the duplicate number if found.

2. Iterating Through the Array:

   for (int i = 0; i < nums.size(); i++)

   A loop is used to iterate through each element of the nums array.

3. Accessing the Absolute Value of Current Element:

   int currentIndex = abs(nums[i]);

    
   • currentIndex is assigned the absolute value of the current element in nums. This is necessary because we might have already marked some elements as negative

4. Checking if the Element at currentIndex is Already Visited:

   if (nums[currentIndex] < 0) { return currentIndex; }
   • If the element at currentIndex is negative, it means this index has been visited before, indicating a duplicate. Hence, currentIndex is returned as the duplicate number.

5. Marking the Element as Visited:

    nums[currentIndex] *= -1;
   • If the element at currentIndex is not negative, we mark it as visited by multiplying it by -1, making it negative.

6. Returning the Result:

   return answerIndex;
   • If no duplicate is found after the loop (which should not happen according to the problem constraints), answerIndex is returned, which is -1. However, in the context of the problem, there will always be a duplicate, so this line should theoretically never execute.

FINALLY !

Consider the array [1, 3, 4, 2, 2].

1. Initial array: [1, 3, 4, 2, 2]
2. First iteration (i = 0):
   • currentIndex = abs(nums[0]) = abs(1) = 1
   • Mark nums[1] as negative: [1, -3, 4, 2, 2]
3. Second iteration (i = 1):
   • currentIndex = abs(nums[1]) = abs(-3) = 3
   • Mark nums[3] as negative: [1, -3, 4, -2, 2]
4. Third iteration (i = 2):
   • currentIndex = abs(nums[2]) = abs(4) = 4
   • Mark nums[4] as negative: [1, -3, 4, -2, -2]
5. Fourth iteration (i = 3):
   • currentIndex = abs(nums[3]) = abs(-2) = 2
   • Mark nums[2] as negative: [1, -3, -4, -2, -2]
6. Fifth iteration (i = 4):
   • currentIndex = abs(nums[4]) = abs(-2) = 2
   • Since nums[2] is negative, it means we've seen this index before.
   • Return currentIndex = 2 as the duplicate number.

• Start by setting a default answer:

  • We'll start by assuming that we haven't found any duplicate, so we set answerIndex to -1.

• Loop through each element in the array:

  • We'll look at each element in the array one by one.

• Find the index that corresponds to the current element:

  • For each number in the array, we'll use its absolute value to find the index it points to.

• Check if the element at this index has been visited before:

  • If the value at the found index is already negative, it means we've visited this index before, indicating a duplicate number.

• Mark the index as visited:

  • If it's not negative, we mark it as visited by multiplying the value at that index by -1.

• Return the duplicate number if found:

  • If we find a negative value at the index, we return that index as the duplicate number.