Rotate Array by right

Author: kshitizsaini113

src/main/java/array/rotate_array/RotateArray.java

@@ -0,0 +1,45 @@
+package array.rotate_array;
+
+/**
+ * Utility class to rotate an integer array to the right by a given number of steps.
+ *
+ * <p>The rotation is performed in-place using the array reversal technique,
+ * achieving O(n) time complexity and O(1) extra space.</p>
+ */
+public class RotateArray {
+
+    /**
+     * Rotates the given array to the right by {@code k} steps.
+     *
+     * <p>If {@code k} is greater than the array length, it is reduced using
+     * the modulo operation.</p>
+     *
+     * @param nums the array to be rotated
+     * @param k the number of steps to rotate the array to the right;
+     *          must be non-negative
+     * @throws ArithmeticException if the array is empty
+     */
+    public void rotate(int[] nums, int k) {
+        k = k % nums.length;
+        reverse(nums, 0, nums.length - k - 1);
+        reverse(nums, nums.length - k, nums.length - 1);
+        reverse(nums, 0, nums.length - 1);
+    }
+
+    /**
+     * Reverses the elements of the array between the given indices.
+     *
+     * @param nums the array whose elements are to be reversed
+     * @param startIdx the starting index of the range (inclusive)
+     * @param lastIdx the ending index of the range (inclusive)
+     */
+    private void reverse(int[] nums, int startIdx, int lastIdx) {
+        while (startIdx < lastIdx) {
+            int temp = nums[startIdx];
+            nums[startIdx] = nums[lastIdx];
+            nums[lastIdx] = temp;
+            startIdx++;
+            lastIdx--;
+        }
+    }
+}

src/main/java/array/rotate_array/package-info.java

@@ -0,0 +1,17 @@
+/**
+ * Provides utilities for performing array rotation operations.
+ *
+ * <p>This package contains classes that implement efficient algorithms
+ * to rotate an integer array to the right by a given number of steps.
+ * The rotation is performed in-place using constant extra space.</p>
+ *
+ * <p>Key concepts used:
+ * <ul>
+ *   <li>Modulo operation to handle large rotation counts</li>
+ *   <li>Array reversal technique for optimal performance</li>
+ * </ul>
+ * </p>
+ *
+ * @since 1.0
+ */
+package array.rotate_array;

src/test/java/array/rotate_array/RotateArrayTest.java

@@ -0,0 +1,48 @@
+package array.rotate_array;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+/**
+ * Test class for {@link RotateArray}.
+ */
+class RotateArrayTest {
+
+    private final RotateArray rotateArray = new RotateArray();
+
+    @Test
+    void testRotateByNormalK() {
+        int[] nums = {1, 2, 3, 4, 5, 6, 7};
+        rotateArray.rotate(nums, 3);
+        assertArrayEquals(new int[]{5, 6, 7, 1, 2, 3, 4}, nums);
+    }
+
+    @Test
+    void testRotateByZero() {
+        int[] nums = {1, 2, 3};
+        rotateArray.rotate(nums, 0);
+        assertArrayEquals(new int[]{1, 2, 3}, nums);
+    }
+
+    @Test
+    void testRotateByArrayLength() {
+        int[] nums = {1, 2, 3, 4};
+        rotateArray.rotate(nums, 4);
+        assertArrayEquals(new int[]{1, 2, 3, 4}, nums);
+    }
+
+    @Test
+    void testRotateByMoreThanArrayLength() {
+        int[] nums = {1, 2, 3};
+        rotateArray.rotate(nums, 5);
+        assertArrayEquals(new int[]{2, 3, 1}, nums);
+    }
+
+    @Test
+    void testSingleElementArray() {
+        int[] nums = {10};
+        rotateArray.rotate(nums, 3);
+        assertArrayEquals(new int[]{10}, nums);
+    }
+}