Alternating groups II

Author: volodimyr

3208.alterating_group_ii/group.py

@@ -0,0 +1,68 @@
+# 3208. Alternating groups II
+# Topics: 'Sliding Window', 'Array'
+# Level: 'Medium'
+
+# There is a circle of red and blue tiles. You are given an array of integers colors and an integer k. The color of tile i is represented by colors[i]:
+
+#     colors[i] == 0 means that tile i is red.
+#     colors[i] == 1 means that tile i is blue.
+
+# An alternating group is every k contiguous tiles in the circle with alternating colors (each tile in the group except the first and last one has a different color from its left and right tiles).
+
+# Return the number of alternating groups.
+
+# Note that since colors represents a circle, the first and the last tiles are considered to be next to each other.
+
+ 
+
+# Example 1:
+
+# Input: colors = [0,1,0,1,0], k = 3
+
+# Output: 3
+
+# Explanation:
+
+# Alternating groups:
+
+# Example 2:
+
+# Input: colors = [0,1,0,0,1,0,1], k = 6
+
+# Output: 2
+
+# Explanation:
+
+# Alternating groups:
+
+# Example 3:
+
+# Input: colors = [1,1,0,1], k = 4
+
+# Output: 0
+
+# Explanation:
+
+ 
+
+# Constraints:
+
+#     3 <= colors.length <= 105
+#     0 <= colors[i] <= 1
+#     3 <= k <= colors.length
+
+from typing import List
+
+class Solution:
+    def numberOfAlternatingGroups(self, colors: List[int], k: int) -> int:
+        for i in range(k-1):
+            colors.append(colors[i])
+        start = 0
+        count = 0
+        for i in range (len(colors)):
+            if i != 0 and colors[i-1] == colors[i]:
+                start = i
+            elif i + 1 - start == k:
+                start += 1
+                count += 1
+        return count

3208.alterating_group_ii/test_group.py

@@ -0,0 +1,115 @@
+from typing import List
+import unittest
+
+from group import Solution
+
+class TestAlternatingGroups(unittest.TestCase):
+    
+    def setUp(self):
+        self.solution = Solution()
+    
+    # Example test cases
+    def test_example1(self):
+        """Test with colors = [0,1,0,1,0], k = 3"""
+        colors = [0, 1, 0, 1, 0]
+        k = 3
+        self.assertEqual(self.solution.numberOfAlternatingGroups(colors, k), 3)
+    
+    def test_example2(self):
+        """Test with colors = [0,1,0,0,1,0,1], k = 6"""
+        colors = [0, 1, 0, 0, 1, 0, 1]
+        k = 6
+        self.assertEqual(self.solution.numberOfAlternatingGroups(colors, k), 2)
+    
+    def test_example3(self):
+        """Test with colors = [1,1,0,1], k = 4"""
+        colors = [1, 1, 0, 1]
+        k = 4
+        self.assertEqual(self.solution.numberOfAlternatingGroups(colors, k), 0)
+    
+    def test_all_ones(self):
+        """Test with all tiles blue"""
+        colors = [1, 1, 1, 1]
+        k = 3
+        self.assertEqual(self.solution.numberOfAlternatingGroups(colors, k), 0)
+    
+    # Fully alternating patterns
+    def test_fully_alternating_pattern(self):
+        """Test with perfect alternating pattern"""
+        colors = [0, 1, 0, 1, 0, 1, 0, 1]
+        k = 4
+        self.assertEqual(self.solution.numberOfAlternatingGroups(colors, k), 8)
+    
+    def test_long_alternating_pattern(self):
+        """Test with longer alternating pattern"""
+        colors = [0, 1] * 10  # [0,1,0,1,...] length 20
+        k = 5
+        self.assertEqual(self.solution.numberOfAlternatingGroups(colors, k), 20)
+    
+    # Partial alternating patterns
+    def test_one_break_in_pattern(self):
+        """Test with one break in alternating pattern"""
+        colors = [0, 1, 0, 1, 1, 0, 1, 0]
+        k = 4
+        # Should find groups that don't include the break at index 4
+        result = self.solution.numberOfAlternatingGroups(colors, k)
+        self.assertGreaterEqual(result, 0)
+    
+    def test_multiple_breaks(self):
+        """Test with multiple breaks in pattern"""
+        colors = [0, 1, 1, 0, 1, 1, 0, 1]
+        k = 3
+        result = self.solution.numberOfAlternatingGroups(colors, k)
+        self.assertGreaterEqual(result, 0)
+    
+    def test_k_equals_3_mixed(self):
+        """Test with k=3 on mixed pattern"""
+        colors = [1, 0, 1, 1, 0]
+        k = 3
+        result = self.solution.numberOfAlternatingGroups(colors, k)
+        self.assertGreaterEqual(result, 0)
+    
+    # Circular property tests
+    def test_circular_connection_alternating(self):
+        """Test circular connection with alternating at boundaries"""
+        colors = [1, 0, 1, 0]
+        k = 3
+        # Since it's circular: [1,0,1,0] connects to itself
+        # Valid groups should consider wraparound
+        result = self.solution.numberOfAlternatingGroups(colors, k)
+        self.assertEqual(result, 4)
+    
+    def test_circular_connection_non_alternating(self):
+        """Test circular connection with same color at boundaries"""
+        colors = [0, 1, 0, 0]
+        k = 3
+        result = self.solution.numberOfAlternatingGroups(colors, k)
+        self.assertGreaterEqual(result, 0)
+    
+    # Larger arrays
+    def test_large_array_mostly_alternating(self):
+        """Test with larger array that's mostly alternating"""
+        colors = [0, 1] * 50  # Length 100
+        k = 10
+        result = self.solution.numberOfAlternatingGroups(colors, k)
+        self.assertEqual(result, 100)
+    
+    def test_large_array_with_breaks(self):
+        """Test with larger array with some breaks"""
+        colors = [0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1]
+        k = 4
+        result = self.solution.numberOfAlternatingGroups(colors, k)
+        self.assertGreaterEqual(result, 0)
+    
+    # Single valid group
+    def test_exactly_one_group(self):
+        """Test where exactly one alternating group exists"""
+        colors = [0, 0, 0, 1, 0, 1]
+        k = 3
+        result = self.solution.numberOfAlternatingGroups(colors, k)
+        self.assertGreaterEqual(result, 0)
+
+
+if __name__ == '__main__':
+    # Run tests with verbose output
+    unittest.main(verbosity=2)