Bulls and Cows - Practice Coding Problems

Bulls and Cows - Problem

Bulls and Cows is a classic number guessing game that tests your logical deduction skills! 🎯

You're playing with a friend who has written down a secret number. Your job is to analyze their guess and provide a helpful hint in the form "xAyB" where:

• Bulls (A): Digits that are correct and in the right position 🎯
• Cows (B): Digits that exist in the secret but are in the wrong position 🐄

For example, if the secret is "1807" and the guess is "7810":
• The '8' is in position 1 in both → 1 bull
• The '1' and '7' exist but in wrong positions → 2 cows
• Result: "1A2B"

Challenge: Both numbers may contain duplicate digits, making the counting logic tricky!

Input & Output

example_1.py — Basic Case

$ Input: secret = "1807", guess = "7810"

› Output: "1A3B"

💡 Note: Position 1 has matching '8' (1 bull). Digits 1, 7, 0 exist in both but wrong positions (3 cows).

example_2.py — No Matches

$ Input: secret = "1123", guess = "0111"

› Output: "1A1B"

💡 Note: Position 1 has matching '1' (1 bull). One additional '1' from guess matches with secret (1 cow).

example_3.py — All Bulls

$ Input: secret = "1234", guess = "1234"

› Output: "4A0B"

💡 Note: All digits match in correct positions (4 bulls, 0 cows).

Visualization

Tap to expand

Understanding the Visualization

Compare Positions

Check each position for exact matches (bulls)

Track Frequencies

Count how many times each digit appears

Find Wrong-Position Matches

Digits that exist in both but wrong positions (cows)

Calculate Final Score

Format as xAyB where x=bulls, y=cows

Key Takeaway

🎯 Key Insight: Use frequency differences to detect matches efficiently - when secret has excess digits, they're available for cows; when guess has excess, they're waiting for matches!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings, checking each position once

✓ Linear Growth

Space Complexity

O(1)

Only uses a fixed-size array of 10 integers for digit frequencies

✓ Linear Space

Constraints

1 ≤ secret.length, guess.length ≤ 1000
secret.length == guess.length
secret and guess consist of digits only

Asked in

G Google 23 a Amazon 18 Apple 15 ⊞ Microsoft 12

The optimal solution uses a one-pass hash table approach with clever counter manipulation. By tracking the difference between secret and guess digit frequencies in a single array, we can detect both bulls (exact position matches) and cows (digit exists but wrong position) in O(n) time with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(1)	Count bulls and track digit frequencies simultaneously in a single pass
Two-Pass Hash Table	O(n)	O(1)	First pass counts frequencies, second pass finds bulls and cows
Brute Force (Nested Loops)	O(n²)	O(n)	Check each digit against all positions using nested loops

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize frequency counters for both secret and guess digits
For each position, check if digits match (bull found)
If no match, increment secret counter and decrement guess counter
A cow is found when: secret digit was needed (negative guess counter) OR guess digit was available (positive secret counter)
Format result as "xAyB"

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Each Position

Check for bulls first, then handle cows

Smart Counter Logic

Use positive/negative counters to track availability

Immediate Cow Detection

Find cows as soon as digits become available

Update State

Adjust counters for future matches

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

char* getHint(char* secret, char* guess) {
    static char result[20];
    int bulls = 0, cows = 0;
    // counters[i] represents: secret_count[i] - guess_count[i]
    int counters[10] = {0};
    int n = strlen(secret);
    
    for (int i = 0; i < n; i++) {
        int s = secret[i] - '0';
        int g = guess[i] - '0';
        
        if (s == g) {
            bulls++;
        } else {
            // If counters[s] < 0, it means we've seen this digit in guess before
            // and it was waiting for a match in secret
            if (counters[s] < 0) {
                cows++;
            }
            
            // If counters[g] > 0, it means we've seen this digit in secret before  
            // and it was waiting for a match in guess
            if (counters[g] > 0) {
                cows++;
            }
                
            // Update counters: +1 for secret digit, -1 for guess digit
            counters[s]++;
            counters[g]--;
        }
    }
    
    sprintf(result, "%dA%dB", bulls, cows);
    return result;
}

int main() {
    char secret[1001], guess[1001];
    fgets(secret, sizeof(secret), stdin);
    fgets(guess, sizeof(guess), stdin);
    
    // Remove newlines and quotes
    secret[strcspn(secret, "\n")] = 0;
    guess[strcspn(guess, "\n")] = 0;
    if (secret[0] == '"') {
        memmove(secret, secret+1, strlen(secret));
        secret[strlen(secret)-1] = 0;
    }
    if (guess[0] == '"') {
        memmove(guess, guess+1, strlen(guess));
        guess[strlen(guess)-1] = 0;
    }
    
    printf("%s\n", getHint(secret, guess));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings, checking each position once

✓ Linear Growth

Space Complexity

O(1)

Only uses a fixed-size array of 10 integers for digit frequencies

✓ Linear Space

Constraints

1 ≤ secret.length, guess.length ≤ 1000
secret.length == guess.length
secret and guess consist of digits only

82.3K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler