From 8036b6f34f14af82ba278641f5b291c11eddbfb3 Mon Sep 17 00:00:00 2001
From: Margaret <62753112+meg-1@users.noreply.github.com>
Date: Thu, 11 Apr 2024 14:55:52 +0300
Subject: [PATCH 1/3] adding a matrix equalization algorithm

---
 matrix/matrix_equalization.py | 45 +++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 matrix/matrix_equalization.py

diff --git a/matrix/matrix_equalization.py b/matrix/matrix_equalization.py
new file mode 100644
index 000000000000..cad592c13f04
--- /dev/null
+++ b/matrix/matrix_equalization.py
@@ -0,0 +1,45 @@
+import sys
+
+
+def array_equalization(vector: list[int], k: int) -> int:
+    """
+
+    This algorithm equalizes all elements of the input vector
+    to a common value, by making the minimal number of
+    "updates" under the constraint of a step size (k)
+
+    >>> array_equalization([1, 1, 6, 2, 4, 6, 5, 1, 7, 2, 2, 1, 7, 2, 2], 4)
+    4
+    >>> array_equalization([22, 81, 88, 71, 22, 81, 632, 81, 81, 22, 92], 2)
+    5
+    >>> array_equalization([-22, 81, -88, 71, 22, 81, 632, 81, -81, -22, 92], 2)
+    5
+    >>> array_equalization([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 5)
+    0
+    >>> array_equalization([sys.maxsize for c in range(10)], 3)
+    0
+    >>> array_equalization([22, 22, 22, 33, 33, 33], 2)
+    2
+
+    """
+    unique_elements = set(vector)
+    min_updates = sys.maxsize
+
+    for element in unique_elements:
+        elem_index = 0
+        updates = 0
+        while elem_index < len(vector):
+            if vector[elem_index] != element:
+                updates += 1
+                elem_index += k
+            else:
+                elem_index += 1
+        min_updates = min(min_updates, updates)
+
+    return min_updates
+
+
+if __name__ == "__main__":
+    from doctest import testmod
+
+    testmod()

From 3fe9825be7b38823c5325d882ef69510a2c61f42 Mon Sep 17 00:00:00 2001
From: Margaret <62753112+meg-1@users.noreply.github.com>
Date: Wed, 24 Apr 2024 18:30:31 +0300
Subject: [PATCH 2/3] Adding url for more details

---
 matrix/matrix_equalization.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/matrix/matrix_equalization.py b/matrix/matrix_equalization.py
index cad592c13f04..9d50591baaa4 100644
--- a/matrix/matrix_equalization.py
+++ b/matrix/matrix_equalization.py
@@ -8,6 +8,8 @@ def array_equalization(vector: list[int], k: int) -> int:
     to a common value, by making the minimal number of
     "updates" under the constraint of a step size (k)
 
+    details: https://www.geeksforgeeks.org/equalize-array-using-array-elements/
+
     >>> array_equalization([1, 1, 6, 2, 4, 6, 5, 1, 7, 2, 2, 1, 7, 2, 2], 4)
     4
     >>> array_equalization([22, 81, 88, 71, 22, 81, 632, 81, 81, 22, 92], 2)

From bd5aae832878898ad9007cd159ccec8c8f6d6b03 Mon Sep 17 00:00:00 2001
From: Margaret <62753112+meg-1@users.noreply.github.com>
Date: Wed, 1 May 2024 13:11:52 +0300
Subject: [PATCH 3/3] Implementing suggestions

---
 matrix/matrix_equalization.py | 34 +++++++++++++++++++++-------------
 1 file changed, 21 insertions(+), 13 deletions(-)

diff --git a/matrix/matrix_equalization.py b/matrix/matrix_equalization.py
index 9d50591baaa4..e7e76505cf63 100644
--- a/matrix/matrix_equalization.py
+++ b/matrix/matrix_equalization.py
@@ -1,31 +1,39 @@
-import sys
+from sys import maxsize
 
 
-def array_equalization(vector: list[int], k: int) -> int:
+def array_equalization(vector: list[int], step_size: int) -> int:
     """
-
     This algorithm equalizes all elements of the input vector
     to a common value, by making the minimal number of
-    "updates" under the constraint of a step size (k)
-
-    details: https://www.geeksforgeeks.org/equalize-array-using-array-elements/
+    "updates" under the constraint of a step size (step_size).
 
     >>> array_equalization([1, 1, 6, 2, 4, 6, 5, 1, 7, 2, 2, 1, 7, 2, 2], 4)
     4
     >>> array_equalization([22, 81, 88, 71, 22, 81, 632, 81, 81, 22, 92], 2)
     5
-    >>> array_equalization([-22, 81, -88, 71, 22, 81, 632, 81, -81, -22, 92], 2)
-    5
     >>> array_equalization([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 5)
     0
-    >>> array_equalization([sys.maxsize for c in range(10)], 3)
-    0
     >>> array_equalization([22, 22, 22, 33, 33, 33], 2)
     2
-
+    >>> array_equalization([1, 2, 3], 0)
+    Traceback (most recent call last):
+    ValueError: Step size must be positive and non-zero.
+    >>> array_equalization([1, 2, 3], -1)
+    Traceback (most recent call last):
+    ValueError: Step size must be positive and non-zero.
+    >>> array_equalization([1, 2, 3], 0.5)
+    Traceback (most recent call last):
+    ValueError: Step size must be an integer.
+    >>> array_equalization([1, 2, 3], maxsize)
+    1
     """
+    if step_size <= 0:
+        raise ValueError("Step size must be positive and non-zero.")
+    if not isinstance(step_size, int):
+        raise ValueError("Step size must be an integer.")
+
     unique_elements = set(vector)
-    min_updates = sys.maxsize
+    min_updates = maxsize
 
     for element in unique_elements:
         elem_index = 0
@@ -33,7 +41,7 @@ def array_equalization(vector: list[int], k: int) -> int:
         while elem_index < len(vector):
             if vector[elem_index] != element:
                 updates += 1
-                elem_index += k
+                elem_index += step_size
             else:
                 elem_index += 1
         min_updates = min(min_updates, updates)