From 922a2248d3a845072cad7d0b594d121c8ae8cb08 Mon Sep 17 00:00:00 2001
From: Hitesh4278 <97452642+Hitesh4278@users.noreply.github.com>
Date: Sun, 16 Jun 2024 13:29:51 +0000
Subject: [PATCH 1/3] Added the Solution of Subarray Product Less than k
---
dsa-problems/leetcode-problems/0700-0799.md | 2 +-
.../0713-subarray-product-less-than-k.md | 281 ++++++++++++++++++
2 files changed, 282 insertions(+), 1 deletion(-)
create mode 100644 dsa-solutions/lc-solutions/0700-0799/0713-subarray-product-less-than-k.md
diff --git a/dsa-problems/leetcode-problems/0700-0799.md b/dsa-problems/leetcode-problems/0700-0799.md
index c82f100e0..2eb8ca074 100644
--- a/dsa-problems/leetcode-problems/0700-0799.md
+++ b/dsa-problems/leetcode-problems/0700-0799.md
@@ -92,7 +92,7 @@ export const problems = [
"problemName": "713. Subarray Product Less Than K",
"difficulty": "Medium",
"leetCodeLink": "https://leetcode.com/problems/subarray-product-less-than-k",
- "solutionLink": "#"
+ "solutionLink": "/dsa-solutions/lc-solutions/0700-0799/subarray-product-less-than-k"
},
{
"problemName": "714. Best Time to Buy and Sell Stock with Transaction Fee",
diff --git a/dsa-solutions/lc-solutions/0700-0799/0713-subarray-product-less-than-k.md b/dsa-solutions/lc-solutions/0700-0799/0713-subarray-product-less-than-k.md
new file mode 100644
index 000000000..7b305d7f2
--- /dev/null
+++ b/dsa-solutions/lc-solutions/0700-0799/0713-subarray-product-less-than-k.md
@@ -0,0 +1,281 @@
+---
+id: subarray-product-less-than-k
+title: Subarray Product Less Than K
+sidebar_label: 713. Subarray Product Less Than K
+
+tags:
+- Array
+- Sliding Window
+
+description: "This is a solution to the Subarray Product Less Than K problem on LeetCode."
+---
+
+## Problem Description
+Given an array of integers nums and an integer k, return the number of contiguous subarrays where the product of all the elements in the subarray is strictly less than k.
+### Examples
+
+**Example 1:**
+```
+Input: nums = [10,5,2,6], k = 100
+Output: 8
+Explanation: The 8 subarrays that have product less than 100 are:
+[10], [5], [2], [6], [10, 5], [5, 2], [2, 6], [5, 2, 6]
+Note that [10, 5, 2] is not included as the product of 100 is not strictly less than k.
+```
+
+**Example 2:**
+```
+Input: nums = [1,2,3], k = 0
+Output: 0
+
+```
+
+
+### Constraints
+- `1 <= nums.length <= 3 * 10^4`
+- `1 <= nums[i] <= 1000`
+- `0 <= k <= 10^6`
+
+## Solution for Path With Minimum Effort Problem
+### Approach
+#### Brute Force
+- Generate All the Subarray and Check whether the which subarray has product less than K.
+
+#### Optimized Approach - Sliding Window
+##### Initialize Pointers and Variables:
+
+- Use two pointers, i and j, to represent the start and end of the current subarray, respectively.
+- Initialize prod to 1 to keep track of the product of elements in the current window.
+- Initialize cnt to 0 to count the number of valid subarrays.
+##### Expand the Window:
+
+- Start with both pointers at the beginning of the array. Expand the window by moving the j pointer to the right, multiplying the product prod by the new element nums[j].
+##### Check the Product:
+
+- If the product prod is less than k, all subarrays ending at j and starting from any position between i and j are valid. Therefore, add j - i + 1 to cnt.
+Shrink the Window:
+
+- If the product prod is greater than or equal to k, move the i pointer to the right until the product is less than k. Each time you move i, divide prod by nums[i].
+##### Repeat:
+
+- Continue expanding the window with j and adjusting i as needed until j reaches the end of the array.
+##### Return the Result:
+
+- The total count cnt is the number of subarrays with a product less than k.
+
+
+
+
+
+ #### Implementation
+ ```jsx live
+ function Solution(arr) {
+ var numSubarrayProductLessThanK = function(nums, k) {
+ let i = 0;
+ let j = 0;
+ let cnt = 0;
+ let prod = 1;
+ while (j < nums.length) {
+ prod *= nums[j];
+ if (prod < k) {
+ cnt += j - i + 1;
+ } else {
+ while (prod >= k && i <= j) {
+ prod /= nums[i];
+ i++;
+ }
+ if (prod < k) {
+ cnt += j - i + 1;
+ }
+ }
+ j++;
+ }
+ return cnt;
+ };
+
+ const input =[10,5,2,6]
+ const k = 100
+ const output = numSubarrayProductLessThanK(input , k)
+ return (
+
+
+ Input:
+ {JSON.stringify(input)}
+
+
+ Output: {output.toString()}
+
+
+ );
+ }
+ ```
+
+ #### Complexity Analysis
+
+ - Time Complexity: $ O(N) $
+ - Space Complexity: $ O(1)$
+
+ ## Code in Different Languages
+
+
+
+ ```javascript
+ var numSubarrayProductLessThanK = function(nums, k) {
+ let i = 0;
+ let j = 0;
+ let cnt = 0;
+ let prod = 1;
+ while (j < nums.length) {
+ prod *= nums[j];
+ if (prod < k) {
+ cnt += j - i + 1;
+ } else {
+ while (prod >= k && i <= j) {
+ prod /= nums[i];
+ i++;
+ }
+ if (prod < k) {
+ cnt += j - i + 1;
+ }
+ }
+ j++;
+ }
+ return cnt;
+};
+
+ ```
+
+
+
+
+ ```typescript
+ function numSubarrayProductLessThanK(nums: number[], k: number): number {
+ let i = 0;
+ let j = 0;
+ let cnt = 0;
+ let prod = 1;
+ while (j < nums.length) {
+ prod *= nums[j];
+ if (prod < k) {
+ cnt += j - i + 1;
+ } else {
+ while (prod >= k && i <= j) {
+ prod /= nums[i];
+ i++;
+ }
+ if (prod < k) {
+ cnt += j - i + 1;
+ }
+ }
+ j++;
+ }
+ return cnt;
+}
+
+ ```
+
+
+
+ ```python
+ class Solution:
+ def numSubarrayProductLessThanK(self, nums, k):
+ i = 0
+ j = 0
+ cnt = 0
+ prod = 1
+ while j < len(nums):
+ prod *= nums[j]
+ if prod < k:
+ cnt += j - i + 1
+ else:
+ while prod >= k and i <= j:
+ prod /= nums[i]
+ i += 1
+ if prod < k:
+ cnt += j - i + 1
+ j += 1
+ return cnt
+
+ ```
+
+
+
+
+ ```java
+ class Solution {
+ public int numSubarrayProductLessThanK(int[] nums, int k) {
+ int i = 0;
+ int j = 0;
+ long cnt = 0;
+ long prod = 1;
+ while (j < nums.length) {
+ prod *= nums[j];
+ if (prod < k) {
+ cnt += j - i + 1;
+ } else {
+ while (prod >= k && i <= j) {
+ prod /= nums[i];
+ i++;
+ }
+ if (prod < k) {
+ cnt += j - i + 1;
+ }
+ }
+ j++;
+ }
+ return (int) cnt;
+ }
+}
+
+ ```
+
+
+
+
+ ```cpp
+ class Solution {
+public:
+ int numSubarrayProductLessThanK(vector& nums, int k) {
+ int i=0;
+ int j=0;
+ long long cnt = 0;
+ long long prod = 1;
+ while(j=k)
+ {
+ while(prod>=k && i<=j)
+ {
+ prod/=nums[i];
+ i++;
+ }
+
+ if(prod
+
+
+
+
+
+## References
+
+- **LeetCode Problem**: [Subarray Product Less Than K](https://leetcode.com/problems/subarray-product-less-than-k/description/)
+
+- **Solution Link**: [LeetCode Solution](https://leetcode.com/problems/subarray-product-less-than-k/solutions)
+
From e946c6b817cca909d0c3aa287ad9a1d1fbbfb24c Mon Sep 17 00:00:00 2001
From: Hitesh4278 <97452642+Hitesh4278@users.noreply.github.com>
Date: Sun, 16 Jun 2024 13:58:37 +0000
Subject: [PATCH 2/3] Adde d the Solution of Maximum Level Sum of a Binary Tree
---
dsa-problems/leetcode-problems/1100-1199.md | 2 +-
...1161-maximum-level-sum-of-a-binary-tree.md | 385 ++++++++++++++++++
2 files changed, 386 insertions(+), 1 deletion(-)
create mode 100644 dsa-solutions/lc-solutions/1100-1199/1161-maximum-level-sum-of-a-binary-tree.md
diff --git a/dsa-problems/leetcode-problems/1100-1199.md b/dsa-problems/leetcode-problems/1100-1199.md
index d68e6facd..470af0b85 100644
--- a/dsa-problems/leetcode-problems/1100-1199.md
+++ b/dsa-problems/leetcode-problems/1100-1199.md
@@ -320,7 +320,7 @@ export const problems = [
"problemName": "1161. Maximum Level Sum of a Binary Tree",
"difficulty": "Medium",
"leetCodeLink": "https://leetcode.com/problems/maximum-level-sum-of-a-binary-tree",
- "solutionLink": "#"
+ "solutionLink": "/dsa-solutions/lc-solutions/1100-1199/maximum-level-sum-of-a-binary-tree"
},
{
"problemName": "1162. As Far from Land as Possible",
diff --git a/dsa-solutions/lc-solutions/1100-1199/1161-maximum-level-sum-of-a-binary-tree.md b/dsa-solutions/lc-solutions/1100-1199/1161-maximum-level-sum-of-a-binary-tree.md
new file mode 100644
index 000000000..21e09c8f6
--- /dev/null
+++ b/dsa-solutions/lc-solutions/1100-1199/1161-maximum-level-sum-of-a-binary-tree.md
@@ -0,0 +1,385 @@
+---
+id: maximum-level-sum-of-a-binary-tree
+title: Maximum Level Sum of a Binary Tree
+sidebar_label: 1161. Maximum Level Sum of a Binary Tree
+tags:
+- Tree
+- Breadth-First Search
+- Binary Tree
+description: "This is a solution to the Maximum Level Sum of a Binary Tree problem on LeetCode."
+---
+
+## Problem Description
+Given the root of a binary tree, the level of its root is 1, the level of its children is 2, and so on.
+
+Return the smallest level x such that the sum of all the values of nodes at level x is maximal.
+### Examples
+
+**Example 1:**
+
+```
+Input: root = [1,7,0,7,-8,null,null]
+Output: 2
+Explanation:
+Level 1 sum = 1.
+Level 2 sum = 7 + 0 = 7.
+Level 3 sum = 7 + -8 = -1.
+So we return the level with the maximum sum which is level 2.
+```
+
+**Example 2:**
+```
+Input: root = [989,null,10250,98693,-89388,null,null,null,-32127]
+Output: 2
+```
+
+### Constraints
+- `The number of nodes in the tree is in the range [1, 10^4]`
+- `-10^5 <= Node.val <= 10^5`
+
+## Solution for Maximum Level Sum of a Binary
+
+### Approach
+The problem is to find the level in a binary tree that has the maximum sum of node values. To solve this, we use a breadth-first search (BFS) approach, which is well-suited for level-order traversal of a tree. BFS allows us to process nodes level by level, making it easy to calculate the sum of values at each level.
+
+#### Initial Checks and Setup:
+
+- If the root is null, return -1 as there are no levels in the tree.
+- Initialize a queue and add the root node to it. This queue will help us traverse the tree level by level.
+- Initialize variables to keep track of the maximum sum (maxSum), the level with the maximum sum (ans), and the current level (level). Set maxSum to a very small value to ensure any level sum will be larger initially.
+#### Level-Order Traversal Using BFS:
+
+- Use a while loop to process nodes until the queue is empty.
+- Increment the level variable at the start of each iteration of the while loop to represent the current level.
+- Determine the number of nodes at the current level (size), which is the current length of the queue.
+- Initialize a temporary sum variable (tempSum) to zero for storing the sum of values at the current level.
+#### Processing Each Level:
+
+- Use a for loop to iterate over all nodes at the current level. The loop runs size times.
+- For each node, dequeue it from the queue, add its value to tempSum, and enqueue its left and right children (if they exist).
+#### Update Maximum Sum and Level:
+
+- After processing all nodes at the current level, compare tempSum with maxSum.
+- If tempSum is greater than maxSum, update maxSum to tempSum and set ans to the current level.
+#### Return the Result:
+
+- Once all levels have been processed and the queue is empty, return ans, which holds the level number with the maximum sum.
+
+
+
+#### Implementation
+
+```jsx live
+function Solution() {
+class TreeNode {
+ constructor(val = 0, left = null, right = null) {
+ this.val = val;
+ this.left = left;
+ this.right = right;
+ }
+}
+
+var maxLevelSum = function(root) {
+ if (!root) return -1;
+
+ let ans = -1;
+ let level = 0;
+ let maxSum = Number.MIN_SAFE_INTEGER;
+ const queue = [root];
+
+ while (queue.length > 0) {
+ level++;
+ const size = queue.length;
+ let tempSum = 0;
+ for (let i = 0; i < size; i++) {
+ const curr = queue.shift();
+ tempSum += curr.val;
+ if (curr.left) queue.push(curr.left);
+ if (curr.right) queue.push(curr.right);
+ }
+ if (tempSum > maxSum) {
+ ans = level;
+ maxSum = tempSum;
+ }
+ }
+
+ return ans;
+};
+function constructTreeFromArray(array) {
+ if (!array.length) return null;
+
+ let root = new TreeNode(array[0]);
+ let queue = [root];
+ let i = 1;
+
+ while (i < array.length) {
+ let currentNode = queue.shift();
+
+ if (array[i] !== null) {
+ currentNode.left = new TreeNode(array[i]);
+ queue.push(currentNode.left);
+ }
+ i++;
+
+ if (i < array.length && array[i] !== null) {
+ currentNode.right = new TreeNode(array[i]);
+ queue.push(currentNode.right);
+ }
+ i++;
+ }
+ return root;
+}
+const array = [1,7,0,7,-8,null,null]
+const root = constructTreeFromArray(array)
+const input = root
+const output = maxLevelSum(root)
+ return (
+
+
+ Input: {JSON.stringify(array)}
+
+
+ Output: {output.toString()}
+
+
+ );
+}
+```
+
+### Code in Different Languages
+
+
+
+
+ ```javascript
+ var maxLevelSum = function(root) {
+ if (!root) return -1;
+
+ let ans = -1;
+ let level = 0;
+ let maxSum = Number.MIN_SAFE_INTEGER;
+ const queue = [root];
+
+ while (queue.length > 0) {
+ level++;
+ const size = queue.length;
+ let tempSum = 0;
+ for (let i = 0; i < size; i++) {
+ const curr = queue.shift();
+ tempSum += curr.val;
+ if (curr.left) queue.push(curr.left);
+ if (curr.right) queue.push(curr.right);
+ }
+ if (tempSum > maxSum) {
+ ans = level;
+ maxSum = tempSum;
+ }
+ }
+
+ return ans;
+};
+```
+
+
+
+ ```typescript
+ class TreeNode {
+ val: number;
+ left: TreeNode | null;
+ right: TreeNode | null;
+ constructor(val: number = 0, left: TreeNode | null = null, right: TreeNode | null = null) {
+ this.val = val;
+ this.left = left;
+ this.right = right;
+ }
+}
+
+function maxLevelSum(root: TreeNode | null): number {
+ if (!root) return -1;
+
+ let ans = -1;
+ let level = 0;
+ let maxSum = Number.MIN_SAFE_INTEGER;
+ const queue: TreeNode[] = [root];
+
+ while (queue.length > 0) {
+ level++;
+ const size = queue.length;
+ let tempSum = 0;
+ for (let i = 0; i < size; i++) {
+ const curr = queue.shift()!;
+ tempSum += curr.val;
+ if (curr.left) queue.push(curr.left);
+ if (curr.right) queue.push(curr.right);
+ }
+ if (tempSum > maxSum) {
+ ans = level;
+ maxSum = tempSum;
+ }
+ }
+
+ return ans;
+}
+
+ ```
+
+
+
+ ```python
+ # Definition for a binary tree node.
+class TreeNode:
+ def __init__(self, val=0, left=None, right=None):
+ self.val = val
+ self.left = left
+ self.right = right
+
+class Solution:
+ def maxLevelSum(self, root: TreeNode) -> int:
+ if not root:
+ return -1
+
+ from collections import deque
+
+ ans = -1
+ level = 0
+ max_sum = float('-inf')
+ queue = deque([root])
+
+ while queue:
+ level += 1
+ size = len(queue)
+ temp_sum = 0
+ for _ in range(size):
+ curr = queue.popleft()
+ temp_sum += curr.val
+ if curr.left:
+ queue.append(curr.left)
+ if curr.right:
+ queue.append(curr.right)
+ if temp_sum > max_sum:
+ ans = level
+ max_sum = temp_sum
+
+ return ans
+
+ ```
+
+
+
+
+```java
+/**
+ * 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;
+ * }
+ * }
+ */
+import java.util.*;
+
+class Solution {
+ public int maxLevelSum(TreeNode root) {
+ if (root == null) return -1;
+
+ int ans = -1;
+ int level = 0;
+ int maxSum = Integer.MIN_VALUE;
+ Queue queue = new LinkedList<>();
+ queue.add(root);
+
+ while (!queue.isEmpty()) {
+ level++;
+ int size = queue.size();
+ int tempSum = 0;
+ for (int i = 0; i < size; i++) {
+ TreeNode curr = queue.poll();
+ tempSum += curr.val;
+ if (curr.left != null) queue.add(curr.left);
+ if (curr.right != null) queue.add(curr.right);
+ }
+ if (tempSum > maxSum) {
+ ans = level;
+ maxSum = tempSum;
+ }
+ }
+
+ return ans;
+ }
+}
+
+```
+
+
+
+```cpp
+/**
+ * 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 maxLevelSum(TreeNode* root) {
+ int ans=-1;
+ int level=0;
+ int sum=INT_MIN;
+ queue q;
+ if(!root) return ans;
+
+ q.push(root);
+
+ while(!q.empty()){
+
+ level++;
+ int size = q.size();
+ int temp=0;
+ while(size--){
+ TreeNode *curr = q.front();
+ q.pop();
+ temp+=curr->val;
+
+ if(curr->left) q.push(curr->left);
+ if(curr->right) q.push(curr->right);
+
+ }
+ if(temp>sum)
+ {
+ ans=level;
+ sum=temp;
+ }
+ }
+
+ return ans;
+ }
+};
+```
+
+
+
+#### Complexity Analysis
+ ##### Time Complexity: $O(N)$ , because of tree traversal
+
+ ##### Space Complexity: $O(1)$
+
+
+
+## References
+
+- **LeetCode Problem**: [Maximum Level Sum of a Binary Tree](https://leetcode.com/problems/maximum-level-sum-of-a-binary-tree/description/)
+
+- **Solution Link**: [LeetCode Solution](https://leetcode.com/problems/maximum-level-sum-of-a-binary-tree/description/)
+
From df365429632a31cd3d115d2eeaafcc665969515e Mon Sep 17 00:00:00 2001
From: Hitesh4278 <97452642+Hitesh4278@users.noreply.github.com>
Date: Sun, 16 Jun 2024 14:27:00 +0000
Subject: [PATCH 3/3] Added the Solution of Subarray Sums Divisible by K
---
dsa-problems/leetcode-problems/0900-0999.md | 2 +-
.../0974-subarray-sums-divisible-by-k.md | 256 ++++++++++++++++++
2 files changed, 257 insertions(+), 1 deletion(-)
create mode 100644 dsa-solutions/lc-solutions/0900-0999/0974-subarray-sums-divisible-by-k.md
diff --git a/dsa-problems/leetcode-problems/0900-0999.md b/dsa-problems/leetcode-problems/0900-0999.md
index 947cb93b7..17a71636f 100644
--- a/dsa-problems/leetcode-problems/0900-0999.md
+++ b/dsa-problems/leetcode-problems/0900-0999.md
@@ -459,7 +459,7 @@ export const problems = [
problemName: "974. Subarray Sums Divisible by K",
difficulty: "Medium",
leetCodeLink: "https://leetcode.com/problems/subarray-sums-divisible-by-k",
- solutionLink: "#"
+ solutionLink: "/dsa-solutions/lc-solutions/0900-0999/subarray-sums-divisible-by-k"
},
{
problemName: "975. Odd Even Jump",
diff --git a/dsa-solutions/lc-solutions/0900-0999/0974-subarray-sums-divisible-by-k.md b/dsa-solutions/lc-solutions/0900-0999/0974-subarray-sums-divisible-by-k.md
new file mode 100644
index 000000000..e6da9f87c
--- /dev/null
+++ b/dsa-solutions/lc-solutions/0900-0999/0974-subarray-sums-divisible-by-k.md
@@ -0,0 +1,256 @@
+---
+id: subarray-sums-divisible-by-k
+title: Subarray Sums Divisible by K
+sidebar_label: 974. Subarray Sums Divisible by K
+
+tags:
+- Array
+- Sliding Window
+- Hashmap
+
+description: "This is a solution to theSubarray Sums Divisible by K problem on LeetCode."
+---
+
+## Problem Description
+Given an integer array nums and an integer k, return the number of non-empty subarrays that have a sum divisible by k.
+
+A subarray is a contiguous part of an array.
+### Examples
+
+**Example 1:**
+```
+Input: nums = [4,5,0,-2,-3,1], k = 5
+Output: 7
+Explanation: There are 7 subarrays with a sum divisible by k = 5:
+[4, 5, 0, -2, -3, 1], [5], [5, 0], [5, 0, -2, -3], [0], [0, -2, -3], [-2, -3]
+```
+
+**Example 2:**
+```
+Input: nums = [5], k = 9
+Output: 0
+```
+
+
+### Constraints
+- `1 <= nums.length <= 3 * 10^4`
+- `-10^4 <= nums[i] <= 10^4`
+- `2 <= k <= 10^4`
+
+## Solution for Subarray Sums Divisible by K Problem
+### Approach
+#### Brute Force
+- Generate All the Subarray and Check whether the which subarray sum is divisible by k.
+
+#### Optimized Approach
+- The problem is to find the number of subarrays whose sum is divisible by a given integer k. The key insight is to use the concept of prefix sums and remainders:
+
+##### Prefix Sum and Remainders:
+- Compute the prefix sum as you iterate through the array.Compute the remainder of the prefix sum divided by k. This remainder helps in identifying subarrays that are divisible by
+k.
+
+##### Handling Negative Remainders:
+- If the remainder is negative, adjust it by adding k to make it positive. This ensures consistent handling of remainders.
+##### Using a HashMap:
+
+- Use a hash map (or dictionary) to count the frequency of each remainder.
+- If the same remainder has been seen before, it means there are subarrays whose sum is divisible by k.
+##### Counting Valid Subarrays:
+
+- For each prefix sum remainder, the count of valid subarrays is incremented by the frequency of the same remainder seen so far.
+
+
+
+
+ #### Implementation
+ ```jsx live
+ function Solution(arr) {
+ var subarraysDivByK = function(nums, k) {
+ let sum = 0;
+ const mp = new Map();
+ mp.set(0, 1);
+ let cnt = 0;
+
+ for (let i = 0; i < nums.length; i++) {
+ sum += nums[i];
+ sum = sum % k;
+ if (sum < 0) {
+ sum += k;
+ }
+ if (mp.has(sum)) {
+ cnt += mp.get(sum);
+ }
+ mp.set(sum, (mp.get(sum) || 0) + 1);
+ }
+
+ return cnt;
+ };
+ const input =[4,5,0,-2,-3,1]
+ const k = 5
+ const output = subarraysDivByK(input , k)
+ return (
+
+
+ Input:
+ {JSON.stringify(input)}
+
+
+ Output: {output.toString()}
+
+
+ );
+ }
+ ```
+
+ #### Complexity Analysis
+
+ - Time Complexity: $ O(n) $
+ - Space Complexity: $ O(k)$
+
+ ## Code in Different Languages
+
+
+
+ ```javascript
+ var subarraysDivByK = function(nums, k) {
+ let sum = 0;
+ const mp = new Map();
+ mp.set(0, 1);
+ let cnt = 0;
+
+ for (let i = 0; i < nums.length; i++) {
+ sum += nums[i];
+ sum = sum % k;
+ if (sum < 0) {
+ sum += k;
+ }
+ if (mp.has(sum)) {
+ cnt += mp.get(sum);
+ }
+ mp.set(sum, (mp.get(sum) || 0) + 1);
+ }
+
+ return cnt;
+};
+ ```
+
+
+
+
+ ```typescript
+ function subarraysDivByK(nums: number[], k: number): number {
+ let sum = 0;
+ const mp: Map = new Map();
+ mp.set(0, 1);
+ let cnt = 0;
+
+ for (let i = 0; i < nums.length; i++) {
+ sum += nums[i];
+ sum = sum % k;
+ if (sum < 0) {
+ sum += k;
+ }
+ if (mp.has(sum)) {
+ cnt += mp.get(sum)!;
+ }
+ mp.set(sum, (mp.get(sum) || 0) + 1);
+ }
+
+ return cnt;
+}
+
+ ```
+
+
+
+ ```python
+ from collections import defaultdict
+
+class Solution:
+ def subarraysDivByK(self, nums, k):
+ sum = 0
+ mp = defaultdict(int)
+ mp[0] = 1
+ cnt = 0
+
+ for num in nums:
+ sum += num
+ sum = sum % k
+ if sum < 0:
+ sum += k
+ cnt += mp[sum]
+ mp[sum] += 1
+
+ return cnt
+
+ ```
+
+
+
+
+ ```java
+ import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+ public int subarraysDivByK(int[] nums, int k) {
+ int sum = 0;
+ Map mp = new HashMap<>();
+ mp.put(0, 1);
+ int cnt = 0;
+
+ for (int num : nums) {
+ sum += num;
+ sum = sum % k;
+ if (sum < 0) {
+ sum += k;
+ }
+ cnt += mp.getOrDefault(sum, 0);
+ mp.put(sum, mp.getOrDefault(sum, 0) + 1);
+ }
+
+ return cnt;
+ }
+}
+
+ ```
+
+
+
+
+ ```cpp
+ class Solution {
+public:
+ int subarraysDivByK(vector& nums, int k) {
+ int sum=0;
+ mapmp;
+ mp[0]=1;
+ int cnt=0;
+ for(int i=0;i
+
+
+
+
+
+## References
+
+- **LeetCode Problem**: [Subarray Sums Divisible by K](https://leetcode.com/problems/subarray-product-less-than-k/description/)
+
+- **Solution Link**: [LeetCode Solution](https://leetcode.com/problems/subarray-sums-divisible-by-k/solutions)
+