Scenario-Based Coding Problems on Nested Loops in Python

Explanation:
The code uses nested loops to print a chessboard pattern based on user input for rows and columns.

• First, it asks the user for the number of rows and columns, storing them in rows and cols, respectively, as integers using int().
• The outer for loop iterates over each row, running rows times. Each time the loop runs, it represents one row of the pattern.
• Inside the outer loop, there is another inner loop (the nested loop) that runs for each column in the current row, iterating cols times. This means that for each row, the inner loop controls how many times the pattern will be printed horizontally.
• In the inner loop:
  • The code checks if the sum of the current row and column numbers (row + col) is even or odd using the condition (row + col) % 2 == 0.
    • If the sum is even, it prints a # symbol.
    • If the sum is odd, it prints a . symbol.
  • The print() statement has end=" " to avoid starting a new line after each symbol. This keeps the symbols in the same row until the inner loop finishes.
• After completing one row (when the inner loop finishes), the print() statement without any arguments moves to the next line, so the next row begins from a new line.
• The process repeats until all rows and columns are printed, creating a chessboard-like pattern.

rows = int(input("Enter the number of rows: "))
cols = int(input("Enter the number of columns: "))

for row in range(rows):
    for col in range(cols):
        if (row + col) % 2 == 0:
            print("#", end=" ")
        else:
            print(".", end=" ")
    print() # Move to next row

Explanation:
This code helps to check where compact and regular cars can park in a parking lot with multiple sections and spots.

• The code first asks how many sections (num_sections) and spots (num_spots) are in the parking lot, and what size the car is (car_size).
• It uses the .lower() function to make sure the car size is checked in lowercase, regardless of how the user enters it.
• The outer while loop starts with section = 1 and repeats for each section of the parking lot.
• Inside this loop, another while loop starts with spot = 1 and checks each parking spot in the current section.
• If the car is compact, the code checks if the spot is in the first half of the section (num_spots // 2). Compact cars can park only there.
• The code allows regular cars to park in any spot, as regular cars can park anywhere.
• After checking each spot, the code moves to the next spot using spot += 1.
• Once all spots in a section are checked, the code moves to the next section by increasing the section number with section += 1.
• This process continues until all sections and spots are checked, showing where each car size can park.

num_sections = int(input("Enter the number of sections in the parking lot: "))  
num_spots = int(input("Enter the number of spots in each section: ")) 
car_size = input("Enter the car size (compact/regular): ").lower() 

section = 1
while section <= num_sections:  
    print(f"Checking Section {section}...")
    spot = 1
    while spot <= num_spots:  # Iterate through each spot in the section
        if car_size == "compact" and spot <= num_spots // 2:  # Compact cars can only park in half of the spots
            print(f"Compact car can park in Spot {spot} of Section {section}.")
        elif car_size == "regular" and (spot <= num_spots // 2 or spot > num_spots // 2):
            # Regular cars can park in any spot
            print(f"Regular car can park in Spot {spot} of Section {section}.")
        spot += 1  # Move to the next spot
    section += 1  # Move to the next section

Explanation:
This code simulates a grid-based treasure hunt where a player searches for a treasure at specific coordinates.

• The code first asks the user to input the treasure_row and treasure_col to specify where the treasure is hidden on the grid.
• It then defines the grid dimensions using grid_rows and grid_cols, set to 4 rows and 5 columns.
• Using nested loops:
  • The outer loop goes through each row (row) in the grid, from 1 to 4.
  • For each row, the inner loop iterates through each column (col), from 1 to 5.
• Inside the loops:
  • The if condition checks if the current row and col match the treasure_row and treasure_col provided by the user.
  • If a match is found, it prints “Found treasure!” to indicate the treasure is located at that position.
  • Otherwise, it prints “Try again.” for all other grid positions.
• This continues until the entire grid is checked, ensuring the treasure can be found if the user provides valid coordinates.

treasure_row = int(input("Enter the treasure row (1-4): "))
treasure_col = int(input("Enter the treasure column (1-5): "))

grid_rows, grid_cols = 4, 5

for row in range(1, grid_rows + 1):  # Loop through each row
    for col in range(1, grid_cols + 1):  # Loop through each column
        if row == treasure_row and col == treasure_col:
            print("Found treasure!")
        else:
            print("Try again.")  

Explanation:
This code creates a grid and checks whether each number in the grid is prime or not.

• The code first asks the user to input the number of rows and cols to define the size of the grid.
• Then, two nested for loops are used:
  • The outer loop goes through each row from 1 to the total number of rows (rows).
  • The inner loop goes through each col from 1 to the total number of columns (cols).
• For each cell in the grid, the number at that position is calculated by multiplying the row and col values, storing it in the variable num.
• Then, the code checks if num is a prime number:
  • If num is less than 2, it cannot be prime, so the variable is_prime is set to False.
  • Otherwise, the code checks if num is divisible by any number between 2 and the square root of num. If it finds a factor, it sets is_prime to False and breaks the loop.
• If is_prime is True, the number is printed. Otherwise, a hyphen (“-“) is printed to represent a non-prime number.
• After each row is processed, the code moves to the next row using print().

rows = int(input("Enter the number of rows: "))
cols = int(input("Enter the number of columns: "))

for row in range(1, rows + 1):  
    for col in range(1, cols + 1): 
        num = row * col  # Calculate the number in the grid
        is_prime = True
        if num < 2:  # Numbers less than 2 are not prime
            is_prime = False
        for i in range(2, int(num ** 0.5) + 1):  # Check for factors
            if num % i == 0:
                is_prime = False
                break
        print(f"{num}" if is_prime else "-", end="  ")
    print()  # Move to the next row

Explanation:
This code calculates the average score for each student and assigns a grade based on the average score.

• First, the code asks for the number of students and stores it in the variable num_students.
• The for loop runs once for each student, from 1 to the total number of students.
  • Inside the loop, it initializes total_score to 0 for each student to keep track of their total score.
  • Then, the code asks how many subjects the student has and stores it in num_subjects.
  • Another for loop runs for each subject, asking for the score and adding it to total_score.
• After collecting all the scores, the code calculates the avg_score by dividing total_score by the number of subjects (num_subjects).
• Based on the average score, it assigns a grade:
  • If the average score is 80 or higher, the grade is “A”.
  • If it’s between 60 and 79, the grade is “B”.
  • Otherwise, the grade is “C”.
• Finally, the code prints the student’s average score and their assigned grade.

num_students = int(input("Enter the number of students: "))  

for student in range(1, num_students + 1):  
    total_score = 0
    num_subjects = int(input(f"Enter the number of subjects for Student {student}: "))  
    
    for subject in range(1, num_subjects + 1):  
        score = int(input(f"Enter score for Subject {subject}: "))
        total_score += score
    
    avg_score = total_score / num_subjects 
    if avg_score >= 80:
        grade = "A"
    elif avg_score >= 60:
        grade = "B"
    else:
        grade = "C"
    
    print(f"Student {student}: Average Score = {avg_score:.2f}, Grade = {grade}")

Explanation:
This code generates a number pyramid where each row displays an increasing sequence of numbers, starting from 1.

• The code first asks for the number of rows in the pyramid and stores it in the variable rows.
• A for loop runs from 1 to the total number of rows (rows + 1). Each iteration corresponds to a row in the pyramid.
  • Inside the first loop, another for loop runs from 1 to the current row number (row + 1). This loop generates the numbers for that row.
  • The print(num, end=" ") statement displays the current number in the sequence, keeping it on the same line with a space in between.
• After printing all the numbers for a row, the outer loop executes a print() statement to move to the next line, creating the pyramid structure.

rows = int(input("Enter the number of rows: "))

for row in range(1, rows + 1):  
    for num in range(1, row + 1): 
        print(num, end=" ")
    print() 

Explanation:
This code simulates a vending machine that accepts coins until the total amount reaches or exceeds the price of a drink.

• The total_amount is initialized to 0, representing the money inserted by the user.
• The drink_price is set to 100 cents (equivalent to $1), which is the cost of the drink.
• A while loop runs as long as total_amount is less than drink_price. This ensures the loop continues until the user inserts enough money.
• Inside the loop:
  • The user is prompted to insert a coin by choosing from three options: 1 for 25 cents, 2 for 10 cents, and 3 for 5 cents.
  • If the user enters an invalid option (anything other than 1, 2, or 3), a nested while loop asks the user to try again until a valid option is chosen.
  • Depending on the user’s choice:
    • If coin_option is 1, 25 cents are added to total_amount.
    • If coin_option is 2, 10 cents are added.
    • If coin_option is 3, 5 cents are added.
• Once the total_amount equals or exceeds drink_price, the loop ends.
• After the loop:
  • If the total amount is sufficient, the message "Enjoy your drink!" is displayed.
  • Otherwise, the message "Please insert more coins." is displayed (though this case will not occur due to the loop’s condition).

total_amount = 0
drink_price = 100  # Price in cents

while total_amount < drink_price:
    coin_option = int(input("Insert a coin (1: 25 cents, 2: 10 cents, 3: 5 cents): "))
    while (coin_option != 1) and (coin_option != 2) and (coin_option != 3): 
        print("Invalid coin option. Please choose 1, 2, or 3.")
        coin_option = int(input("Insert a coin (1: 25 cents, 2: 10 cents, 3: 5 cents): "))

    if coin_option == 1:
        total_amount += 25
    elif coin_option == 2:
        total_amount += 10
    else: 
        total_amount += 5

if total_amount >= drink_price:
    print("Enjoy your drink!")
else:
    print("Please insert more coins.")

Explanation:
The code is a countdown timer that counts down from a specified number of minutes and seconds to zero.

• First the user enters the timer’s duration in minutes (minutes) and seconds (seconds) using input(), and these values are converted to integers with int().
• Then a while loop runs as long as there are any minutes or seconds left (minutes > 0 or seconds > 0).
• Inside the loop, if seconds > 0, it displays the remaining time in the MM:SS format using print(f"{minutes:02d}:{seconds:02d}"), ensuring two-digit formatting.
• The program pauses for 1 second using time.sleep(1) (from the time library which is used here to add a one-second pause between each countdown step, making the timer function realistically.) and decreases seconds by 1.
• When seconds reach 0 and minutes remain, minutes decreases by 1, and seconds resets to 59 to start counting down the new minute.
• Once both minutes and seconds reach 0, the program ends and displays "Time's up!".

import time

# Input the duration of the timer in minutes and seconds
minutes = int(input("Enter minutes: "))
seconds = int(input("Enter seconds: "))

while minutes > 0 or seconds > 0:  # Outer loop runs until the timer reaches 0
    while seconds > 0:  # Inner loop counts down the seconds
        print(f"{minutes:02d}:{seconds:02d}")  # Display the time in MM:SS format
        time.sleep(1)  # Wait for 1 second
        seconds -= 1  # Decrease seconds by 1
    if minutes > 0:  # When seconds reach 0 and minutes are remaining
        minutes -= 1  # Decrease minutes by 1
        seconds = 59  # Reset seconds to 59 for the new minute

print("Time's up!")

Explanation:
The code simulates a car’s journey through a grid of intersections, where each intersection has a traffic signal (red, yellow, or green), and the car’s movement depends on the signals.

• The user is prompted to input the number of rows (rows) and columns (columns) for the grid. These values define the grid size.
• A message "Car's journey through the grid:" is displayed to indicate the start of the simulation.
• For each row in the grid (for i in range(1, rows + 1)), the user provides the traffic signals for that row as a space-separated string (e.g., "green red yellow"). These signals are stored as a list using the split() method.
• Next, the program iterates through each column in the current row (for j in range(1, columns + 1)), processing one signal at a time.
  • The signal for the current intersection (signal = row_signals[j - 1]) is retrieved, and the intersection is identified by its coordinates (i, j).
  • The signal is displayed in uppercase for clarity using signal.upper().
  • Based on the signal:
    • If the signal is "green", the car moves forward, and a corresponding message is printed.
    • If the signal is "yellow", the car waits at the intersection, and this is communicated to the user.
    • If the signal is "red", the car stops and turns back. In this case, the break statement exits the inner loop (columns), and the outer loop (rows) also terminates due to the nested structure.
• The else block after the inner loop ensures the car continues to the next row only if no red signal is encountered. However, encountering a red signal stops the journey entirely.

rows = int(input("Enter the number of rows in the grid: ")) 
columns = int(input("Enter the number of columns in the grid: "))  

print("\nCar's journey through the grid:")
for i in range(1, rows + 1): 
    print(f"Enter signals for row {i} (use 'red', 'yellow', 'green', separated by spaces):")
    row_signals = input().split()  
    for j in range(1, columns + 1):  # Loop through each column in the current row
        signal = row_signals[j - 1]  # Access the corresponding signal
        print(f"Intersection ({i}, {j}) has a {signal.upper()} signal.")
        if signal == "green":
            print("Car moves forward.")
        elif signal == "yellow":
            print("Car waits at the intersection.")
        elif signal == "red":
            print("Car stops and turns back.")
            break
    else:
        continue
    break

Explanation:
This code simulates collecting loot from different buildings and floors in a game.

• First, the code takes the number of buildings (num_buildings) and the number of floors per building (num_floors) as input using the input() function.
• Then, it prints a message to start the loot simulation.
• The code loops through each building using for building in range(1, num_buildings + 1) and prints a message when entering a building.
• Inside each building loop, another loop runs through each floor of that building, using for floor in range(1, num_floors + 1), and asks for a loot item found on that floor.
• After collecting loot information, the program asks if the user wants to take the loot using input("Do you want to take this loot? (yes/no): ").lower(). the input() function is used for user input, and .lower() ensures that the user’s response is in lowercase to avoid mismatches.
• It then checks if the user answers “yes” and adds the loot to the inventory or leaves it behind.
• After finishing a building’s floors, it prints that the floors in the building are checked.
• Finally, after all buildings are processed, the code prints “Loot collection completed!”

num_buildings = int(input("Enter the number of buildings in the map: "))
num_floors = int(input("Enter the number of floors in each building: "))

print("\nLoot Simulation Begins:\n")

print("Your inventory contains the following loot:")
for building in range(1, num_buildings + 1):
    print(f"Entering Building {building}...")
    for floor in range(1, num_floors + 1):
        loot = input(f"Enter loot item for Building {building}, Floor {floor}: ")
        print(f"Loot found on Floor {floor}: {loot}")
        take_loot = input("Do you want to take this loot? (yes/no): ").lower()
        if take_loot == "yes":
            print(f"{loot} added to inventory.")
        else:
            print(f"{loot} left behind.")
    print(f"Finished checking all floors in Building {building}.\n")

print("Loot collection completed!")

Explanation:
This code simulates a robot cleaning a room, checking the cleanliness of sections in a grid-like room, and stopping once two sections are clean.

• The code first takes the number of rows (rows) and columns (columns) of the room as input.
• The variable clean_count is initialized to 0 to keep track of how many sections are clean.
• The outer for loop, for i in range(1, rows + 1), loops through each row of the room.
• Inside this loop, it asks the user to input the cleanliness status for each section in the row (either “dirty” or “clean”).
• The inner for loop, for j in range(1, columns + 1), loops through each column in the current row, and checks each section’s cleanliness.
• The code then checks if the section is “dirty”. If it is, it prints that the robot is cleaning the section, and it resets the clean_count to 0 (indicating the robot is cleaning a section).
• If the section is already “clean”, it increments the clean_count by 1 and prints that the section is clean.
• When clean_count reaches 2 (meaning two clean sections have been checked), it prints that the robot has stopped cleaning, and all clean sections are checked, then breaks out of the inner loop.
• The else in the inner loop ensures the outer loop continues until the robot finishes cleaning.
• The break in both loops ensures the robot stops as soon as two clean sections are checked.

rows = int(input("Enter the number of rows in the room: "))
columns = int(input("Enter the number of columns in the room: "))

clean_count = 0

for i in range(1, rows + 1):  # Loop through each row
    print(f"Enter the cleanliness of row {i} (use 'dirty' or 'clean', separated by spaces):")
    
    for j in range(1, columns + 1):  # Loop through each column in the current row
        section = input()  # Input the cleanliness status of each section
        print(f"Robot encounters section ({i}, {j}) which is {section}.")
        
        if section == "dirty":
            print("Cleaning the section...")
            clean_count = 0  # Reset clean count when robot cleans
        else:
            clean_count += 1
            print("Section is already clean.")
        
        if clean_count == 2:
            print("Robot stopped cleaning. All clean sections checked.")
            break
    else:
        continue
    break

Explanation:
This code generates and displays a multiplication table in a well-aligned format, where each number is padded with spaces to ensure all numbers have equal width for neat alignment.

• The code first takes an integer n as input, representing the size of the multiplication table (i.e., the table will have n rows and n columns).
• The variable max_number is set to n * n, which is the highest number in the table (the result of multiplying n by itself).
• The variable max_width is initialized to 0. This will hold the maximum number of digits in any number of the table.
• The while temp > 0 loop is used to count how many digits are in the max_number. It repeatedly divides temp by 10, increasing max_width by 1 each time, until temp becomes 0.
• After determining the width of the largest number, the program enters a nested for loop. The outer loop iterates through each row from 1 to n, and the inner loop iterates through each column from 1 to n.
• Inside the inner loop, the product of the current row and column (row * col) is calculated and stored in product.
• The code then calculates the width (number of digits) of the current product using a similar process as before (looping through and dividing by 10).
• To ensure the numbers align correctly, the code prints the necessary spaces. The number of spaces printed is equal to max_width - width, where width is the number of digits in the current product.
• Finally, the product is printed, followed by a space. After printing all columns for a row, print() is called to move to the next line.

n = int(input("Enter the size of the table (n): "))

max_number = n * n
max_width = 0

# Find the number of digits in max_number 
temp = max_number
while temp > 0:
    max_width += 1
    temp //= 10
for row in range(1, n + 1):
    for col in range(1, n + 1):
        product = row * col

        # Determine the number of digits in the current product 
        width = 0
        temp = product
        while temp > 0:
            width += 1
            temp //= 10

        for _ in range(max_width - width):
            print(" ", end="")

        print(product, end=" ")
    print()

Explanation:
This code simulates navigating through a maze, where the user encounters rooms that are either open paths or walls. The goal is to count how many open rooms the user passes until encountering a wall.

• The code starts by asking the user to input the number of rooms in the maze (rooms).
• It initializes a variable open_rooms_passed to 0, which will keep track of the number of open rooms the user passes.
• The room_number is set to 1, representing the first room in the maze.
• The while loop runs as long as room_number is less than or equal to rooms, allowing the user to check each room in the maze.
• Inside the loop, the user is asked to input the status of the current room (whether it is an open path or a wall). The input is converted to lowercase using .lower() to handle any case variations.
• If the room is an open path, open_rooms_passed is incremented by 1, and a message is printed saying the room is an open path and the user can move forward.
• If the room is a wall, the program prints a message saying the user cannot move forward and breaks out of the loop, stopping further room checks.
• After each iteration, the room_number is incremented by 1 to move to the next room.
• Once the loop ends, the code prints the total number of open rooms the user passed (open_rooms_passed).

rooms = int(input("Enter the number of rooms in the maze: "))

open_rooms_passed = 0

room_number = 1
while room_number <= rooms:
    room_status = input(f"Is room {room_number} an open path or a wall? (Enter 'open' or 'wall'): ").lower()
    if room_status == "open":
        open_rooms_passed += 1
        print(f"Room {room_number} is an open path. You can move forward.")
    elif room_status == "wall":
        print(f"Room {room_number} is a wall. You can't move forward.")
        break
    room_number += 1

print(f"Total open rooms passed: {open_rooms_passed}")

Explanation:
This code calculates the total number of animals in a zoo, where the zoo is divided into several sections. For each section, it asks for the number of different animal types and the number of animals of each type.

• The user is first asked to input the number of sections in the zoo (sections).
• The variable total_animals is initialized to 0. This will hold the total number of animals in the zoo.
• A for loop starts with section_number ranging from 1 to sections, representing each section of the zoo.
• Inside the loop, the user is asked how many different animal types are in the current section (types_of_animals).
• Then, for each animal type in that section, another for loop asks for the number of animals of that type (animals_of_this_type).
• The number of animals of that type is added to animals_in_section, which tracks the total number of animals in the current section.
• After processing all animal types in the current section, animals_in_section is added to total_animals, which keeps track of the overall total number of animals in the zoo.
• A message is printed to show the total number of animals counted in the current section.
• This process repeats for all sections in the zoo.
• Finally, the code prints the total number of animals in the zoo, stored in total_animals.

sections = int(input("Enter the number of sections in the zoo: "))
total_animals = 0

for section_number in range(1, sections + 1):
    animals_in_section = 0
    types_of_animals = int(input(f"Enter the number of different animal types in section {section_number}: "))
    
    for animal_type in range(1, types_of_animals + 1):
        animals_of_this_type = int(input(f"Enter the number of animals of type {animal_type} in section {section_number}: "))
        animals_in_section += animals_of_this_type  # Add to section total
    
    total_animals += animals_in_section  # Add to overall total for the zoo
    print(f"Counting {animals_in_section} animals in section {section_number}.")

print(f"Total animals in the zoo: {total_animals}")

Explanation:
This code keeps track of the completed tasks in a space mission, divided into different phases. For each phase, the user inputs the number of tasks, and the code checks whether each task has been completed.

• The user is asked to input the number of phases in the space mission (phases).
• A variable completed_tasks is initialized to 0. This will store the count of tasks that are completed throughout the mission.
• A while loop is used to go through each phase in the mission. The loop runs as long as phase_number is less than or equal to phases.
• For each phase, the user is asked how many tasks are there in that phase (tasks).
• Then, a second while loop goes through each task in the current phase. It checks the status of the task: whether it’s completed or not.
• If the task is completed (the user enters ‘yes’), the code adds 1 to completed_tasks and prints a message confirming the task is completed.
• If the task is not completed (the user enters ‘no’), the code prints a message saying the task is not completed.
• After checking all tasks in the current phase, the code moves on to the next phase by increasing phase_number.
• Finally, the code prints the total number of tasks completed in the mission, stored in completed_tasks.

phases = int(input("Enter the number of phases in the space mission: "))

completed_tasks = 0

phase_number = 1
while phase_number <= phases:
    tasks = int(input(f"Enter the number of tasks in phase {phase_number}: "))
    task_number = 1
    while task_number <= tasks:
        status = input(f"Is task {task_number} in phase {phase_number} completed? (Enter 'yes' or 'no'): ").lower()
        if status == "yes":
            completed_tasks += 1
            print(f"Task {task_number} in phase {phase_number} is completed.")
        else:
            print(f"Task {task_number} in phase {phase_number} is not completed.")
        task_number += 1
    phase_number += 1
              
print(f"Total tasks completed in the mission: {completed_tasks}")