Encuentre el jugador que ganará eligiendo un número en el rango [1, K] con suma total N

Dados dos enteros K y N , y dado también que Alice y Bob están jugando. En un solo movimiento, un jugador puede elegir un número en el rango [1, K] , y el jugador cuyo número hace que el total sea igual a N gana el juego. Imprima Alice si Alice gana el juego, si no , Bob , si Alice y Bob juegan el juego de manera alternativa y óptima y Alice comienza el juego.

Ejemplos:

Entrada: K = 7, N = 8
Salida: Bob
Explicación: No hay forma de que Alicia gane el juego. Cuando Alicia elige cualquier número del 1 al 7 (ambos incluidos), el oponente gana el juego en el siguiente turno haciendo un total de 8. Supongamos que eliges el número 5, el oponente elige el 3 y gana el juego, haciendo un total de 5+3=8.

Entrada: K = 7, N = 50
Salida: Alice

Planteamiento: Este problema se puede resolver utilizando el concepto de Teoría de Juegos . Observando el estado ganador . El truco para atrapar aquí es que Alice siempre puede repetir un ciclo de (K+1) , cualquiera que sea la elección de Bob . Supongamos que en algún momento si Bob elige a , Alice puede elegir [(K+1)-a ]  manteniendo la selección dentro del rango de 1 a K y formando así un ciclo de (K+1) . Ahora, como Alice tiene la primera oportunidad, Alice debe elegir Resto que queda en Dividir N por (K+1)en el Inicio para que luego pueda seguir repitiendo el ciclo de (K+1) y lograr el total como N .
Ahora, la observación es que si N%(K+1) es 0 , es el único caso en el que es imposible que Alice gane el juego.
Siga los pasos que se indican a continuación para resolver el problema.

• Compruebe si N% (K + 1) es 0, imprima Bob .
• En cualquier otro caso, imprime Alicia .

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

// C++ program for above approach
#include <iostream>
using namespace std;
 
// Function to predict the winner
void predictTheWinner(int K, int N)
{
 
    if (N % (K + 1) == 0)
        cout << "Bob";
    else
        cout << "Alice";
}
 
// Driver Code
int main()
{
 
    // Given Input
    int K = 7, N = 50;
 
    // Function call
    predictTheWinner(K, N);
 
    return 0;
}

// Java program for the above approach
 
import java.io.*;
 
class GFG {
   
// Function to predict the winner
static void predictTheWinner(int K, int N)
{
 
    if (N % (K + 1) == 0)
         System.out.println( "Bob");
    else
         System.out.println("Alice");
}
 
// Driver Code
    public static void main (String[] args) {
        // Given Input
    int K = 7, N = 50;
 
    // Function call
    predictTheWinner(K, N);
    }
}
// This code is contributed by Potta Lokesh

# Python 3 program for above approach
 
# Function to predict the winner
def predictTheWinner(K, N):
    if (N % (K + 1) == 0):
        print("Bob")
    else:
        print("Alice")
 
# Driver Code
if __name__ == '__main__':
    # Given Input
    K = 7
    N = 50
 
    # Function call
    predictTheWinner(K, N)
     
    # This code is contributed by SURENDRA_GANGWAR.

// C# program for the above approach
 
using System;
 
public class GFG {
   
    // Function to predict the winner
    static void predictTheWinner(int K, int N)
    {
     
        if (N % (K + 1) == 0)
             Console.WriteLine( "Bob");
        else
             Console.WriteLine("Alice");
    }
 
    // Driver Code
    public static void Main (string[] args) {
        // Given Input
        int K = 7, N = 50;
 
        // Function call
        predictTheWinner(K, N);
    }
}
 
// This code is contributed by AnkThon

<script>
 
// javascript program for above approach
 
// Function to predict the winner
function predictTheWinner(K, N)
{
 
    if (N % (K + 1) == 0)
        document.write("Bob");
    else
        document.write("Alice");
}
 
// Driver Code
    // Given Input
    var K = 7, N = 50;
 
    // Function call
    predictTheWinner(K, N);
 
// This code is contributed by ipg2016107.
</script>

Alice

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