Skip to content
Related Articles

Related Articles

Maximum number formed from array with K number of adjacent swaps allowed

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 05 Aug, 2021
View Discussion
Improve Article
Save Article

Given an array a[ ] and the number of adjacent swap operations allowed are K. The task is to find the max number that can be formed using these swap operations. 
Examples: 
 

Input : a[]={ 1, 2, 9, 8, 1, 4, 9, 9, 9 }, K = 4 
Output : 9 8 1 2 1 4 9 9 9 
After 1st swap a[ ] becomes 1 9 2 8 1 4 9 9 9 
After 2nd swap a[ ] becomes 9 1 2 8 1 4 9 9 9 
After 3rd swap a[ ] becomes 9 1 8 2 1 4 9 9 9 
After 4th swap a[ ] becomes 9 8 1 2 1 4 9 9 9
Input : a[]={2, 5, 8, 7, 9}, K = 2 
Output : 8 2 5 7 9 

Approach: 
 

  • Starting from the first digit, check for the next K digits and store the index of the largest number.
  • Bring that greatest digit to the top by swapping the adjacent digits.
  • Reduce to value of K by the number of adjacent swaps done.
  • Repeat the above steps until the number of swaps becomes zero.

Below is the implementation of the above approach 
 

C++




// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the
// elements of the array
void print(int arr[], int n)
{
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}
 
// Exchange array elements one by
// one from  right to left side
// starting from the current position
// and ending at the target position
void swapMax(int* arr, int target_position,
                      int current_position)
{
    int aux = 0;
    for (int i = current_position;
         i > target_position; i--) {
        aux = arr[i - 1];
        arr[i - 1] = arr[i];
        arr[i] = aux;
    }
}
 
// Function to return the
// maximum number array
void maximizeArray(int* arr,
                   int length, int swaps)
{
    // Base condition
    if (swaps == 0)
        return;
 
    // Start from the first index
    for (int i = 0; i < length; i++) {
        int max_index = 0, max = INT_MIN;
 
        // Search for the next K elements
        int limit = (swaps + i) > length ?
                        length : swaps + i;
 
        // Find index of the maximum
        // element in next K elements
        for (int j = i; j <= limit; j++) {
            if (arr[j] > max) {
                max = arr[j];
                max_index = j;
            }
        }
 
        // Update the value of
        // number of swaps
        swaps -= (max_index - i);
 
        // Update the array elements by
        // swapping adjacent elements
        swapMax(arr, i, max_index);
 
        if (swaps == 0)
            break;
    }
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 9, 8, 1, 4, 9, 9, 9 };
    int length = sizeof(arr) / sizeof(int);
    int swaps = 4;
    maximizeArray(arr, length, swaps);
 
    print(arr, length);
 
    return 0;
}

Java




// Java implementation of the above approach
class GFG
{
 
// Function to print the
// elements of the array
static void print(int arr[], int n)
{
    for (int i = 0; i < n; i++)
    {
        System.out.print(arr[i] + " ");
    }
    System.out.println();
}
 
// Exchange array elements one by
// one from right to left side
// starting from the current position
// and ending at the target position
static void swapMax(int[] arr, int target_position,
                    int current_position)
{
    int aux = 0;
    for (int i = current_position;
        i > target_position; i--)
    {
        aux = arr[i - 1];
        arr[i - 1] = arr[i];
        arr[i] = aux;
    }
}
 
// Function to return the
// maximum number array
static void maximizeArray(int[] arr,
                int length, int swaps)
{
    // Base condition
    if (swaps == 0)
        return;
 
    // Start from the first index
    for (int i = 0; i < length; i++)
    {
        int max_index = 0, max = Integer.MIN_VALUE;
 
        // Search for the next K elements
        int limit = (swaps + i) > length ?
                        length : swaps + i;
 
        // Find index of the maximum
        // element in next K elements
        for (int j = i; j <= limit; j++)
        {
            if (arr[j] > max)
            {
                max = arr[j];
                max_index = j;
            }
        }
 
        // Update the value of
        // number of swaps
        swaps -= (max_index - i);
 
        // Update the array elements by
        // swapping adjacent elements
        swapMax(arr, i, max_index);
 
        if (swaps == 0)
            break;
    }
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, 2, 9, 8, 1, 4, 9, 9, 9 };
    int length = arr.length;
    int swaps = 4;
    maximizeArray(arr, length, swaps);
 
    print(arr, length);
}
}
 
/* This code is contributed by PrinciRaj1992 */

Python3




# Python3 implementation of the above approach
import sys
 
# Function to print the
# elements of the array
def print_ele(arr, n) :
     
    for i in range(n) :
        print(arr[i],end=" ");
         
    print();
 
# Exchange array elements one by
# one from right to left side
# starting from the current position
# and ending at the target position
def swapMax(arr, target_position,
                    current_position) :
                         
    aux = 0;
    for i in range(current_position, target_position,-1) :
        aux = arr[i - 1];
        arr[i - 1] = arr[i];
        arr[i] = aux;
 
# Function to return the
# maximum number array
def maximizeArray(arr, length, swaps) :
 
    # Base condition
    if (swaps == 0) :
        return;
 
    # Start from the first index
    for i in range(length) :
        max_index = 0; max = -(sys.maxsize-1);
         
        # Search for the next K elements
        if (swaps + i) > length :
            limit = length
        else:
            limit = swaps + i
             
        # Find index of the maximum
        # element in next K elements
        for j in range(i, limit + 1) :
            if (arr[j] > max) :
                max = arr[j];
                max_index = j;
                 
        # Update the value of
        # number of swaps
        swaps -= (max_index - i);
 
        # Update the array elements by
        # swapping adjacent elements
        swapMax(arr, i, max_index);
 
        if (swaps == 0) :
            break;
 
# Driver code
if __name__ == "__main__" :
 
    arr = [ 1, 2, 9, 8, 1, 4, 9, 9, 9 ];
    length = len(arr);
    swaps = 4;
    maximizeArray(arr, length, swaps);
 
    print_ele(arr, length);
 
# This code is contributed by AnkitRai01

C#




// C# program to find the sum
// and product of k smallest and
// k largest prime numbers in an array
 
using System;
     
class GFG
{
 
// Function to print the
// elements of the array
static void print(int []arr, int n)
{
    for (int i = 0; i < n; i++)
    {
        Console.Write(arr[i] + " ");
    }
    Console.WriteLine();
}
 
// Exchange array elements one by
// one from right to left side
// starting from the current position
// and ending at the target position
static void swapMax(int[] arr, int target_position,
                    int current_position)
{
    int aux = 0;
    for (int i = current_position;
        i > target_position; i--)
    {
        aux = arr[i - 1];
        arr[i - 1] = arr[i];
        arr[i] = aux;
    }
}
 
// Function to return the
// maximum number array
static void maximizeArray(int[] arr,
                int length, int swaps)
{
    // Base condition
    if (swaps == 0)
        return;
 
    // Start from the first index
    for (int i = 0; i < length; i++)
    {
        int max_index = 0, max = int.MinValue;
 
        // Search for the next K elements
        int limit = (swaps + i) > length ?
                        length : swaps + i;
 
        // Find index of the maximum
        // element in next K elements
        for (int j = i; j <= limit; j++)
        {
            if (arr[j] > max)
            {
                max = arr[j];
                max_index = j;
            }
        }
 
        // Update the value of
        // number of swaps
        swaps -= (max_index - i);
 
        // Update the array elements by
        // swapping adjacent elements
        swapMax(arr, i, max_index);
 
        if (swaps == 0)
            break;
    }
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 1, 2, 9, 8, 1, 4, 9, 9, 9 };
    int length = arr.Length;
    int swaps = 4;
    maximizeArray(arr, length, swaps);
 
    print(arr, length);
}
}
 
/* This code is contributed by PrinciRaj1992 */

Javascript




<script>
 
// JavaScript implementation of the above approach
 
 
// Function to print the
// elements of the array
function print(arr, n) {
    for (let i = 0; i < n; i++) {
        document.write(arr[i] + " ");
    }
    document.write("<br>");
}
 
// Exchange array elements one by
// one from right to left side
// starting from the current position
// and ending at the target position
function swapMax(arr, target_position, current_position) {
    let aux = 0;
    for (let i = current_position; i > target_position; i--) {
        aux = arr[i - 1];
        arr[i - 1] = arr[i];
        arr[i] = aux;
    }
}
 
// Function to return the
// maximum number array
function maximizeArray(arr, length, swaps) {
    // Base condition
    if (swaps == 0)
        return;
 
    // Start from the first index
    for (let i = 0; i < length; i++) {
        let max_index = 0, max = Number.MIN_SAFE_INTEGER;
 
        // Search for the next K elements
        let limit = (swaps + i) > length ?
            length : swaps + i;
 
        // Find index of the maximum
        // element in next K elements
        for (let j = i; j <= limit; j++) {
            if (arr[j] > max) {
                max = arr[j];
                max_index = j;
            }
        }
 
        // Update the value of
        // number of swaps
        swaps -= (max_index - i);
 
        // Update the array elements by
        // swapping adjacent elements
        swapMax(arr, i, max_index);
 
        if (swaps == 0)
            break;
    }
}
 
// Driver code
 
let arr = [1, 2, 9, 8, 1, 4, 9, 9, 9];
let length = arr.length;
let swaps = 4;
maximizeArray(arr, length, swaps);
 
print(arr, length);
 
// This code is contributed by gfgking
 
</script>

Output: 

9 8 1 2 1 4 9 9 9

 

Time Complexity: O(N*N) where N is the length of given array
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!