Sumas máximas y mínimas de dos números con reemplazos de dígitos

Dados dos números positivos calcular las sumas mínimas y máximas posibles de dos números. Se nos permite reemplazar el dígito 5 con el dígito 6 y viceversa en cualquiera de los números dados o en ambos.
Ejemplos: 
 

Input  : x1 = 645 x2 = 666
Output : Minimum Sum: 1100 (545 + 555)
         Maximum Sum: 1312 (646 + 666)

Input: x1 = 5466 x2 = 4555
Output: Minimum sum: 10010
        Maximum Sum: 11132

Dado que ambos números son positivos, siempre obtenemos la suma máxima si reemplazamos 5 con 6 en ambos números. Y obtenemos una suma mínima si reemplazamos 6 con 5 en ambos números. A continuación se muestra la implementación de C++ basada en este hecho.
 

C++

// C++ program to find maximum and minimum
// possible sums of two numbers that we can
// get if replacing digit from 5 to 6 and vice
// versa are allowed.
#include<bits/stdc++.h>
using namespace std;
 
// Find new value of x after replacing digit
// "from" to "to"
int replaceDig(int x, int from, int to)
{
    int result = 0;
    int multiply = 1;
 
    while (x > 0)
    {
        int reminder = x % 10;
 
        // Required digit found, replace it
        if (reminder == from)
            result = result + to * multiply;
 
        else
            result = result + reminder * multiply;
 
        multiply *= 10;
        x = x / 10;
    }
    return result;
}
 
// Returns maximum and minimum possible sums of
// x1 and x2 if digit replacements are allowed.
void calculateMinMaxSum(int x1, int x2)
{
    // We always get minimum sum if we replace
    // 6 with 5.
    int minSum = replaceDig(x1, 6, 5) +
                 replaceDig(x2, 6, 5);
 
    // We always get maximum sum if we replace
    // 5 with 6.
    int maxSum = replaceDig(x1, 5, 6) +
                 replaceDig(x2, 5, 6);
    cout << "Minimum sum = " << minSum;
    cout << "nMaximum sum = " << maxSum;
}
 
// Driver code
int main()
{
    int x1 = 5466, x2 = 4555;
    calculateMinMaxSum(x1, x2);
    return 0;
}

Java

// Java program to find maximum and minimum
// possible sums of two numbers that we can
// get if replacing digit from 5 to 6 and vice
// versa are allowed.
class GFG {
     
    // Find new value of x after replacing digit
    // "from" to "to"
    static int replaceDig(int x, int from, int to)
    {
         
        int result = 0;
        int multiply = 1;
     
        while (x > 0)
        {
            int reminder = x % 10;
     
            // Required digit found, replace it
            if (reminder == from)
                result = result + to * multiply;
     
            else
                result = result + reminder * multiply;
     
            multiply *= 10;
            x = x / 10;
        }
        return result;
    }
     
    // Returns maximum and minimum possible sums of
    // x1 and x2 if digit replacements are allowed.
    static void calculateMinMaxSum(int x1, int x2)
    {
         
        // We always get minimum sum if we replace
        // 6 with 5.
        int minSum = replaceDig(x1, 6, 5) +
                    replaceDig(x2, 6, 5);
     
        // We always get maximum sum if we replace
        // 5 with 6.
        int maxSum = replaceDig(x1, 5, 6) +
                    replaceDig(x2, 5, 6);
        System.out.print("Minimum sum = " + minSum);
        System.out.print("\nMaximum sum = " + maxSum);
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int x1 = 5466, x2 = 4555;
        calculateMinMaxSum(x1, x2);
    }
}
  
// This code is contributed by Anant Agarwal.

Python3

# Python3 program to find maximum
# and minimum possible sums of
# two numbers that we can get if
# replacing digit from 5 to 6
# and vice versa are allowed.
 
 
# Find new value of x after
# replacing digit "from" to "to"
def replaceDig(x, from1, to):
    result = 0
    multiply = 1
 
    while (x > 0):
        reminder = x % 10
 
        # Required digit found,
        # replace it
        if (reminder == from1):
            result = result + to * multiply
 
        else:
            result = result + reminder * multiply
 
        multiply *= 10
        x = int(x / 10)
    return result
 
# Returns maximum and minimum
# possible sums of x1 and x2
# if digit replacements are allowed.
def calculateMinMaxSum(x1, x2):
     
    # We always get minimum sum
    # if we replace 6 with 5.
    minSum = replaceDig(x1, 6, 5) +replaceDig(x2, 6, 5)
 
    # We always get maximum sum
    # if we replace 5 with 6.
    maxSum = replaceDig(x1, 5, 6) +replaceDig(x2, 5, 6)
    print("Minimum sum =" , minSum)
    print("Maximum sum =" , maxSum,end=" ")
 
# Driver code
if __name__=='__main__':
    x1 = 5466
    x2 = 4555
    calculateMinMaxSum(x1, x2)
 
# This code is contributed
# by mits

C#

// C# program to find maximum and minimum
// possible sums of two numbers that we can
// get if replacing digit from 5 to 6 and vice
// versa are allowed.
using System;
 
class GFG {
     
    // Find new value of x after
    // replacing digit "from" to "to"
    static int replaceDig(int x, int from,
                                 int to)
    {
        int result = 0;
        int multiply = 1;
     
        while (x > 0)
        {
            int reminder = x % 10;
     
            // Required digit found,
            // replace it
            if (reminder == from)
                result = result + to * multiply;
     
            else
                result = result + reminder * multiply;
     
            multiply *= 10;
            x = x / 10;
        }
        return result;
    }
     
    // Returns maximum and minimum
    // possible sums of x1 and x2
    // if digit replacements are allowed.
    static void calculateMinMaxSum(int x1, int x2)
    {
         
        // We always get minimum sum if
        // we replace 6 with 5.
        int minSum = replaceDig(x1, 6, 5) +
                     replaceDig(x2, 6, 5);
     
        // We always get maximum sum if
        //  we replace 5 with 6.
        int maxSum = replaceDig(x1, 5, 6) +
                       replaceDig(x2, 5, 6);
        Console.Write("Minimum sum = " + minSum);
        Console.Write("\nMaximum sum = " + maxSum);
    }
     
    // Driver code
    public static void Main ()
    {
        int x1 = 5466, x2 = 4555;
        calculateMinMaxSum(x1, x2);
    }
}
 
// This code is contributed by Nitin Mittal.

PHP

<?php
// PHP program to find maximum
// and minimum possible sums of
// two numbers that we can get if
// replacing digit from 5 to 6
// and vice versa are allowed.
 
 
// Find new value of x after
// replacing digit "from" to "to"
function replaceDig($x, $from, $to)
{
    $result = 0;
    $multiply = 1;
 
    while ($x > 0)
    {
        $reminder = $x % 10;
 
        // Required digit found,
        // replace it
        if ($reminder == $from)
            $result = $result + $to *
                           $multiply;
 
        else
            $result = $result +
                      $reminder *
                      $multiply;
 
        $multiply *= 10;
        $x = $x / 10;
    }
    return $result;
}
 
// Returns maximum and minimum
// possible sums of x1 and x2
// if digit replacements are allowed.
function calculateMinMaxSum($x1, $x2)
{
    // We always get minimum sum
    // if we replace 6 with 5.
$minSum = replaceDig($x1, 6, 5) +
           replaceDig($x2, 6, 5);
 
    // We always get maximum sum
    // if we replace 5 with 6.
    $maxSum = replaceDig($x1, 5, 6) +
               replaceDig($x2, 5, 6);
    echo "Minimum sum = " , $minSum,"\n";
    echo "Maximum sum = " , $maxSum;
}
 
// Driver code
$x1 = 5466; $x2 = 4555;
calculateMinMaxSum($x1, $x2);
 
// This code is contributed
// by nitin mittal.
?>

Javascript

<script>
 
// Javascript program to find maximum and minimum
// possible sums of two numbers that we can
// get if replacing digit from 5 to 6 and vice
// versa are allowed.
 
     
// Find new value of x after replacing digit
// "from" to "to"
function replaceDig(x , from , to)
{
     
    var result = 0;
    var multiply = 1;
 
    while (x > 0)
    {
        var reminder = x % 10;
 
        // Required digit found, replace it
        if (reminder == from)
            result = result + to * multiply;
 
        else
            result = result + reminder * multiply;
 
        multiply *= 10;
        x = parseInt(x / 10);
    }
    return result;
}
 
// Returns maximum and minimum possible sums of
// x1 and x2 if digit replacements are allowed.
function calculateMinMaxSum(x1 , x2)
{
     
    // We always get minimum sum if we replace
    // 6 with 5.
    var minSum = replaceDig(x1, 6, 5) +
                replaceDig(x2, 6, 5);
 
    // We always get maximum sum if we replace
    // 5 with 6.
    var maxSum = replaceDig(x1, 5, 6) +
                replaceDig(x2, 5, 6);
    document.write("Minimum sum = " + minSum);
    document.write("<br>Maximum sum = " + maxSum);
}
 
// Driver code
var x1 = 5466, x2 = 4555;
calculateMinMaxSum(x1, x2);
 
// This code contributed by shikhasingrajput
 
</script>

Producción :  

Minimum sum = 10010
Maximum sum = 11132

Complejidad de tiempo : O(logn) 
Espacio auxiliar : O(1)

Este artículo es una contribución de Roshni Agarwal . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
 

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *