Scenario-Based Coding Problems on Loops in Python

Explanation:
This code calculates the number of stars counted over a specified number of nights.

• It asks you to input the number of nights you will count stars, storing this value in the nights variable as an integer using int(input()).
• The total_stars variable starts at 0 to keep track of the overall star count.
• A for loop runs from 1 to nights + 1, where each iteration represents a single night.
• Inside the loop, the code asks you to input the number of stars counted on the current night, storing the value in the stars variable as an integer.
• The code adds the stars counted that night to the total_stars using total_stars += stars.
• After updating the total, the code prints the cumulative total of stars so far along with the night number.
• When the loop ends, the code prints the total number of stars you counted across all the nights, formatted in a complete sentence.

nights = int(input("How many nights will you count stars? "))

total_stars = 0

for night in range(1, nights + 1):
    stars = int(input(f"How many stars did you count on night {night}? "))
    total_stars += stars  # Add this night's stars to the total
    print(f"After night {night}, total stars so far: {total_stars}")

print(f"In {nights} nights, you counted a total of {total_stars} stars!")

Explanation:
This code calculates the total water consumed over 7 days.

• First, the total_water variable is initialized to 0 to keep track of the running total of water consumed.
• Then, a for loop is used to repeat the process of asking for daily water intake. It runs for 7 days (from day 1 to day 7) using the range(1, 8).
• Inside the loop, the input() function asks the user to enter the amount of water they drank on each day. This input is converted into a float using float() to handle decimal values, representing liters.
• The total_water is updated by adding the daily intake to it after each day’s input.
• Finally, after the loop finishes, the print() function displays the total water consumed over the 7 days.

total_water = 0

for day in range(1, 8):
    daily_water = float(input(f"Enter water intake for Day {day} (in liters): "))
    total_water += daily_water

print(f"Total water consumed: {total_water} liters")

Explanation:
This code calculates the total number of pages read in a month, considering that the number of pages read per day increases each week.

• First, it asks the user to enter the number of pages read per day during the first week, and the total number of days in the month. These inputs are converted into integers using int().
• The total_pages variable is initialized to 0 to keep track of the total pages read. The variable pages_per_day is set to the pages read in the first week and weeks_in_month is calculated by dividing the total days by 7 to get the number of full weeks. The remaining days after the full weeks are calculated using the modulus operator (%).
• Then, a for loop runs through each week in the month. For each full week, it adds the pages read to total_pages by multiplying the pages read per day by 7. After each week, the pages per day are increased by 5.
• After the loop, if there are any remaining days (less than a full week), it adds the pages read for those remaining days to total_pages.
• Finally, the print() function displays the total pages read over the month.

pages_per_day_first_week = int(input("Enter the number of pages you read per day in the first week: "))
days_in_month = int(input("Enter the number of days in the month: "))

total_pages = 0
pages_per_day = pages_per_day_first_week
weeks_in_month = days_in_month // 7  # Calculate number of full weeks
remaining_days = days_in_month % 7  # Days left after full weeks

# Loop through each week
for week in range(1, weeks_in_month + 1):
    total_pages += pages_per_day * 7  # Add pages read in each full week
    pages_per_day += 5  # Increase pages per day by 5 for the next week

# Handle the remaining days in the last partial week
if remaining_days > 0:
    total_pages += pages_per_day * remaining_days

print(f"Total pages read: {total_pages}")

Explanation:
This code helps track spending during shopping and alerts the user if they exceed their budget.

• The total_spent variable is initialized to 0 to keep track of the total amount spent, and the budget is set to $150.
• A while loop runs as long as total_spent is less than or equal to the budget. Inside the loop, the input() function asks the user for the cost of their shopping, and the float() function converts this input into a decimal number to handle monetary values.
• After each expense is entered, it is added to the total_spent.
• If the updated total_spent is still within the budget, the remaining amount is calculated by subtracting total_spent from budget. The program then prints the total spent and the remaining budget.
• If the updated total_spent exceeds the budget, the amount exceeded is calculated by subtracting budget from total_spent. The program warns the user that they have exceeded the budget and displays how much they went over.

total_spent = 0
budget = 150

while total_spent <= budget:
    expense = float(input("Enter the cost of your shopping: "))
    total_spent += expense
    
    if total_spent <= budget:
        remaining = budget - total_spent
        print(f"Total spent: ${total_spent:.2f}. You have ${remaining:.2f} remaining.")
    else:
        exceeded = total_spent - budget
        print(f"Total spent: ${total_spent:.2f}. Warning: You exceeded your budget by ${exceeded:.2f}.")

Explanation:
This code generates a simple pattern of stars (*) where each row has an increasing number of stars, starting from 1 star in the first row.

• The variable row is initialized to 1 to represent the starting row, and total_rows is set to 5, defining the total number of rows in the pattern.
• A while loop runs as long as the current row number is less than or equal to total_rows.
• Inside the loop, the print() function prints a string of stars, with the number of stars determined by multiplying the * character by the current value of row. For example, when row is 1, it prints one star, and when row is 2, it prints two stars.
• After printing the stars for the current row, the row variable is incremented by 1 (row += 1), moving to the next row.
• The loop continues until all rows are printed.

row = 1
total_rows = 5

while row <= total_rows:
    print("*" * row)  # Print stars equal to the current row number
    row += 1  # Move to the next row

Explanation:
This code reverses a 3-digit lottery ticket number and displays it as a “reward code.”

• The ticket_number variable is initialized by taking the user’s input, which is converted into an integer using int().
• The reversed_number variable is initialized to 0 and will store the reversed ticket number as the digits are extracted.
• A while loop runs as long as the ticket_number is greater than 0. Inside the loop, the last digit of ticket_number is extracted using the modulus operator (% 10) and stored in the variable digit.
• The extracted digit is then added to reversed_number, but first, reversed_number is multiplied by 10 to shift its digits left (making space for the new digit).
• After adding the digit, the last digit is removed from ticket_number using integer division (// 10).
• The loop continues until all digits are reversed, and then the print() function displays the final reversed reward code.

ticket_number = int(input("Enter a 3-digit lottery ticket number: "))

reversed_number = 0

while ticket_number > 0:
    digit = ticket_number % 10  # Extract the last digit
    reversed_number = reversed_number * 10 + digit  # Add it to the reversed number
    ticket_number //= 10  # Remove the last digit

print(f"The reversed reward code is: {reversed_number}")

Explanation:
This code calculates the total earnings from parking fees for 10 cars, based on the duration of their parking.

• The total_earnings variable is initialized to 0 to keep track of the total amount earned.
• A for loop runs 10 times, once for each car, using range(1, 11). For each iteration, the program asks the user to input the parking duration (in hours) for the current car using the input() function, which is converted into an integer using int().
• If the parking duration is more than 1 hour, the parking fee is calculated as $5 for the first hour, and $3 for each additional hour (calculated by subtracting 1 from the total hours and multiplying by 3 (hours - 1) * 3).
• If the parking duration is 1 hour or less, the fee is simply $5.
• The calculated fee for each car is added to the total_earnings.
• After all 10 cars have been processed, the print() function displays the total earnings from the parking fees.

total_earnings = 0

for car in range(1, 11):
    hours = int(input(f"Enter parking duration for car {car} (in hours): "))
    if hours > 1:
        fee = 5 + (hours - 1) * 3  # $5 for the first hour, $3 for each additional hour
    else:
        fee = 5  # $5 for the first hour
    total_earnings += fee 

print("Total earnings:", total_earnings)

Explanation:
The code calculates the total cost of buying units of a product, applying a discount for each additional unit.

• The user inputs the price_per_unit, which is then converted into a floating-point number using float(). This represents the price for one unit of the product.
• A for loop runs from 1 to 10, iterating through the number of units being bought. For each loop iteration, the current number of units is stored in the units variable.
• For each unit, the code calculates the discounted price by subtracting $0.50 for every additional unit beyond the first. The formula used is price_per_unit - (units - 1) * 0.5. The first unit has no discount, while the price decreases for each additional unit.
• The code calculates the total cost for the current number of units by multiplying the number of units by the discounted price.
• The print() function displays the current number of units, the discounted price per unit, and the total cost for that quantity. The price and cost are formatted to two decimal places using :.2f.

price_per_unit = float(input("Enter the price per unit: "))

for units in range(1, 11):
    # Calculate the discounted price for each additional unit
    discount_price = price_per_unit - (units - 1) * 0.5
    total_cost = units * discount_price  # Total cost for the number of units

    print(f"Units: {units}, Price per Unit: ${discount_price:.2f}, Total Cost: ${total_cost:.2f}")

Explanation:
The code simulates making potion batches, changing the ingredients each time while keeping track of how much is used.

• It starts with 5 units of herb and 10 units of moonstone. The total_ingredients starts at 0 to keep track of all the ingredients used, and batch_number starts at 1 to count the batches.
• A while loop keeps running as long as total_ingredients is less than or equal to 100.
• Inside the loop, the code adds the herb and moonstone for each batch and updates the total_ingredients.
• The code prints details of each batch: how much herb and moonstone were used, how many ingredients in total for that batch, and the running total.
• After each batch, the code reduces herb by 1 and adds 2 to moonstone for the next batch. It also increases the batch_number by 1.
• The loop keeps going until the total_ingredients is more than 100.
• When the loop finishes, the code prints the total_ingredients used after all the batches.

herb = 5
moonstone = 10
total_ingredients = 0
batch_number = 1

while total_ingredients <= 100:
    batch_ingredients = herb + moonstone
    total_ingredients += batch_ingredients
    
    print(f"Brewing Batch {batch_number}:")
    print(f"  Herb used: {herb} units")
    print(f"  Moonstone used: {moonstone} units")
    print(f"  Total ingredients used in this batch: {batch_ingredients} units")
    print(f"  Total ingredients so far: {total_ingredients} units\n")
    
    # Update the ingredients for the next batch
    herb -= 1
    moonstone += 2
    batch_number += 1

print(f"Total ingredients used after all batches: {total_ingredients} units")

Explanation:
This code draws a rectangle shape made of # symbols to represent the wooden post.

Explanation:
This code determines whether a number is prime, calculates its factorial if it is prime, and counts the digits in the factorial.

• First, the user inputs a number using int(input()), which is stored in the variable number.
• The code initializes is_prime as True, factorial as 1, and digits as 0.
• A for loop runs from 1 to the value of number (inclusive). Inside the loop:
  • It checks if number is divisible by any value other than 1 and itself. If it finds such a divisor, it sets is_prime to False.
  • If the number is still considered prime and i is less than or equal to number, the code multiplies factorial by i to calculate the factorial.
• After the loop finishes, the code checks the value of is_prime:
  • If the number is prime and greater than 1, it prints that the number is prime, displays the factorial, and counts the digits in the factorial. To count digits, it converts the factorial to a string using str() and finds its length using len().
  • If the number is not prime, it simply prints that the number is not prime.

number = int(input("Enter a number: "))

is_prime = True
factorial = 1
digits = 0

for i in range(1, number + 1):
    # Check for primality (only runs for numbers greater than 1)
    if i > 1 and number % i == 0 and i != number:
        is_prime = False
    
    # Calculate factorial
    if is_prime and i <= number:
        factorial *= i

# Check the result of primality
if is_prime and number > 1:
    print(f"{number} is a prime number.")
    print(f"Factorial of {number} is {factorial}.")
    
    # Count digits in the factorial 
    factorial_str = str(factorial)
    digits = len(factorial_str)
    
    print(f"Total digits in the factorial: {digits}.")
else:
    print(f"{number} is not a prime number.")

Explanation:
This code takes a number, applies some transformations to it, and calculates a decoded value based on its digits.

• The user inputs a number, and it is stored in the variable number.
• The code multiplies number by 3 and stores the result in new_number.
• The code then converts new_number into a string (new_number_str) to easily access each individual digit.
• A for loop iterates through each digit in the string:
  • It converts each digit back to an integer.
  • If the digit is even (i.e., divisible by 2), the code subtracts 1 from it and adds the result to decoded_value.
  • If the digit is odd, the code adds 1 to it and then adds the result to decoded_value.
• After processing all digits, the code prints the final decoded_value.

number = int(input("Enter a number to decode: "))

new_number = number * 3

#Convert to string to access each digit
new_number_str = str(new_number)

decoded_value = 0

for digit in new_number_str:
    digit = int(digit) 
    
    if digit % 2 == 0:  # If the digit is even
        decoded_value += (digit - 1)
    else:  # If the digit is odd
        decoded_value += (digit + 1)  

print(f"The decoded number is: {decoded_value}")

Explanation:
This code calculates and displays the amount of money accumulated after each year with compound interest.

• The principal is set to 1000, the rate is set to 5%, and the years is set to 10.
• A for loop runs from 1 to years (inclusive), where each iteration represents a year.
• Inside the loop, the code calculates the amount using the compound interest formula:
  • It multiplies the principal by (1 + rate / 100) ** year, where rate / 100 is the annual interest rate, and ** year raises it to the power of the current year to account for compounding.
• The code then prints the year and the accumulated amount, formatting it to two decimal places.

principal = 1000
rate = 5  # Annual interest rate in percentage
years = 10

for year in range(1, years + 1):
    amount = principal * (1 + rate / 100) ** year  # Compound interest formula
    print(f"Year {year}: Amount = ${amount:.2f}")

Explanation:
This code calculates the electricity bill for multiple households based on their consumption and a tiered pricing system.

• The rates for the first 100 kWh and above 100 kWh are set as rate_1 (0.10) and rate_2 (0.15), respectively. The number of households is set to 5, with num_households = 5.
• The for loop iterates over each household from 1 to num_households.
• For each household, the code prompts the user to input their electricity consumption (consumption), measured in kWh.
• If the consumption is less than or equal to 100 kWh, the bill is calculated by multiplying consumption by rate_1.
• However, if the consumption exceeds 100 kWh, the code incorrectly calculates the bill by adding two parts: the first 100 kWh at rate_1 and any additional consumption at rate_2.
• After the calculation, the code prints the consumption and the bill for the household, formatted to two decimal places.

rate_1 = 0.10  # Rate for first 100 kWh
rate_2 = 0.15  # Rate for above 100 kWh

num_households = 5

for household in range(1, num_households + 1):
    consumption = int(input(f"Enter household {household} electricity consumption (kWh): "))

    if consumption <= 100:
        bill = consumption * rate_1  
        bill = (100 * rate_1) + ((consumption - 100) * rate_2)  

    print(f"Household {household}: Consumption = {consumption} kWh, Bill = ${bill:.2f}")

Explanation:
This code simulates a game where you start with a number and perform actions over several rounds.

• First, the code asks the user for the initial_number (starting number) and rounds (number of rounds to play). A variable count_rounds is initialized to keep track of the rounds you survive.
• The for loop runs for each round, starting from 1 to rounds. In each round:
• The code checks if the round number is even or odd.
• If it’s even, the number is doubled; if it’s odd, the number is increased by 3.
• The next step checks if the number contains the digit ‘7’. This is done by converting the number to a string using str(number). The str() function allows us to treat the number as a string so that we can check if ‘7’ is in the string. If ‘7’ is found, the game ends. The message "You lose!" is printed, and the break statement is used to exit the loop, ending the game early.
• If the number doesn’t contain ‘7’, the code checks if it’s divisible by 4. If it is, the number is halved, and a message is shown. This is done using integer division (//), which divides the number and keeps it as an integer.
• If the number isn’t divisible by 4, a message is displayed saying you survive the round, and the count_rounds is incremented.
• Finally, the code prints how many rounds you survived before losing.

initial_number = int(input("Enter the starting number: "))  
rounds = int(input("Enter the number of rounds: ")) 
count_rounds = 0  

for round_num in range(1, rounds + 1):
    number = initial_number
    
    if round_num % 2 == 0:
        number *= 2  
    else:
        number += 3  
    
    # Check if the number contains '7'
    if '7' in str(number):
        print(f"Round {round_num}: The number {number} contains '7'. You lose!")
        break  #the game ends

    # Check if the number is divisible by 4 
    if number % 4 == 0:
        number = number // 2
        print(f"Round {round_num}: The number {number} was divisible by 4, halved!")
    else:
        print(f"Round {round_num}: You survive with the number {number}.")
        count_rounds += 1  # Increment rounds survived

print(f"\nYou survived {count_rounds} rounds before failing!")