Bulls and Cows

Bulls and Cows - Problem

You are playing the Bulls and Cows game with your friend. You write down a secret number and ask your friend to guess what the number is. When your friend makes a guess, you provide a hint with the following info:

Bulls: Digits in the guess that are in the correct position

Cows: Digits in the guess that are in your secret number but are located in the wrong position (specifically, the non-bull digits in the guess that could be rearranged to become bulls)

Given the secret number and your friend's guess, return the hint for your friend's guess.

The hint should be formatted as "xAyB", where x is the number of bulls and y is the number of cows.

Note: Both secret and guess may contain duplicate digits.

Input & Output

Example 1 — Basic Case

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

› Output: 1A3B

💡 Note: Bull: position 1 (8==8). Cows: digit 1 (pos 0→2), digit 0 (pos 2→3), digit 7 (pos 3→0). Total: 1 bull, 3 cows.

Example 2 — No Cows

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

› Output: 1A1B

💡 Note: Bull: position 1 (1==1). Cow: one digit 1 from guess matches secret (secret has 2 ones total, after removing bull secret has 1 one remaining, guess has 2 ones remaining, so min(1,2)=1 cow).

Example 3 — All Bulls

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

› Output: 4A0B

💡 Note: All positions match exactly: 4 bulls, 0 cows.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 A Apple 6

The key insight is to separate bulls (exact position matches) from cows (digit matches in wrong positions). The optimal approach uses frequency counting or single-pass counter arrays to efficiently track available digits. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force

⏱️ Time: O(n²) Space: O(n)

First pass identifies bulls by comparing each position. Second pass uses nested loops to match remaining digits from guess with remaining digits from secret for cows.

Frequency Counting

⏱️ Time: O(n) Space: O(1)

Single pass to count bulls and build frequency maps. Then use the frequency maps to efficiently count cows by finding common digits.

Single Pass Optimized

⏱️ Time: O(n) Space: O(1)

Most efficient approach using single pass with two counter arrays. Bulls are counted when characters match at same position. Cows are counted by tracking available characters using counters.

Brute Force — Algorithm Steps

Step 1: Compare each position to count bulls
Step 2: Use nested loops to match remaining digits for cows
Step 3: Format result as xAyB

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Bulls

Compare positions directly

Nested Loops

Match remaining digits with O(n²) complexity

Result

Format as xAyB

Code -

solution.c — C

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

char* solution(char* secret, char* guess) {
    int len = strlen(secret);
    int bulls = 0;
    char secretRemaining[1000];
    char guessRemaining[1000];
    int remainingCount = 0;
    
    // Count bulls and collect remaining characters
    for (int i = 0; i < len; i++) {
        if (secret[i] == guess[i]) {
            bulls++;
        } else {
            secretRemaining[remainingCount] = secret[i];
            guessRemaining[remainingCount] = guess[i];
            remainingCount++;
        }
    }
    
    // Count cows using nested loops
    int cows = 0;
    bool used[1000] = {false};
    for (int i = 0; i < remainingCount; i++) {
        for (int j = 0; j < remainingCount; j++) {
            if (!used[j] && guessRemaining[i] == secretRemaining[j]) {
                cows++;
                used[j] = true;
                break;
            }
        }
    }
    
    char* result = malloc(20);
    sprintf(result, "%dA%dB", bulls, cows);
    return result;
}

int main() {
    char secret[1000], guess[1000];
    fgets(secret, sizeof(secret), stdin);
    secret[strcspn(secret, "\n")] = 0;
    fgets(guess, sizeof(guess), stdin);
    guess[strcspn(guess, "\n")] = 0;
    printf("%s\n", solution(secret, guess));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

First pass O(n) for bulls, then nested loops O(n²) for cow matching

⚠ Quadratic Growth

Space Complexity

O(n)

Arrays to store remaining characters after removing bulls

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler