Skip to Content
Technical Articles
Author's profile photo Kallol Chakraborty

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 numsfind 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
    INTERFACES if_oo_adt_classrun.

  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.

  METHOD if_oo_adt_classrun~main.

*    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

      3 Comments
      You must be Logged on to comment or reply to a post.
      Author's profile photo First Name Last Name
      First Name Last Name

      "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.

      Author's profile photo Kallol Chakraborty
      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

      Author's profile photo Ananya Bhawsinghka
      Ananya Bhawsinghka

      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 ) )..