Welcome to Subscribe On Youtube

3865. Reverse K Subarrays 🔒

Description

You are given an integer array nums of length n and an integer k.

You must partition the array into k contiguous subarrays of equal length and reverse each subarray.

It is guaranteed that n is divisible by k.

Return the resulting array after performing the above operation.

 

Example 1:

Input: nums = [1,2,4,3,5,6], k = 3

Output: [2,1,3,4,6,5]

Explanation:

• The array is partitioned into k = 3 subarrays: [1, 2], [4, 3], and [5, 6].
• After reversing each subarray: [2, 1], [3, 4], and [6, 5].
• Combining them gives the final array [2, 1, 3, 4, 6, 5].

Example 2:

Input: nums = [5,4,4,2], k = 1

Output: [2,4,4,5]

Explanation:

• The array is partitioned into k = 1 subarray: [5, 4, 4, 2].
• Reversing it produces [2, 4, 4, 5], which is the final array.

 

Constraints:

• 1 <= n == nums.length <= 1000
• 1 <= nums[i] <= 1000
• 1 <= k <= n
• n is divisible by k.

Solutions

Solution 1: Simulation

Since we need to partition the array into $k$ subarrays of equal length, the length of each subarray is $m = \frac{n}{k}$. We can use a loop to traverse the array with a step size of $m$, and in each iteration, reverse the current subarray.

The time complexity is $O(n)$, where $n$ is the length of the array $\textit{nums}$. The space complexity is $O(1)$, as we only use a constant amount of extra space.

• Java
• C++
• Python
• Go
• TypeScript
• RenderScript

• class Solution {
      public int[] reverseSubarrays(int[] nums, int k) {
          int n = nums.length;
          int m = n / k;
          for (int i = 0; i < n; i += m) {
              int l = i, r = i + m - 1;
              while (l < r) {
                  int t = nums[l];
                  nums[l++] = nums[r];
                  nums[r--] = t;
              }
          }
          return nums;
      }
  }
  
  

• class Solution {
  public:
      vector<int> reverseSubarrays(vector<int>& nums, int k) {
          int n = nums.size();
          int m = n / k;
          for (int i = 0; i < n; i += m) {
              int l = i, r = i + m - 1;
              while (l < r) {
                  swap(nums[l++], nums[r--]);
              }
          }
          return nums;
      }
  };
  
  

• class Solution:
      def reverseSubarrays(self, nums: list[int], k: int) -> list[int]:
          n = len(nums)
          m = n // k
          for i in range(0, n, m):
              nums[i : i + m] = nums[i : i + m][::-1]
          return nums
  
  

• func reverseSubarrays(nums []int, k int) []int {
  	n := len(nums)
  	m := n / k
  	for i := 0; i < n; i += m {
  		l, r := i, i+m-1
  		for l < r {
  			nums[l], nums[r] = nums[r], nums[l]
  			l++
  			r--
  		}
  	}
  	return nums
  }
  
  

• function reverseSubarrays(nums: number[], k: number): number[] {
      const n = nums.length;
      const m = Math.floor(n / k);
      for (let i = 0; i < n; i += m) {
          let l = i,
              r = i + m - 1;
          while (l < r) {
              const t = nums[l];
              nums[l++] = nums[r];
              nums[r--] = t;
          }
      }
      return nums;
  }
  
  

• impl Solution {
      pub fn reverse_subarrays(mut nums: Vec<i32>, k: i32) -> Vec<i32> {
          let n = nums.len();
          let m = n / k as usize;
  
          for i in (0..n).step_by(m) {
              let mut l = i;
              let mut r = i + m - 1;
              while l < r {
                  nums.swap(l, r);
                  l += 1;
                  r -= 1;
              }
          }
  
          nums
      }
  }
  
  

All Problems

All Solutions