Merge branch 'CodeHarborHub:main' into lc-sol-3033

Author: VaishnaviMankala19

dsa-problems/leetcode-problems/0600-0699.md

@@ -597,7 +597,7 @@ export const problems = [
         "problemName": "697. Degree of an Array",
         "difficulty": "Easy",
         "leetCodeLink": "https://leetcode.com/problems/degree-of-an-array",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/lc-solutions/0600-0699/degree-of-an-array"
     },
     {
         "problemName": "698. Partition to K Equal Sum Subsets",

dsa-solutions/lc-solutions/0400-0499/0413-arithmetic-slices.md

@@ -0,0 +1,125 @@
+---
+id: arithmetic-slices
+title: Arithmetic Slices (LeetCode)
+sidebar_label: 0413-Arithmetic Slices
+tags:
+  - Array
+  - Dynamic Programming
+description: Given an integer array nums, return the number of arithmetic subarrays of nums.
+sidebar_position: 0413
+---
+
+## Problem Description
+
+An integer array is called arithmetic if it consists of at least three elements and if the difference between any two consecutive elements is the same.
+- For example, `[1,3,5,7,9]`, `[7,7,7,7]`, and `[3,-1,-5,-9]` are arithmetic sequences.
+
+Given an integer array nums, return the number of arithmetic subarrays of nums.
+
+A subarray is a contiguous subsequence of the array.
+
+### Example 1
+
+- **Input:** `nums = [1,2,3,4]`
+- **Output:** `3`
+- **Explanation:** We have 3 arithmetic slices in nums: [1, 2, 3], [2, 3, 4] and [1,2,3,4] itself.
+
+### Example 2
+
+- **Input:** ` nums = [1]`
+- **Output:** `0`
+
+### Constraints
+
+- `1 <= nums.length <= 5000`
+- `-1000 <= nums[i] <= 1000`
+
+## Approach
+- 1. Initialize Variables: Before looping through the nums, we initialize the ans variable to 0. This variable will accumulate the total count of arithmetic subarrays. We also initialize a cnt variable to 0; it keeps track of consecutive pairs with the same difference. The d variable, which holds the current common difference between pairs, is set to a number outside the valid range (3000) to handle the edge case at the beginning of the array.
+
+- 2. Loop through pairwise(nums): We iterate over each pair (a, b) in pairwise(nums). Here, a and b represent consecutive elements in nums.
+
+- 3. Check the Difference and Update Counter: We compare the difference b - a with the current d. If they're equal, increment cnt by 1, because this extends the current arithmetic subarray sequence by one element. If they're different, update d to the new difference b - a and reset cnt to 0, because we're starting to count a new set of arithmetic subarrays.
+
+- 4. Update the Answer: Add the current cnt to ans in each iteration. By adding cnt, we're accounting for all the new arithmetic subarrays that end at the current element b. The reason adding cnt works is that for each extension of an arithmetic subarray by one element, we introduce exactly cnt new subarrays where cnt is the count of previous consecutive elements that were part of such subarrays.
+
+- 5. Return Result: After the loop completes, ans represents the total number of arithmetic subarrays in nums, which is then returned as the final answer.
+
+### Solution Code
+
+#### Python
+
+```python
+from itertools import pairwise
+
+class Solution:
+    def numberOfArithmeticSlices(self, nums: List[int]) -> int:
+        total_slices = 0 
+        current_sequence_length = 0 
+        previous_difference = 3000
+        for current_num, next_num in pairwise(nums):
+            current_difference = next_num - current_num
+            if current_difference == previous_difference:
+                current_sequence_length += 1
+            else:
+                previous_difference = current_difference
+                current_sequence_length = 0
+            total_slices += current_sequence_length
+        return total_slices
+```
+
+#### C++
+```c++
+class Solution {
+public:
+    int numberOfArithmeticSlices(vector<int>& nums) {
+        int totalSlices = 0;  
+        int currentStreak = 0; 
+        int previousDifference = 3000; 
+        for (int i = 0; i < nums.size() - 1; ++i) { 
+            int currentDifference = nums[i + 1] - nums[i]; 
+            if (currentDifference == previousDifference) {
+                ++currentStreak;
+            } else {
+                previousDifference = currentDifference;
+                currentStreak = 0;
+            }
+            totalSlices += currentStreak; 
+        }
+        return totalSlices; 
+    }
+};
+
+```
+
+#### Java
+```Java
+class Solution {
+    public int numberOfArithmeticSlices(int[] nums) {
+        int arithmeticSliceCount = 0;  
+        int currentSliceLength = 0;   
+        int difference = 3000;       
+        for (int i = 0; i < nums.length - 1; ++i) {
+            if (nums[i + 1] - nums[i] == difference) {
+                ++currentSliceLength;
+            } else {
+                difference = nums[i + 1] - nums[i];
+                currentSliceLength = 0;
+            }
+            arithmeticSliceCount += currentSliceLength;
+        }
+        return arithmeticSliceCount;
+    }
+}
+        
+```
+
+
+
+
+#### Conclusion
+- Time Complexity
+The time complexity is o(n).
+
+- Space Complexity
+The space complexity is O(1).

dsa-solutions/lc-solutions/0600-0699/0697-degree-of-an-array.md

@@ -0,0 +1,131 @@
+---
+id: degree-of-an-array
+title: Degree of an Array
+sidebar_label: 0697 - Degree of an Array
+tags:
+  - Hash Table
+  - Array
+  - Sliding Window
+description: "This is a solution to the Degree of an Array problem on LeetCode."
+---
+
+## Problem Description
+
+Given a non-empty array of non-negative integers `nums`, the **degree** of this array is defined as the maximum frequency of any one of its elements.
+
+Your task is to find the smallest possible length of a (contiguous) subarray of `nums`, that has the same degree as `nums`.
+
+### Examples
+
+**Example 1:**
+
+```
+Input: nums = [1,2,2,3,1]
+Output: 2
+Explanation: 
+The input array has a degree of 2 because both elements 1 and 2 appear twice.
+Of the subarrays that have the same degree:
+[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
+The shortest length is 2. So return 2.
+```
+
+**Example 2:**
+
+```
+Input: nums = [1,2,2,3,1,4,2]
+Output: 6
+Explanation: 
+The degree is 3 because the element 2 is repeated 3 times.
+So [2,2,3,1,4,2] is the shortest subarray, therefore returning 6.
+```
+
+### Constraints
+
+- `nums.length` will be between 1 and 50,000.
+- `nums[i]` will be an integer between 0 and 49,999.
+
+## Solution for Degree of an Array
+
+### Approach: Left and Right Index
+#### Intuition and Algorithm
+
+An array that has degree `d`, must have some element `x` occur `d` times. If some subarray has the same degree, then some element `x` (that occurred d times), still occurs `d` times. The shortest such subarray would be from the first occurrence of `x` until the last occurrence.
+
+For each element in the given array, let's know `left`, the index of its first occurrence; and `right`, the index of its last occurrence. For example, with `nums = [1,2,3,2,5]` we have `left[2] = 1` and `right[2] = 3`.
+
+Then, for each element `x` that occurs the maximum number of times, `right[x] - left[x] + 1` will be our candidate answer, and we'll take the minimum of those candidates.
+
+## Code in Different Languages
+
+<Tabs>
+<TabItem value="java" label="Java">
+  <SolutionAuthor name="@Shreyash3087"/>
+
+```java
+class Solution {
+    public int findShortestSubArray(int[] nums) {
+        Map<Integer, Integer> left = new HashMap(),
+            right = new HashMap(), count = new HashMap();
+
+        for (int i = 0; i < nums.length; i++) {
+            int x = nums[i];
+            if (left.get(x) == null) {
+                left.put(x, I);
+            }
+            right.put(x, i);
+            count.put(x, count.getOrDefault(x, 0) + 1);
+        }
+
+        int ans = nums.length;
+        int degree = Collections.max(count.values());
+        for (int x: count.keySet()) {
+            if (count.get(x) == degree) {
+                ans = Math.min(ans, right.get(x) - left.get(x) + 1);
+            }
+        }
+        return ans;
+    }
+}
+```
+
+</TabItem>
+<TabItem value="python" label="Python">
+  <SolutionAuthor name="@Shreyash3087"/>
+
+```python
+class Solution(object):
+    def findShortestSubArray(self, nums):
+        left, right, count = {}, {}, {}
+        for i, x in enumerate(nums):
+            if x not in left:
+                left[x] = i
+            right[x] = i
+            count[x] = count.get(x, 0) + 1
+
+        ans = len(nums)
+        degree = max(count.values())
+        for x in count:
+            if count[x] == degree:
+                ans = min(ans, right[x] - left[x] + 1)
+
+        return ans
+```
+</TabItem>
+</Tabs>
+
+## Complexity Analysis
+
+### Time Complexity: $O(N)$
+
+> **Reason**:  where N is the length of `nums`. Every loop is through $O(N)$ items with $O(1)$ work inside the for-block.
+
+### Space Complexity: $O(N)$
+
+> **Reason**: the space used by `left`, `right`, and `count`.
+
+
+## References
+
+- **LeetCode Problem**: [Degree of an Array](https://leetcode.com/problems/degree-of-an-array/description/)
+
+- **Solution Link**: [Degree of an Array](https://leetcode.com/problems/degree-of-an-array/solutions/)