Add identical pairs problem

Author: sudheerj

src/java1/algorithms/array/identicalPairs/IdenticalPairs.java

@@ -0,0 +1,29 @@
+package java1.algorithms.array.identicalPairs;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class IdenticalPairs {
+    private static int findIdenticalPairs(int[] nums){
+        int count = 0;
+        Map<Integer, Integer> frequencyMap = new HashMap<>();
+
+        for (int num : nums) {
+            if(frequencyMap.containsKey(num)) {
+                count += frequencyMap.get(num);
+            }
+            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) +1);
+        }
+
+        return count;
+    }
+    public static void main(String[] args) {
+        int[] nums1 = new int[]{6, 3, 1, 5, 3, 6, 5, 6};
+        int[] nums2 = new int[]{2, 2, 2, 2};
+        int[] nums3 = new int[]{1, 2, 3, 4};
+
+        System.out.println(findIdenticalPairs(nums1));
+        System.out.println(findIdenticalPairs(nums2));
+        System.out.println(findIdenticalPairs(nums3));
+    }
+}

src/java1/algorithms/array/identicalPairs/IdenticalPairs.md

@@ -0,0 +1,38 @@
+**Description:**
+Given an integer array `nums`, find the number of identical pairs. 
+
+**Note:** A pair `(i, j)` is called identical if `nums[i] == nums[j]` and `i < j`.
+
+### Examples
+Example 1:
+
+Input: nums = [6, 3, 1, 5, 3, 6, 5, 6]
+Output: 5
+
+Example 2:
+
+Input: nums = [2, 2, 2, 2],
+Output: 6
+
+Example 2:
+
+Input: nums = [1, 2, 3, 4],
+Output: 0
+
+**Algorithmic Steps**
+This problem is solved with the help of array traversal and map for storing the frequency of each number. The algorithmic approach can be summarized as follows:
+
+1. Create a function named `findIdenticalPairs`, which accepts input array(`nums`) to find the number of identical pairs.
+   
+2. Initialize a `count` variale to 0, which indicates the number of identical pairs, and a frequency map(`frequencyMap`) to count the occurrances of each number in an array.
+   
+3. Iterate over given array(`num`), add the the number of times a number appeared to count variable if the number has been appeared before.
+
+4. Increment the current number appeared by 1.
+   
+5. Return `count` variable, which indicate the number of identical paris formed.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of elements in an array. This is because we need to iterate over all the elements at most once for finding the identical pairs.
+ 
+It takes constant time complexity of `O(n)` due to a map additional datastructure for storing the frequency of each number.

src/javascript/algorithms/array/24.identicalPairs/identicalPairs.js

@@ -0,0 +1,23 @@
+function findIdenticalPairs(nums){
+    let count = 0;
+    let frequencyMap = {};
+
+    for (const num of nums) {
+        if(frequencyMap[num]) {
+            count += frequencyMap[num];
+            frequencyMap[num]++;
+        } else {
+            frequencyMap[num] = 1;
+        }
+    }
+
+    return count;
+}
+
+const nums1 = [6, 3, 1, 5, 3, 6, 5, 6];
+const nums2 = [2, 2, 2, 2];
+const nums3 = [1, 2, 3, 4];
+
+console.log(findIdenticalPairs(nums1));
+console.log(findIdenticalPairs(nums2));
+console.log(findIdenticalPairs(nums3));

src/javascript/algorithms/array/24.identicalPairs/identicalPairs.md

@@ -0,0 +1,38 @@
+**Description:**
+Given an integer array `nums`, find the number of identical pairs. 
+
+**Note:** A pair `(i, j)` is called identical if `nums[i] == nums[j]` and `i < j`.
+
+### Examples
+Example 1:
+
+Input: nums = [6, 3, 1, 5, 3, 6, 5, 6]
+Output: 5
+
+Example 2:
+
+Input: nums = [2, 2, 2, 2],
+Output: 6
+
+Example 2:
+
+Input: nums = [1, 2, 3, 4],
+Output: 0
+
+**Algorithmic Steps**
+This problem is solved with the help of array traversal and map for storing the frequency of each number. The algorithmic approach can be summarized as follows:
+
+1. Create a function named `findIdenticalPairs`, which accepts input array(`nums`) to find the number of identical pairs.
+   
+2. Initialize a `count` variale to 0, which indicates the number of identical pairs, and a frequency map(`frequencyMap`) to count the occurrances of each number in an array.
+   
+3. Iterate over given array(`num`), add the the number of times a number appeared to count variable if the number has been appeared before.
+
+4. Increment the current number appeared by 1.
+   
+5. Return `count` variable, which indicate the number of identical paris formed.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of elements in an array. This is because we need to iterate over all the elements at most once for finding the identical pairs.
+ 
+It takes constant time complexity of `O(n)` due to a map additional datastructure for storing the frequency of each number.