Merge branch 'CodeHarborHub:main' into lcsol-3024

Author: VaishnaviMankala19

assets/Avl-Tree.png

@@ -573,7 +573,7 @@ export const problems = [
         "problemName": "693. Binary Number with Alternating Bits",
         "difficulty": "Easy",
         "leetCodeLink": "https://leetcode.com/problems/binary-number-with-alternating-bits",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/lc-solutions/0600-0699/binary-number-with-alternating-bits"
     },
     {
         "problemName": "694. Number of Distinct Islands",
@@ -591,13 +591,13 @@ export const problems = [
         "problemName": "696. Count Binary Substrings",
         "difficulty": "Easy",
         "leetCodeLink": "https://leetcode.com/problems/count-binary-substrings",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/lc-solutions/0600-0699/count-binary-substrings"
     },
     {
         "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-problems/leetcode-problems/0600-0699.md

@@ -0,0 +1,195 @@
+---
+id: avl-tree-search
+title: AVL Tree Search (Geeks for Geeks)
+sidebar_label: AVL Tree Search
+tags:
+  - Beginner
+  - Search Algorithms
+  - Geeks for Geeks
+  - CPP
+  - Python
+  - Java
+  - JavaScript
+  - DSA
+description: "This is a solution to the AVL Tree Search problem on Geeks for Geeks."
+---
+
+## What is AVL Tree Search?
+
+AVL Tree Search is a search operation performed on an AVL tree, a self-balancing binary search tree. In an AVL tree, the heights of the two child subtrees of any node differ by no more than one, ensuring O(log N) time complexity for search operations.
+
+## Algorithm for AVL Tree Search
+
+1. Start at the root node of the AVL tree.
+2. Compare the target value with the value of the current node:
+- If the target value equals the current node's value, return the node.
+- If the target value is less than the current node's value, move to the left child.
+- If the target value is greater than the current node's value, move to the right child.
+3. Repeat step 2 until the target value is found or the current node becomes null.
+4. If the target value is not found, return null.
+
+## How does AVL Tree Search work?
+
+- It begins by comparing the target value to the value of the root node.
+- If the target value matches the root node's value, the search is complete.
+- If the target value is less than the root node's value, the search continues in the left subtree.
+- If the target value is greater than the root node's value, the search continues in the right subtree.
+- This process continues until the target value is found or a leaf node is reached without finding the target value.
+
+![Example for AVL Tree Search(GFG)](../../assets/Avl-Tree.png)
+
+## Problem Description
+
+Given an AVL tree and a target element, implement the AVL Tree Search algorithm to find the node containing the target value in the tree. If the element is not present, return null.
+
+## Examples
+
+**Example 1:**
+```
+Input:
+AVL Tree: 
+        9
+       / \
+      5  12
+     / \   \
+    2   7  15
+
+Target: 7
+Output: Node with value 7
+
+```
+
+## Your Task:  
+
+You don't need to read input or print anything. Complete the function avlTreeSearch() which takes the root of the AVL tree and a target value as input parameters and returns the node containing the target value. If the target value is not present in the tree, return null.
+
+Expected Time Complexity: $O(LogN)$
+Expected Auxiliary Space: $O(1)$
+
+## Constraints
+
+- $1 <= Number of nodes <= 10^5$
+- $1 <= Node value <= 10^6$
+- $1 <= Target value <= 10^6$
+
+## Implementation
+
+<Tabs>
+
+  <TabItem value="C++" label="C++">
+  <SolutionAuthor name="@ngmuraqrdd"/>
+  ```cpp
+  #include <iostream>
+
+struct AVLNode {
+    int value;
+    AVLNode* left;
+    AVLNode* right;
+    AVLNode(int val) : value(val), left(nullptr), right(nullptr) {}
+};
+
+AVLNode* avlTreeSearch(AVLNode* root, int target) {
+    AVLNode* current = root;
+    while (current) {
+        if (current->value == target) {
+            return current;
+        } else if (current->value < target) {
+            current = current->right;
+        } else {
+            current = current->left;
+        }
+    }
+    return nullptr;
+}
+
+int main() {
+    AVLNode* root = new AVLNode(9);
+    root->left = new AVLNode(5);
+    root->right = new AVLNode(12);
+    root->left->left = new AVLNode(2);
+    root->left->right = new AVLNode(7);
+    root->right->right = new AVLNode(15);
+
+    int target = 7;
+    AVLNode* result = avlTreeSearch(root, target);
+    if (result) {
+        std::cout << "Node with value " << result->value << " found." << std::endl;
+    } else {
+        std::cout << "Node not found." << std::endl;
+    }
+
+    return 0;
+}
+
+  </TabItem>
+
+  <TabItem value="Java" label="Java">
+  <SolutionAuthor name="@ngmuraqrdd"/>
+  ```java
+  class AVLNode {
+    int value;
+    AVLNode left, right;
+    AVLNode(int value) {
+        this.value = value;
+        left = right = null;
+    }
+}
+
+public class AVLTreeSearch {
+    public static AVLNode avlTreeSearch(AVLNode root, int target) {
+        AVLNode current = root;
+        while (current != null) {
+            if (current.value == target) {
+                return current;
+            } else if (current.value < target) {
+                current = current.right;
+            } else {
+                current = current.left;
+            }
+        }
+        return null;
+    }
+
+    public static void main(String[] args) {
+        AVLNode root = new AVLNode(9);
+        root.left = new AVLNode(5);
+        root.right = new AVLNode(12);
+        root.left.left = new AVLNode(2);
+        root.left.right = new AVLNode(7);
+        root.right.right = new AVLNode(15);
+
+        int target = 7;
+        AVLNode result = avlTreeSearch(root, target);
+        if (result != null) {
+            System.out.println("Node with value " + result.value + " found.");
+        } else {
+            System.out.println("Node not found.");
+        }
+    }
+}
+
+ ```
+ </TabItem>  
+</Tabs>
+
+## Complexity Analysis
+
+- **Time Complexity**:$O(log n)$, where $n$ is the number of nodes in the AVL tree. The height of the tree is kept balanced, leading to logarithmic time complexity.
+- **Space Complexity**: $O(1)$, as no extra space is required apart from the input tree.
+
+## Advantages and Disadvantages
+
+**Advantages:**
+- Ensures balanced tree structure for efficient search, insert, and delete operations.
+- Fast search time due to logarithmic time complexity.
+
+**Disadvantages:**
+- Requires additional rotations to maintain balance during insert and delete operations.
+- More complex to implement compared to simple binary search trees.
+
+
+## References
+
+- **GFG Problem:** [GFG Problem](https://www.geeksforgeeks.org/practice-questions-height-balancedavl-tree//)
+- **Author's Geeks for Geeks Profile:** [MuraliDharan](https://www.geeksforgeeks.org/user/ngmuraqrdd/)
+

dsa-solutions/Searching-Algorithms/05-AVL-Tree-Search.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).