Find the winner of the Game to Win by erasing any two consecutive similar alphabets (original) (raw)

Last Updated : 11 Jul, 2025

Given a string consisting of lower case alphabets.
Rules of the Game:

• A player can choose a pair of similar consecutive characters and erase them.
• There are two players playing the game, the player who makes the last move wins.

The task is to find the winner if A goes first and both play optimally.
Examples:

Input: str = "kaak" Output: B Explanation: Initial String: "kaak" A's turn: removes: "aa" Remaining String: "kk" B's turn: removes: "kk" Remaining String: "" Since B was the last one to play B is the winner.

Input: str = "kk" Output: A

Approach: We can use a stack to simplify the problem.

• Each time we encounter a character that is different from the one present in the top of the stack we add it to the stack.
• If the stack top and the next character match we pop the character from the stack and increment the count.
• At the end, we just need to see who wins by checking count%2.

Below is the implementation of the above approach:

C++ `

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

// Function to play the game // and find the winner void findWinner(string s) { int i, count = 0, n; n = s.length(); stack st;

// ckecking the top of the stack with
// the i th character of the string
// add it to the stack if they are different
// otherwise increment count
for (i = 0; i < n; i++) {
    if (st.empty() || st.top() != s[i]) {
        st.push(s[i]);
    }
    else {
        count++;
        st.pop();
    }
}

// Check who has won
if (count % 2 == 0) {
    cout << "B" << endl;
}
else {
    cout << "A" << endl;
}

}

// Driver code int main() { string s = "kaak";

findWinner(s);

return 0;

}

Java

// Java implementation for above approach import java.util.*;

class GFG {

// Function to play the game // and find the winner static void findWinner(String s) { int i, count = 0, n; n = s.length(); Stack st = new Stack();

// ckecking the top of the stack with
// the i th character of the string
// add it to the stack if they are different
// otherwise increment count
for (i = 0; i < n; i++) 
{
    if (st.isEmpty() || 
        st.peek() != s.charAt(i))
    {
        st.push(s.charAt(i));
    } 
    else
    {
        count++;
        st.pop();
    }
}

// Check who has won
if (count % 2 == 0) 
{
    System.out.println("B");
} 
else
{
    System.out.println("A");
}

}

// Driver code public static void main(String[] args) { String s = "kaak";

findWinner(s);

} }

// This code is contributed by Rajput-Ji

Python3

Python3 implementation of the approach

Function to play the game

and find the winner

def findWinner(s) :

count = 0
n = len(s); 
st = []; 

# ckecking the top of the stack with 
# the i th character of the string 
# add it to the stack if they are different 
# otherwise increment count 
for i in range(n) :
    if (len(st) == 0 or st[-1] != s[i]) : 
        st.append(s[i]); 
        
    else : 
        count += 1; 
        st.pop(); 

# Check who has won 
if (count % 2 == 0) :
    print("B"); 

else :
    print("A"); 
    

Driver code

if name == "main" :

s = "kaak"; 

findWinner(s);

This code is contributed by AnkitRai01

C#

// C# implementation for above approach using System; using System.Collections.Generic;

class GFG {

// Function to play the game // and find the winner static void findWinner(String s) { int i, count = 0, n; n = s.Length; Stack st = new Stack();

// ckecking the top of the stack with
// the i th character of the string
// add it to the stack if they are different
// otherwise increment count
for (i = 0; i < n; i++) 
{
    if (st.Count == 0 || 
        st.Peek() != s[i])
    {
        st.Push(s[i]);
    } 
    else
    {
        count++;
        st.Pop();
    }
}

// Check who has won
if (count % 2 == 0) 
{
    Console.WriteLine("B");
} 
else
{
    Console.WriteLine("A");
}

}

// Driver code public static void Main(String[] args) { String s = "kaak";

findWinner(s);

} }

// This code is contributed by 29AjayKumar

JavaScript

`

Time Complexity: O(n)

Auxiliary Space: O(n)