# Maximise the sum of two Numbers using at most one swap between them

• Difficulty Level : Medium
• Last Updated : 24 Nov, 2021

Given two natural numbers N1 and N2, the task is to find the maximum sum possible after swapping of a single digit between them.
Examples:

Input: N1 = 984788, N2 = 706
Output: 988194
Explanation:
Swapping 4 from N1 with 7 from N2, we get N1 = 987788 and N2 = 406
Sum = 988194

Input: N1 = 9987, N2 = 123
Output: 10740
Explanation:
Swapping 8 from N1 with 1 from N2, we get N1 = 9917 and N2 = 823
Sum = 10740

Approach:

1. Compare N1 and N2 and store the digits of the larger of the two in array arr1 and that of the smaller in arr2 respectively.
2. If both the numbers are of different lengths, find the index of maximum element in arr2, and the most significant index in arr1, and swap them to maximize the sum.
3. If both the numbers are of same length
• Iterate both the arrays arr1 and arr2 at the same time.
• For each digit at index i in both the arrays, find the difference between the current digit and the largest digit left to index ‘i’.
• Compare the difference to find the most significant digit and most significant index, whose value needs to be swapped.
4. Restore the new numbers from arr1 and arr2 and calculate the maximized sum.

Below code is the implementation of the above approach:

## C++

 `// C++ program to maximise the sum of two``// Numbers using at most one swap between them` `#include ``using` `namespace` `std;` `#define MAX 100` `// Function to maximize the sum``// by swapping only one digit``void` `findMaxSum(``int` `n1, ``int` `n2)``{` `    ``int` `arr1[MAX] = { 0 }, arr2[MAX] = { 0 };``    ``int` `l1 = 0, l2 = 0;` `    ``int` `max1 = max(n1, n2);``    ``int` `min1 = min(n1, n2);` `    ``// Store digits of max(n1, n2)``    ``for` `(``int` `i = max1; i > 0; i /= 10)``        ``arr1[l1++] = (i % 10);` `    ``// Store digits of min(n1, n2)``    ``for` `(``int` `i = min1; i > 0; i /= 10)``        ``arr2[l2++] = (i % 10);` `    ``int` `f = 0;` `    ``// If length of the two numbers``    ``// are unequal``    ``if` `(l1 != l2) {``        ``// Find the most significant number``        ``// and the most significant index``        ``// for swapping``        ``int` `index = (max_element(arr2, arr2 + l2) - arr2);``        ``for` `(``int` `i = l1 - 1; i > (l2 - 1); i--) {``            ``if` `(arr1[i] < arr2[index]) {``                ``swap(arr1[i], arr2[index]);``                ``f = 1;``                ``break``;``            ``}``        ``}``    ``}` `    ``// If both numbers are``    ``// of equal length``    ``if` `(f != 1) {` `        ``int` `index1 = 0, index2 = 0;``        ``int` `diff1 = 0, diff2 = 0;``        ``for` `(``int` `i = l2 - 1; i >= 0; i--) {` `            ``// Fetch the index of current maximum``            ``// digit present in both the arrays``            ``index1 = (max_element(arr1, arr1 + i) - arr1);``            ``index2 = (max_element(arr2, arr2 + i) - arr2);` `            ``// Compute the difference``            ``diff1 = (arr2[index2] - arr1[i]);``            ``diff2 = (arr1[index1] - arr2[i]);` `            ``// Find the most significant index``            ``// and the most significant digit``            ``// to be swapped``            ``if` `(diff1 > 0 || diff2 > 0) {` `                ``if` `(diff1 > diff2) {``                    ``swap(arr1[i], arr2[index2]);``                    ``break``;``                ``}` `                ``else` `if` `(diff2 > diff1) {``                    ``swap(arr2[i], arr1[index1]);``                    ``break``;``                ``}` `                ``else` `if` `(diff1 == diff2) {` `                    ``if` `(index1 <= index2) {``                        ``swap(arr2[i], arr1[index1]);``                        ``break``;``                    ``}` `                    ``else` `if` `(index2 <= index1) {``                        ``swap(arr1[i], arr2[index2]);``                        ``break``;``                    ``}``                ``}``            ``}``        ``}``    ``}` `    ``// Restore the new numbers``    ``int` `f_n1 = 0, f_n2 = 0;``    ``for` `(``int` `i = l1 - 1; i >= 0; i--) {``        ``f_n1 = (f_n1 * 10) + arr1[i];``        ``f_n2 = (f_n2 * 10) + arr2[i];``    ``}` `    ``// Display the maximized sum``    ``cout << (f_n1 + f_n2) << ``"\n"``;``}` `// Driver function``int` `main()``{``    ``int` `N1 = 9987;``    ``int` `N2 = 123;` `    ``findMaxSum(N1, N2);``    ``return` `0;``}`

## Java

 `// Java program to maximise the sum of two``// Numbers using at most one swap between them``import` `java.util.*;` `class` `GFG{` `static` `int` `MAX = ``100``;` `static` `int` `max_element(``int` `arr[], ``int` `pos)``{``    ``int` `tmp = arr[``0``];``    ``int` `ind = ``0``;``    ` `    ``for``(``int` `i = ``1``; i < pos; i++)``    ``{``        ``if` `(tmp < arr[i])``        ``{``            ``tmp = arr[i];``            ``ind = i;``        ``}``    ``}``    ``return` `ind;``}` `// Function to maximize the sum``// by swapping only one digit``static` `void` `findMaxSum(``int` `n1, ``int` `n2)``{``    ``int` `[]arr1 = ``new` `int``[MAX];``    ``int` `[]arr2 = ``new` `int``[MAX];``    ``int` `l1 = ``0``, l2 = ``0``;` `    ``int` `max1 = Math.max(n1, n2);``    ``int` `min1 = Math.min(n1, n2);` `    ``// Store digits of max(n1, n2)``    ``for``(``int` `i = max1; i > ``0``; i /= ``10``)``        ``arr1[l1++] = (i % ``10``);` `    ``// Store digits of min(n1, n2)``    ``for``(``int` `i = min1; i > ``0``; i /= ``10``)``        ``arr2[l2++] = (i % ``10``);` `    ``int` `f = ``0``;` `    ``// If length of the two numbers``    ``// are unequal``    ``if` `(l1 != l2)``    ``{``        ` `        ``// Find the most significant number``        ``// and the most significant index``        ``// for swapping``        ``int` `index = (max_element(arr2, l2));``        ``for``(``int` `i = l1 - ``1``; i > (l2 - ``1``); i--)``        ``{``            ``if` `(arr1[i] < arr2[index])``            ``{``                ``int` `tmp = arr1[i];``                ``arr1[i] = arr2[index];``                ``arr2[index] = tmp;``                ``f = ``1``;``                ``break``;``            ``}``        ``}``    ``}` `    ``// If both numbers are``    ``// of equal length``    ``if` `(f != ``1``)``    ``{``        ``int` `index1 = ``0``, index2 = ``0``;``        ``int` `diff1 = ``0``, diff2 = ``0``;``        ` `        ``for``(``int` `i = l2 - ``1``; i >= ``0``; i--)``        ``{``            ` `            ``// Fetch the index of current maximum``            ``// digit present in both the arrays``            ``index1 = (max_element(arr1, i));``            ``index2 = (max_element(arr2, i));` `            ``// Compute the difference``            ``diff1 = (arr2[index2] - arr1[i]);``            ``diff2 = (arr1[index1] - arr2[i]);` `            ``// Find the most significant index``            ``// and the most significant digit``            ``// to be swapped``            ``if` `(diff1 > ``0` `|| diff2 > ``0``)``            ``{``                ``if` `(diff1 > diff2)``                ``{``                    ``int` `tmp = arr1[i];``                    ``arr1[i] = arr2[index2];``                    ``arr2[index2] = tmp;``                    ``break``;``                ``}` `                ``else` `if` `(diff2 > diff1)``                ``{``                    ``int` `tmp = arr1[index1];``                    ``arr1[index1] = arr2[i];``                    ``arr2[i] = tmp;``                    ``break``;``                ``}` `                ``else` `if` `(diff1 == diff2)``                ``{``                    ``if` `(index1 <= index2)``                    ``{``                        ``int` `tmp = arr1[index1];``                        ``arr1[index1] = arr2[i];``                        ``arr2[i] = tmp;``                        ``break``;``                    ``}` `                    ``else` `if` `(index2 <= index1)``                    ``{``                        ``int` `tmp = arr1[i];``                        ``arr1[i] = arr2[index2];``                        ``arr2[index2] = tmp;``                        ``break``;``                    ``}``                ``}``            ``}``        ``}``    ``}` `    ``// Restore the new numbers``    ``int` `f_n1 = ``0``, f_n2 = ``0``;``    ``for``(``int` `i = l1 - ``1``; i >= ``0``; i--)``    ``{``        ``f_n1 = (f_n1 * ``10``) + arr1[i];``        ``f_n2 = (f_n2 * ``10``) + arr2[i];``    ``}` `    ``// Display the maximized sum``    ``System.out.println(f_n1 + f_n2);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `N1 = ``9987``;``    ``int` `N2 = ``123``;` `    ``findMaxSum(N1, N2);``}``}` `// This code is contributed by grand_master`

## Python3

 `# Python program to maximise the sum of two``# Numbers using at most one swap between them``MAX` `=` `100` `# Function to maximize the sum``# by swapping only one digit``def` `findMaxSum(n1, n2):` `    ``arr1 ``=` `[``0``]``*``(``MAX``)``    ``arr2 ``=` `[``0``]``*``(``MAX``)``    ``l1 ``=` `0``    ``l2 ``=` `0` `    ``max1 ``=` `max``(n1, n2);``    ``min1 ``=` `min``(n1, n2);` `    ``# Store digits of max(n1, n2)``    ``i ``=` `max1``    ``while` `i > ``0``:``        ``arr1[l1] ``=` `(i ``%` `10``)``        ``l1 ``+``=` `1``        ``i ``/``/``=` `10` `    ``# Store digits of min(n1, n2)``    ``i ``=` `min1``    ``while` `i > ``0``:``        ``arr2[l2] ``=` `(i ``%` `10``)``        ``l2 ``+``=` `1``        ``i ``/``/``=` `10` `    ``f ``=` `0``    ` `    ``# If length of the two numbers``    ``# are unequal``    ``if` `(l1 !``=` `l2):``        ` `        ``# Find the most significant number``        ``# and the most significant index``        ``# for swapping``        ``index ``=` `arr2.index(``max``(arr2))``        ``for` `i ``in` `range` `( l1 ``-` `1``, (l2 ``-` `1``), ``-``1``):``            ``if` `(arr1[i] < arr2[index]):``                ``(arr1[i], arr2[index]) ``=` `(arr2[index],arr1[i])``                ``f ``=` `1``                ``break` `    ``# If both numbers are``    ``# of equal length``    ``if` `(f !``=` `1``):` `        ``index1 ``=` `0``        ``index2 ``=` `0``        ``diff1 ``=` `0``        ``diff2 ``=` `0``        ``for` `i ``in` `range``( l2 ``-` `1``, ``-``1``,``-``1``):``            ` `            ``# Fetch the index of current maximum``            ``# digit present in both the arrays``            ``index1 ``=` `arr1.index(``max``(arr1[:i]))``            ``index2 ``=` `arr2.index(``max``(arr2[:i]))``            ` `            ``# Compute the difference``            ``diff1 ``=` `(arr2[index2] ``-` `arr1[i]);``            ``diff2 ``=` `(arr1[index1] ``-` `arr2[i]);``            `  `            ``# Find the most significant index``            ``# and the most significant digit``            ``# to be swapped``            ``if` `(diff1 > ``0` `or` `diff2 > ``0``):``                ``if` `(diff1 > diff2):``                    ``arr1[i], arr2[index2] ``=` `arr2[index2],arr1[i]``                    ``break` `                ``elif` `(diff2 > diff1):``                    ``arr2[i], arr1[index1] ``=` `arr1[index1],arr2[i]``                    ``break` `                ``elif` `(diff1 ``=``=` `diff2):``                    ``if` `(index1 <``=` `index2):``                        ``arr2[i], arr1[index1] ``=` `arr1[index1],arr2[i]``                        ``break` `                    ``elif` `(index2 <``=` `index1):``                        ``arr1[i], arr2[index2] ``=` `arr2[index2],arr1[i]``                        ``break``;` `    ``# Restore the new numbers``    ``f_n1 ``=` `0``    ``f_n2 ``=` `0``    ``for` `i ``in` `range` `(l1 ``-` `1``, ``-``1``,``-``1``):``        ``f_n1 ``=` `(f_n1 ``*` `10``) ``+` `arr1[i]``        ``f_n2 ``=` `(f_n2 ``*` `10``) ``+` `arr2[i]``    ` `    ``# Display the maximized sum``    ``print``(f_n1 ``+` `f_n2)` `# Driver function``N1 ``=` `9987``N2 ``=` `123` `findMaxSum(N1, N2)` `# This code is contributed by ANKITKUMAR34`

## C#

 `// C# program to maximise the sum of two``// Numbers using at most one swap between them``using` `System;` `class` `GFG{` `static` `int` `MAX = 100;` `static` `int` `max_element(``int` `[]arr, ``int` `pos)``{``    ``int` `tmp = arr;``    ``int` `ind = 0;``    ` `    ``for``(``int` `i = 1; i < pos; i++)``    ``{``        ``if` `(tmp < arr[i])``        ``{``            ``tmp = arr[i];``            ``ind = i;``        ``}``    ``}``    ``return` `ind;``}` `// Function to maximize the sum``// by swapping only one digit``static` `void` `findMaxSum(``int` `n1, ``int` `n2)``{` `    ``int` `[]arr1 = ``new` `int``[MAX];``    ``int` `[]arr2 = ``new` `int``[MAX];``    ``int` `l1 = 0, l2 = 0;` `    ``int` `max1 = Math.Max(n1, n2);``    ``int` `min1 = Math.Min(n1, n2);` `    ``// Store digits of max(n1, n2)``    ``for``(``int` `i = max1; i > 0; i /= 10)``        ``arr1[l1++] = (i % 10);` `    ``// Store digits of min(n1, n2)``    ``for``(``int` `i = min1; i > 0; i /= 10)``        ``arr2[l2++] = (i % 10);` `    ``int` `f = 0;` `    ``// If length of the two numbers``    ``// are unequal``    ``if` `(l1 != l2)``    ``{``        ` `        ``// Find the most significant number``        ``// and the most significant index``        ``// for swapping``        ``int` `index = (max_element(arr2,l2));``        ``for``(``int` `i = l1 - 1; i > (l2 - 1); i--)``        ``{``            ``if` `(arr1[i] < arr2[index])``            ``{``                ``int` `tmp = arr1[i];``                ``arr1[i] = arr2[index];``                ``arr2[index] = tmp;``                ``f = 1;``                ``break``;``            ``}``        ``}``    ``}` `    ``// If both numbers are``    ``// of equal length``    ``if` `(f != 1)``    ``{``        ``int` `index1 = 0, index2 = 0;``        ``int` `diff1 = 0, diff2 = 0;``        ` `        ``for``(``int` `i = l2 - 1; i >= 0; i--)``        ``{``            ` `            ``// Fetch the index of current maximum``            ``// digit present in both the arrays``            ``index1 = (max_element(arr1, i));``            ``index2 = (max_element(arr2, i));` `            ``// Compute the difference``            ``diff1 = (arr2[index2] - arr1[i]);``            ``diff2 = (arr1[index1] - arr2[i]);` `            ``// Find the most significant index``            ``// and the most significant digit``            ``// to be swapped``            ``if` `(diff1 > 0 || diff2 > 0)``            ``{``                ``if` `(diff1 > diff2)``                ``{``                    ``int` `tmp = arr1[i];``                    ``arr1[i] = arr2[index2];``                    ``arr2[index2] = tmp;``                    ``break``;``                ``}` `                ``else` `if` `(diff2 > diff1)``                ``{``                    ``int` `tmp = arr1[index1];``                    ``arr1[index1] = arr2[i];``                    ``arr2[i] = tmp;``                    ``break``;``                ``}` `                ``else` `if` `(diff1 == diff2)``                ``{``                    ``if` `(index1 <= index2)``                    ``{``                        ``int` `tmp = arr1[index1];``                        ``arr1[index1] = arr2[i];``                        ``arr2[i] = tmp;``                        ``break``;``                    ``}` `                    ``else` `if` `(index2 <= index1)``                    ``{``                        ``int` `tmp = arr1[i];``                        ``arr1[i] = arr2[index2];``                        ``arr2[index2] = tmp;``                        ``break``;``                    ``}``                ``}``            ``}``        ``}``    ``}` `    ``// Restore the new numbers``    ``int` `f_n1 = 0, f_n2 = 0;``    ``for``(``int` `i = l1 - 1; i >= 0; i--)``    ``{``        ``f_n1 = (f_n1 * 10) + arr1[i];``        ``f_n2 = (f_n2 * 10) + arr2[i];``    ``}` `    ``// Display the maximized sum``    ``Console.Write(f_n1 + f_n2);``}` `// Driver code``public` `static` `void` `Main(``string``[] args)``{``    ``int` `N1 = 9987;``    ``int` `N2 = 123;` `    ``findMaxSum(N1, N2);``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``

Output:

`10740`

Time Complexity: O(n)

Auxiliary Space: O(MAX)

My Personal Notes arrow_drop_up