Lesson 7: Keep Going Until...

Part 1

Some Things Don't Have a Fixed End

Think about playing a board game. You don't say "we'll play exactly 15 turns." You play until someone wins. That could take 10 minutes or two hours — you don't know in advance.

Or think about practicing free throws. You don't stop after exactly 20 shots. You keep going until you make 5 in a row, or until dinner's ready, or until your arms get tired.

These are situations where you don't know the end point. You just keep going and observe what happens, round after round, until some condition tells you to stop.

This is called inductive reasoning — building understanding through repeated observation. Scientists do it: run an experiment, observe the result, repeat, and eventually draw a conclusion. Today, you're going to do the same thing — by building a game.

Part 2

Loops That Run Forever (Until You Say Stop)

In Lesson 5, we learned while loops: "keep going while a condition is True." There's a special version of this that's incredibly useful for games and menus:

# A loop that runs until the user says stop
round_num = 0

while True:
    round_num = round_num + 1
    answer = input(f"Round {round_num} — Keep going? (yes/no) ")
    
    if answer.lower() == "no":
        break

print()
print(f"You went {round_num} rounds!")

How while True Works

while True: creates a loop that would run forever — because True is always True.

But inside the loop, we use break to escape when we're ready.

This pattern is perfect when you don't know how many times to repeat. The loop keeps going, and the code inside decides when to stop.

Think of it as: "Keep doing this. I'll tell you when I'm done."

Part 3

Rock Paper Scissors — The Logic

Let's build Rock Paper Scissors. Before we code, let's think about the rules. This is deductive reasoning (from Lesson 3) — clear rules that determine the outcome:

The Rules

Rock beats Scissors (rock crushes scissors)

Scissors beats Paper (scissors cut paper)

Paper beats Rock (paper covers rock)

If both choose the same thing → it's a tie

Let's start simple — one round against the computer:

import random

# The three choices
choices = ["rock", "paper", "scissors"]

# Get player choice
player = input("Rock, Paper, or Scissors? ").lower()

# Computer picks randomly
computer = random.choice(choices)

print(f"You chose: {player}")
print(f"Computer chose: {computer}")
print()

# Determine winner
if player == computer:
    print("It's a tie! 🤝")
elif player == "rock" and computer == "scissors":
    print("You win! Rock crushes scissors! 🎉")
elif player == "scissors" and computer == "paper":
    print("You win! Scissors cut paper! 🎉")
elif player == "paper" and computer == "rock":
    print("You win! Paper covers rock! 🎉")
else:
    print("Computer wins! 😤")

Play it a few times. Notice that the computer's choice is truly random — sometimes you win, sometimes you lose, sometimes it's a tie. There's no way to predict a single round.

But what if you played 20 rounds? Would you start to notice patterns? That's inductive reasoning — building understanding from repeated observations.

Part 4

Making It a Real Game

One round isn't a game — it's a coin flip. A real game needs multiple rounds and a way to keep score. Let's combine while True with our RPS logic:

import random

choices = ["rock", "paper", "scissors"]

# Track stats
player_wins = 0
computer_wins = 0
ties = 0

print("╔══════════════════════════════╗")
print("  ROCK PAPER SCISSORS")
print("  Type 'quit' to stop")
print("╚══════════════════════════════╝")
print()

while True:
    player = input("Rock, Paper, or Scissors? ").lower()
    
    # Check if player wants to quit
    if player == "quit":
        break
    
    # Check for valid input
    if player not in choices:
        print("Please type rock, paper, or scissors.")
        print()
        continue
    
    computer = random.choice(choices)
    
    print(f"You: {player} | Computer: {computer}")
    
    # Determine winner
    if player == computer:
        print("Tie! 🤝")
        ties = ties + 1
    elif (player == "rock" and computer == "scissors") or \
         (player == "scissors" and computer == "paper") or \
         (player == "paper" and computer == "rock"):
        print("You win! 🎉")
        player_wins = player_wins + 1
    else:
        print("Computer wins! 😤")
        computer_wins = computer_wins + 1
    
    print()

# Show final stats
total = player_wins + computer_wins + ties
print()
print("═" * 30)
print("  FINAL STATS")
print("═" * 30)
print(f"  Rounds played: {total}")
print(f"  You won:       {player_wins}")
print(f"  Computer won:  {computer_wins}")
print(f"  Ties:          {ties}")

New Things

continue skips the rest of the loop and starts the next round immediately. We use it when the player types something invalid — no point in comparing "banana" to the computer's choice.

not in is the opposite of in: player not in choices means "the player's input isn't in our list of valid choices."

\ at the end of a line means "this line continues on the next line." It lets us split a long condition across multiple lines so it's easier to read.

Play 10+ rounds and look at your stats. Are they roughly even? With random choices, you'd expect to win about 1/3 of the time, lose 1/3, and tie 1/3. Do your results match that prediction? That's inductive reasoning — checking if your observations match a hypothesis.

Part 5

First to 3 Wins

Instead of playing forever, let's make it a real tournament — first player to win 3 rounds takes the match:

import random

choices = ["rock", "paper", "scissors"]
wins_needed = 3

player_wins = 0
computer_wins = 0
round_num = 0

print("╔══════════════════════════════╗")
print(f"  FIRST TO {wins_needed} WINS!")
print("╚══════════════════════════════╝")
print()

while player_wins < wins_needed and computer_wins < wins_needed:
    round_num = round_num + 1
    
    print(f"--- Round {round_num} ---")
    print(f"Score: You {player_wins} - {computer_wins} Computer")
    
    player = input("Rock, Paper, or Scissors? ").lower()
    
    if player not in choices:
        print("Invalid! Try again.")
        print()
        round_num = round_num - 1
        continue
    
    computer = random.choice(choices)
    print(f"Computer chose: {computer}")
    
    if player == computer:
        print("Tie! Go again.")
    elif (player == "rock" and computer == "scissors") or \
         (player == "scissors" and computer == "paper") or \
         (player == "paper" and computer == "rock"):
        print("You win this round! ✓")
        player_wins = player_wins + 1
    else:
        print("Computer wins this round! ✗")
        computer_wins = computer_wins + 1
    
    print()

# Announce winner
print("═" * 30)
if player_wins == wins_needed:
    print(f"  🏆 YOU WIN THE MATCH!")
else:
    print(f"  💻 COMPUTER WINS THE MATCH!")
print(f"  Final: You {player_wins} - {computer_wins} Computer")
print(f"  Total rounds: {round_num}")
print("═" * 30)

The Loop Condition

while player_wins < wins_needed and computer_wins < wins_needed:

This loop keeps going as long as neither player has reached 3 wins. The moment either one hits 3, the condition becomes False and the loop stops.

Notice: ties don't count toward anyone's score. The game could theoretically go on for a very long time if there are many ties — and you can't predict how many rounds it'll take. That's why this is an inductive problem, not a deductive one.

Part 6

Tracking Patterns in Results

Scientists don't just observe — they look for patterns in their observations. Let's add streak tracking to see if there are any "hot streaks" or "cold streaks":

import random

choices = ["rock", "paper", "scissors"]

player_wins = 0
computer_wins = 0
current_streak = 0
best_streak = 0
results = []

print("ROCK PAPER SCISSORS — STREAK TRACKER")
print("Type 'quit' to stop and see your stats")
print("═" * 40)
print()

while True:
    player = input("Rock, Paper, or Scissors? ").lower()
    if player == "quit":
        break
    if player not in choices:
        print("Invalid! Try rock, paper, or scissors.")
        continue
    
    computer = random.choice(choices)
    print(f"You: {player} | Computer: {computer} → ", end="")
    
    if player == computer:
        print("Tie")
        results.append("T")
        current_streak = 0
    elif (player == "rock" and computer == "scissors") or \
         (player == "scissors" and computer == "paper") or \
         (player == "paper" and computer == "rock"):
        print("WIN ✓")
        results.append("W")
        player_wins = player_wins + 1
        current_streak = current_streak + 1
        if current_streak > best_streak:
            best_streak = current_streak
    else:
        print("LOSS ✗")
        results.append("L")
        computer_wins = computer_wins + 1
        current_streak = 0
    print()

# Show analysis
total = len(results)
if total > 0:
    print("═" * 40)
    print("GAME ANALYSIS")
    print("═" * 40)
    print(f"  Rounds: {total}")
    print(f"  Wins: {player_wins} | Losses: {computer_wins} | Ties: {total - player_wins - computer_wins}")
    print(f"  Win rate: {int(player_wins / total * 100)}%")
    print(f"  Best win streak: {best_streak}")
    print()
    print("  Results: " + " ".join(results))
    print()
    if best_streak >= 3:
        print("  🔥 Nice streak!")
    if player_wins > computer_wins:
        print("  🏆 You beat the computer overall!")
    elif computer_wins > player_wins:
        print("  💻 Computer had the edge this time.")
    else:
        print("  🤝 Perfectly balanced!")

Tracking With Lists

We use results.append("W") to record each round's outcome. At the end, we have a complete history like ["W", "L", "T", "W", "W", "L"].

" ".join(results) turns that list into a readable string: "W L T W W L". The .join() command puts a space between each item.

The streak tracker works by counting consecutive wins. Every win increases current_streak. Any loss or tie resets it to 0. We track the best_streak by checking if the current streak beats the record.

Part 7

Drawing Conclusions From Data

Let's run a bigger experiment. Instead of playing manually, let's have the computer play against itself 1000 times and see what patterns emerge:

import random

choices = ["rock", "paper", "scissors"]
games = 1000

wins_1 = 0
wins_2 = 0
ties = 0

# Track what each choice does
rock_wins = 0
paper_wins = 0
scissors_wins = 0

for i in range(games):
    p1 = random.choice(choices)
    p2 = random.choice(choices)
    
    if p1 == p2:
        ties = ties + 1
    elif (p1 == "rock" and p2 == "scissors") or \
         (p1 == "scissors" and p2 == "paper") or \
         (p1 == "paper" and p2 == "rock"):
        wins_1 = wins_1 + 1
        if p1 == "rock": rock_wins = rock_wins + 1
        if p1 == "paper": paper_wins = paper_wins + 1
        if p1 == "scissors": scissors_wins = scissors_wins + 1
    else:
        wins_2 = wins_2 + 1

print(f"RESULTS OF {games} RANDOM GAMES")
print("═" * 35)
print(f"  Player 1 wins: {wins_1} ({int(wins_1/games*100)}%)")
print(f"  Player 2 wins: {wins_2} ({int(wins_2/games*100)}%)")
print(f"  Ties:          {ties} ({int(ties/games*100)}%)")
print()
print("WHEN PLAYER 1 WON, THEY USED:")
total_p1_wins = rock_wins + paper_wins + scissors_wins
if total_p1_wins > 0:
    print(f"  Rock:     {rock_wins} ({int(rock_wins/total_p1_wins*100)}%)")
    print(f"  Paper:    {paper_wins} ({int(paper_wins/total_p1_wins*100)}%)")
    print(f"  Scissors: {scissors_wins} ({int(scissors_wins/total_p1_wins*100)}%)")
print()
print("CONCLUSION:")
print("With random choices, each player wins")
print("about 33% of the time, ties 33%.")
print("No choice is better than another!")
print("(This is what makes RPS fair.)")

Inductive Reasoning in Action

We didn't prove that each player wins 33% of the time using math (that would be deductive reasoning). Instead, we observed 1000 games and noticed the pattern.

This is how induction works: observe, observe, observe, then conclude. The more observations, the more confident the conclusion.

Run it again — you'll get slightly different numbers each time, but they'll always hover around 33/33/33. That consistency across many trials is what makes the conclusion strong.

Part 8

What If the Computer Cheats?

What if the computer's choices aren't perfectly random? What if it slightly favors rock? Could you detect that through observation?

import random

# SECRET: the computer is biased toward rock!
# It picks rock 50% of the time, paper 25%, scissors 25%
biased_choices = ["rock", "rock", "paper", "scissors"]

rock_count = 0
paper_count = 0
scissors_count = 0
games = 200

for i in range(games):
    choice = random.choice(biased_choices)
    if choice == "rock":
        rock_count = rock_count + 1
    elif choice == "paper":
        paper_count = paper_count + 1
    else:
        scissors_count = scissors_count + 1

print(f"COMPUTER'S CHOICES OVER {games} GAMES")
print("═" * 35)
bar_r = "█" * int(rock_count / games * 30)
bar_p = "█" * int(paper_count / games * 30)
bar_s = "█" * int(scissors_count / games * 30)
print(f"  Rock:     {bar_r} {int(rock_count/games*100)}%")
print(f"  Paper:    {bar_p} {int(paper_count/games*100)}%")
print(f"  Scissors: {bar_s} {int(scissors_count/games*100)}%")
print()
print("🔍 DETECTIVE ANALYSIS:")
print("The computer picks rock about 50% of the time!")
print("If you know this, what should YOU always pick?")
print()
print("Answer: PAPER! It beats rock, which the")
print("computer chooses most often.")

This is a perfect example of inductive reasoning. You didn't know the computer was biased. But by observing many games, you detected the pattern. And once you know the pattern, you can exploit it — always pick paper to beat the computer's favorite move.

This is how scientists work: observe, detect patterns, form a theory, test it.

Part 9

The Complete Tournament

Let's build the final version — a polished tournament with everything we've learned:

import random

# === ROCK PAPER SCISSORS TOURNAMENT ===

emojis = {"rock": "🪨", "paper": "📄", "scissors": "✂️"}
choices = ["rock", "paper", "scissors"]

print("╔══════════════════════════════╗")
print("  🪨 📄 ✂️  TOURNAMENT")
print("  Rock Paper Scissors")
print("╚══════════════════════════════╝")
print()

wins_needed = int(input("First to how many wins? "))
print()

player_wins = 0
computer_wins = 0
round_num = 0
results = []
player_choices = {"rock": 0, "paper": 0, "scissors": 0}

while player_wins < wins_needed and computer_wins < wins_needed:
    round_num = round_num + 1
    
    # Score display
    p_bar = "●" * player_wins + "○" * (wins_needed - player_wins)
    c_bar = "●" * computer_wins + "○" * (wins_needed - computer_wins)
    print(f"Round {round_num}  |  You [{p_bar}]  vs  [{c_bar}] CPU")
    
    player = input("Your move: ").lower()
    
    if player not in choices:
        print("Pick rock, paper, or scissors!")
        round_num = round_num - 1
        print()
        continue
    
    computer = random.choice(choices)
    player_choices[player] = player_choices[player] + 1
    
    p_emoji = emojis[player]
    c_emoji = emojis[computer]
    
    print(f"  {p_emoji}  vs  {c_emoji}")
    
    if player == computer:
        print("  TIE — go again!")
        results.append("T")
        round_num = round_num - 1
    elif (player == "rock" and computer == "scissors") or \
         (player == "scissors" and computer == "paper") or \
         (player == "paper" and computer == "rock"):
        print("  YOU WIN this round! ✓")
        player_wins = player_wins + 1
        results.append("W")
    else:
        print("  CPU WINS this round! ✗")
        computer_wins = computer_wins + 1
        results.append("L")
    
    print()

# Final results
print("═" * 35)
if player_wins == wins_needed:
    print("  🏆 YOU WIN THE TOURNAMENT! 🏆")
else:
    print("  💻 COMPUTER WINS THE TOURNAMENT")
print(f"  Final: You {player_wins} - {computer_wins} Computer")
print("═" * 35)
print()

# Stats
total = len(results)
print("MATCH STATISTICS:")
print(f"  Total rounds: {total}")
print(f"  Results: {' '.join(results)}")
print()
print("YOUR CHOICES:")
for move in choices:
    count = player_choices[move]
    if total > 0:
        pct = int(count / total * 100)
    else:
        pct = 0
    bar = "█" * int(pct / 5) + "░" * (20 - int(pct / 5))
    print(f"  {emojis[move]} {move:8s} {bar} {pct}%")
print()
print("💡 Did you favor one choice? Humans often do!")
print("   A truly random player picks each 33% of the time.")

New Thing · Dictionaries Preview

emojis = {"rock": "🪨", "paper": "📄", "scissors": "✂️"} is a dictionary — it pairs keys with values. emojis["rock"] gives "🪨".

We also use player_choices as a dictionary to count how often you pick each move.

Dictionaries are like lists, but instead of positions (0, 1, 2) they use names ("rock", "paper", "scissors"). We'll explore them properly in a later lesson.

Part 10

What You Just Did

You built a game where the outcome is uncertain — you can't predict who will win any single round. But by playing many rounds, you can observe patterns (win rate, streaks, choice bias) and draw conclusions.

That's inductive reasoning.

Unlike deductive reasoning (Lesson 3), where you start with rules and reach guaranteed conclusions, inductive reasoning starts with observations and builds probable conclusions. The more observations, the stronger the conclusion — but it's never 100% certain.

The Big Idea

Some problems can't be solved by thinking ahead — you have to try, observe, and learn. Keep going until you have enough data to see the pattern. This is how scientists discover laws of nature, how athletes find winning strategies, and how you figure out what works and what doesn't.

Thinking Questions

What's the difference between deductive reasoning ("if the rule is X, then Y must happen") and inductive reasoning ("I've observed X twenty times, so Y probably happens")?
After playing many rounds, did you notice yourself favoring a particular choice? Why do humans have trouble being truly random?
If the computer secretly favored scissors 60% of the time, what strategy would you use? How many rounds would you need to detect the bias?

Challenges

Level Up

Challenge 1 · Number Guessing Game

The computer picks a random number between 1 and 100. The player guesses, and the computer says "too high" or "too low." Keep going until they guess correctly. Track how many guesses it took. Hint: random.randint(1, 100) picks a random whole number.

Challenge 2 · Best of 5 With Stats

Modify the tournament so that after each match, the player can choose to play again. Track stats across all matches (total wins, total losses, matches won). Display an all-time record at the end.

Challenge 3 · Smart Computer

Make the computer track what the player picks most often, then choose the counter. If the player picks rock 50% of the time, the computer should start picking paper more. The computer learns from observation — it does inductive reasoning too!

Summary

What You Learned

Thinking Skill

Inductive Reasoning — drawing conclusions from repeated observations. Ask: "What pattern do I see after many trials? What can I conclude?"

Python Concepts

while True: ... break — a loop that runs until you tell it to stop

continue — skip to the next loop iteration

not in — check if something is NOT in a list

.join() — turn a list into a string with a separator

Game loops — the while True pattern for interactive programs

Streak tracking — counting consecutive events

Dictionaries preview — {"key": "value"} pairs

Win rate / statistics — calculating percentages from counts

Lessons 1–7

Decomposition — break big problems into small steps

Abstraction — decide what details matter

Deductive Reasoning — rules + facts = guaranteed conclusions

Categorization — organize related items into groups

Pattern Recognition — spot what repeats and what changes

Automation — templates that handle repetitive tasks

Inductive Reasoning — observations → probable conclusions

Keep Going Until... The Art of Not Knowing When to Stop