Bulls and Cows - Practice Coding Problems

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 (but secret has 3 ones, guess has 2 after removing bull, so min(2,1)=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

Understanding the Visualization

Input

secret='1807', guess='7810'

Process

Compare positions and count digit matches

Output

Format as xAyB (1A3B)

Key Takeaway

🎯 Key Insight: Bulls are position matches, cows are digit matches in wrong positions - use frequency counting for efficiency

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

Approach	Time	Space	Notes
✓ Brute Force	O(n²)	O(n)	Check each position for bulls, then nested loops to find cows
Single Pass Optimized	O(n)	O(1)	Count bulls and cows in one pass using counter arrays
Frequency Counting	O(n)	O(1)	Use hash maps to count digit frequencies for efficient cow matching

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