# Maximize distance between two elements of Array by at most X swaps

• Last Updated : 01 Jun, 2021

Given an array arr[] of unique elements and three integers X, A, and B. The task is to print the maximum possible distance between elements A and B in atmost X swaps with the adjacent elements.
Examples:

Input: arr[] = {5, 1, 3, 2}, X = 1, A = 2, B = 3
Output:
Explanation:
3 is swapped with it’s adjacent element 1. So, the distance between element 3 and 2 is 2 and no more interchanges are possible since X = 1.
Input: arr = {100, 33, 10, 1}, X = 5, A = 100, B = 1
Output:
Explanation:
As the elements are already the beginning and ending element, the distance between them is already maximized.

Approach: The following steps can be followed to compute the result:

• In case the given X is 0, then |index(A)-index(B)| is returned as final answer.
• If the elements are already at index 0 and n-1, return N-1 as the distance is already maximized.
• Else, the greater index element is swapped X times with their adjacent element till it is less than the size of the array.
• After reaching the end of the array if X > 0; then the smaller index element is swapped with its previous elements till X is not equal to 0.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to maximize the distance``// between the two elements of the``// array by at most X swaps``void` `max_distance(``int` `a[], ``int` `n, ``int` `x,``                  ``int` `A, ``int` `B)``{``    ``// Initialize the variables``    ``int` `g = 0, h = 0;` `    ``// Iterate till the length of the array``    ``for` `(``int` `i = 0; i < n; i++) {``        ``// Check if current element is A``        ``if` `(a[i] == A)``            ``// Store index``            ``g = i;` `        ``// Check if current element is B``        ``if` `(a[i] == B)``            ``// Store index``            ``h = i;``    ``}` `    ``// If X = 0, swapping can not be done``    ``if` `(x == 0) {``        ``cout << ``abs``(g - h);``    ``}` `    ``// If elements are at starting and ending``    ``// indices, then the distance``    ``// is already maximum``    ``else` `if` `((g == 0) && (h == (n - 1)))``        ``cout << n - 1 << endl;` `    ``else` `if` `((g == n - 1) && (h == 0))``        ``cout << n - 1 << endl;` `    ``else` `{` `        ``// Greater index is incremented``        ``// till x > 0 and the``        ``// index of element < size of array``        ``if` `(h > g) {``            ``while` `((x > 0) && (h < n - 1)) {``                ``h++;``                ``x--;``            ``}` `            ``// Check if reached the size of array``            ``// and x > 0, then the``            ``// smaller index is decremented``            ``if` `(x > 0) {``                ``while` `((x > 0) && (g > 0)) {``                    ``g--;``                    ``x--;``                ``}``            ``}``            ``cout << h - g << endl;``        ``}` `        ``// Greater index is incremented till x>0``        ``// and index of element < size of array``        ``else` `{``            ``while` `((x > 0) && (g < n - 1)) {``                ``g++;``                ``x--;``            ``}` `            ``// Check if reached the size of the array``            ``// and x > 0 the smaller index``            ``// is decremented``            ``if` `(x > 0) {``                ``while` `((x > 0) && (h > 0)) {``                    ``h--;``                    ``x--;``                ``}``            ``}``            ``cout << g - h << endl;``        ``}``    ``}``}` `// Driver code``int` `main()``{``    ``int` `a[] = { 100, 33, 10, 1 };``    ``int` `x = 5, A = 100, B = 1;``    ``int` `n = ``sizeof``(a) / ``sizeof``(a);``    ``max_distance(a, n, x, A, B);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function to maximize the distance``// between the two elements of the``// array by at most X swaps``static` `void` `max_distance(``int` `a[], ``int` `n, ``int` `x,``                         ``int` `A, ``int` `B)``{``    ` `    ``// Initialize the variables``    ``int` `i, g = ``0``, h = ``0``;` `    ``// Iterate till the length of the array``    ``for``(i = ``0``; i < n; i++)``    ``{``        ` `        ``// Check if current element is A``        ``if` `(a[i] == A)``        ` `            ``// Store index``            ``g = i;` `        ``// Check if current element is B``        ``if` `(a[i] == B)``        ` `            ``// Store index``            ``h = i;``    ``}` `    ``// If X = 0, swapping can not be done``    ``if` `(x == ``0``)``    ``{``        ``System.out.print(Math.abs(g - h));``    ``}` `    ``// If elements are at starting and``    ``// ending indices, then the distance``    ``// is already maximum``    ``else` `if` `((g == ``0``) && (h == (n - ``1``)))``        ``System.out.println(n - ``1``);` `    ``else` `if` `((g == n - ``1``) && (h == ``0``))``        ``System.out.println(n - ``1``);` `    ``else``    ``{``        ` `        ``// Greater index is incremented``        ``// till x > 0 and theindex of``        ``// element < size of array``        ``if` `(h > g)``        ``{``            ``while` `((x > ``0``) && (h < n - ``1``))``            ``{``                ``h++;``                ``x--;``            ``}` `            ``// Check if reached the size of``            ``// array and x > 0, then the``            ``// smaller index is decremented``            ``if` `(x > ``0``)``            ``{``                ``while` `((x > ``0``) && (g > ``0``))``                ``{``                    ``g--;``                    ``x--;``                ``}``            ``}``            ``System.out.println(h - g);``        ``}` `        ``// Greater index is incremented till x>0``        ``// and index of element < size of array``        ``else``        ``{``            ``while` `((x > ``0``) && (g < n - ``1``))``            ``{``                ``g++;``                ``x--;``            ``}` `            ``// Check if reached the size of the array``            ``// and x > 0 the smaller index``            ``// is decremented``            ``if` `(x > ``0``)``            ``{``                ``while` `((x > ``0``) && (h > ``0``))``                ``{``                    ``h--;``                    ``x--;``                ``}``            ``}``            ``System.out.println(g - h);``        ``}``    ``}``}` `// Driver code``public` `static` `void` `main (String []args)``{``    ``int` `a[] = { ``100``, ``33``, ``10``, ``1` `};``    ``int` `x = ``5``, A = ``100``, B = ``1``;``    ``int` `n = a.length;``    ` `    ``max_distance(a, n, x, A, B);``}``}` `// This code is contributed by chitranayal`

## Python3

 `# Python3 program for the above approach` `# Function to maximize the distance``# between the two elements of the``# array by at most X swaps``def` `max_distance(a, n, x, A, B):``    ` `    ``# Initialize the variables``    ``g ``=` `0``    ``h ``=` `0``    ` `    ``for` `i ``in` `range``(``0``, n):``        ` `        ``# Check if current element is A``        ``if` `(a[i] ``=``=` `A):``            ` `            ``# Store index``            ``g ``=` `i``            ` `        ``# Check if current element is B``        ``if` `(a[i] ``=``=` `B):``            ` `            ``# Store index``            ``h ``=` `i``            ` `    ``# If X = 0, swapping can not be done``    ``if` `(x ``=``=` `0``):``        ``print``(``abs``(g ``-` `h))``        ` `    ``# If elements are at starting and``    ``# ending indices, then the distance``    ``# is already maximum``    ``elif` `((g ``=``=` `0``) ``and` `(h ``=``=` `(n ``-` `1``))):``        ``print``(n ``-` `1``, end ``=` `'')``        ` `    ``elif` `((g ``=``=` `n ``-` `1``) ``and` `(h ``=``=` `0``)):``        ``print``(n ``-` `1``, end ``=` `'')``    ``else``:``        ` `        ``# Greater index is incremented``        ``# till x > 0 and the``        ``# index of element < size of array``        ``if` `(h > g):``            ``while` `((x > ``0``) ``and` `(h < n ``-` `1``)):``                ``h ``+``=` `1``                ``x ``-``=` `1``                ` `                ``# Check if reached the size``                ``# of array and x > 0, then the``                ``# smaller index is decremented``                ``if` `(x > ``0``):``                    ``while` `((x > ``0``) ``and` `(g > ``0``)):``                        ``g ``-``=` `1``                        ``x ``-``=` `1``                        ` `                ``print``(h ``-` `g, end ``=` `'')``                ` `        ``# Greater index is incremented till x>0``        ``# and index of element < size of array``        ``else``:``            ``while` `((x > ``0``) ``and` `(g < n ``-` `1``)):``                ``g ``+``=` `1``                ``x ``-``=` `1``                ` `            ``# Check if reached the size of``            ``# the array and x > 0 the smaller``            ``# index is decremented``            ``if` `(x > ``0``):``                ``while` `((x > ``0``) ``and` `(h > ``0``)):``                    ``h ``-``=` `1``                    ``x ``-``=` `1``                    ` `            ``print``(g ``-` `h, end ``=` `'')``            ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``a ``=` `[ ``100``, ``33``, ``10``, ``1` `]``    ``x ``=` `5``    ``A ``=` `100``    ``B ``=` `1``    ``n ``=` `len``(a)``    ` `    ``max_distance(a, n, x, A, B)``                    ` `# This code is contributed by virusbuddah_    `

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to maximize the distance``// between the two elements of the``// array by at most X swaps``static` `void` `max_distance(``int` `[]a, ``int` `n, ``int` `x,``                         ``int` `A, ``int` `B)``{``    ` `    ``// Initialize the variables``    ``int` `i, g = 0, h = 0;` `    ``// Iterate till the length of the array``    ``for``(i = 0; i < n; i++)``    ``{``        ` `        ``// Check if current element is A``        ``if` `(a[i] == A)``        ` `            ``// Store index``            ``g = i;` `        ``// Check if current element is B``        ``if` `(a[i] == B)``        ` `            ``// Store index``            ``h = i;``    ``}` `    ``// If X = 0, swapping can not be done``    ``if` `(x == 0)``    ``{``        ``Console.Write(Math.Abs(g - h));``    ``}` `    ``// If elements are at starting and``    ``// ending indices, then the distance``    ``// is already maximum``    ``else` `if` `((g == 0) && (h == (n - 1)))``        ``Console.WriteLine(n - 1);` `    ``else` `if` `((g == n - 1) && (h == 0))``        ``Console.WriteLine(n - 1);` `    ``else``    ``{``        ` `        ``// Greater index is incremented``        ``// till x > 0 and theindex of``        ``// element < size of array``        ``if` `(h > g)``        ``{``            ``while` `((x > 0) && (h < n - 1))``            ``{``                ``h++;``                ``x--;``            ``}` `            ``// Check if reached the size of``            ``// array and x > 0, then the``            ``// smaller index is decremented``            ``if` `(x > 0)``            ``{``                ``while` `((x > 0) && (g > 0))``                ``{``                    ``g--;``                    ``x--;``                ``}``            ``}``            ``Console.WriteLine(h - g);``        ``}` `        ``// Greater index is incremented till x>0``        ``// and index of element < size of array``        ``else``        ``{``            ``while` `((x > 0) && (g < n - 1))``            ``{``                ``g++;``                ``x--;``            ``}` `            ``// Check if reached the size of the``            ``// array and x > 0 the smaller index``            ``// is decremented``            ``if` `(x > 0)``            ``{``                ``while` `((x > 0) && (h > 0))``                ``{``                    ``h--;``                    ``x--;``                ``}``            ``}``            ``Console.WriteLine(g - h);``        ``}``    ``}``}` `// Driver code``public` `static` `void` `Main(String []args)``{``    ``int` `[]a = { 100, 33, 10, 1 };``    ``int` `x = 5, A = 100, B = 1;``    ``int` `n = a.Length;``    ` `    ``max_distance(a, n, x, A, B);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``
Output:
`3`

My Personal Notes arrow_drop_up