###### Technical Articles # Easy way to perform Next Permutation in SAP BTP ABAP(Steampunk), JS & Python

## Introduction

This is part of the Easy way to write algorithms in ABAP: Series 01. For more algorithms, please check the main blog-post.

## Problem

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

Time Complexity: O(n)

Space Complexity: O(1)

### ABAP

``````CLASS zcl_algo_nxtpermut DEFINITION
PUBLIC
FINAL
CREATE PUBLIC .

PUBLIC SECTION.
* Mandatory declaration

PROTECTED SECTION.
PRIVATE SECTION.
TYPES ty_nums TYPE STANDARD TABLE OF i WITH EMPTY KEY.

METHODS getNextPermutation
CHANGING lt_nums TYPE STANDARD TABLE.

METHODS reverseNumbers
CHANGING lt_nums TYPE ty_nums
lv_i    TYPE i
lv_j    TYPE i.

METHODS swapNumbers
CHANGING lt_nums TYPE ty_nums
lv_i    TYPE i
lv_j    TYPE i.

ENDCLASS.

CLASS zcl_algo_nxtpermut IMPLEMENTATION.

*    lt_nums = VALUE ty_nums( ( 3 ) ( 2 ) ( 1 ) ).
DATA(lt_nums) = VALUE ty_nums( ( 1 ) ( 3 ) ( 5 ) ( 4 ) ( 2 ) ).
*    lt_nums = VALUE ty_nums( ( 1 ) ( 2 ) ( 3 ) ).

*   calling the method
getNextPermutation( CHANGING lt_nums = lt_nums ).

out->write( |next permutation:------->| ).
out->write( lt_nums ).

FREE lt_nums.

ENDMETHOD.

METHOD getNextPermutation.

DATA(lv_i) = 1.
DATA(lv_j) = 1.

*   step: 1
LOOP AT lt_nums ASSIGNING FIELD-SYMBOL(<lf_wa>) STEP -1 FROM lines( lt_nums ) - 1.
IF sy-tabix GE 1 AND <lf_wa> < lt_nums[ sy-tabix + 1 ].
lv_i = lines( lt_nums ) + 1 - sy-tabix.
EXIT.
ENDIF.
ENDLOOP.

UNASSIGN <lf_wa>.

*   base condition
IF lv_i = 1.
lv_j = lines( lt_nums ).
swapNumbers( CHANGING lt_nums = lt_nums
lv_i = lv_i
lv_j = lv_j ).

ELSE.
*     step: 2
LOOP AT lt_nums ASSIGNING <lf_wa> FROM 1 TO lv_i.
IF <lf_wa> > lt_nums[ lv_i ].
lv_j = sy-tabix - 1.
EXIT.
ENDIF.
ENDLOOP.
*     step: 3
swapNumbers( CHANGING lt_nums = lt_nums
lv_i = lv_i
lv_j = lv_j ).
*     step: 4: manipulations
lv_j += 1.
lv_i = lines( lt_nums ).
*   step: 5
reverseNumbers( CHANGING lt_nums = lt_nums
lv_i = lv_j
lv_j = lv_i ).
ENDIF.

UNASSIGN <lf_wa>.
FREE: lv_i, lv_j.

ENDMETHOD.

METHOD reverseNumbers.
WHILE lv_i < lv_j.
swapNumbers( CHANGING lt_nums = lt_nums
lv_i = lv_i
lv_j = lv_j ).

lv_i += 1.
lv_j -= 1.
ENDWHILE.

ENDMETHOD.

METHOD swapNumbers.
DATA(lv_temp) = 0.

*   swapping
lv_temp = lt_nums[ lv_i ].
lt_nums[ lv_i ] =  lt_nums[ lv_j ].
lt_nums[ lv_j ] = lv_temp.

FREE lv_temp.
ENDMETHOD.

ENDCLASS.
``````

### Python

``````class Solution:
def nextPermutation(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
"""

# index of the first element that is smaller than the element to its right
lv_index = -1

for i in range(len(nums) - 1, 0, -1):
if nums[i] > nums[i - 1]:
lv_index = i - 1
break

# Base condition
if lv_index == -1:
reverse(nums, 0, len(nums) - 1)
return

j = len(nums) - 1

for i in range(len(nums) - 1, lv_index, -1):
if nums[i] > nums[lv_index]:
j = i
break

# swapping
nums[lv_index], nums[j] = nums[j], nums[lv_index]
# reversing
reverse(nums, lv_index + 1, len(nums) - 1)

# reverse method
def reverse(nums, i, j):
while i < j:
# swapping
nums[i], nums[j] = nums[j], nums[i]
# incrementing
i += 1
j -= 1
``````

### JavaScript

``````/**
* @param {number[]} nums
* @return {void} Do not return anything, modify nums in-place instead.
*/
var nextPermutation = function (nums) {

if ((nums === null) || (nums.length <= 1)) return;

var i = nums.length - 2;

while (i >= 0 && nums[i] >= nums[i + 1]) i--;
if (i >= 0) {
var j = nums.length - 1;
while (nums[j] <= nums[i]) j--;
swap_numbers(nums, i, j);
}
/** reversing the right side of the array */
reverse_numbers(nums, i + 1, nums.length - 1);

};

function swap_numbers(array, i, j) {
var temp = array[i];
array[i] = array[j];
array[j] = temp;
}

function reverse_numbers(array, i, j) {
while (i < j) swap_numbers(array, i++, j--);
}``````

N.B: For ABAP, I am using SAP BTP ABAP Environment 2211 Release.

Happy Coding! 🙂

### Assigned Tags

You must be Logged on to comment or reply to a post. "znextpermutation" should not be a class because calculating a permutation is not an object. znextpermutation is a a function.

When you insist on doing this in an object oriented way, you can define a class for your "ARRAY_OF_INT_WITH_EVERY_DIGIT_ONCE" and define a method for calculation of the next permutation.  Your array would be an instance variable filled on object creation.

Due to the not ideal abstraction you are using instance variables like global variables in procedural programming which is not desirable.

Your JS solution is better because it does not use object oriented programming at all which leads to better code. Kallol Chakraborty
Blog Post Author

Dear First Name Last Name,

Thanks for checking out the blogpost. I have made necessary changes & updated the blogpost.

Hope you will like it now. 🙂

Regards,

Kallol Hi Kallol, I am not sure if the ABAP logic is complete. Your base condition will with array of size 3. Also, your other logic will fail for bigger array size. Try with input

DATA(lt_nums) = VALUE ty_nums( ( 2 ) ( 6 ) ( 3 ) ( 5 ) ( 4 ) ( 1 ) )..