Skip to content
Related Articles

Related Articles

Find the winner of game of repeatedly removing the first character to empty given string
  • Difficulty Level : Medium
  • Last Updated : 10 Feb, 2021

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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<string>& 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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.

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output: 

Player 2

 

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :