🎯 [06 FEB] Added POTD and leet code daily challenge

Author: SunilGudivada

Diff for: geeksForGeeks/POTD/README.md

@@ -12,6 +12,7 @@
 
 |      #          |Problem                          |Link                         |
 |----------------|-------------------------------|-----------------------------|
+|6 February 2021|✴️️️️️️️️️️️️️️ `Minimum Swaps to Sort` | [Problem Link](https://practice.geeksforgeeks.org/problems/minimum-swaps/1)|
 |5 February 2021|✴️️️️️️️️️️️️️️ `Transfiguration` | [Problem Link](https://practice.geeksforgeeks.org/problems/b6b3297ccfb1ad5f66a9c2b92979170417adf114/1)|
 |4 February 2021|🔺️️️️️️️️️️ `Shortest Unique prefix for every word` | [Problem Link](https://practice.geeksforgeeks.org/problems/shortest-unique-prefix-for-every-word/1#)|
 |3 February 2021|✳️️️️️️️️️️ `Excel Sheet - [part -1] ` | [Problem Link](https://practice.geeksforgeeks.org/problems/excel-sheet5448/1#)|

Diff for: geeksForGeeks/POTD/_2022/FEB/_06FEB2022_MinimumSwapstoSort.java

@@ -0,0 +1,62 @@
+package geeksForGeeks.POTD._2022.FEB;
+
+import java.util.*;
+
+/**
+ * @docs https://practice.geeksforgeeks.org/problems/minimum-swaps/1#
+ * Given an array of n distinct elements. Find the minimum number of swaps required to sort the array in strictly increasing order.
+ *
+ *
+ * Example 1:
+ *
+ * Input:
+ * nums = {2, 8, 5, 4}
+ * Output:
+ * 1
+ * Explaination:
+ * swap 8 with 4.
+ * Example 2:
+ *
+ * Input:
+ * nums = {10, 19, 6, 3, 5}
+ * Output:
+ * 2
+ * Explaination:
+ * swap 10 with 3 and swap 19 with 5.
+ *
+ * Your Task:
+ * You do not need to read input or print anything. Your task is to complete the function minSwaps()
+ * which takes the nums as input parameter and
+ * returns an integer denoting the minimum number of swaps required to sort the array.
+ * If the array is already sorted, return 0.
+ *
+ *
+ * Expected Time Complexity: O(nlogn)
+ * Expected Auxiliary Space: O(n)
+ *
+ *
+ * Constraints:
+ * 1 ≤ n ≤ 10^5
+ * 1 ≤ numsi ≤ 106
+ */
+public class _06FEB2022_MinimumSwapstoSort {
+    public int minSwaps(int[] nums)
+    {
+        // Code here
+        int n = nums.length;
+        int[] arr = nums.clone();
+        Arrays.sort(arr);
+        int ans = 0;
+        Map<Integer,Integer> map = new HashMap<>();
+        for(int i=0;i<n;i++) map.put(arr[i],i);
+        for(int i=0;i<n;i++){
+            while(map.get(nums[i])!=i){
+                ans++;
+                int temp = nums[i];
+                nums[i] = nums[map.get(temp)];
+                nums[map.get(temp)] = temp;
+            }
+        }
+        return ans;
+    }
+}

Diff for: leetCode/DailyChallenge/_2022/FEB/_06FEB2022_RemoveDuplicatesfromSortedArrayII.java

@@ -0,0 +1,65 @@
+package leetCode.DailyChallenge._2022.FEB;
+
+/**
+ * @docs https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/
+ *
+ * Given an integer array nums sorted in non-decreasing order,
+ * remove some duplicates in-place such that each unique element appears at most twice.
+ * The relative order of the elements should be kept the same.
+ *
+ * Since it is impossible to change the length of the array in some languages,
+ * you must instead have the result be placed in the first part of the array nums. More formally,
+ * if there are k elements after removing the duplicates, then the first k elements of nums should hold the final result.
+ * It does not matter what you leave beyond the first k elements.
+ *
+ * Return k after placing the final result in the first k slots of nums.
+ *
+ * Do not allocate extra space for another array.
+ * You must do this by modifying the input array in-place with O(1) extra memory.
+ *
+ * Custom Judge:
+ *
+ * The judge will test your solution with the following code:
+ *
+ * int[] nums = [...]; // Input array
+ * int[] expectedNums = [...]; // The expected answer with correct length
+ *
+ * int k = removeDuplicates(nums); // Calls your implementation
+ *
+ * assert k == expectedNums.length;
+ * for (int i = 0; i < k; i++) {
+ *     assert nums[i] == expectedNums[i];
+ * }
+ * If all assertions pass, then your solution will be accepted.
+ *
+ *
+ *
+ * Example 1:
+ *
+ * Input: nums = [1,1,1,2,2,3]
+ * Output: 5, nums = [1,1,2,2,3,_]
+ * Explanation: Your function should return k = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively.
+ * It does not matter what you leave beyond the returned k (hence they are underscores).
+ * Example 2:
+ *
+ * Input: nums = [0,0,1,1,1,1,2,3,3]
+ * Output: 7, nums = [0,0,1,1,2,3,3,_,_]
+ * Explanation: Your function should return k = 7, with the first seven elements of nums being 0, 0, 1, 1, 2, 3 and 3 respectively.
+ * It does not matter what you leave beyond the returned k (hence they are underscores).
+ *
+ *
+ * Constraints:
+ *
+ * 1 <= nums.length <= 3 * 10^4
+ * -104 <= nums[i] <= 10^4
+ * nums is sorted in non-decreasing order.
+ */
+public class _06FEB2022_RemoveDuplicatesfromSortedArrayII {
+    public int removeDuplicates(int[] nums) {
+        int i = 0;
+        for (int n : nums)
+            if (i < 2 || n > nums[i-2])
+                nums[i++] = n;
+        return i;
+    }
+}