Skip to content
Related Articles

Related Articles

Improve Article

Lexicographically largest permutation possible by a swap that is smaller than a given array

  • Difficulty Level : Medium
  • Last Updated : 06 Jul, 2021

Given an array arr[] consisting of N integers, the task is to find the lexicographically largest permutation of the given array possible by exactly one swap, which is smaller than the given array. If it is possible to obtain such a permutation, then print that permutation. Otherwise, print “-1”.

Examples:

Input: arr[] = {5, 4, 3, 2, 1} 
Output: 5 4 3 1 2
Explanation:
Lexicographically, the largest permutation which is smaller than the given array can be formed by swapping 2 and 1.
Hence, the resultant permutation is {5, 4, 3, 1, 2}

Input: arr[] = {1, 2, 3, 4, 5}
Output: -1

 

Approach: The given problem can be solved by finding the last element which is greater than its next element, and swapping it with the next smaller element in the array. Follow the steps below to solve the problem:



Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to lexicographic largest
// permutation possible by a swap
// that is smaller than given array
void findPermutation(vector<int>& arr)
{
    int N = arr.size();
    int i = N - 2;
 
    // Find the index of first element
    // such that arr[i] > arr[i + 1]
    while (i >= 0 && arr[i] <= arr[i + 1])
        i--;
 
    // If the array is sorted
    // in increasing order
    if (i == -1) {
        cout << "-1";
        return;
    }
 
    int j = N - 1;
 
    // Find the index of first element
    // which is smaller than arr[i]
    while (j > i && arr[j] >= arr[i])
        j--;
 
    // If arr[j] == arr[j-1]
    while (j > i && arr[j] == arr[j - 1]) {
 
        // Decrement j
        j--;
    }
 
    // Swap the element
    swap(arr[i], arr[j]);
 
    // Print the array arr[]
    for (auto& it : arr) {
        cout << it << ' ';
    }
}
 
// Driver Code
int main()
{
    vector<int> arr = { 1, 2, 5, 3, 4, 6 };
    findPermutation(arr);
 
    return 0;
}

Java




// java program for the above approach
import java.util.*;
class GFG{
     
  
// Function to lexicographic largest
// permutation possible by a swap
// that is smaller than given array
static void findPermutation(int[] arr)
{
    int N = arr.length;
    int i = N - 2;
  
    // Find the index of first element
    // such that arr[i] > arr[i + 1]
    while (i >= 0 && arr[i] <= arr[i + 1])
        i--;
  
    // If the array is sorted
    // in increasing order
    if (i == -1)
    {
         System.out.print("-1");
        return;
    }
  
    int j = N - 1;
  
    // Find the index of first element
    // which is smaller than arr[i]
    while (j > i && arr[j] >= arr[i])
        j--;
  
    // If arr[j] == arr[j-1]
    while (j > i && arr[j] == arr[j - 1])
    {
  
        // Decrement j
        j--;
    }
  
    // Swap the element
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  
    // Print the array arr[]
    for(int it : arr)
    {
        System.out.print(it + " ");
    }
}
 
 
// Driver code
public static void main(String[] args)
{
    int[] arr = { 1, 2, 5, 3, 4, 6 };
    findPermutation(arr);
}
}
 
// This code is contributed by splevel62.

C#




// C# program for the above approach
using System;
 
class GFG{
 
// Function to lexicographic largest
// permutation possible by a swap
// that is smaller than given array
static void findPermutation(int[] arr)
{
    int N = arr.Length;
    int i = N - 2;
 
    // Find the index of first element
    // such that arr[i] > arr[i + 1]
    while (i >= 0 && arr[i] <= arr[i + 1])
        i--;
 
    // If the array is sorted
    // in increasing order
    if (i == -1)
    {
        Console.Write("-1");
        return;
    }
 
    int j = N - 1;
 
    // Find the index of first element
    // which is smaller than arr[i]
    while (j > i && arr[j] >= arr[i])
        j--;
 
    // If arr[j] == arr[j-1]
    while (j > i && arr[j] == arr[j - 1])
    {
 
        // Decrement j
        j--;
    }
 
    // Swap the element
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
 
    // Print the array arr[]
    foreach(int it in arr)
    {
        Console.Write(it + " ");
    }
}
 
// Driver Code
public static void Main()
{
    int[] arr = { 1, 2, 5, 3, 4, 6 };
    findPermutation(arr);
}
}
 
// This code is contributed by ukasp

Python3




# Python program for the above approach
 
# Function to lexicographic largest
# permutation possible by a swap
# that is smaller than given array
def findPermutation(arr):
 
    N = len(arr)
    i = N - 2
 
    # Find the index of first element
    # such that arr[i] > arr[i + 1]
    while (i >= 0 and arr[i] <= arr[i + 1]):
        i -= 1
 
    # If the array is sorted
    # in increasing order
    if (i == -1) :
        print("-1")
        return
     
 
    j = N - 1
 
    # Find the index of first element
    # which is smaller than arr[i]
    while (j > i and arr[j] >= arr[i]):
        j -= 1
 
    # If arr[j] == arr[j-1]
    while (j > i and arr[j] == arr[j - 1]) :
 
        # Decrement j
        j -= 1
     
 
    # Swap the element
    temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
 
    # Pr the array arr[]
    for it in arr :
        print(it, end = " ")
     
# Driver Code
arr =  [ 1, 2, 5, 3, 4, 6 ]
findPermutation(arr)
 
# This code is contributed by code_hunt.

Javascript




<script>
 
// Javascript program for the above approach
 
// Function to lexicographic largest
// permutation possible by a swap
// that is smaller than given array
function findPermutation(arr)
{
    let N = arr.length;
    let i = N - 2;
  
    // Find the index of first element
    // such that arr[i] > arr[i + 1]
    while (i >= 0 && arr[i] <= arr[i + 1])
        i--;
  
    // If the array is sorted
    // in increasing order
    if (i == -1)
    {
        document.write("-1");
        return;
    }
  
    let j = N - 1;
  
    // Find the index of first element
    // which is smaller than arr[i]
    while (j > i && arr[j] >= arr[i])
        j--;
  
    // If arr[j] == arr[j-1]
    while (j > i && arr[j] == arr[j - 1])
    {
        // Decrement j
        j--;
    }
  
    // Swap the element
    let temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  
    // Print the array arr[]
    for(let it in arr)
    {
        document.write(arr[it] + " ");
    }
}
 
// Driver Code
     
    let arr = [ 1, 2, 5, 3, 4, 6 ];
    findPermutation(arr);
       
</script>
Output: 
1 2 4 3 5 6

 

Time Complexity: O(N)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :