rotate array

Author: volodimyr

189.rotate_array/rotate.go

@@ -0,0 +1,57 @@
+// 189. Rotate array
+// Topics: 'Array', 'Math', 'Two pointer'
+// Level: 'Medium'
+
+//Given an integer array nums, rotate the array to the right by k steps, where k is non-negative.
+
+// Example 1:
+
+// Input: nums = [1,2,3,4,5,6,7], k = 3
+// Output: [5,6,7,1,2,3,4]
+// Explanation:
+// rotate 1 steps to the right: [7,1,2,3,4,5,6]
+// rotate 2 steps to the right: [6,7,1,2,3,4,5]
+// rotate 3 steps to the right: [5,6,7,1,2,3,4]
+
+// Example 2:
+
+// Input: nums = [-1,-100,3,99], k = 2
+// Output: [3,99,-1,-100]
+// Explanation:
+// rotate 1 steps to the right: [99,-1,-100,3]
+// rotate 2 steps to the right: [3,99,-1,-100]
+
+// Constraints:
+
+//     1 <= nums.length <= 105
+//     -231 <= nums[i] <= 231 - 1
+//     0 <= k <= 105
+
+// Follow up:
+
+//     Try to come up with as many solutions as you can. There are at least three different ways to solve this problem.
+//     Could you do it in-place with O(1) extra space?
+
+package rotatearray
+
+func rotate(nums []int, k int) {
+	k = k % len(nums)
+	if k == 0 {
+		return
+	}
+	k = k % len(nums)
+	if k == 0 {
+		return
+	}
+	reverse(nums)
+	reverse(nums[:k])
+	reverse(nums[k:])
+}
+
+func reverse(nums []int) {
+	for i, j := 0, len(nums)-1; i < j; {
+		nums[i], nums[j] = nums[j], nums[i]
+		i++
+		j--
+	}
+}

189.rotate_array/rotate_test.go

@@ -0,0 +1,149 @@
+package rotatearray
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestRotate(t *testing.T) {
+	tests := []struct {
+		name string
+		nums []int
+		k    int
+		want []int
+	}{
+		{
+			name: "example 1 - rotate by 3",
+			nums: []int{1, 2, 3, 4, 5, 6, 7},
+			k:    3,
+			want: []int{5, 6, 7, 1, 2, 3, 4},
+		},
+		{
+			name: "example 2 - rotate by 2",
+			nums: []int{-1, -100, 3, 99},
+			k:    2,
+			want: []int{3, 99, -1, -100},
+		},
+		{
+			name: "k equals array length",
+			nums: []int{1, 2, 3, 4},
+			k:    4,
+			want: []int{1, 2, 3, 4},
+		},
+		{
+			name: "k greater than array length",
+			nums: []int{1, 2, 3},
+			k:    5,
+			want: []int{2, 3, 1},
+		},
+		{
+			name: "k is zero",
+			nums: []int{1, 2, 3, 4},
+			k:    0,
+			want: []int{1, 2, 3, 4},
+		},
+		{
+			name: "single element array",
+			nums: []int{1},
+			k:    3,
+			want: []int{1},
+		},
+		{
+			name: "two element array rotate by 1",
+			nums: []int{1, 2},
+			k:    1,
+			want: []int{2, 1},
+		},
+		{
+			name: "rotate by 1",
+			nums: []int{1, 2, 3, 4, 5},
+			k:    1,
+			want: []int{5, 1, 2, 3, 4},
+		},
+		{
+			name: "rotate entire array multiple times",
+			nums: []int{1, 2, 3},
+			k:    9,
+			want: []int{1, 2, 3},
+		},
+		{
+			name: "array with negative numbers",
+			nums: []int{-5, -3, -1, 0, 2, 4},
+			k:    2,
+			want: []int{2, 4, -5, -3, -1, 0},
+		},
+		{
+			name: "array with duplicates",
+			nums: []int{1, 1, 2, 2, 3, 3},
+			k:    3,
+			want: []int{2, 3, 3, 1, 1, 2},
+		},
+		{
+			name: "large k value",
+			nums: []int{1, 2, 3, 4, 5},
+			k:    100003,
+			want: []int{3, 4, 5, 1, 2},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Make a copy since rotate modifies in-place
+			nums := make([]int, len(tt.nums))
+			copy(nums, tt.nums)
+
+			rotate(nums, tt.k)
+
+			if !reflect.DeepEqual(nums, tt.want) {
+				t.Errorf("rotate() = %v, want %v", nums, tt.want)
+			}
+		})
+	}
+}
+
+func TestReverse(t *testing.T) {
+	tests := []struct {
+		name string
+		nums []int
+		want []int
+	}{
+		{
+			name: "reverse odd length array",
+			nums: []int{1, 2, 3, 4, 5},
+			want: []int{5, 4, 3, 2, 1},
+		},
+		{
+			name: "reverse even length array",
+			nums: []int{1, 2, 3, 4},
+			want: []int{4, 3, 2, 1},
+		},
+		{
+			name: "reverse single element",
+			nums: []int{1},
+			want: []int{1},
+		},
+		{
+			name: "reverse two elements",
+			nums: []int{1, 2},
+			want: []int{2, 1},
+		},
+		{
+			name: "reverse empty array",
+			nums: []int{},
+			want: []int{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			nums := make([]int, len(tt.nums))
+			copy(nums, tt.nums)
+
+			reverse(nums)
+
+			if !reflect.DeepEqual(nums, tt.want) {
+				t.Errorf("reverse() = %v, want %v", nums, tt.want)
+			}
+		})
+	}
+}