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

[kallolathome]

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

A 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

    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! 🙂

[InvalidUsername]

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

[kallolathome]

Dear user__name,

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

Hope you will like it now. 🙂

Regards,

Kallol

[abhawsinghka-1]

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