C++ Code To Find An Index Where This Is A Hash Collision

1. Import vectors, unordered sets, and IO libraries as needed.
2. Function findCollisionIndex (a, P):
            a. Create a blank set called buckets.
            b. For every item in the array P[k]:
                        i. Use the modulo operation to calculate the bucket for P[k]: bucket = P[k] % a.
                        ii. Return I as the collision index if the bucket is located within the set buckets.
                        iii. If not, place the bucket into the designated buckets.
c. Return -1 if, after processing every element, no collision is discovered.
3. Main function:
a. Declare the variables a and n; 
b. Read the input for a and n; 
c. Make an array P that is empty and has size n;
d. Read the input for the P elements. 
e. Make use of findCollisionIndex(a, P) and assign collisionIndex to the outcome.
f. If the collisionIndex is not equal to -1:
                       print- "Collision is found at index no: " + collisionIndex.
             g.otherwise,
 	           print- "No collision found".
4. End of Algorithm

#include<iostream>
#include<vector>
#include<unordered_set>
int findColl (int a, const std::vector<int>& P) {
    std::unordered_set<int> buckets; 
     for (int i = 0; i < P.size(); ++i)
      {
           int bucket = P[i] % a; 
           if (buckets.find(bucket) != buckets.end())
           {
            return i;
        }
        buckets.insert(bucket);
    }
    return -1; // No collision
}
int main() {
    int a;
    std::cout << "Enter the number of buckets (a): ";
    std::cin >> a;
    int n;
    std::cout << "Enter the number of elements in the array (n): ";
    std::cin >> n;
    // Input the elements of the array (P)
    std::vector<int> P(n); 
    std::cout << "Enter the elements of the array:" << std::endl; 
    for (int i = 0; i < n; ++i) {
        std::cin >> P[i];
    }
    int collisionIndex = findColl(a, P);
    if (collisionIndex != -1) {
        std::cout << "Collision found at index: " << collisionIndex << std::endl;
    } else {
        std::cout << "No collision found." << std::endl;
    }
    return 0;
}

a:= size of P 
Create an array called Arr with the size n, then fill it with ?0? 
initialize: i = 0; when i < n, update (increase I value by 1), do: 
z = P[i] 
If Arr[z mod n] is not equal to zero,
then 
                return i
            increase  Arr[z mod n] by 1
return i

#include<iostream>
#include<vector>
#include<unordered_set>
int findCollisionIndex(int n, const std::vector<int>& P) 
{
       std::vector<int> arr(n, 0); 
       for (int i = 0; i < P.size(); ++i) 
       {
        int z = P[i];
        int bucket = z % n;
        if (arr[bucket] != 0) {
            return i;
        }
        arr[bucket]++;
    }
    return -1;
}
int main() {
    int n, x;   
    // Input the number of buckets (n)
    std::cout << "Enter the number of buckets (n): ";
    std::cin >> n;
    // Input the number of elements in the array (x) 
    std::cout << "Enter the number of elements in the array (x): ";
    std::cin >> x;
    // Input the elements of the array (P)
    std::vector<int> P(n); 
    std::cout << "Enter the elements of the array:" << std::endl; 
    for (int i = 0; i < x; ++i) {
        std::cin >> P[i];
    }
    // Find the collision index and print the result
    int collisionIndex = findCollisionIndex(n, P);
    if (collisionIndex != -1) {
        std::cout << "Collision found at index: " << collisionIndex << std::endl;
    } else {
        std::cout << "No collision found." << std::endl;
    }
    return 0;
}