Number Guessing Game - Problem

Create an interactive number guessing game where the computer generates a random number between 1 and 100, and the player tries to guess it.

Game Rules:

Generate a random number between 1-100 (inclusive)
Player enters guesses one by one
After each guess, provide feedback: "Too high", "Too low", or "Correct!"
When the correct number is guessed, display the total number of attempts
The game ends when the player guesses correctly

Note: For this implementation, you'll receive the target number and a list of guesses, then return the sequence of feedback messages ending with the attempt count.

Input & Output

Example 1 — Basic Game

$ Input: target = 67, guesses = [50, 80, 67]

› Output: ["Too low", "Too high", "Correct!", "Attempts: 3"]

💡 Note: First guess 50 is too low, second guess 80 is too high, third guess 67 is correct. Game ends after 3 attempts.

Example 2 — Quick Win

$ Input: target = 42, guesses = [42]

› Output: ["Correct!", "Attempts: 1"]

💡 Note: Lucky first guess! Player gets it right immediately in just 1 attempt.

Example 3 — Longer Game

$ Input: target = 25, guesses = [50, 30, 20, 25]

› Output: ["Too high", "Too high", "Too low", "Correct!", "Attempts: 4"]

💡 Note: Player gradually narrows down: 50 too high, 30 too high, 20 too low, finally 25 is correct after 4 attempts.

Constraints

1 ≤ target ≤ 100
1 ≤ guesses.length ≤ 20
1 ≤ guesses[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to process each guess sequentially, comparing it with the target to generate appropriate feedback. Best approach is early termination processing which stops as soon as the correct answer is found. Time: O(n), Space: O(k) where k is the number of attempts until correct.

Common Approaches

✓ Early Termination Processing

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

Same sequential processing but with explicit early termination when the correct answer is found. This avoids unnecessary processing of remaining guesses.

Linear Feedback Processing

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

Iterate through each guess one by one, compare it with the target number, and generate appropriate feedback message. Continue until correct guess is found.

Early Termination Processing — Algorithm Steps

Process guesses one by one
Generate feedback for each guess
Stop immediately when correct guess found
Return feedback array with attempt count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Processing

Begin with target and guess list

Check Each Guess

Compare and generate feedback

Early Return

Stop immediately when correct answer found

Code -

solution.c — C

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

int main() {
    int target;
    scanf("%d", &target);
    
    char line[1000];
    scanf(" %[^\n]", line);
    
    // Parse [1,2,3] format manually
    int guesses[100];
    int count = 0;
    char* ptr = line + 1; // Skip '['
    char* token;
    char temp[1000];
    strcpy(temp, ptr);
    temp[strlen(temp) - 1] = '\0'; // Remove ']'
    
    token = strtok(temp, ",");
    while (token != NULL) {
        guesses[count++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    printf("[");
    int first = 1;
    int attempts = 0;
    for (int i = 0; i < count; i++) {
        if (!first) printf(",");
        first = 0;
        attempts++;
        
        if (guesses[i] == target) {
            printf("\"Correct!\"");
            printf(",\"Attempts: %d\"", attempts);
            break;
        } else if (guesses[i] < target) {
            printf("\"Too low\"");
        } else {
            printf("\"Too high\"");
        }
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, process all n guesses if correct answer is last

✓ Linear Growth

Space Complexity

O(k)

Store k feedback messages where k is attempts until correct guess

⚡ Linearithmic Space

32.3K Views

Medium Frequency

~15 min Avg. Time

850 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

Number Guessing Game - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Early Termination Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler