Merge pull request #24 from mrid88/feature/alterating-groups

Solution #3208 - Mridul/Edited - 09/03/2025

Author: JRS296

Daily Questions/#3208 - Alterating Groups II - Medium/Explanation.md

@@ -0,0 +1,67 @@
+## Explanation of the `numberOfAlternatingGroups` Method
+
+The `numberOfAlternatingGroups` method in the `Solution` class takes an array of integers `colors` and an integer `k` as input, and returns the number of alternating groups of size `k` within the array.
+
+### Code Breakdown
+
+1. **Initialization**
+    ```java
+    int window = 1;
+    int res = 0;
+    int n = colors.length;
+    int i = 0;
+    int j = 1;
+    ```
+    - `window`: Keeps track of the current window size.
+    - `res`: Stores the count of alternating groups of size `k`.
+    - `n`: Stores the length of the `colors` array.
+    - `i`, `j`: Pointers to traverse the array.
+
+2. **While Loop to Traverse the Array**
+    ```java
+    while(i < colors.length) {
+        if(colors[(j-1) % n] != colors[j%n]) {
+            window++;
+            j++;
+        }else {
+            i = j;
+            j = i + 1;
+            window = 1;
+            continue;
+        }
+
+        if(window == k) {
+            res++;
+            if(colors[(j-1) % n] != colors[j%n]) {
+                i++;
+                window -= 1;
+            }else {
+                i = j;
+                j = i + 1;
+                window = 1;
+            }
+        }
+    }
+    ```
+    - The loop iterates through the array while `i` is less than the length of `colors`.
+    - It checks if the current and the next colors are different. If they are different, the window size is incremented, and `j` is incremented.
+    - If they are the same, it resets the window and continues the iteration.
+    - When the window size reaches `k`, it increments the `res` count and adjusts the window accordingly.
+
+3. **Return the Result**
+    ```java
+    return res;
+    ```
+    - Returns the total count of alternating groups of size `k`.
+
+### Example
+
+Given the `colors` array `[1, 2, 1, 2, 1]` and `k = 3`:
+- The method will return `2` since there are two alternating groups of size 3: `[1, 2, 1]` and `[2, 1, 2]`.
+
+### Time Complexity
+- The time complexity of this method is O(n), where `n` is the length of the `colors` array, as it traverses the array a constant number of times.
+
+### Space Complexity
+- The space complexity is O(n) as only a few variables are used, and no additional data structures are required.
+

Daily Questions/#3208 - Alterating Groups II - Medium/Solution.java

@@ -0,0 +1,34 @@
+class Solution {
+    public int numberOfAlternatingGroups(int[] colors, int k) {
+        int window = 1;
+        int res = 0;
+        int n = colors.length;
+        int i = 0;
+        int j = 1;
+        while(i < colors.length) {
+            if(colors[(j-1) % n] != colors[j%n]) {
+                window++;
+                j++;
+            }else {
+                i = j;
+                j = i + 1;
+                window = 1;
+                continue;
+            }
+            
+            if(window == k) {
+                res++;
+                if(colors[(j-1) % n] != colors[j%n]) {
+                    i++;
+                    window -= 1;
+                }else {
+                    i = j;
+                    j = i + 1;
+                    window = 1;
+                }   
+            }
+        }
+
+        return res;
+    }
+}