🚀 23-Sep-2020

Author: sureshmangs

competitive programming/leetcode/1365. How Many Numbers Are Smaller Than the Current Number.cpp

@@ -0,0 +1,88 @@
+Given the array nums, for each nums[i] find out how many numbers in the array are smaller than it. That is, for each nums[i] you have to count the number of valid j's such that j != i and nums[j] < nums[i].
+
+Return the answer in an array.
+
+
+
+Example 1:
+
+Input: nums = [8,1,2,2,3]
+Output: [4,0,1,1,3]
+Explanation:
+For nums[0]=8 there exist four smaller numbers than it (1, 2, 2 and 3).
+For nums[1]=1 does not exist any smaller number than it.
+For nums[2]=2 there exist one smaller number than it (1).
+For nums[3]=2 there exist one smaller number than it (1).
+For nums[4]=3 there exist three smaller numbers than it (1, 2 and 2).
+Example 2:
+
+Input: nums = [6,5,4,8]
+Output: [2,1,0,3]
+Example 3:
+
+Input: nums = [7,7,7,7]
+Output: [0,0,0,0]
+
+
+Constraints:
+
+2 <= nums.length <= 500
+0 <= nums[i] <= 100
+
+
+
+
+// Brute Force
+
+class Solution {
+public:
+    vector<int> smallerNumbersThanCurrent(vector<int>& nums) {
+        vector<int> res;
+
+       int n=nums.size();
+
+        for(int i=0;i<n;i++){
+            int cnt=0;
+            for(int j=0;j<n;j++){
+                if(i!=j && nums[j]<nums[i])
+                    cnt++;
+            }
+            res.push_back(cnt);
+        }
+
+        return res;
+    }
+};
+
+
+
+
+// Optimized
+// Store the count in a bucket and take the running sum.
+
+class Solution {
+public:
+    vector<int> smallerNumbersThanCurrent(vector<int>& nums) {
+        vector<int> res;
+        vector<int> freq(101, 0);
+
+        int n=nums.size();
+
+        for(auto &x :nums)
+            freq[x]++;
+
+        for(int i=1;i<101;i++){
+            freq[i]+=freq[i-1];
+        }
+
+        for(int i=0;i<n;i++){
+            if(nums[i]==0){
+                res.push_back(0);
+            } else {
+                res.push_back(freq[nums[i]-1]);
+            }
+        }
+
+        return res;
+    }
+};

competitive programming/leetcode/1389. Create Target Array in the Given Order.cpp

@@ -0,0 +1,65 @@
+Given two arrays of integers nums and index. Your task is to create target array under the following rules:
+
+Initially target array is empty.
+From left to right read nums[i] and index[i], insert at index index[i] the value nums[i] in target array.
+Repeat the previous step until there are no elements to read in nums and index.
+Return the target array.
+
+It is guaranteed that the insertion operations will be valid.
+
+
+
+Example 1:
+
+Input: nums = [0,1,2,3,4], index = [0,1,2,2,1]
+Output: [0,4,1,3,2]
+Explanation:
+nums       index     target
+0            0        [0]
+1            1        [0,1]
+2            2        [0,1,2]
+3            2        [0,1,3,2]
+4            1        [0,4,1,3,2]
+Example 2:
+
+Input: nums = [1,2,3,4,0], index = [0,1,2,3,0]
+Output: [0,1,2,3,4]
+Explanation:
+nums       index     target
+1            0        [1]
+2            1        [1,2]
+3            2        [1,2,3]
+4            3        [1,2,3,4]
+0            0        [0,1,2,3,4]
+Example 3:
+
+Input: nums = [1], index = [0]
+Output: [1]
+
+
+Constraints:
+
+1 <= nums.length, index.length <= 100
+nums.length == index.length
+0 <= nums[i] <= 100
+0 <= index[i] <= i
+
+
+
+
+
+
+class Solution {
+public:
+    vector<int> createTargetArray(vector<int>& nums, vector<int>& index) {
+        vector<int> res;
+
+        int n=nums.size();
+
+        for(int i=0;i<n;i++){
+            res.insert(res.begin()+index[i], nums[i]);
+        }
+
+        return res;
+    }
+};

competitive programming/leetcode/1512. Number of Good Pairs.cpp

@@ -0,0 +1,59 @@
+Given an array of integers nums.
+
+A pair (i,j) is called good if nums[i] == nums[j] and i < j.
+
+Return the number of good pairs.
+
+
+
+Example 1:
+
+Input: nums = [1,2,3,1,1,3]
+Output: 4
+Explanation: There are 4 good pairs (0,3), (0,4), (3,4), (2,5) 0-indexed.
+Example 2:
+
+Input: nums = [1,1,1,1]
+Output: 6
+Explanation: Each pair in the array are good.
+Example 3:
+
+Input: nums = [1,2,3]
+Output: 0
+
+
+Constraints:
+
+1 <= nums.length <= 100
+1 <= nums[i] <= 100
+
+
+
+
+
+
+class Solution {
+public:
+    int numIdenticalPairs(vector<int>& nums) {
+        unordered_map<int, int> m;
+        for(auto &num: nums){
+            m[num]++;
+        }
+
+        int res=0;
+
+        for(auto [num, freq]: m){
+            if(freq>1){
+                res+=(freq*(freq-1))/2;
+            }
+        }
+
+        return res;
+    }
+};
+
+
+
+//We can just count each value. Then, n elements with the same value can form n * (n - 1) / 2 pairs.
+
+