Added 2 new Qs

Author: devangi2000

Arrays/CountPairsWithAbsouteDifferenceK2006.cpp

@@ -0,0 +1,68 @@
+// Given an integer array nums and an integer k, return the number of pairs (i, j) where i < j such that |nums[i] - nums[j]| == k.
+
+// The value of |x| is defined as:
+
+// x if x >= 0.
+// -x if x < 0.
+ 
+
+// Example 1:
+
+// Input: nums = [1,2,2,1], k = 1
+// Output: 4
+// Explanation: The pairs with an absolute difference of 1 are:
+// - [1,2,2,1]
+// - [1,2,2,1]
+// - [1,2,2,1]
+// - [1,2,2,1]
+// Example 2:
+
+// Input: nums = [1,3], k = 3
+// Output: 0
+// Explanation: There are no pairs with an absolute difference of 3.
+// Example 3:
+
+// Input: nums = [3,2,1,5,4], k = 2
+// Output: 3
+// Explanation: The pairs with an absolute difference of 2 are:
+// - [3,2,1,5,4]
+// - [3,2,1,5,4]
+// - [3,2,1,5,4]
+ 
+
+// Constraints:
+
+// 1 <= nums.length <= 200
+// 1 <= nums[i] <= 100
+// 1 <= k <= 99
+
+
+// BRUTE FORCE
+
+class Solution {
+public:
+    int countKDifference(vector<int>& nums, int k) {
+        int count = 0;
+        for(int i = 0; i < nums.size() - 1; i++)
+            for(int j = i+1; j < nums.size(); j++)
+                if(abs(nums[j] - nums[i]) == k)
+                    ++count;
+        return count;
+    }
+};
+
+// HASHING
+
+class Solution {
+public:
+    int countKDifference(vector<int>& nums, int k) {
+        int count = 0;
+        unordered_map<int, int> m;
+        for(int i = 0; i < nums.size(); i++){
+            count += m[nums[i] + k] > 0 ? m[nums[i] + k] : 0;
+            count += m[nums[i] - k] > 0 ? m[nums[i] - k] : 0;
+            m[nums[i]]++;
+        }            
+        return count;
+    }
+};

Arrays/CountPairsWithAbsouteDifferenceK2006.java

@@ -0,0 +1,67 @@
+// Given an integer array nums and an integer k, return the number of pairs (i, j) where i < j such that |nums[i] - nums[j]| == k.
+
+// The value of |x| is defined as:
+
+// x if x >= 0.
+// -x if x < 0.
+ 
+
+// Example 1:
+
+// Input: nums = [1,2,2,1], k = 1
+// Output: 4
+// Explanation: The pairs with an absolute difference of 1 are:
+// - [1,2,2,1]
+// - [1,2,2,1]
+// - [1,2,2,1]
+// - [1,2,2,1]
+// Example 2:
+
+// Input: nums = [1,3], k = 3
+// Output: 0
+// Explanation: There are no pairs with an absolute difference of 3.
+// Example 3:
+
+// Input: nums = [3,2,1,5,4], k = 2
+// Output: 3
+// Explanation: The pairs with an absolute difference of 2 are:
+// - [3,2,1,5,4]
+// - [3,2,1,5,4]
+// - [3,2,1,5,4]
+ 
+
+// Constraints:
+
+// 1 <= nums.length <= 200
+// 1 <= nums[i] <= 100
+// 1 <= k <= 99
+
+
+// BRUTE FORCE
+
+class Solution {
+    public int countKDifference(int[] nums, int k) {
+        int count = 0;
+        for(int i = 0; i < nums.length - 1; i++)
+            for(int j = i+1; j < nums.length; j++)
+                if(Math.abs(nums[j] - nums[i]) == k)
+                    ++count;
+        return count;
+    }
+}
+
+
+// HASHING
+
+class Solution {
+    public int countKDifference(int[] nums, int k) {
+        int count = 0;
+        Map<Integer, Integer> mp = new HashMap<>();
+        for(int i : nums){
+            count += mp.containsKey(i + k) ? mp.get(i + k) : 0;
+            count += mp.containsKey(i - k) ? mp.get(i - k) : 0;
+            mp.put(i, mp.getOrDefault(i, 0)+1);
+        }
+        return count;
+    }
+}

Trees/RangeSumOfBST938.cpp

@@ -0,0 +1,51 @@
+// Given the root node of a binary search tree and two integers low and high, return the sum of values of all nodes with a value in the inclusive range [low, high].
+
+ 
+
+// Example 1:
+
+
+// Input: root = [10,5,15,3,7,null,18], low = 7, high = 15
+// Output: 32
+// Explanation: Nodes 7, 10, and 15 are in the range [7, 15]. 7 + 10 + 15 = 32.
+// Example 2:
+
+
+// Input: root = [10,5,15,3,7,13,18,1,null,6], low = 6, high = 10
+// Output: 23
+// Explanation: Nodes 6, 7, and 10 are in the range [6, 10]. 6 + 7 + 10 = 23.
+ 
+
+// Constraints:
+
+// The number of nodes in the tree is in the range [1, 2 * 104].
+// 1 <= Node.val <= 105
+// 1 <= low <= high <= 105
+// All Node.val are unique.
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    int rangeSumBST(TreeNode* root, int low, int high) {
+        if(!root) return 0;
+        if(root->val <= high and root->val >= low)
+            return root->val + rangeSumBST(root->left, low, high)
+            + rangeSumBST(root->right, low, high);
+        else if(root->val < low)
+            return rangeSumBST(root->right, low, high);
+        else if(root->val > high)
+            return rangeSumBST(root->left, low, high);
+        else return 0;
+    }
+};
+    

Trees/RangeSumOfBST938.java

@@ -0,0 +1,52 @@
+// Given the root node of a binary search tree and two integers low and high, return the sum of values of all nodes with a value in the inclusive range [low, high].
+
+ 
+
+// Example 1:
+
+
+// Input: root = [10,5,15,3,7,null,18], low = 7, high = 15
+// Output: 32
+// Explanation: Nodes 7, 10, and 15 are in the range [7, 15]. 7 + 10 + 15 = 32.
+// Example 2:
+
+
+// Input: root = [10,5,15,3,7,13,18,1,null,6], low = 6, high = 10
+// Output: 23
+// Explanation: Nodes 6, 7, and 10 are in the range [6, 10]. 6 + 7 + 10 = 23.
+ 
+
+// Constraints:
+
+// The number of nodes in the tree is in the range [1, 2 * 104].
+// 1 <= Node.val <= 105
+// 1 <= low <= high <= 105
+// All Node.val are unique.
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int rangeSumBST(TreeNode root, int low, int high) {
+        if(root == null) return 0;
+        if(root.val >= low && root.val <= high)
+            return root.val + rangeSumBST(root.left, low, high) + rangeSumBST(root.right, low, high);
+        else if(root.val < low)
+            return rangeSumBST(root.right, low, high);
+        else if(root.val > high)
+            return rangeSumBST(root.left, low, high);
+        else return 0;
+    }
+}