Find the winner of game of repeatedly removing the first character to empty given string (original) (raw)

Last Updated : 23 Jul, 2025

Given a positive integer N, representing the count of players playing the game and an array of strings arr[], consisting of the numeric strings made up of digits from the range ['1', 'N']. Considering ith player is assigned with the string arr[i], the task is to find the winner of the game when all N players play the game optimally as per the following rules:

Player 1 starts the game, removes the first character of the string arr[1]( 1-based indexing ), say X, and in the next turn Xth player will play the game and remove the first character of arr[X] and so on.
The player who is not able to remove any character from the assigned string will win the game.

Examples:

Input: N = 3, arr[] = { "323", "2", "2" }
Output: Player 2
Explanation:
Turn 1: Removing arr[0][0] by Player 1 modifies arr[0] to "23".
Turn 2: Removing arr[2][0] by Player 3 modifies arr[2] to "".
Turn 3: Removing arr[1][0] by Player 2 modifies arr[1] to "".
Turn 4: Player 2 is not able to remove any characters from arr[1].
Therefore, player 2 wins the game.

Input: N = 3, arr[] = { "121", "21", "23123" }
Output: Player 1

Approach: The problem can be solved using Queue to remove the first character of each string efficiently. Follow the steps below to solve the problem:

Initialize an array of Queues, say Q[], such that Q[i] stores the characters of the string arr[i].
Traverse the array Q[] using variable i as per the rules of the game and check if the count of characters in Q[i] is 0 or not. If found to be true, then print the "Player i".

Below is the implementation of the above approach:

C++ `

// C++ program to implement // the above approach

#include <bits/stdc++.h> using namespace std;

// Function to find the winner of a game of // repeatedly removing the first character // to empty a string void find_Winner(vector& arr, int N) {

// Store characters of each
// string of the array arr[]
vector<queue<char> > Q(N);

// Stores count of strings in arr[]
int M = arr.size();

// Traverse the array arr[]
for (int i = 0; i < M; i++) {

    // Stores length of current string
    int len = arr[i].length();

    // Traverse the string
    for (int j = 0; j < len; j++) {

        // Insert arr[i][j]
        Q[i].push(arr[i][j] - 1);
    }
}

// 1st Player starts the game
int player = 0;

while (Q[player].size() > 0) {

    // Stores the player number
    // for the next turn
    int nextPlayer
        = Q[player].front() - '0';

    // Remove 1st character of
    // current string
    Q[player].pop();

    // Update player number for
    // the next turn
    player = nextPlayer;
}

cout << "Player " << (player + 1);

}

// Driver Code int main() {

int N = 3;
vector<string> arr
    = { "323", "2", "2" };

find_Winner(arr, N);
return 0;

}

Java

// Java program to implement // the above approach import java.util.*;

class GFG {

// Function to find the winner of a game of // repeatedly removing the first character // to empty a String static void find_Winner(String[] arr, int N) {

// Store characters of each
// String of the array arr[]
@SuppressWarnings("unchecked")
Vector<Character> [] Q = new Vector[N];
for (int i = 0; i < Q.length; i++)
    Q[i] = new Vector<Character>();

// Stores count of Strings in arr[]
int M = arr.length;

// Traverse the array arr[]
for (int i = 0; i < M; i++) 
{

    // Stores length of current String
    int len = arr[i].length();

    // Traverse the String
    for (int j = 0; j < len; j++)
    {

        // Insert arr[i][j]
        Q[i].add(arr[i].charAt(j));
    }

}

// 1st Player starts the game
int player = 0;

while (Q[player].size() > 0 ) 
{

    // Stores the player number
    // for the next turn
    int nextPlayer
        = Q[player].get(0) - '0'-1;

    // Remove 1st character of
    // current String
    Q[player].remove(0);

    // Update player number for
    // the next turn
    player = nextPlayer;
}
System.out.print("Player " +  (player + 1));

}

// Driver Code public static void main(String[] args) { int N = 3; String[] arr = { "323", "2", "2" }; find_Winner(arr, N); } }

// This code is contributed by gauravrajput1

Python3

Python3 program to implement

the above approach

Function to find the winner of a game of

repeatedly removing the first character

to empty a string

def find_Winner(arr, N) :

# Store characters of each
# string of the array arr[]
Q = [0]*N   
for i in range(N) :        
    Q[i] = []

# Stores count of strings in arr[]
M = len(arr)

# Traverse the array arr[]
for i in range(M) :

    # Stores length of current string
    Len = len(arr[i])

    # Traverse the string
    for j in range(Len) :

        # Insert arr[i][j]
        Q[i].append(ord(arr[i][j]) - 1)

# 1st Player starts the game
player = 0

while (len(Q[player]) > 0) :

    # Stores the player number
    # for the next turn
    nextPlayer = Q[player][0] - ord('0')

    # Remove 1st character of
    # current string
    del Q[player][0]

    # Update player number for
    # the next turn
    player = nextPlayer

print("Player", (player + 1))

N = 3 arr = [ "323", "2", "2" ]

find_Winner(arr, N)

This code is contributed by divyeshrabadiya07.

C#

// C# program to implement // the above approach using System; using System.Collections.Generic;

class GFG{

// Function to find the winner of a game of // repeatedly removing the first character // to empty a String static void find_Winner(String[] arr, int N) {

// Store characters of each
// String of the array []arr
List<char> [] Q = new List<char>[N];
for(int i = 0; i < Q.Length; i++)
    Q[i] = new List<char>();
    
// Stores count of Strings in []arr
int M = arr.Length;

// Traverse the array []arr
for(int i = 0; i < M; i++) 
{
    
    // Stores length of current String
    int len = arr[i].Length;

    // Traverse the String
    for(int j = 0; j < len; j++)
    {
        
        // Insert arr[i,j]
        Q[i].Add(arr[i][j]);
    }
}

// 1st Player starts the game
int player = 0;

while (Q[player].Count > 0 ) 
{
    
    // Stores the player number
    // for the next turn
    int nextPlayer = Q[player][0] - '0'- 1;
    
    // Remove 1st character of
    // current String
    Q[player].RemoveAt(0);

    // Update player number for
    // the next turn
    player = nextPlayer;
}
Console.Write("Player " + (player + 1));

}

// Driver Code public static void Main(String[] args) { int N = 3; String[] arr = { "323", "2", "2" };

find_Winner(arr, N);

} }

// This code is contributed by Rajput-Ji

JavaScript

Time Complexity: O(N * M), where M is the length of the longest string present in the array.
Auxiliary Space: O(N * M)