Add set mismatch problem

Author: sudheerj

README.md

@@ -64,6 +64,7 @@ List of Programs related to data structures and algorithms
 | 23  | Disappeared numbers                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/23.disappearedNumbers/disappearedNumbers.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/23.disappearedNumbers/disappearedNumbers.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/23.disappearedNumbers/disappearedNumbers.md)        | Easy | Array traversal |
 | 24  | Identical pairs                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/24.identicalPairs/identicalPairs.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/24.identicalPairs/identicalPairs.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/24.identicalPairs/identicalPairs.md)        | Easy | Array traversal & map |
 | 25  | Destination City                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/25.destinationCity/destinationCity.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/25.destinationCity/destinationCity.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/25.destinationCity/destinationCity.md)        | Easy | Array traversal & set |
+| 26  | Set mismatch                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/26.setMismatch/setMismatch.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/25.setMismatch/setMismatch.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/26.setMismatch/setMismatch.md)        | Easy | Array traversal & marking numbers |
 
 ### String
 

src/java1/algorithms/array/destinationCity/DestinationCity.md

@@ -26,7 +26,7 @@ This problem is solved with the help of array traversal and hash set for storing
 
 2. Initialize a `fromCities` set variale to store the list of from cities in paths. The given paths array is traversed and `fromCities` is populated with all from city values. 
 
-3. Iterate over given array(`path`) agin, return the toCity value as destination city if that city doesn't exist inside `fromCities`. This is because only destination city cannot have a outgoing path.
+3. Iterate over given array(`path`) again, return the toCity value as destination city if that city doesn't exist inside `fromCities`. This is because only destination city cannot have a outgoing path.
 
 **Time and Space complexity:**
 This algorithm has a time complexity of `O(n)`, where `n` is the number of path elements in an array. This is because we need to iterate over all the elements at most twice for finding the destination city.

src/java1/algorithms/array/setMismatch/SetMismatch.java

@@ -0,0 +1,35 @@
+package java1.algorithms.array.setMismatch;
+
+import java.util.Arrays;
+
+public class SetMismatch {
+    private static int[] findDuplicateAndMissing(int[] nums){
+        int length = nums.length;
+        int duplicate = -1;
+        int missing = -1;
+
+        for (int num : nums) {
+            num = Math.abs(num);
+            if(nums[num-1]<0) {
+                duplicate = num;
+            } else {
+                nums[num-1] = -nums[num-1];
+            }
+        }
+
+        for (int i=0; i< length; i++) {
+            if(nums[i]>0) {
+                missing = i+1;
+            }
+        }
+
+        return new int[]{duplicate, missing};
+    }
+    public static void main(String[] args) {
+        int[] nums1 = new int[]{1,3,3,4};
+        int[] nums2 = new int[]{1,1};
+
+        System.out.println(Arrays.toString(findDuplicateAndMissing(nums1)));
+        System.out.println(Arrays.toString(findDuplicateAndMissing(nums2)));
+    }
+}

src/java1/algorithms/array/setMismatch/SetMismatch.md

@@ -0,0 +1,31 @@
+**Description:**
+Given an integer array `nums` representing a set of numbers, where the set originally contained all integers from 1 to `n`. However, due to an error, one number in the set has been duplicated, and one number is missing. Find the duplicated number and the missing number in the array.
+
+### Examples
+Example 1:
+
+Input: nums = [1,3,3,4]
+Output: [ 3, 2 ]
+
+Example 2:
+
+Input: nums = [1,1]
+Output: [ 1, 2 ]
+
+**Algorithmic Steps**
+This problem is solved with the help of array traversal and marking the numbers which exists by negating them. The algorithmic approach can be summarized as follows:
+
+1. Create a function named `findDuplicateAndMissing`, which accepts input array(`nums`) to find the duplicated and missing numbers in the form of an array.
+   
+2. Calculate integers length with in `length` variable, and initialize `duplicated` and `missing` numbers to -1. 
+   
+3. Iterate over given array(`nums`) to find the duplicated value through marking of each number.
+   
+4. Iterate over given array(`nums`) again to find the missing number by checking each number is greater than zero or not.
+   
+5. Return an array with duplicated and missing values in the form of an array.
+
+**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 twice for finding the duplicated and missing numbers.
+ 
+It takes constant time complexity of `O(1)` without using any datastructures other than constant variables.

src/java1/algorithms/hashmap/minOperationsAlternating/MinOperationsAlternating.java

@@ -0,0 +1,5 @@
+package java1.algorithms.hashmap.minOperationsAlternating;
+
+public class MinOperationsAlternating {
+    
+}

src/java1/algorithms/hashmap/minOperationsAlternating/MinOperationsAlternating.md

@@ -26,7 +26,7 @@ This problem is solved with the help of array traversal and hash set for storing
 
 2. Initialize a `fromCities` set variale to store the list of from cities in paths. The given paths array is traversed and `fromCities` is populated with all from city values. 
 
-3. Iterate over given array(`path`) agin, return the toCity value as destination city if that city doesn't exist inside `fromCities`. This is because only destination city cannot have a outgoing path.
+3. Iterate over given array(`path`) again, return the toCity value as destination city if that city doesn't exist inside `fromCities`. This is because only destination city cannot have a outgoing path.
 
 **Time and Space complexity:**
 This algorithm has a time complexity of `O(n)`, where `n` is the number of path elements in an array. This is because we need to iterate over all the elements at most twice for finding the destination city.

src/javascript/algorithms/array/25.destinationCity/destinationCity.md

@@ -0,0 +1,27 @@
+function findDuplicateAndMissing(nums){
+    const length = nums.length;
+    let duplicate = -1;
+    let missing = -1;
+
+    for (let num of nums) {
+        num = Math.abs(num);
+        if(nums[num-1]<0) {
+            duplicate = num;
+        } else {
+            nums[num-1] = -nums[num-1];
+        }
+    }
+
+    for (let i=0; i<length; i++) {
+        if(nums[i] >0) {
+            missing = i+1;
+        }
+    }
+
+    return [duplicate, missing];
+}
+
+const nums1 = [1,3,3,4];
+const nums2 = [1,1];
+console.log(findDuplicateAndMissing(nums1));
+console.log(findDuplicateAndMissing(nums2));

src/javascript/algorithms/array/26.setMismatch/setMismatch.js

@@ -0,0 +1,31 @@
+**Description:**
+Given an integer array `nums` representing a set of numbers, where the set originally contained all integers from 1 to `n`. However, due to an error, one number in the set has been duplicated, and one number is missing. Find the duplicated number and the missing number in the array.
+
+### Examples
+Example 1:
+
+Input: nums = [1,3,3,4]
+Output: [ 3, 2 ]
+
+Example 2:
+
+Input: nums = [1,1]
+Output: [ 1, 2 ]
+
+**Algorithmic Steps**
+This problem is solved with the help of array traversal and marking the numbers which exists by negating them. The algorithmic approach can be summarized as follows:
+
+1. Create a function named `findDuplicateAndMissing`, which accepts input array(`nums`) to find the duplicated and missing numbers in the form of an array.
+   
+2. Calculate integers length with in `length` variable, and initialize `duplicated` and `missing` numbers to -1. 
+   
+3. Iterate over given array(`nums`) to find the duplicated value through marking of each number.
+   
+4. Iterate over given array(`nums`) again to find the missing number by checking each number is greater than zero or not.
+   
+5. Return an array with duplicated and missing values in the form of an array.
+
+**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 twice for finding the duplicated and missing numbers.
+ 
+It takes constant time complexity of `O(1)` without using any datastructures other than constant variables.

src/javascript/algorithms/array/26.setMismatch/setMismatch.md

@@ -0,0 +1,3 @@
+function minOperations(){
+    
+}