Guessing Game (Jackpot) — while Loops

A random number, a while loop, and a counter — plus a manual binary-search strategy that turns brute-force guessing into a fast, deliberate hunt.

Overview

This is a Loops exercise. The program picks a random "jackpot" number, and the user keeps guessing until they get it right. It's a practical demonstration of:

• The while loop (loop that runs until a condition becomes false)
• if / else branching inside a loop
• Using a counter variable to track how many attempts were made
• A simple manual binary search strategy for guessing efficiently

Key Concepts

• random.randint(a, b) — generates a random integer between a and b (inclusive).
• while <condition>: — repeats the block as long as the condition is True. Here it keeps running as long as guess != jackpot.
• int(input(...)) — takes user input (which is always a string) and converts it to an integer so it can be compared numerically.
• Counter pattern — a variable (counter) initialized before the loop and incremented (counter += 1) on every iteration, used to count how many times something happened.
• Binary search (manual) — instead of guessing randomly, the player narrows the range by roughly halving it each time based on "higher"/"lower" feedback — the same logic behind efficient search algorithms.

Detailed Explanation

How the program works (step-by-step)

1. Generate a random number between 1 and 100 and store it in jackpot.
2. Ask the user for a first guess and store it as an integer in guess.
3. Initialize counter = 1 (this guess already counts as attempt #1).
4. Enter a while loop that continues as long as the guess is wrong (guess != jackpot):
   • If guess < jackpot → print "Guess higher".
   • Else (meaning guess > jackpot, since equality would've exited the loop) → print "Guess lower".
   • Ask for a new guess and increment the counter.
5. Once guess == jackpot, the while condition becomes False, so the loop stops.
6. Print "Sahi Jawab" (Hindi for "Correct Answer") and show the total number of attempts taken.

Why else alone works (without a second elif guess > jackpot)

Since the while loop only continues when guess != jackpot, inside the loop the guess can never be equal to the jackpot. So there are only two real possibilities left: guess < jackpot or guess > jackpot. That's why a plain else safely covers the "guess is too high" case without needing an explicit comparison.

Commands / Syntax

import random

jackpot = random.randint(1, 100)

guess = int(input("Chal guess kar"))
counter = 1

while guess != jackpot:
    if guess < jackpot:
        print("Guess higher")
    else:
        print("Guess lower")

    guess = int(input("Chal guess kar"))
    counter += 1

print("Sahi Jawab")
print("You took", counter, "attempts")

Line-by-line notes

Line	Purpose
random.randint(1, 100)	Picks the secret number the player must guess
int(input("Chal guess kar"))	Reads guess from user; int() is required because input() always returns a string
counter = 1	Starts counting from the very first guess
while guess != jackpot:	Loop keeps running until the guess matches
if guess < jackpot / else	Gives the player a hint to go higher or lower
counter += 1	Increments attempt count on every loop pass
print("You took", counter, "attempts")	Final summary after the loop ends

Note: print() with comma-separated arguments (e.g. print("You took", counter, "attempts")) automatically inserts spaces between the values — no need to manually convert counter to a string or use string concatenation.

Example Run

Using a binary search strategy (start at the midpoint of the range, then keep halving), the game was solved in this sequence — the actual jackpot turned out to be 58:

Attempt	Guess	Feedback
1	30	Guess higher
2	50	Guess higher
3	70	Guess lower
4	60	Guess lower
5	55	Guess higher
6	57	Guess higher
7	59	Guess lower
8	58	✅ Sahi Jawab

Final output:

Sahi Jawab
You took 8 attempts

💡 Tip: Guessing the midpoint of the current possible range each time (like 1–100 → 50 → 75 or 25, etc.) is far more efficient than guessing randomly — this is exactly the idea behind the binary search algorithm, which finds a value in a sorted range in roughly log₂(n) steps.

Things to Remember

Quick Revision

A while loop repeats until guess != jackpot becomes False. Each pass: compare the guess to the jackpot, print a hint ("Guess higher"/"Guess lower"), take a new guess, and bump a counter. Once correct, the loop exits and prints how many attempts (counter) it took. Guessing via binary search (halving the range each time) solves it in very few tries — in the traced example, 8 attempts to find jackpot = 58.