Scenario-Based Questions on Nested Loops in Mojo

Explanation:

This code generates a schedule for each day, listing tasks based on the user’s input for days and tasks per day.

• First, the user is prompted to input the number of days and the number of tasks per day.
• The outer loop (for day in range(1, days + 1)) iterates over each day, printing the day number.
• The inner loop (for task in range(1, tasks + 1)) iterates over the tasks. It checks the task number using conditions: if the task is 1, it prints "Checking Emails", if task 2, it prints "Meeting with Team", and for other tasks, it prints "Documenting Work". A print() at the end ensures that the next day’s tasks appear on a new line. 

days = int(input("Enter the number of days: "))
tasks = int(input("Enter the number of tasks per day: "))

for day in range(1, days + 1):  
    print(f"Day {day}: ", end="")
    for task in range(1, tasks + 1):  
        if task == 1:
            print("Checking Emails", end=", ")
        elif task == 2:
            print("Meeting with Team", end=", ")
        else:
            print("Documenting Work", end=", ")
    print()

Explanation:

This code calculates the overtime hours and pay for multiple employees and determines the “Overtime Champion” based on who has the most overtime hours.

• The program first takes the number of employees (employees) as input. Two variables, max_overtime and champion, are initialized to keep track of the highest overtime hours and the corresponding employee. 
• The outer loop runs for each employee. Inside this loop, the total_overtime for the employee is initialized to 0, and a day counter is set to 1 to process each day’s overtime. The inner while loop runs for each of the three days, prompting the user to enter the overtime hours worked by the employee for that day. 
• If the hours worked are greater than 8, the overtime hours (hours worked minus 8) are added to total_overtime. After processing all three days, the total overtime hours are used to calculate the overtime pay (overtime_pay = total_overtime * 10), and the result is displayed for the employee.
• The program then checks if the current employee has worked more overtime than the previous maximum (if total_overtime > max_overtime:). If so, max_overtime is updated, and the current employee is marked as the new champion. 

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

max_overtime = 0
champion = 0

for employee in range(1, employees + 1):  
    total_overtime = 0
    day = 1

    while day <= 3:
        hours = int(input("Employee " + str(employee) + " Day " + str(day) + " hours: "))
        if hours > 8:
            total_overtime += hours - 8
        day += 1

    overtime_pay = total_overtime * 10
    print("Employee", employee)
    print("Overtime Hours:", total_overtime)
    print("Overtime Pay: $", overtime_pay)

    if total_overtime > max_overtime:
        max_overtime = total_overtime
        champion = employee

print("The Overtime Champion is Employee", champion, "with a bonus of $50!")

Explanation:

This code takes input for the number of students and their scores in three tests calculates the average score for each student, and determines if they passed or failed based on that average.

• It first asks the user to input the total number of students (students) and initializes a counter (passed_students) to track how many students pass.
• The outer loop (for student in range(1, students + 1)) iterates over each student. For each student, the code sets the total_score to 0 and initializes the test counter (test = 1).
• Inside the loop, a while loop runs three times, prompting the user to input each test score (score) and adding it to total_score. After all scores are entered, the average score is calculated by dividing total_score by 3.
• The program then checks if the average is greater than or equal to 50. If true, it prints a pass message and increments the passed_students counter otherwise, it prints a fail message. Finally, it outputs the total number of passed students.

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

for student in range(1, students + 1): 
    total_score = 0
    test = 1

    while test <= 3:
        score = float(input("Enter Test " + str(test) + " score for Student " + str(student) + ": "))
        total_score += score
        test += 1

    average = total_score / 3
    print("Student", student, "Average:", average)

    if average >= 50:
        print("Student", student, "Result: Pass")
        passed_students += 1
    else:
        print("Student", student, "Result: Fail")

print("Total Students Passed:", passed_students)

Explanation:

This code calculates the total quantity of two products (A and B) in three sections and displays the result for each product.

• The product variable is initialized to 1, representing product A, and a while loop runs twice, once for each product (A and B). For each product, the total_quantity is set to 0, and the section counter is initialized to 1 to represent the sections where the product is located. 
• Inside the loop, another while loop runs three times to handle input for each section. The product_name is assigned based on whether it’s product A or B, and the quantity for the current section is entered by the user. The entered quantity is added to total_quantity, and the section counter is incremented.
• After all three sections are processed for a product, the total quantity is displayed. The product counter is then incremented to process the next product.

product = 1

while product <= 2:
    total_quantity = 0
    section = 1

    while section <= 3:
        if product == 1:
            product_name = "A"
        else:
            product_name = "B"

        quantity = int(input("Enter quantity of Product " + product_name + " in Section " + str(section) + ": "))
        total_quantity += quantity
        section += 1

    print("Total Quantity of Product", product_name, ":", total_quantity)
    product += 1

Explanation:

This code generates a pattern of numbers based on the number of rows specified by the user.

• The program first takes the number of rows (rows) as input. 
• Then, the outer loop starts from row 1 and runs until the specified number of rows is reached. Inside the outer loop, the num variable is initialized to 1 at the beginning of each row. 
• The inner loop runs for each number in the current row, printing the numbers from 1 up to the current row number (num += 1). The end="" in the print function ensures that the numbers are printed on the same line, separated by a space. 
• After printing the numbers for the current row, print("") move the cursor to the next line. The row counter is then incremented to process the next row. This continues until the specified number of rows is printed.

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

row = 1
while row <= rows:
    num = 1
    while num <= row:
        print(num, " ", end="")
        num += 1
    print("")
    row += 1

Explanation:

This code finds all the prime numbers between a given start and end number, calculates their sum, and displays both the prime numbers and their total sum.

• First, the program takes the starting (start) and ending (end) numbers as input from the user. It then initializes two variables: sum_primes to store the sum of prime numbers and prime_numbers to store the prime numbers as a string. 
• The num variable is initialized to the start value and the outer while loop runs as long as num is less than or equal to the end value.
• For each number (num) in the specified range, the program checks if it is prime. The is_prime variable is set to True at the beginning of each iteration. An inner while loop starts with div = 2 and checks if num is divisible by any number between 2 and num / 2.
• If any divisor is found (i.e., num % div == 0), it sets is_prime to False and breaks the loop, meaning the number is not prime. If no divisors are found and num is greater than 1, it is considered prime. The prime number is then added to the sum_primes, and the prime number is appended to the prime_numbers string.
• After processing all numbers in the range, the program prints the list of prime numbers and the sum of these primes.

start = int(input("Enter the starting number: "))
end = int(input("Enter the ending number: "))

sum_primes = 0
prime_numbers = ""

num = start
while num <= end:
    is_prime = True
    div = 2
    while div <= num / 2:
        if num % div == 0:
            is_prime = False
            break
        div += 1
    if is_prime and num > 1:
        sum_primes += num
        prime_numbers += str(num) + " "
    num += 1

print("The prime numbers between", start, "and", end, "are:", prime_numbers)
print("The sum of these prime numbers is:", sum_primes)

Explanation:

This code generates an inverted triangle pattern of stars based on the number of levels specified by the user. 

• The program first takes the number of levels (levels) as input. The level variable is initialized to the total number of levels and is used in the outer while loop, which runs until level reaches 1.
• In each iteration of the outer loop, the program first prints spaces to align the stars in the correct position. The inner whileloop prints the spaces, where the number of spaces decreases as the level number decreases.
• After printing the spaces, the program prints the stars. The star variable is used to print stars (*) for the current level. The inner loop runs for the number of stars equal to the current level. Each star is printed with a space after it (end=" ").
• After printing the stars for a particular level, the program moves to the next line (print("")) and decrements the levelcounter to handle the next level of the pyramid. This process continues until the pattern is fully printed.

levels = int(input("Enter the number of levels in your climb: "))

level = levels
while level >= 1:
    space = 1
    while space <= (levels - level):
        print(" ", end="")
        space += 1
    
    star = 1
    while star <= level:
        print("*", end=" ")
        star += 1
    print("")
    level -= 1

Explanation:

This code calculates the “energy” of each cell in a grid and finds the total energy for all cells.

• The user provides the number of rows (rows) and columns (cols), and the variable total_energy is initialized to 0 to store the cumulative energy.
• The outer loop starts with row at 1 and runs until it equals the number of rows, iterating over each row. Inside this loop, the inner loop begins with col at 1 and processes each column in the current row.
• For each cell, the energy is calculated as the sum of row and col, printed on the same line, and added to total_energy. After completing one row, a print() moves to the next line, and the outer loop increments row to proceed to the next. Once the grid is fully processed, the program prints the total energy of all cells.

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

total_energy = 0

row = 1
while row <= rows:
    col = 1
    while col <= cols:
        energy = row + col
        print(energy, " ", end="")
        total_energy += energy
        col += 1
    print()
    row += 1

print("Total energy:", total_energy)

Explanation:

This code calculates the “magical energy” for each cell in a grid, where the energy of a cell is determined by multiplying its row and column indices. It also computes the total magical energy of the grid and identifies the highest energy level.

• The program starts by asking the user to input the number of rows (rows) and columns (cols). Two variables, total_energy and highest_energy, are initialized to 0 to keep track of the cumulative energy and the maximum energy value, respectively. 
• The outer while loop begins with row set to 1 and iterates over each row. Inside this loop, the inner while loop starts with col at 1 and processes each column in the current row. For each cell, the energy is calculated as row * col, printed on the same line, and added to total_energy.
• If the current energy exceeds highest_energy, it is updated to reflect the new maximum value. After printing all columns for a row, a print() moves to the next line, and the outer loop increments row to process the next row. 

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

total_energy = 0
highest_energy = 0

row = 1
while row <= rows:
    col = 1
    while col <= cols:
        energy = row * col
        print(energy, " ", end="")
        total_energy += energy
        if energy > highest_energy:
            highest_energy = energy
        col += 1
    print()
    row += 1

print("Total Magical Energy:", total_energy)
print("Highest Energy Level:", highest_energy)

Explanation:

This code investigates whether a given number is a perfect number and then finds all perfect numbers up to a specified limit. A perfect number is a positive integer that is equal to the sum of its proper divisors (excluding itself).

• First, the program takes two inputs from the user: number and limit.
• For the given number, it calculates the sum of its divisors using a for loop, which checks every number from 1 to half of number. If a divisor divides the number evenly (number % divisor == 0), it is added to sum_of_divisors.
• After the loop, if the sum_of_divisors is equal to number, it means the number is perfect, and the program prints that it is a perfect number. If not, it prints that the number is not perfect.
• After investigating the given number, the program then checks all numbers from 1 to the limit to identify perfect numbers. For each number, it calculates the sum of its divisors using the same method and checks if the sum equals the number. If it does, the number is printed as a perfect number.

number = int(input("Enter the number to investigate: "))
limit = int(input("Investigate all perfect numbers up to: "))

sum_of_divisors = 0
for divisor in range(1, number // 2 + 1):
    if number % divisor == 0:
        sum_of_divisors += divisor

if sum_of_divisors == number:
    print("Investigating number:", number)
    print("Sum of divisors of", number, "(excluding itself):", sum_of_divisors)
    print(number, "is a perfect number!")
else:
    print("Investigating number:", number)
    print(number, "is not a perfect number.")

print("Perfect numbers up to", limit, ":")
for num in range(1, limit + 1):
    sum_of_divisors = 0
    for divisor in range(1, num // 2 + 1):
        if num % divisor == 0:
            sum_of_divisors += divisor
    
    if sum_of_divisors == num:
        print(num)

Explanation:

This code calculates the greatest common divisor (GCD) of the watering intervals of pairs of sprinklers.

• It first takes input for the number of sprinkler pairs (num_pairs).
• For each pair, the program prompts the user to enter the watering intervals for both sprinklers. The intervals are stored in sprinkler_1 and sprinkler_2. The GCD is calculated by repeatedly dividing the larger number by the smaller number and replacing the larger number with the remainder until the remainder is 0. At this point, the smaller number is the GCD.

num_pairs = int(input("Enter the number of sprinkler pairs: "))

for i in range(1, num_pairs + 1):
    print(f"Enter details for sprinkler pair {i}:")

    sprinkler_1 = int(input("Watering interval for sprinkler 1: "))
    sprinkler_2 = int(input("Watering interval for sprinkler 2: "))

    a = sprinkler_1
    b = sprinkler_2
    
    while b != 0:
        temp = b
        b = a % b
        a = temp
        
    print(f"GCD of their watering intervals: {a}")

Explanation:

This code represents a menu-driven program for managing student marks, where users can input student data, view marks, calculate averages, and find the highest and lowest marks in each subject.

• Initially, the program prompts the user for the number of students and then displays a menu with five options. 
• The first option allows users to input marks for each student across three subjects: Math, Science, and English. However, an issue arises because the variables math_marks, science_marks, and english_marks are overwritten for each student, resulting in only the last student’s marks being stored. 
• The second option allows viewing all student marks, but again, due to overwriting, it only shows the last entered marks.
• The third option calculates the average marks for each student but encounters the same problem of storing only the last student’s marks.
• The fourth option displays the highest and lowest marks for each subject, but as with the other operations, it doesn’t track multiple students’ data properly. Lastly, the fifth option exits the program. 

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

# Menu-driven program
while True:
    print("\nMenu:")
    print("1. Input student marks")
    print("2. View all student marks")
    print("3. Calculate average marks of each student")
    print("4. Display highest and lowest marks in each subject")
    print("5. Exit")
    
    choice = int(input("Enter your choice: "))

    if choice == 1:
        # Input student marks
        print("Enter marks for ", n, " students:")
        student_counter = 1
        while student_counter <= n:
            print("\nStudent ", student_counter, ":")
            math_marks = int(input("Enter Math marks: "))
            science_marks = int(input("Enter Science marks: "))
            english_marks = int(input("Enter English marks: "))
            student_counter += 1

    elif choice == 2:
        # View all student marks
        print("\nAll student marks:")
        student_counter = 1
        while student_counter <= n:
            print("Student ", student_counter, ":")
            print("Math = ", math_marks, ", Science = ", science_marks, ", English = ", english_marks)
            student_counter += 1

    elif choice == 3:
        # Calculate average marks of each student
        print("\nAverage marks of each student:")
        student_counter = 1
        while student_counter <= n:
            total_marks = math_marks + science_marks + english_marks
            average_marks = total_marks / 3
            print("Student ", student_counter, "Average: ", average_marks)
            student_counter += 1

    elif choice == 4:
        # Display highest and lowest marks in each subject
        print("\nHighest and Lowest Marks in each subject:")
        student_counter = 1
        math_highest = math_marks
        math_lowest = math_marks
        science_highest = science_marks
        science_lowest = science_marks
        english_highest = english_marks
        english_lowest = english_marks
        
        while student_counter <= n:
            # Math
            if math_marks > math_highest:
                math_highest = math_marks
            if math_marks < math_lowest:
                math_lowest = math_marks
                
            # Science
            if science_marks > science_highest:
                science_highest = science_marks
            if science_marks < science_lowest:
                science_lowest = science_marks
                
            # English
            if english_marks > english_highest:
                english_highest = english_marks
            if english_marks < english_lowest:
                english_lowest = english_marks

            student_counter += 1
        
        print("Math: Highest = ", math_highest, ", Lowest = ", math_lowest)
        print("Science: Highest = ", science_highest, ", Lowest = ", science_lowest)
        print("English: Highest = ", english_highest, ", Lowest = ", english_lowest)

    elif choice == 5:
        # Exit
        print("Exiting the program.")
        break
    
    else:
        print("Invalid choice, please try again.")

Explanation:

This code generates a diamond-shaped pattern using squares of numbers.

• The code begins by prompting the user to input the number of rows, stored in n, for the upper half of the diamond. 
• The program then uses a while loop to iterate through the rows, with row starting at 1 and increasing up to n. For each row, the program first calculates the number of spaces required for center alignment by using another while loop with the variable spaces, where the number of spaces printed is determined by the difference between n and the current row.
• Following the spaces, another while loop is used to print the squares of numbers from 1 to the current row, with each square calculated as column * column, where column starts at 1 and increases up to the current row number.
• Once the upper half is printed, the program moves to the lower half by decrementing row from n - 1 and repeating the process. In this part, the number of spaces and the squares printed decreases in reverse order. 

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

# Upper half of the diamond
row = 1
while row <= n:
    # Print leading spaces for center alignment
    spaces = 1
    while spaces <= (n - row):
        print(" ", end=" ")
        spaces += 1
    
    # Print the squares of the numbers for the current row
    column = 1
    while column <= row:
        print((column * column), end=" ")
        column += 1
    
    print()  # Move to the next line after each row
    row += 1

# Lower half of the diamond (reverse of the upper half)
row = n - 1
while row >= 1:
    # Print leading spaces for center alignment
    spaces = 1
    while spaces <= (n - row):
        print(" ", end=" ")
        spaces += 1
    
    # Print the squares of the numbers for the current row
    column = 1
    while column <= row:
        print((column * column), end=" ")
        column += 1
    
    print()  # Move to the next line after each row
    row -= 1

Explanation:

The program calculates the factorial of each number in a user-defined range and finds the sum of the digits of each factorial.

• The program begins by asking the user for a starting number (start) and an ending number (end) to define a range of numbers.
• It then uses a while loop to iterate through each number in the range, starting from start and continuing until end. For each number in the range, the program calculates its factorial by initializing a variable called factorial to 1 and using another while loop, where a counter i starts from 1 and increments up to the current number. In each iteration, factorialis multiplied by i, resulting in the factorial of the number.
• After the factorial is calculated, the program determines the sum of the digits of the factorial. It initializes a variable sum_of_digits to 0 and creates a copy of the factorial value in a variable named temp. Using another while loop, it repeatedly extracts the last digit of temp using the modulus operator (temp % 10), adds it to sum_of_digits, and removes the last digit from temp by dividing it by 10 using integer division (temp // 10). This process continues until all digits are processed and temp becomes 0.
• The program then displays the current number (num), its factorial (factorial), and the sum of the digits of the factorial (sum_of_digits). Finally, the loop increments num to move to the next number in the range.

start = int(input("Enter the starting number of the range: "))
end = int(input("Enter the ending number of the range: "))

num = start
while num <= end:
    # Calculate the factorial
    factorial = 1
    i = 1
    while i <= num:
        factorial *= i
        i += 1

    # Calculate the sum of the digits of the factorial
    sum_of_digits = 0
    temp = factorial
    while temp > 0:
        digit = temp % 10
        sum_of_digits += digit
        temp = temp // 10

    print("Number:", num)
    print("Factorial:", factorial)
    print("Sum of digits of factorial:", sum_of_digits)
    print()

    num += 1

Explanation:

This program is a simple calculator that performs basic arithmetic operations (addition, subtraction, multiplication, division) based on user input, and continues calculating until the user chooses to exit.

• The program begins by prompting the user to enter two numbers (num1 and num2) and an arithmetic operation (operation). 
• Based on the selected operation, the program calculates the result (result). If the operation is addition (+), subtraction (-), or multiplication (*), the program directly performs the operation. 
• If the operation is division (/), it first checks if num2 is not zero to avoid division by zero errors. If the user inputs an invalid operation, the program prompts for the operation again. 
• Once the result is displayed, it asks whether the user wants to perform another operation. If the response (continue_calculating) is not “yes” or “no,” the program continues asking until a valid input is provided. If the user answers “no,” the program prints a goodbye message and exits. Here’s a flow of the program:

while True:
    num1 = int(input("Enter the first number: "))
    num2 = int(input("Enter the second number: "))
    operation = input("Enter the operation (+, -, *, /): ")

    # Perform the calculation based on the operation
    result = 0
    if operation == "+":
        result = num1 + num2
    elif operation == "-":
        result = num1 - num2
    elif operation == "*":
        result = num1 * num2
    elif operation == "/":
        if num2 != 0:
            result = num1 / num2
        else:
            print("Error: Division by zero is not allowed.")
            continue
    else:
        print("Invalid operation! Please enter one of (+, -, *, /).")
        continue

    print("Result:", result)

    # Ask if the user wants to perform another operation
    continue_calculating = input("Do you want to perform another operation (yes/no)? ").lower()
    
    # Nested loop for the decision to continue or exit
    while continue_calculating != "yes" and continue_calculating != "no":
        print("Invalid input! Please type 'yes' or 'no'.")
        continue_calculating = input("Do you want to perform another operation (yes/no)? ").lower()
    
    # Break the outer loop if user decides to exit
    if continue_calculating == "no":
        print("Exiting the calculator. Goodbye!")
        break