score = int(input("Whole-number score: "))
lower_ok = score >= 0
upper_ok = score <= 100
valid = lower_ok and upper_ok
print("Lower limit:", lower_ok)
print("Upper limit:", upper_ok)
print("Valid score:", valid)

The two comparisons establish separate limits. Both must hold for a valid score. This first version assumes integer text; a range condition does not catch a conversion failure occurring before it.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

response = input("Type yes or y: ").strip()
accepted = (response == "yes") or (response == "y")
print("Accepted:", accepted)

Each operand is now a comparison. The original response == "yes" or "y" evaluates a truthy second operand when the first comparison is false, so it does not implement the intended two-response test.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

number = int(input("Whole number: "))
if number > 0:
    print("Positive")
elif number < 0:
    print("Negative")
else:
    print("Zero")
if number % 2 == 0:
    print("Even")

Sign categories are exclusive, so one chain is appropriate. Evenness is a separate property. An independent if allows a positive or negative number to receive an evenness notice without replacing its sign result.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

score = int(input("Score from 0 to 100: "))
if score < 0 or score > 100:
    print("Invalid score")
elif score >= 80:
    print("Distinction")
elif score >= 50:
    print("Pass")
else:
    print("Not a pass")

The range rejection prevents invalid values receiving ordinary bands. Testing >= 80 before >= 50 leaves the lower threshold for values not already in the distinction route. Only one chain branch runs.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

for number in range(5, 0, -1):
    print(number)
print("Launch!")
base = int(input("Table number: "))
for multiplier in range(1, 11):
    print(f"{base} x {multiplier} = {base * multiplier}")

for assigns each supplied range value to its loop variable. The indented body repeats; the launch statement is outside the body and runs once after it. Excluding the stop gives the intended endpoints.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

limit = int(input("Positive whole-number limit: "))
total = 0
count = 0
for number in range(1, limit + 1):
    if number % 2 == 0:
        total += number
        count += 1
print("Even total:", total)
print("Even count:", count)
if count > 0:
    print("Even mean:", total / count)
else:
    print("No qualifying values")

limit + 1 compensates for the excluded stop. The condition filters additions without changing the range visits. The guard prevents division by zero when no positive even value qualifies.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

score = int(input("Score from 0 to 100: "))
while score < 0 or score > 100:
    print("Outside the allowed range")
    score = int(input("Try again: "))
print("Accepted score:", score)

while tests before its body. The initial valid response skips the body; an invalid response enters it. The new assignment ensures the next test examines the new value instead of repeatedly rejecting the same one.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

total = 0
while True:
    value = int(input("Non-negative count, or -1 to finish: "))
    if value == -1:
        break
    if value < 0:
        print("That negative value is not accepted")
        continue
    total += value
print("Total:", total)

The sentinel is a control signal, not data. Its check precedes the negative-value rejection. continue skips the addition for an unacceptable negative count; the next iteration reads a fresh value.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

count = 0
while count < 6:
    count += 1
    if count == 3:
        continue
    if count == 5:
        break
    print(count)
print("Finished")

continue at three skips the second test and print for that iteration. break at five exits the loop entirely. The initial update keeps progress even when the remaining body is skipped.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

total = 0
for number in range(1, 4):
    total += number
print("Total:", total)
text = input("Whole-number count: ")
try:
    count = int(text)
except ValueError:
    print("That response is not a whole number")
else:
    print("Converted count:", count)

total = 0 belongs before repetition to preserve earlier additions. The ValueError handler responds to unsuitable integer text. A successfully converted negative number may still be unsuitable for the application, so validation remains separate.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

# Number guessing game: fixed secret for reproducible testing
MIN_NUMBER = 1
MAX_NUMBER = 20
MAX_ATTEMPTS = 5
secret = 12
attempts = 0
won = False
quit_game = False

print("Guess the secret number")
print(f"Range: {MIN_NUMBER} to {MAX_NUMBER}; accepted guesses: {MAX_ATTEMPTS}")

while attempts < MAX_ATTEMPTS and not won:
    text = input(f"Guess {MIN_NUMBER} to {MAX_NUMBER}, or quit: ").strip()
    if text == "quit":
        quit_game = True
        break

    try:
        guess = int(text)
    except ValueError:
        print("Enter a whole number or the command quit")
        continue

    if guess < MIN_NUMBER or guess > MAX_NUMBER:
        print("That number is outside the allowed range")
        continue

    attempts += 1
    if guess < secret:
        print("Too low")
    elif guess > secret:
        print("Too high")
    else:
        won = True

if quit_game:
    print(f"Game ended after {attempts} accepted guesses.")
elif won:
    print(f"Correct! You used {attempts} accepted guesses.")
else:
    print(f"No guesses left. The secret was {secret}.")

The state records what happened, rather than treating every loop exit as a loss. continue prevents rejected responses reaching the counter; break handles quit; the while condition stops after success or the accepted-attempt limit.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

# Number guessing game: fixed secret for reproducible testing
MIN_NUMBER = 1
MAX_NUMBER = 20
MAX_ATTEMPTS = 5
secret = 12
attempts = 0
won = False
quit_game = False

print("Guess the secret number")
print(f"Range: {MIN_NUMBER} to {MAX_NUMBER}; accepted guesses: {MAX_ATTEMPTS}")

while attempts < MAX_ATTEMPTS and not won:
    text = input(f"Guess {MIN_NUMBER} to {MAX_NUMBER}, or quit: ").strip()
    if text.lower() == "quit":
        quit_game = True
        break

    try:
        guess = int(text)
    except ValueError:
        print("Enter a whole number or the command quit")
        continue

    if guess < MIN_NUMBER or guess > MAX_NUMBER:
        print("That number is outside the allowed range")
        continue

    attempts += 1
    if guess < secret:
        print("Too low")
    elif guess > secret:
        print("Too high")
    else:
        won = True

if quit_game:
    print(f"Game ended after {attempts} accepted guesses.")
elif won:
    print(f"Correct! You used {attempts} accepted guesses.")
else:
    print(f"No guesses left. The secret was {secret}.")

lower returns lowercase text for the command comparison. The existing strip removes surrounding whitespace. The numeric path, validation order and accepted-attempt count remain unchanged. Rechecking earlier routes provides evidence that the extension did not damage them.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.