Determine el ganador del juego colocando las bolas en fila

Dada la cantidad de bolas pequeñas y grandes N y M respectivamente, la tarea es encontrar qué jugador gana si tanto el jugador X como el Y juegan de manera óptima al realizar los siguientes dos movimientos:

• El jugador X intentará mantener el mismo tipo de bola , es decir, pequeña seguida de otra bola pequeña o bola grande seguida de una bola grande.
• El jugador Y pondrá diferentes tipos de pelota , es decir, pequeña seguida de una grande o viceversa.

El jugador que no puede hacer un movimiento pierde el juego. La tarea es encontrar qué jugador ganó el juego el número dado de bolas. Se da que el jugador X siempre empieza primero.

Ejemplos:

Entrada: N = 3 M = 1
Salida: X 
Explicación:    
Como solo hay 1 bola grande, el jugador X la pondrá primero. 
El jugador Y pone una bola pequeña junto a una grande, porque puede poner otro tipo de bola al lado. 
Luego el jugador X pone una pelota pequeña (del mismo tipo). Ahora, el jugador Y no puede quedarse con la pelota y, por lo tanto, no puede hacer un movimiento
Secuencia = {grande, pequeño, pequeño}, por lo tanto, la puntuación sería X = 2 e Y = 1.
Por lo tanto, el jugador X gana.

Entrada: N = 4 M = 4 
Salida: Y     
Explicación:  
Primer movimiento del jugador X = pequeño, primer movimiento del jugador Y = grande ( N = 4, M = 3 )
Segundo movimiento del jugador X = grande, segundo movimiento del jugador Y = pequeño ( N = 3, M = 2 )
Tercer movimiento del jugador X = pequeño, tercer movimiento del jugador Y = grande ( N = 2, M = 1 )
Cuarto movimiento del jugador X = grande, cuarto movimiento del jugador Y = pequeño ( N = 1, M = 0 ).
Por lo tanto, el jugador Y gana ya que el jugador X no puede hacer ningún movimiento. 
 

Enfoque: siga los pasos que se indican a continuación para resolver el problema:

• Compruebe si el número de bolas pequeñas es mayor o igual al número de bolas grandes , entonces el jugador X tendrá una puntuación N – 1 ya que el jugador X colocará primero la bola pequeña, luego el jugador Y colocará inmediatamente un tipo diferente de bola y ahora el jugador X pondrá la misma bola que el tipo del jugador Y. Este proceso continuará hasta el final del juego.
• De lo contrario, si las bolas grandes son más grandes que las bolas pequeñas , entonces el jugador X tendrá una puntuación de M – 1 y el jugador Y tendrá una puntuación de N , el enfoque será el mismo que el mencionado anteriormente. Aquí, el jugador X primero comenzará manteniendo la pelota grande primero.
• Al final, compare las puntuaciones de ambos jugadores e imprima el ganador como salida.

A continuación se muestra la implementación del enfoque anterior:

// C++ program for the above approach
#include <iostream>
using namespace std;
 
// Function to find the winner of the
// Game by arranging the balls in a row
void findWinner(int n, int m)
{
    int X = 0;
    int Y = 0;
 
    // Check if small balls are greater
    // or equal to the large ones
    if (n >= m) {
 
        // X can place balls
        // therefore scores n-1
        X = n - 1;
        Y = m;
    }
 
    // Condition if large balls
    // are greater than small
    else {
 
        // X can have m-1 as a score
        // since greater number of
        // balls can only be adjacent
        X = m - 1;
        Y = n;
    }
 
    // Compare the score
    if (X > Y)
        cout << "X";
 
    else if (Y > X)
        cout << "Y";
 
    else
        cout << "-1";
}
 
// Driver Code
int main()
{
    // Given number of small balls(N)
    // and number of large balls(M)
    int n = 3, m = 1;
 
    // Function call
    findWinner(n, m);
    return 0;
}

// Java program for the above approach
class GFG{
   
// Function to find the winner of the
// Game by arranging the balls in a row
static void findWinner(int n, int m)
{
    int X = 0;
    int Y = 0;
  
    // Check if small balls are greater
    // or equal to the large ones
    if (n >= m)
    {
  
        // X can place balls
        // therefore scores n-1
        X = n - 1;
        Y = m;
    }
  
    // Condition if large balls
    // are greater than small
    else
    {
  
        // X can have m-1 as a score
        // since greater number of
        // balls can only be adjacent
        X = m - 1;
        Y = n;
    }
  
    // Compare the score
    if (X > Y)
        System.out.print("X");
  
    else if (Y > X)
        System.out.print("Y");
  
    else
        System.out.print("-1");
}
  
// Driver Code
public static void main(String[] args)
{
    // Given number of small balls(N)
    // and number of large balls(M)
    int n = 3, m = 1;
  
    // Function call
    findWinner(n, m);
}
}
 
// This code is contributed by rock_cool

# Python3 program for the above approach
 
# Function to find the winner of the
# Game by arranging the balls in a row
def findWinner(n, m):
    X = 0;
    Y = 0;
 
    # Check if small balls are greater
    # or equal to the large ones
    if (n >= m):
 
        # X can place balls
        # therefore scores n-1
        X = n - 1;
        Y = m;
 
    # Condition if large balls
    # are greater than small
    else:
 
        # X can have m-1 as a score
        # since greater number of
        # balls can only be adjacent
        X = m - 1;
        Y = n;
     
    # Compare the score
    if (X > Y):
        print("X");
 
    elif(Y > X):
        print("Y");
 
    else:
        print("-1");
 
# Driver Code
if __name__ == '__main__':
   
    # Given number of small balls(N)
    # and number of large balls(M)
    n = 3;
    m = 1;
 
    # Function call
    findWinner(n, m);
 
# This code is contributed by Rohit_ranjan

// C# program for the above approach
using System;
class GFG{
   
// Function to find the winner of the
// Game by arranging the balls in a row
static void findWinner(int n, int m)
{
    int X = 0;
    int Y = 0;
  
    // Check if small balls are greater
    // or equal to the large ones
    if (n >= m)
    {
  
        // X can place balls
        // therefore scores n-1
        X = n - 1;
        Y = m;
    }
  
    // Condition if large balls
    // are greater than small
    else
    {
  
        // X can have m-1 as a score
        // since greater number of
        // balls can only be adjacent
        X = m - 1;
        Y = n;
    }
  
    // Compare the score
    if (X > Y)
        Console.Write("X");
  
    else if (Y > X)
        Console.Write("Y");
  
    else
        Console.Write("-1");
}
  
// Driver Code
public static void Main(String[] args)
{
    // Given number of small balls(N)
    // and number of large balls(M)
    int n = 3, m = 1;
  
    // Function call
    findWinner(n, m);
}
}
 
// This code is contributed by sapnasingh4991

<script>
 
// Javascript program for the above approach
 
// Function to find the winner of the
// Game by arranging the balls in a row
function findWinner(n, m)
{
    let X = 0;
    let Y = 0;
 
    // Check if small balls are greater
    // or equal to the large ones
    if (n >= m)
    {
         
        // X can place balls
        // therefore scores n-1
        X = n - 1;
        Y = m;
    }
 
    // Condition if large balls
    // are greater than small
    else
    {
         
        // X can have m-1 as a score
        // since greater number of
        // balls can only be adjacent
        X = m - 1;
        Y = n;
    }
 
    // Compare the score
    if (X > Y)
        document.write("X");
 
    else if (Y > X)
        document.write("Y");
 
    else
        document.write("-1");
}
 
// Driver code
 
// Given number of small balls(N)
// and number of large balls(M)
let n = 3, m = 1;
 
// Function call
findWinner(n, m);
 
// This code is contributed by divyesh072019
 
</script>

X

Tiempo Complejidad: O(1)
Espacio Auxiliar: O(1)