Given a binary string **S** of length **N**, the task is to find the winner of the game if two players **A** and** B** plays optimally as per the following rules:

- Player A always starts the game.
- In a player’s first turn, he can move to any index (
*1-based indexing*) consisting of**‘0’**and make it**‘1’**. - For the subsequent turns, if any player is at index
**i**, then he can move to one of it’s adjacent indice, if it contains**0**, and convert it to**‘1’**after moving. - If any player is unable to move to any position during his turn, then the player loses the game.

The task is to find the winner of the game.

**Examples:**

Input:S = “1100011”Output:Player AExplanation:

The indices 3, 4 and 5 consists of 0s and indices 1, 2, 6 and 7 consists of 1s.

A starts by flipping the character at index 4..

B flips either the index 3 or 5.

A is now left with only one index adjacent to 4, which B did not pick. After A flips the character at that index, B does not have any character to flip. Since B has no moves, A wins.

Hence, print “Player A”.

Input:S = “11111”Output:Player B

**Approach:** The idea is to store the length of all the substrings consisting only of **0s** from the given array **arr[]** in another array, say **V[]**. Now, the following cases arise:

**If the size of V is 0****:**In this case, the array does not contain any**0s**. Therefore,**Player A**can’t make any move and loses the game. Hence, print**Player B**.**If the size of V is 1****:**In this case, there is 1 substring consisting only of**0s**, say of length**L**. If the value of**L**is odd, then**Player A**wins the game. Otherwise,**Player B**wins the game.- In all other cases: Store the length of the largest and the second-largest consecutive segment of
**0**s in**first**and**second**respectively.**Player A**can win the game if and only if the value of**first**is odd and**(first + 1)/2 > second**. Otherwise,**Player B**wins the game.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to check if player A wins` `// the game or not` `void` `findWinner(string a, ` `int` `n)` `{` ` ` `// Stores size of the groups of 0s` ` ` `vector<` `int` `> v;` ` ` `// Stores size of the group of 0s` ` ` `int` `c = 0;` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `// Increment c by 1 if a[i] is 0` ` ` `if` `(a[i] == ` `'0'` `) {` ` ` `c++;` ` ` `}` ` ` `// Otherwise, push the size` ` ` `// in array and reset c to 0` ` ` `else` `{` ` ` `if` `(c != 0)` ` ` `v.push_back(c);` ` ` `c = 0;` ` ` `}` ` ` `}` ` ` `if` `(c != 0)` ` ` `v.push_back(c);` ` ` `// If there is no substring of` ` ` `// odd length consisting only of 0s` ` ` `if` `(v.size() == 0) {` ` ` `cout << ` `"Player B"` `;` ` ` `return` `;` ` ` `}` ` ` `// If there is only 1 substring of` ` ` `// odd length consisting only of 0s` ` ` `if` `(v.size() == 1) {` ` ` `if` `(v[0] & 1)` ` ` `cout << ` `"Player A"` `;` ` ` `// Otherwise` ` ` `else` ` ` `cout << ` `"Player B"` `;` ` ` `return` `;` ` ` `}` ` ` `// Stores the size of the largest` ` ` `// and second largest substrings of 0s` ` ` `int` `first = INT_MIN;` ` ` `int` `second = INT_MIN;` ` ` `// Traverse the array v[]` ` ` `for` `(` `int` `i = 0; i < v.size(); i++) {` ` ` `// If current element is greater` ` ` `// than first, then update both` ` ` `// first and second` ` ` `if` `(a[i] > first) {` ` ` `second = first;` ` ` `first = a[i];` ` ` `}` ` ` `// If arr[i] is in between` ` ` `// first and second, then` ` ` `// update second` ` ` `else` `if` `(a[i] > second` ` ` `&& a[i] != first)` ` ` `second = a[i];` ` ` `}` ` ` `// If the condition is satisfied` ` ` `if` `((first & 1)` ` ` `&& (first + 1) / 2 > second)` ` ` `cout << ` `"Player A"` `;` ` ` `else` ` ` `cout << ` `"Player B"` `;` `}` `// Driver Code` `int` `main()` `{` ` ` `string S = ` `"1100011"` `;` ` ` `int` `N = S.length();` ` ` `findWinner(S, N);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.util.*;` `public` `class` `GFG` `{` ` ` `// Function to check if player A wins` ` ` `// the game or not` ` ` `static` `void` `findWinner(String a, ` `int` `n)` ` ` `{` ` ` `// Stores size of the groups of 0s` ` ` `Vector<Integer> v = ` `new` `Vector<Integer>(); ` ` ` `// Stores size of the group of 0s` ` ` `int` `c = ` `0` `;` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `{` ` ` `// Increment c by 1 if a[i] is 0` ` ` `if` `(a.charAt(i) == ` `'0'` `)` ` ` `{` ` ` `c++;` ` ` `}` ` ` `// Otherwise, push the size` ` ` `// in array and reset c to 0` ` ` `else` ` ` `{` ` ` `if` `(c != ` `0` `)` ` ` `v.add(c);` ` ` `c = ` `0` `;` ` ` `}` ` ` `}` ` ` `if` `(c != ` `0` `)` ` ` `v.add(c);` ` ` `// If there is no substring of` ` ` `// odd length consisting only of 0s` ` ` `if` `(v.size() == ` `0` `)` ` ` `{` ` ` `System.out.print(` `"Player B"` `);` ` ` `return` `;` ` ` `}` ` ` `// If there is only 1 substring of` ` ` `// odd length consisting only of 0s` ` ` `if` `(v.size() == ` `1` `)` ` ` `{` ` ` `if` `((v.get(` `0` `) & ` `1` `) != ` `0` `)` ` ` `System.out.print(` `"Player A"` `);` ` ` `// Otherwise` ` ` `else` ` ` `System.out.print(` `"Player B"` `);` ` ` `return` `;` ` ` `}` ` ` `// Stores the size of the largest` ` ` `// and second largest substrings of 0s` ` ` `int` `first = Integer.MIN_VALUE;` ` ` `int` `second = Integer.MIN_VALUE;` ` ` `// Traverse the array v[]` ` ` `for` `(` `int` `i = ` `0` `; i < v.size(); i++)` ` ` `{` ` ` `// If current element is greater` ` ` `// than first, then update both` ` ` `// first and second` ` ` `if` `(a.charAt(i) > first) {` ` ` `second = first;` ` ` `first = a.charAt(i);` ` ` `}` ` ` `// If arr[i] is in between` ` ` `// first and second, then` ` ` `// update second` ` ` `else` `if` `(a.charAt(i) > second` ` ` `&& a.charAt(i) != first)` ` ` `second = a.charAt(i);` ` ` `}` ` ` `// If the condition is satisfied` ` ` `if` `((first & ` `1` `) != ` `0` ` ` `&& (first + ` `1` `) / ` `2` `> second)` ` ` `System.out.print(` `"Player A"` `);` ` ` `else` ` ` `System.out.print(` `"Player B"` `);` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `String S = ` `"1100011"` `;` ` ` `int` `N = S.length();` ` ` `findWinner(S, N);` ` ` `}` `}` `// This code is contributed by divyeshrabadiya07.` |

## Python3

`# Python3 program for the above approach` `import` `sys` `# Function to check if player A wins` `# the game or not` `def` `findWinner(a, n) :` ` ` `# Stores size of the groups of 0s` ` ` `v ` `=` `[]` ` ` `# Stores size of the group of 0s` ` ` `c ` `=` `0` ` ` `# Traverse the array` ` ` `for` `i ` `in` `range` `(` `0` `, n) :` ` ` `# Increment c by 1 if a[i] is 0` ` ` `if` `(a[i] ` `=` `=` `'0'` `) :` ` ` `c ` `+` `=` `1` ` ` `# Otherwise, push the size` ` ` `# in array and reset c to 0` ` ` `else` `:` ` ` `if` `(c !` `=` `0` `) :` ` ` `v.append(c)` ` ` `c ` `=` `0` ` ` ` ` `if` `(c !` `=` `0` `) :` ` ` `v.append(c)` ` ` `# If there is no substring of` ` ` `# odd length consisting only of 0s` ` ` `if` `(` `len` `(v) ` `=` `=` `0` `) :` ` ` `print` `(` `"Player B"` `, end ` `=` `"")` ` ` `return` ` ` `# If there is only 1 substring of` ` ` `# odd length consisting only of 0s` ` ` `if` `(` `len` `(v) ` `=` `=` `1` `) :` ` ` `if` `((v[` `0` `] & ` `1` `) !` `=` `0` `) :` ` ` `print` `(` `"Player A"` `, end ` `=` `"")` ` ` `# Otherwise` ` ` `else` `:` ` ` `print` `(` `"Player B"` `, end ` `=` `"")` ` ` `return` ` ` `# Stores the size of the largest` ` ` `# and second largest substrings of 0s` ` ` `first ` `=` `sys.minsize` ` ` `second ` `=` `sys.minsize` ` ` `# Traverse the array v[]` ` ` `for` `i ` `in` `range` `(` `len` `(v)) :` ` ` `# If current element is greater` ` ` `# than first, then update both` ` ` `# first and second` ` ` `if` `(a[i] > first) :` ` ` `second ` `=` `first` ` ` `first ` `=` `a[i]` ` ` `# If arr[i] is in between` ` ` `# first and second, then` ` ` `# update second` ` ` `elif` `(a[i] > second ` `and` `a[i] !` `=` `first) :` ` ` `second ` `=` `a[i]` ` ` `# If the condition is satisfied` ` ` `if` `(((first & ` `1` `) !` `=` `0` `) ` `and` `(first ` `+` `1` `) ` `/` `/` `2` `> second) :` ` ` `print` `(` `"Player A"` `, end ` `=` `"")` ` ` `else` `:` ` ` `print` `(` `"Player B"` `, end ` `=` `"")` `S ` `=` `"1100011"` `N ` `=` `len` `(S)` `findWinner(S, N)` `# This code is contributed by divyesh072019.` |

## C#

`// C# program to implement` `// the above approach` `using` `System;` `using` `System.Collections.Generic;` `using` `System.Linq;` `class` `GFG{` ` ` `// Function to check if player A wins` ` ` `// the game or not` ` ` `static` `void` `findWinner(` `string` `a, ` `int` `n)` ` ` `{` ` ` `// Stores size of the groups of 0s` ` ` `List<` `int` `> v = ` `new` `List<` `int` `>(); ` ` ` `// Stores size of the group of 0s` ` ` `int` `c = 0;` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `// Increment c by 1 if a[i] is 0` ` ` `if` `(a[i] == ` `'0'` `)` ` ` `{` ` ` `c++;` ` ` `}` ` ` `// Otherwise, push the size` ` ` `// in array and reset c to 0` ` ` `else` ` ` `{` ` ` `if` `(c != 0)` ` ` `v.Add(c);` ` ` `c = 0;` ` ` `}` ` ` `}` ` ` `if` `(c != 0)` ` ` `v.Add(c);` ` ` `// If there is no substring of` ` ` `// odd length consisting only of 0s` ` ` `if` `(v.Count == 0)` ` ` `{` ` ` `Console.Write(` `"Player B"` `);` ` ` `return` `;` ` ` `}` ` ` `// If there is only 1 substring of` ` ` `// odd length consisting only of 0s` ` ` `if` `(v.Count == 1)` ` ` `{` ` ` `if` `((v[0] & 1) != 0)` ` ` `Console.Write(` `"Player A"` `);` ` ` `// Otherwise` ` ` `else` ` ` `Console.Write(` `"Player B"` `);` ` ` `return` `;` ` ` `}` ` ` `// Stores the size of the largest` ` ` `// and second largest substrings of 0s` ` ` `int` `first = Int32.MinValue;` ` ` `int` `second = Int32.MinValue;` ` ` `// Traverse the array v[]` ` ` `for` `(` `int` `i = 0; i < v.Count; i++)` ` ` `{` ` ` `// If current element is greater` ` ` `// than first, then update both` ` ` `// first and second` ` ` `if` `(a[i] > first) {` ` ` `second = first;` ` ` `first = a[i];` ` ` `}` ` ` `// If arr[i] is in between` ` ` `// first and second, then` ` ` `// update second` ` ` `else` `if` `(a[i] > second` ` ` `&& a[i] != first)` ` ` `second = a[i];` ` ` `}` ` ` `// If the condition is satisfied` ` ` `if` `((first & 1) != 0` ` ` `&& (first + 1) / 2 > second)` ` ` `Console.Write(` `"Player A"` `);` ` ` `else` ` ` `Console.Write(` `"Player B"` `);` ` ` `}` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` `string` `S = ` `"1100011"` `;` ` ` `int` `N = S.Length;` ` ` `findWinner(S, N);` `}` `}` `// This code is contributed by splevel62.` |

## Javascript

`<script>` ` ` `// Javascript program to implement the above approach` ` ` ` ` `// Function to check if player A wins` ` ` `// the game or not` ` ` `function` `findWinner(a, n)` ` ` `{` ` ` `// Stores size of the groups of 0s` ` ` `let v = [];` ` ` `// Stores size of the group of 0s` ` ` `let c = 0;` ` ` `// Traverse the array` ` ` `for` `(let i = 0; i < n; i++)` ` ` `{` ` ` `// Increment c by 1 if a[i] is 0` ` ` `if` `(a[i] == ` `'0'` `)` ` ` `{` ` ` `c++;` ` ` `}` ` ` `// Otherwise, push the size` ` ` `// in array and reset c to 0` ` ` `else` ` ` `{` ` ` `if` `(c != 0)` ` ` `v.push(c);` ` ` `c = 0;` ` ` `}` ` ` `}` ` ` `if` `(c != 0)` ` ` `v.push(c);` ` ` `// If there is no substring of` ` ` `// odd length consisting only of 0s` ` ` `if` `(v.length == 0)` ` ` `{` ` ` `document.write(` `"Player B"` `);` ` ` `return` `;` ` ` `}` ` ` `// If there is only 1 substring of` ` ` `// odd length consisting only of 0s` ` ` `if` `(v.length == 1)` ` ` `{` ` ` `if` `((v[0] & 1) != 0)` ` ` `document.write(` `"Player A"` `);` ` ` `// Otherwise` ` ` `else` ` ` `document.write(` `"Player B"` `);` ` ` `return` `;` ` ` `}` ` ` `// Stores the size of the largest` ` ` `// and second largest substrings of 0s` ` ` `let first = Number.MIN_VALUE;` ` ` `let second = Number.MIN_VALUE;` ` ` `// Traverse the array v[]` ` ` `for` `(let i = 0; i < v.length; i++)` ` ` `{` ` ` `// If current element is greater` ` ` `// than first, then update both` ` ` `// first and second` ` ` `if` `(a[i] > first) {` ` ` `second = first;` ` ` `first = a[i];` ` ` `}` ` ` `// If arr[i] is in between` ` ` `// first and second, then` ` ` `// update second` ` ` `else` `if` `(a[i] > second && a[i] != first)` ` ` `second = a[i];` ` ` `}` ` ` `// If the condition is satisfied` ` ` `if` `((first & 1) != 0 && parseInt((first + 1) / 2, 10) > second)` ` ` `document.write(` `"Player A"` `);` ` ` `else` ` ` `document.write(` `"Player B"` `);` ` ` `}` ` ` ` ` `let S = ` `"1100011"` `;` ` ` `let N = S.length;` ` ` `findWinner(S, N);` ` ` ` ` `// This code is contributed by suresh07.` `</script>` |

**Output:**

Player A

**Time Complexity:** O(N) **Auxiliary Space:** O(N)