Bulls And Cows

                                            
class Solution {
public:
    string getHint(string secret, string guess) {
        int bulls = 0, cows = 0;
        unordered_map<char, int> secretFreq, guessFreq;

        for (int i = 0; i < secret.size(); i++) {
            if (secret[i] == guess[i]) {
                bulls++;
            } else {
                secretFreq[secret[i]]++;
                guessFreq[guess[i]]++;
            }
        }

        for (auto& p : secretFreq) {
            cows += min(p.second, guessFreq[p.first]);
        }

        return to_string(bulls) + "A" + to_string(cows) + "B";
    }
};

                                            
class Solution {
    public String getHint(String secret, String guess) {
        int bulls = 0;
        int cows = 0;
        
        int[] secretCount = new int[10];
        int[] guessCount = new int[10];
        
        for (int i = 0; i < secret.length(); i++) {
            char s = secret.charAt(i);
            char g = guess.charAt(i);
            if (s == g) {
                bulls++;
            } else {
                secretCount[s - '0']++;
                guessCount[g - '0']++;
            }
        }
        
        for (int i = 0; i < 10; i++) {
            cows += Math.min(secretCount[i], guessCount[i]);
        }
        
        return bulls + "A" + cows + "B";
    }
}

                                            
public class Solution {
    public string GetHint(string secret, string guess) {
        int bulls = 0, cows = 0;
        int[] counts = new int[10];
        
        for (int i = 0; i < secret.Length; i++) {
            if (secret[i] == guess[i]) {
                bulls++;
            } else {
                if (counts[secret[i] - '0'] < 0) cows++;
                if (counts[guess[i] - '0'] > 0) cows++;
                counts[secret[i] - '0']++;
                counts[guess[i] - '0']--;
            }
        }
        
        return bulls + "A" + cows + "B";
    }
}

                                            
/**
 * @param {string} secret
 * @param {string} guess
 * @return {string}
 */
var getHint = function(secret, guess) {
    let bulls = 0;
    let cows = 0;
    const secretFreq = new Array(10).fill(0);
    const guessFreq = new Array(10).fill(0);
    
    for (let i = 0; i < secret.length; i++) {
        if (secret[i] === guess[i]) {
            bulls++;
        } else {
            secretFreq[parseInt(secret[i])]++;
            guessFreq[parseInt(guess[i])]++;
        }
    }
    
    for (let i = 0; i < 10; i++) {
        cows += Math.min(secretFreq[i], guessFreq[i]);
    }
    
    return `${bulls}A${cows}B`;
};

                                            
function getHint(secret: string, guess: string): string {
    let bulls = 0;
    let cows = 0;
    const secretCount = new Array(10).fill(0);
    const guessCount = new Array(10).fill(0);
    
    for (let i = 0; i < secret.length; i++) {
        if (secret[i] === guess[i]) {
            bulls++;
        } else {
            secretCount[parseInt(secret[i])]++;
            guessCount[parseInt(guess[i])]++;
        }
    }
    
    for (let i = 0; i < 10; i++) {
        cows += Math.min(secretCount[i], guessCount[i]);
    }
    
    return `${bulls}A${cows}B`;
};

                                            
class Solution {
    /**
     * @param String $secret
     * @param String $guess
     * @return String
     */
    function getHint($secret, $guess) {
        $bulls = 0;
        $cows = 0;
        $secretMap = [];
        $guessMap = [];

        for ($i = 0; $i < strlen($secret); $i++) {
            if ($secret[$i] === $guess[$i]) {
                $bulls++;
            } else {
                if (!isset($secretMap[$secret[$i]])) {
                    $secretMap[$secret[$i]] = 0;
                }
                $secretMap[$secret[$i]]++;
                
                if (!isset($guessMap[$guess[$i]])) {
                    $guessMap[$guess[$i]] = 0;
                }
                $guessMap[$guess[$i]]++;
            }
        }
        
        foreach ($secretMap as $digit => $count) {
            if (isset($guessMap[$digit])) {
                $cows += min($guessMap[$digit], $count);
            }
        }

        return $bulls . 'A' . $cows . 'B';
    }
}

                                            
class Solution {
    func getHint(_ secret: String, _ guess: String) -> String {
        var bulls = 0
        var cows = 0
        var nums = Array(repeating: 0, count: 10)
        
        for i in 0..<secret.count {
            let s = secret[secret.index(secret.startIndex, offsetBy: i)]
            let g = guess[guess.index(guess.startIndex, offsetBy: i)]
            
            if s == g {
                bulls += 1
            } else {
                if nums[Int(s.asciiValue!) - 48] < 0 { cows += 1 }
                if nums[Int(g.asciiValue!) - 48] > 0 { cows += 1 }
                nums[Int(s.asciiValue!) - 48] += 1
                nums[Int(g.asciiValue!) - 48] -= 1
            }
        }
        
        return "\(bulls)A\(cows)B"
    }
}

                                            
class Solution {
    fun getHint(secret: String, guess: String): String {
        var bulls = 0
        var cows = 0
        val secretDigits = IntArray(10)
        val guessDigits = IntArray(10)
        
        for (i in secret.indices) {
            val s = secret[i]
            val g = guess[i]
            if (s == g) {
                bulls++
            } else {
                secretDigits[s - '0']++
                guessDigits[g - '0']++
            }
        }
        
        for (i in 0 until 10) {
            cows += min(secretDigits[i], guessDigits[i])
        }
        
        return "${bulls}A${cows}B"
    }
}

                                            
func getHint(secret string, guess string) string {
    bulls := 0
    cows := 0
    counts := make([]int, 10)

    for i := 0; i < len(secret); i++ {
        s := secret[i] - '0'
        g := guess[i] - '0'
        if s == g {
            bulls++
        } else {
            if counts[s] < 0 {
                cows++
            }
            if counts[g] > 0 {
                cows++
            }
            counts[s]++
            counts[g]--
        }
    }

    return fmt.Sprintf("%dA%dB", bulls, cows)
}

To solve this coding challenge, you need to determine how many digits your friend's guess has in common with your secret number, and classify those digits as either "bulls" (correct digit in the correct position) or "cows" (correct digit but in the wrong position). Here, I'll describe the methodology in detail and provide pseudocode for you to follow.

Explanation

The "Bulls and Cows" game involves comparing two numbers:

Bulls: Count of digits that are the same in both
secret

and
guess

at the same positions.
Cows: Count of digits that are in both
secret

and
guess

but not in the same positions, after excluding the bulls.

Detailed Steps in Pseudocode

Step 1: Initialize Variables

First, you need counters for bulls and cows. You also need to keep track of the frequency of each digit (0-9) in both

secret

and

guess

to compute cows.

Step 2: First Pass to Count Bulls

Loop through each digit in

secret

and

guess

. If the digits are the same, increment the bulls' counter.

Step 3: Collect Frequencies

For the digits that are not bulls, record their occurrences in frequency counters for both the

secret

and

guess

Step 4: Compute Cows

Loop through the frequency counters for digits (0-9). For each digit, the number of cows is the minimum value between the two frequency counters, as it indicates how many times this digit can be matched between

secret

and

guess

in different positions.

Step 5: Format and Return the Result

Format the result as "xAyB", where x is the number of bulls and y is the number of cows.

Pseudocode with Comments

                                            
# Initialize counters for bulls and cows
bulls = 0
cows = 0

# Initialize lists for frequency counting, one for secret and one for guess
secret_frequency = array of size 10 initialized to 0
guess_frequency = array of size 10 initialized to 0

# Iterate over each digit in the secret and guess
for i = 0 to length of secret - 1:
if secret[i] == guess[i]:  # If digits are the same in both secret and guess
bulls += 1
else:
# Increment the frequency counts for non-bull digits
secret_frequency[secret[i]] += 1
guess_frequency[guess[i]] += 1

# Compute the number of cows based on frequency counts
for i = 0 to 9:  # Since digits range from 0 to 9
cows += min(secret_frequency[i], guess_frequency[i])

# Construct the result string
result = bulls + "A" + cows + "B"

# Return the formatted result
return result

This pseudocode provides a detailed step-by-step guide to implement the solution for the "Bulls and Cows" challenge. It ensures you correctly identify and count bulls and cows and format the result appropriately.

Final Summary:

Bulls are the digits in your friend's
guess

that match the
secret

in both digit and position.
Cows are the digits in your friend's
guess

that match the
secret

in digit but not in position.
The solution efficiently counts these using two passes over the inputs: one to find bulls and collect frequency counts, and another to compute cows from these counts. The result is then formatted as "xAyB".