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 9Input : 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 the 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++ 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 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 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# 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 */ |
<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> |
9 8 1 2 1 4 9 9 9
Time Complexity: O(N*N) where N is the length of given array.
Auxiliary Space: O(1)