Skip to content
Related Articles

Related Articles

Improve Article

Lexicographically smallest permutation of Array such that prefix sum till any index is not equal to K

  • Last Updated : 07 Jul, 2021

Given an array arr[], consisting of N distinct positive integers and an integer K, the task is to find the lexicographically smallest permutation of the array, such that the sum of elements of any prefix of the output array is not equal to the K. If there exists no such permutation, then print “-1“. Otherwise, print the output array.

Examples:

Input: arr[] = {2, 6, 4, 5, 3, 1}, K = 15
Output: 1 2 3 4 6 5
Explanation:
The lexicographically smallest permutation of the given array is, {1, 2, 3, 4, 6, 5} having no prefix of sum equal to 15.

Input: arr[]={3, 1, 4, 6}, K = 12
Output: 1 3 4 6
Explanation:
The lexicographically smallest permutation of the given array is, {1, 3, 4, 6} having no prefix of sum equal to 12.

Approach: The problem can be solved by first sorting the array in ascending order and then swapping the last element of the prefix whose sum is equal to K, with the next element. Follow the steps below to solve this problem: 



  • If the sum of the array is equal to K, then print “-1” as it will be impossible to find any permutation of the array satisfying the conditions.
  • Sort the array in ascending order.
  • Initialize a variable, say preSum as 0 to store the sum of a prefix.
  • Iterate over the range [0, N-2] using the variable i and perform the following steps:
    • Increment preSum by arr[i].
    • If preSum is equal to K, then swap arr[i] and arr[i+1] and then break.
  • Finally, after completing the above steps, print the elements of the array, arr[].

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the output array
// satisfying given conditions
void findpermutation(int arr[], int N, int K)
{
    int sum = 0;
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++) {
        sum = sum + arr[i];
    }
 
    // If sum is equal to K
    if (sum == K) {
        cout << -1 << endl;
    }
    else {
        // Sort array in ascending order
        sort(arr, arr + N);
 
        // Stores the sum of a prefix
        int preSum = 0;
 
        // Traverse the array arr[]
        for (int i = 0; i < N; i++) {
            // Update the preSum
            preSum = preSum + arr[i];
            // If preSum is equal to K
            if (preSum == K) {
                // Swap
                swap(arr[i], arr[i + 1]);
                break;
            }
        }
 
        // Print the array arr[]
        for (int i = 0; i < N; i++) {
            cout << arr[i] << " ";
        }
 
        cout << endl;
    }
}
 
// Driver code
int main()
{
    int arr[] = { 2, 6, 4, 5, 3, 1 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 15;
 
    findpermutation(arr, N, K);
}

Java




// Java program for the above approach
import java.util.*;
  
class GFG{
 
// Function to find the output array
// satisfying given conditions
static void findpermutation(int arr[], int N, int K)
{
    int sum = 0;
 
    // Traverse the array arr[]
    for(int i = 0; i < N; i++)
    {
        sum = sum + arr[i];
    }
 
    // If sum is equal to K
    if (sum == K)
    {
        System.out.println(-1);
    }
    else
    {
         
        // Sort array in ascending order
        Arrays.sort(arr);
 
        // Stores the sum of a prefix
        int preSum = 0;
 
        // Traverse the array arr[]
        for(int i = 0; i < N; i++)
        {
             
            // Update the preSum
            preSum = preSum + arr[i];
             
            // If preSum is equal to K
            if (preSum == K)
            {
                 
                // Swap
                swap(arr, i, i + 1);
                break;
            }
        }
         
        // Print the array arr[]
        for(int i = 0; i < N; i++)
        {
            System.out.print(arr[i] + " ");
        }
        System.out.println( );
    }
}
 
static int[] swap(int []arr, int i, int j)
{
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
    return arr;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 2, 6, 4, 5, 3, 1 };
    int N = arr.length;
    int K = 15;
 
    findpermutation(arr, N, K);
}
}
 
// This code is contributed by shivanisinghss2110

Python3




# Pyhton3 program for the above approach
 
# Function to find the output array
# satisfying given conditions
def findpermutation(arr, N, K):
     
    sum = 0
 
    # Traverse the array arr[]
    for i in range(0, N):
        sum = sum + arr[i]
         
    # If sum is equal to K
    if (sum == K):
        print("-1")
    else:
         
        # Sort array in ascending order
        arr.sort()
 
        # Stores the sum of a prefix
        preSum = 0
 
        # Traverse the array arr[]
        for i in range(0, N):
             
            # Update the preSum
            preSum = preSum + arr[i]
             
            # If preSum is equal to K
            if (preSum == K):
                 
                #  Swap
                temp = arr[i]
                arr[i] = arr[i + 1]
                arr[i + 1] = temp
 
        # Print the array arr[]
        for i in range(0, N):
            print(arr[i], end = " ")
 
# Driver code
arr = [ 2, 6, 4, 5, 3, 1 ]
N = len(arr)
K = 15
 
findpermutation(arr, N, K)
 
# This code is contributed by amreshkumar3

C#




// C# program for the above approach
using System;
 
class GFG{
 
// Function to find the output array
// satisfying given conditions
static void findpermutation(int []arr, int N, int K)
{
    int sum = 0;
 
    // Traverse the array arr[]
    for(int i = 0; i < N; i++)
    {
        sum = sum + arr[i];
    }
 
    // If sum is equal to K
    if (sum == K)
    {
         Console.WriteLine(-1);
    }
    else
    {
         
        // Sort array in ascending order
        Array.Sort(arr);
 
        // Stores the sum of a prefix
        int preSum = 0;
 
        // Traverse the array arr[]
        for(int i = 0; i < N; i++)
        {
             
            // Update the preSum
            preSum = preSum + arr[i];
             
            // If preSum is equal to K
            if (preSum == K)
            {
                 
                // Swap
                swap(arr, i, i + 1);
                break;
            }
        }
         
        // Print the array arr[]
        for(int i = 0; i < N; i++)
        {
             Console.WriteLine(arr[i] + " ");
        }
         Console.WriteLine( );
    }
}
 
static int[] swap(int []arr, int i, int j)
{
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
    return arr;
}
 
// Driver code
static void Main()
{
    int []arr= { 2, 6, 4, 5, 3, 1 };
    int N = arr.Length;
    int K = 15;
 
    findpermutation(arr, N, K);
}
}
 
// This code is contributed by SoumikMondal

Javascript




<script>
 
// JavaScript program for the above approach
 
// Function to find the output array
// satisfying given conditions
function findpermutation(arr, N, K)
{
    var sum = 0;
     
    var i;
    // Traverse the array arr[]
    for (i = 0; i < N; i++) {
        sum = sum + arr[i];
    }
 
    // If sum is equal to K
    if (sum == K) {
        document.write(-1);
     }
    else {
        // Sort array in ascending order
        arr = arr.sort(function(a, b) {
          return a - b;
         });
 
        // Stores the sum of a prefix
        var preSum = 0;
 
        // Traverse the array arr[]
        for (i = 0; i < N; i++) {
            // Update the preSum
            preSum = preSum + arr[i];
            // If preSum is equal to K
            if (preSum == K) {
                // Swap
                var temp  = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
                break;
            }
        }
 
        // Print the array arr[]
        for (i = 0; i < N; i++) {
             document.write(arr[i] + " ");
        }
 
        document.write("<br>")
    }
}
 
// Driver code
    arr = [2, 6, 4, 5, 3, 1];
    N = arr.length;
    K = 15;
 
    findpermutation(arr, N, K);
 
</script>
Output
1 2 3 4 6 5 

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 :