# JSDevLife

JavaScript Solutions, Competitive programming in JavaScript, MCQ in JS

# A solution to LeetCode Problem 31. Next Permutation in JavaScript

If you're preparing for technical interviews or want to improve your coding skills, solving practice problems on LeetCode is a great way.

In this post, we'll discuss a solution to the "31. Next Permutation" problem on LeetCode.

### Problem Statement:

permutation of an array of integers is an arrangement of its members into a sequence or linear order.

• For example, for `arr = [1,2,3]`, the following are all the permutations of `arr``[1,2,3], [1,3,2], [2, 1, 3], [2, 3, 1], [3,1,2], [3,2,1]`.

The next permutation of an array of integers is the next lexicographically greater permutation of its integer. More formally, if all the permutations of the array are sorted in one container according to their lexicographical order, then the next permutation of that array is the permutation that follows it in the sorted container. If such arrangement is not possible, the array must be rearranged as the lowest possible order (i.e., sorted in ascending order).

• For example, the next permutation of `arr = [1,2,3]` is `[1,3,2]`.
• Similarly, the next permutation of `arr = [2,3,1]` is `[3,1,2]`.
• While the next permutation of `arr = [3,2,1]` is `[1,2,3]` because `[3,2,1]` does not have a lexicographical larger rearrangement.

Given an array of integers `nums`find the next permutation of `nums`.

The replacement must be in place and use only constant extra memory.

Example 1:

```Input: nums = [1,2,3]
Output: [1,3,2]
```

Example 2:

```Input: nums = [3,2,1]
Output: [1,2,3]
```

Example 3:

```Input: nums = [1,1,5]
Output: [1,5,1]
```

Constraints:

• `1 <= nums.length <= 100`
• ```0 <= nums[i] <= 100 ```

### Solution:

The key to this solution is the use of two pointers, i and j. The pointer i starts at the second-to-last element of the array and moves left until it finds an element that is smaller than the element to its right (or until it reaches the beginning of the array). This element is the pivot element.

Next, the pointer j starts at the end of the array and moves left until it finds an element that is larger than the pivot element. This element is the successor element.

Once the pivot and successor elements have been found, the code swaps their values and then reverses the elements to the right of the pivot element. This results in the next permutation of the given array.

Here is the implementation of this solution in JavaScript:

var nextPermutation = function(nums) {
let j = nums.length - 1, i = j - 1;
while (nums[i + 1] <= nums[i]) i--;
if (~i) {
while (nums[j] <= nums[i]) j--;
swap(nums, i, j);
}
for (let k = i + 1, stop = (i + nums.length) / 2; k < stop; k++) {
swap(nums, k, nums.length - k + i);
}
};

function swap(nums, i, j) {
let temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}

The complexity of the solution you provided for LeetCode Problem 31, "Next Permutation," is O(n).

#### This is because the solution uses two pointers that each iterate over the entire array once, resulting in a time complexity of O(n). In addition, the solution performs constant-time operations (such as in-place swapping and reversal of a subarray) on the array, which do not significantly impact the overall time complexity.

Therefore, the solution has a linear time complexity and should be efficient for arrays of any size.

I hope this helps as a reference for solving LeetCode Problem 31 in JavaScript! Let me know if you have any questions or if you'd like to see any additional examples.