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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to maximise the sum of two
// Numbers using at most one swap between them
 
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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[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
    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

chevron_right


Output: 

10740





 

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.




My Personal Notes arrow_drop_up

Practice until my ideals becomes my rivals

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.