Encuentre el ganador del juego donde X elige 1, luego Y elige 2, luego X elige 3 y así sucesivamente

Dos jugadores X e Y están eligiendo números alternativamente con X eligiendo primero. En el primer turno, X elige 1, luego Y elige 2, luego X elige 3 y el juego continúa así. Cuando un jugador no puede elegir un número, pierde el juego. Dados 2 números enteros A y B que denotan la suma máxima de los números, X e Y pueden elegir respectivamente. Encuentra al ganador del juego. 

Ejemplos:

Entrada : A = 3, B = 2
Salida : Y
Explicación : Inicialmente, X elige 1, Y elige 2. 
Ahora, en el tercer movimiento, X solo puede elegir 3, por lo que la suma (1+3) = 4.
4 excede el total permitido suma para X, es decir, 3. Así que el ganador es Y 

Entrada : A = 4, B = 2
Salida : X 

Enfoque: La tarea se puede resolver manteniendo 2 sumas, una para X y otra para Y. Siga los pasos a continuación para resolver el problema:

• El límite máximo de X e Y es A y B respectivamente.
• Inicialice la suma total de X e Y con 0.
• Inicializar contador con 0.
• Ejecutar bucle while hasta ( total_x ≤ A y total_y ≤ B )
• Contador de incrementos
• Después de la ruptura del bucle, comprueba quién cruzó el límite primero.

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

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the winner
void winner(int A, int B)
{
    // Initialize with zero
    int total_x, total_y, counter = 0;
 
    // Fixed limit
    while (total_x <= A && total_y <= B) {
        // Increment counter
        counter = counter + 1;
 
        // X's total
        total_x = total_x + counter;
 
        // Increment counter
        counter = counter + 1;
 
        // Y's total
        total_y = total_y + counter;
    }
    if (total_x > A && total_y > B)
        cout << "Y";
    else if (total_x > A)
        cout << "Y";
    else
        cout << "X";
}
 
// Driver Code
int main()
{
    int A = 3, B = 2;
    winner(A, B);
    return 0;
}

// C program for the above approach
#include <stdio.h>
 
// Function to find the winner
void winner(int A, int B)
{
    // Initialize with zero
    int total_x, total_y, counter = 0;
 
    // Fixed limit
    while (total_x <= A && total_y <= B) {
        // Increment counter
        counter = counter + 1;
 
        // X's total
        total_x = total_x + counter;
 
        // Increment counter
        counter = counter + 1;
 
        // Y's total
        total_y = total_y + counter;
    }
    if (total_x > A && total_y > B)
        printf("Y");
    else if (total_x > A)
        printf("Y");
    else
        printf("X");
}
 
// Driver Code
void main()
{
    int A = 3, B = 2;
    winner(A, B);
}

// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG {
 
  // Function to find the winner
  static void winner(int A, int B)
  {
    // Initialize with zero
    int total_x = 0, total_y = 0, counter = 0;
 
    // Fixed limit
    while (total_x <= A && total_y <= B) {
      // Increment counter
      counter = counter + 1;
 
      // X's total
      total_x = total_x + counter;
 
      // Increment counter
      counter = counter + 1;
 
      // Y's total
      total_y = total_y + counter;
    }
    if (total_x > A && total_y > B)
      System.out.println("Y");
    else if (total_x > A)
      System.out.println("Y");
    else
      System.out.println("X");
  }
 
  // Driver Code
  public static void main (String[] args) {
    int A = 3, B = 2;
    winner(A, B);
  }
}
 
// This code is contributed by hrithikgarg03188.

# Python program for the above approach
 
# Function to find the winner
def winner(A, B):
     
    # Initialize with zero
    total_x = 0
    total_y = 0
    counter = 0
 
    # Fixed limit
    while (total_x <= A and total_y <= B):
         
        # Increment counter
        counter = counter + 1
 
        # X's total
        total_x = total_x + counter
 
        # Increment counter
        counter = counter + 1
 
        # Y's total
        total_y = total_y + counter
     
    if (total_x > A and total_y > B):
        print("Y")
    elif (total_x > A):
        print("Y")
    else:
        print("X")
 
# Driver Code
 
A = 3
B = 2
winner(A, B)
 
# This code is contributed by Samim Hossain Mondal.

// C# program for the above approach
using System;
class GFG {
 
  // Function to find the winner
  static void winner(int A, int B)
  {
    // Initialize with zero
    int total_x = 0, total_y = 0, counter = 0;
 
    // Fixed limit
    while (total_x <= A && total_y <= B) {
      // Increment counter
      counter = counter + 1;
 
      // X's total
      total_x = total_x + counter;
 
      // Increment counter
      counter = counter + 1;
 
      // Y's total
      total_y = total_y + counter;
    }
    if (total_x > A && total_y > B)
      Console.WriteLine("Y");
    else if (total_x > A)
      Console.WriteLine("Y");
    else
      Console.WriteLine("X");
  }
 
  // Driver Code
  public static void Main () {
    int A = 3, B = 2;
    winner(A, B);
  }
}
 
// This code is contributed by Samim Hossain Mondal.

<script>
    // JavaScript code for the above approach
 
    // Function to find the winner
    function winner(A, B)
    {
     
        // Initialize with zero
        let total_x, total_y, counter = 0;
 
        // Fixed limit
        while (total_x <= A && total_y <= B)
        {
         
            // Increment counter
            counter = counter + 1;
 
            // X's total
            total_x = total_x + counter;
 
            // Increment counter
            counter = counter + 1;
 
            // Y's total
            total_y = total_y + counter;
        }
        if (total_x > A && total_y > B)
            document.write("Y")
        else if (total_x > A)
            document.write("Y")
        else
            document.write("X")
    }
 
    // Driver Code
    let A = 3, B = 2;
    winner(A, B);
 
   // This code is contributed by Potta Lokesh
</script>

Y

Complejidad de tiempo : O(log N)
Espacio auxiliar : O(1)