# RGYB(color) Slots Game to guess the correct color for the correct slot

Given that you have four slots, and each slot will contain a color red (R), yellow (Y), green (G), blue (B) respectively. For example, if you select YGGR (Slot-1 is yellow, Slots-2 and -3 are green, Slot -4 is red). The colors of slots are not known to you beforehand. You will make a guess about the colors. You might, for example, guess YRGB.

When you guess the correct color for the correct slot, you get a “hit” If you guess a color that exists but is in the wrong slot, you get a “pseudo-hit:’ Note that a slot that is a hit can never count as a pseudo-hit.

Given a guess and a solution, your task is to write a program to calculate the number of hits and pseudo-hits.

Examples:

Input: solution -> RGBY, Guess -> GGRR Output: hit -> 1, pseudohit -> 1 Input: solution -> RGYB, Guess -> YGRR Output: hit -> 1, pseudohit -> 2 Input: solution -> RGYB, Guess -> GGYR Output: hit -> 2, pseudohit -> 1

A **simple solution** will be to traverse both strings simultaneously and check the characters of both strings. If both strings have same character then it is a hit and thus increment the count of hits. If the characters of strings do not match at a position, then traverse the solution string again to see if the character in guess is occurred anywhere in solution string or not, if yes increment count of pseudo hits. **Time Complexity**: O(N*N) , where N is the length of string.

An **efficient solution** is to create a frequency array which stores how many times each character occurs in solution, excluding times when the slot is a “hit”. Then, we iterate through guess to count the number of pseudo-hits.

Below is the implementation of above approach:

## C++

`// CPP code to solve RGYB game` `#include<iostream>` `#include<string>` `using` `namespace` `std;` `int` `hits = 0;` `int` `pseudoHits = 0;` `// maximum no of colors are 4 RGYB` `int` `MAX_COLORS = 4;` `// Function to assign code to a slot` `// based on the color they have` `int` `codeOfColor(` `char` `c)` `{` ` ` `switch` `(c)` ` ` `{` ` ` `case` `'B'` `: ` `return` `0;` ` ` `case` `'G'` `: ` `return` `1;` ` ` `case` `'R'` `: ` `return` `2;` ` ` `case` `'Y'` `: ` `return` `3;` ` ` `default` `:` ` ` `return` `-1;` ` ` `}` `}` `// Function to calculate number of hits` `// and pseudo hits` `void` `calcResult(string guess, string solution)` `{` ` ` `hits = 0;` ` ` `pseudoHits = 0;` ` ` ` ` `if` `(guess.length() != solution.length())` ` ` `cout<<` `"Incorrect Input"` `<<endl;` ` ` ` ` `// frequency array to store how many times` ` ` `// each character occurs in solution string ` ` ` `int` `frequencies[MAX_COLORS] ={ 0 };` ` ` ` ` `// Compute hits and build frequency table` ` ` `for` `(` `int` `i = 0; i < guess.length() ;i++)` ` ` `{` ` ` `if` `(guess[i] == solution[i])` ` ` `hits++;` ` ` ` ` `else` ` ` `{` ` ` `// Only increment the frequency table (which` ` ` `// will be used for pseudo-hits) if it's not` ` ` `// a hit. If it's a hit, the slot has already` ` ` `// been "used."` ` ` `int` `codecolor = codeOfColor(solution[i]);` ` ` `frequencies[codecolor]++;` ` ` `}` ` ` `}` ` ` ` ` `// Compute pseudo-hits` ` ` `for` `(` `int` `i = 0; i < guess.length(); i++)` ` ` `{` ` ` `int` `codecolor = codeOfColor(guess[i]);` ` ` ` ` `if` `(codecolor >= 0 && frequencies[codecolor] > 0` ` ` `&& guess[i] != solution[i])` ` ` `{` ` ` `pseudoHits++;` ` ` `frequencies[codecolor]--;` ` ` `}` ` ` `}` ` ` ` ` `cout << ` `"hits -> "` `<< hits << ` `" Pseudo hits -> "` ` ` `<< pseudoHits << endl;` `}` `// Driver code to test above function` `int` `main()` `{` ` ` `string solution = ` `"GGRR"` `;` ` ` `string guess = ` `"RGBY"` `;` ` ` ` ` `calcResult(solution, guess);` ` ` ` ` `solution = ` `"YGRR"` `;` ` ` `guess = ` `"RGYB"` `;` ` ` ` ` `calcResult(solution, guess);` `}` `// This code is contributed by Sumit Ghosh` |

## Java

`// Java code to solve RGYB game` `import` `java.util.*;` `import` `java.lang.*;` `import` `java.io.*;` `class` `CalcRes` `{` ` ` `static` `int` `hits = ` `0` `;` ` ` `static` `int` `pseudoHits = ` `0` `;` ` ` ` ` `// Function to assign code to a slot` ` ` `// based on the color they have` ` ` `static` `int` `codeOfColor(` `char` `c)` ` ` `{` ` ` `switch` `(c)` ` ` `{` ` ` `case` `'B'` `: ` `return` `0` `;` ` ` `case` `'G'` `: ` `return` `1` `;` ` ` `case` `'R'` `: ` `return` `2` `;` ` ` `case` `'Y'` `: ` `return` `3` `;` ` ` `default` `:` ` ` `return` `-` `1` `;` ` ` `}` ` ` `}` ` ` ` ` `// maximum no of colors are 4 RGYB` ` ` `static` `int` `MAX_COLORS = ` `4` `;` ` ` ` ` `// Function to calculate number of hits` ` ` `// and pseudo hits` ` ` `static` `void` `calcResult(String guess, String solution)` ` ` `{ ` ` ` `hits = ` `0` `;` ` ` `pseudoHits = ` `0` `;` ` ` ` ` `if` `(guess.length() != solution.length())` ` ` `System.out.println(` `"Incorrect Input"` `);` ` ` ` ` `// frequency array to store how many times` ` ` `// each character occurs in solution string` ` ` `int` `[] frequencies = ` `new` `int` `[MAX_COLORS];` ` ` `// Compute hits and build frequency table` ` ` `for` `(` `int` `i = ` `0` `; i < guess.length(); i++)` ` ` `{` ` ` `if` `(guess.charAt(i) == solution.charAt(i))` ` ` `{` ` ` `hits++;` ` ` `}` ` ` `else` ` ` `{` ` ` `/*` ` ` `Only increment the frequency table (which will be` ` ` `used for pseudo-hits) if it's not a hit. If it's a` ` ` `hit, the slot has already been "used."` ` ` `*/` ` ` `int` `codeofcolor = codeOfColor(solution.charAt(i));` ` ` `frequencies[codeofcolor]++;` ` ` `}` ` ` `}` ` ` `// Compute pseudo-hits` ` ` `for` `(` `int` `i = ` `0` `; i < guess.length(); i++)` ` ` `{` ` ` `int` `codeofcolor = codeOfColor(guess.charAt(i));` ` ` `if` `(codeofcolor >= ` `0` `&& frequencies[codeofcolor] > ` `0` `&&` ` ` `guess.charAt(i) != solution.charAt(i))` ` ` `{` ` ` `pseudoHits++;` ` ` `frequencies[codeofcolor]--;` ` ` `}` ` ` `}` ` ` ` ` `System.out.println(` `"hits -> "` `+ hits +` ` ` `" Pseudo hits -> "` `+ pseudoHits);` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{ ` ` ` `String solution = ` `"GGRR"` `;` ` ` `String guess = ` `"RGBY"` `;` ` ` ` ` `calcResult(solution, guess);` ` ` ` ` `solution = ` `"YGRR"` `;` ` ` `guess = ` `"RGYB"` `;` ` ` ` ` `calcResult(solution, guess);` ` ` `}` `}` |

## Python

`# Python code to solve RGYB game` `hits ` `=` `0` `pseudoHits ` `=` `0` ` ` `# maximum no of colors are 4 RGYB` `MAX_COLORS ` `=` `4` ` ` `# Function to assign code to a slot` `# based on the color they have` `def` `codeOfColor(c):` ` ` `if` `c ` `=` `=` `'B'` `:` ` ` `return` `0` `;` ` ` `elif` `c ` `=` `=` `'G'` `:` ` ` `return` `1` `;` ` ` `elif` `c ` `=` `=` `'R'` `:` ` ` `return` `2` `;` ` ` `elif` `c ` `=` `=` `'Y'` `:` ` ` `return` `3` `;` ` ` `else` `:` ` ` `return` `-` `1` `;` `# Function to calculate number of hits` `# and pseudo hits` `def` `calcResult(guess, solution):` ` ` `hits ` `=` `0` ` ` `pseudoHits ` `=` `0` ` ` `if` `(` `len` `(guess) !` `=` `len` `(solution)):` ` ` `print` `"Incorrect Input"` ` ` ` ` `# frequency array to store how many times` ` ` `# each character occurs in solution string ` ` ` `frequencies ` `=` `[` `0` `for` `i ` `in` `range` `(MAX_COLORS)]` ` ` ` ` `# Compute hits and build frequency table` ` ` `for` `i ` `in` `range` `(` `len` `(guess)):` ` ` `if` `(guess[i] ` `=` `=` `solution[i]):` ` ` `hits ` `+` `=` `1` ` ` `else` `:` ` ` `# Only increment the frequency table (which` ` ` `# will be used for pseudo-hits) if it's not` ` ` `# a hit. If it's a hit, the slot has already` ` ` `# been "used."` ` ` `codecolor ` `=` `codeOfColor(solution[i])` ` ` `frequencies[codecolor] ` `+` `=` `1` ` ` `# Compute pseudo-hits` ` ` `for` `i ` `in` `range` `(` `len` `(guess)):` ` ` `codecolor ` `=` `codeOfColor(guess[i])` ` ` `if` `codecolor >` `=` `0` `and` `frequencies[codecolor] > ` `0` `and` `guess[i] !` `=` `solution[i]:` ` ` `pseudoHits ` `+` `=` `1` ` ` `frequencies[codecolor] ` `-` `=` `1` ` ` `print` `"hits -> "` `, hits, ` `" Pseudo hits -> "` `, pseudoHits` ` ` `# Driver code to test above function` `solution ` `=` `"GGRR"` `guess ` `=` `"RGBY"` `calcResult(solution, guess)` `solution ` `=` `"YGRR"` `guess ` `=` `"RGYB"` `calcResult(solution, guess)` `#This code is contributed by Sachin Bisht` |

## C#

`// C# code to solve RGYB game` `using` `System;` `class` `GFG {` ` ` ` ` `static` `int` `hits = 0;` ` ` `static` `int` `pseudoHits = 0;` ` ` ` ` `// Function to assign code to a slot` ` ` `// based on the color they have` ` ` `static` `int` `codeOfColor(` `char` `c)` ` ` `{` ` ` `switch` `(c)` ` ` `{` ` ` `case` `'B'` `: ` `return` `0;` ` ` `case` `'G'` `: ` `return` `1;` ` ` `case` `'R'` `: ` `return` `2;` ` ` `case` `'Y'` `: ` `return` `3;` ` ` `default` `: ` `return` `-1;` ` ` `}` ` ` `}` ` ` ` ` `// maximum no of colors are 4 RGYB` ` ` `static` `int` `MAX_COLORS = 4;` ` ` ` ` `// Function to calculate number of hits` ` ` `// and pseudo hits` ` ` `static` `void` `calcResult(` `string` `guess, ` `string` `solution)` ` ` `{` ` ` `hits = 0;` ` ` `pseudoHits = 0;` ` ` ` ` `if` `(guess.Length != solution.Length)` ` ` `Console.Write(` `"Incorrect Input"` `);` ` ` ` ` `// frequency array to store how many` ` ` `// times each character occurs in` ` ` `// solution string` ` ` `int` `[]frequencies = ` `new` `int` `[MAX_COLORS];` ` ` `// Compute hits and build frequency table` ` ` `for` `(` `int` `i = 0; i < guess.Length; i++)` ` ` `{` ` ` `if` `(guess[i] == solution[i])` ` ` `{` ` ` `hits++;` ` ` `}` ` ` `else` ` ` `{` ` ` ` ` `/* Only increment the frequency table` ` ` `(which will be used for pseudo-hits)` ` ` `if it's not a hit. If it's a hit, the` ` ` `slot has already been "used." */` ` ` `int` `codeofcolor = codeOfColor(solution[i]);` ` ` `frequencies[codeofcolor]++;` ` ` `}` ` ` `}` ` ` `// Compute pseudo-hits` ` ` `for` `(` `int` `i = 0; i < guess.Length; i++)` ` ` `{` ` ` `int` `codeofcolor = codeOfColor(guess[i]);` ` ` `if` `(codeofcolor >= 0 &&` ` ` `frequencies[codeofcolor] > 0 &&` ` ` `guess[i] != solution[i])` ` ` `{` ` ` `pseudoHits++;` ` ` `frequencies[codeofcolor]--;` ` ` `}` ` ` `}` ` ` ` ` `Console.WriteLine(` `"hits -> "` `+ hits +` ` ` `" Pseudo hits -> "` `+ pseudoHits);` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `string` `solution = ` `"GGRR"` `;` ` ` `string` `guess = ` `"RGBY"` `;` ` ` ` ` `calcResult(solution, guess);` ` ` ` ` `solution = ` `"YGRR"` `;` ` ` `guess = ` `"RGYB"` `;` ` ` ` ` `calcResult(solution, guess);` ` ` `}` `}` `// This code is contributed by nitin mittal.` |

## Javascript

`<script>` `// JavaScript code to solve RGYB game` `let hits = 0;` `let pseudoHits = 0;` `// maximum no of colors are 4 RGYB` `let MAX_COLORS = 4;` `// Function to assign code to a slot` `// based on the color they have` `function` `codeOfColor(c) {` ` ` `switch` `(c) {` ` ` `case` `'B'` `: ` `return` `0;` ` ` `case` `'G'` `: ` `return` `1;` ` ` `case` `'R'` `: ` `return` `2;` ` ` `case` `'Y'` `: ` `return` `3;` ` ` `default` `:` ` ` `return` `-1;` ` ` `}` `}` `// Function to calculate number of hits` `// and pseudo hits` `function` `calcResult(guess, solution) {` ` ` `hits = 0;` ` ` `pseudoHits = 0;` ` ` `if` `(guess.length != solution.length)` ` ` `document.write(` `"Incorrect Input<br>"` `);` ` ` `// frequency array to store how many times` ` ` `// each character occurs in solution string ` ` ` `let frequencies = ` `new` `Array(MAX_COLORS).fill(0);` ` ` `// Compute hits and build frequency table` ` ` `for` `(let i = 0; i < guess.length; i++) {` ` ` `if` `(guess[i] == solution[i])` ` ` `hits++;` ` ` `else` `{` ` ` `// Only increment the frequency table (which` ` ` `// will be used for pseudo-hits) if it's not` ` ` `// a hit. If it's a hit, the slot has already` ` ` `// been "used."` ` ` `let codecolor = codeOfColor(solution[i]);` ` ` `frequencies[codecolor]++;` ` ` `}` ` ` `}` ` ` `// Compute pseudo-hits` ` ` `for` `(let i = 0; i < guess.length; i++) {` ` ` `let codecolor = codeOfColor(guess[i]);` ` ` `if` `(codecolor >= 0 && frequencies[codecolor] > 0` ` ` `&& guess[i] != solution[i]) {` ` ` `pseudoHits++;` ` ` `frequencies[codecolor]--;` ` ` `}` ` ` `}` ` ` `document.write(` `"hits -> "` `+ hits + ` `" Pseudo hits -> "` ` ` `+ pseudoHits + ` `"<br>"` `);` `}` `// Driver code to test above function` `let solution = ` `"GGRR"` `;` `let guess = ` `"RGBY"` `;` `calcResult(solution, guess);` `solution = ` `"YGRR"` `;` `guess = ` `"RGYB"` `;` `calcResult(solution, guess);` `// This code is contributed by _saurabh_jaiswal` `</script>` |

**Output: **

hits -> 1 Pseudo hits -> 1 hits -> 1 Pseudo hits -> 2

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

This article is contributed by **Mr. Somesh Awasthi**. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.