Dinero máximo que se puede retirar en dos pasos

Hay dos casilleros en efectivo, uno tiene una cantidad X de monedas y el otro tiene una cantidad Y de monedas, puede retirar dinero como máximo dos veces, cuando retire de un casillero obtendrá el dinero total del casillero y el casillero será recargado con Z – 1 moneda si tenía Z monedas inicialmente. La tarea es encontrar el máximo de monedas que puedes obtener.
Ejemplos: 
 

Entrada: X = 6, Y = 3 
Salida: 11 
Tomar del casillero X, es decir, 6 
Ahora, X = 5 e Y = 3 
Tomar nuevamente del casillero X, es decir, 5.
Entrada: X = 4, Y = 4 
Salida: 8 
 

Enfoque: para maximizar la cantidad de monedas, tome del casillero que tenga el valor máximo, luego actualice el casillero y nuevamente tome del casillero con el valor máximo.
A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the maximum coins we can get
int maxCoins(int X, int Y)
{
 
    // Update elements such that X > Y
    if (X < Y)
        swap(X, Y);
 
    // Take from the maximum
    int coins = X;
 
    // Refill
    X--;
 
    // Again, take the maximum
    coins += max(X, Y);
 
    return coins;
}
 
// Driver code
int main()
{
 
    int X = 7, Y = 5;
 
    cout << maxCoins(X, Y);
 
    return 0;
}

// Java implementation of the approach
import java.util.*;
 
class GFG {
    // Function to return the maximum coins we can get
    static int maxCoins(int X, int Y)
    {
 
        // Update elements such that X > Y
        if (X < Y) {
            swap(X, Y);
        }
 
        // Take from the maximum
        int coins = X;
 
        // Refill
        X--;
 
        // Again, take the maximum
        coins += Math.max(X, Y);
 
        return coins;
    }
 
    static void swap(int X, int Y)
    {
        int temp = X;
        X = Y;
        Y = temp;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int X = 7, Y = 5;
        System.out.println(maxCoins(X, Y));
    }
}
 
// This code has been contributed by 29AjayKumar

# Python3 implementation of the approach
 
# Function to return the maximum coins we can get
def maxCoins(X, Y) :
 
    # Update elements such that X > Y
    if (X < Y) :
        X, Y = Y, X;
 
    # Take from the maximum
    coins = X;
 
    # Refill
    X -= 1;
 
    # Again, take the maximum
    coins += max(X, Y);
 
    return coins;
 
 
# Driver code
if __name__ == "__main__" :
 
    X = 7; Y = 5;
 
    print(maxCoins(X, Y));
     
    # This code is contributed by Ryuga

// C# implementation of the approach
using System;
 
class GFG {
    // Function to return the maximum coins we can get
    static int maxCoins(int X, int Y)
    {
 
        // Update elements such that X > Y
        if (X < Y) {
            swap(X, Y);
        }
 
        // Take from the maximum
        int coins = X;
 
        // Refill
        X--;
 
        // Again, take the maximum
        coins += Math.Max(X, Y);
 
        return coins;
    }
 
    static void swap(int X, int Y)
    {
        int temp = X;
        X = Y;
        Y = temp;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int X = 7, Y = 5;
        Console.WriteLine(maxCoins(X, Y));
    }
}
 
/* This code contributed by PrinciRaj1992 */

<?php
// PHP implementation of the approach
 
// Function to return the maximum coins we can get
function maxCoins($X, $Y)
{
    // Update elements such that X > Y
    if ($X < $Y)
        swap($X, $Y);
 
    // Take from the maximum
    $coins = $X;
 
    // Refill
    $X--;
 
    // Again, take the maximum
    $coins += max($X, $Y);
 
    return $coins;
}
 
// Driver code
 
$X = 7;
$Y = 5;
 
echo maxCoins($X, $Y);
 
// This code is contributed by Naman_Garg.
 
?>

<script>
 
// Javascript implementation of the approach
 
// Function to return the maximum coins we can get
function maxCoins(X, Y)
{
 
    // Update elements such that X > Y
    if (X < Y) {
        let temp = X;
        X = Y;
        Y = temp;
    }
 
    // Take from the maximum
    let coins = X;
 
    // Refill
    X--;
 
    // Again, take the maximum
    coins += Math.max(X, Y);
 
    return coins;
}
 
// Driver code
 
    let X = 7, Y = 5;
 
    document.write(maxCoins(X, Y));
 
</script>

13

Complejidad de tiempo: O(1), ya que no hay bucle.

Espacio Auxiliar: O(1), ya que no se ha ocupado ningún espacio extra.