Scenario-Based Coding Questions on Operators in Mojo

Explanation:

This program calculates the final bill for a restaurant meal. It takes the cost of the meal, the cost of a drink, and a service charge percentage entered by the user.

• The program first asks the user to enter the cost of the meal, drink, and service_charge_percentage.
• After getting the inputs, the program adds the cost of the meal and the drink to find the total cost. This total is stored in the total variable.
• Next, it calculates the service charge by dividing the percentage by 100 to convert it into a decimal (e.g., 10% becomes 0.1), which is needed to calculate the portion of the total based on the percentage, and then multiply it by the total. The result is saved in the service_charge variable.
• Finally, the program adds service_charge to the total cost to find the final bill. This amount is stored in the final_bill variable. The program then displays the final bill to the user.

meal = Float(input("Please give the cost of the meal you ordered: "))
drink = Float(input("Please give the cost of the drink you ordered: "))
service_charge_percent = Float(input("Enter the service charge percentage: "))

total = meal + drink
service_charge = (service_charge_percent / 100) * total
final_bill = total + service_charge

print(f"Final bill is: {final_bill}")

Explanation:

This program takes a temperature given in Celsius and calculates its equivalent value in Fahrenheit using a simple formula.

• The program prompts the user to input the temperature in Celsius, which is then saved in the celsius variable.
• To convert Celsius to Fahrenheit, the program multiplies the Celsius temperature by 9, divides the result by 5, adds 32, and then stores the final value in the fahrenheit variable.

celsius = Float(input("Enter temperature in Celsius: "))
fahrenheit = (celsius * 9 / 5) + 32

print(f"Temperature in Fahrenheit is: {fahrenheit}")

Explanation:

This program divides a certain number of candies equally among friends and calculates if there are any leftover candies.

• The program first asks the user to input the total number of candies and the number of friends. The inputs are converted to integers (using Int()) and stored in the variables total_candies and friends.
• Next, the program calculates how many candies each friend should get by dividing total_candies by friends. The result is stored in the candies_per_friend variable.
• Then, the program calculates how many candies will be left over after dividing them. It uses the modulo operator (%) to find the remainder when dividing total_candies by friends. This remainder is stored in the leftover_candies variable.

total_candies = Int(input("Kindly enter the total number of candies available:  "))
friends = Int(input("Enter the number of friends: "))

candies_per_friend = total_candies / friends
leftover_candies = total_candies % friends

print(f"Each friend gets {candies_per_friend} candies.")
print(f"Candies left over: {leftover_candies}")

Explanation:

This program calculates a car’s distance based on its speed and the time it travels.

• The program begins by prompting the user to enter the car’s speed in miles per hour and the time traveled in hours, which are saved in the speed and time variables, respectively.
• After getting the inputs, the program calculates the distance the car has traveled by multiplying the speed by the time. This result is stored in the distance variable.

speed = Int(input("Input the car's speed in miles per hour: "))
time = Int(input("Enter the time in hours: "))

distance = speed * time

print(f"Distance is: {distance}")

Explanation:

The program calculates how to find the perimeter of a rectangle.

• It first asks the user to enter the length and width of the rectangle, which are stored in the length and width variables.
• To calculate the perimeter of a rectangle, you first add the length and width together. Then, you multiply the sum by 2 to get the total perimeter. This final result is stored in the perimeter variable.

length = Int(input("Enter the rectangle's length:  "))
width = Int(input("Enter the rectangle's width: "))

perimeter = 2 * (length + width)

print(f"Perimeter of a rectangle is: {perimeter}")

Explanation:

This program calculates the total cost of fuel for a trip.

• The program asks the user to input the fuel consumption per 100 km, the distance to travel in kilometers, and the cost of fuel per liter, storing these values in the fuel_per_100km, distance, and fuel_cost variables, respectively.
• To calculate how much fuel is needed for the trip, the program divides the distance by 100 and then multiplies it by the fuel consumption per 100 km (fuel_per_100km). This result is stored in the fuel_needed variable.
• After that, the program calculates the total fuel cost by multiplying the fuel needed (fuel_needed) by the cost per liter of fuel (fuel_cost). The total cost is saved in the total_cost variable.

fuel_per_100km = Float(input("Enter fuel consumption per 100 km: "))
distance = Float(input("Enter the distance to travel in km: "))
fuel_cost = Float(input("Enter the cost of fuel per liter: "))

fuel_needed = (distance / 100) * fuel_per_100km
total_cost = fuel_needed * fuel_cost

print(f"Total cost: {total_cost}")

Explanation:

This program calculates the average score of five courses.

• It first asks the user to enter the score for each of the five courses, and these values are stored in variables course_score1, course_score2, course_score3, course_score4, and course_score5.
• Then, the program adds all the scores together to find the total.
• After that, it divides the total by 5 to calculate the average score.

course_score1 = Float(input("Enter the score for course 1: "))
course_score2 = Float(input("Enter the score for course 2: "))
course_score3 = Float(input("Enter the score for course 3: "))
course_score4 = Float(input("Enter the score for course 4: "))
course_score5 = Float(input("Enter the score for course 5: "))

total = course_score1 + course_score2 + course_score3 + course_score4 + course_score5
average = total / 5

print(f"Average is: {average}")

Explanation:

This program helps you figure out how much money you’ll have left after shopping.

• The program starts by asking you to enter the total amount of money budget and the prices of three products product_price1, product_price2, and product_price3.
• Then program calculates the total cost of these products by adding their prices together and stores the result in the total_cost variable. 
• After that, it calculates the remaining money by subtracting the total_cost from your budget and stores this value in the remaining_budget variable.

budget = Float(input("Enter your total budget: "))
product_price1 = Float(input("Enter the price of product 1: "))
product_price2 = Float(input("Enter the price of product 2: "))
product_price3 = Float(input("Enter the price of product 3: "))

total_cost = product_price1 + product_price2 + product_price3
remaining_budget = budget - total_cost

print(f"Remaining Budget: {remaining_budget}")

Explanation:

This program helps calculate how much each person needs to pay when splitting a bill, including a tip. 

• User start by entering the total bill amount (bill), the number of friends (people), and the tip percentage (tip_percent).
• The program first divides the bill by the number of people (bill / people) to find out how much each person has to pay.
• The program calculates the tip for each person by converting the tip percentage into a decimal (tip_percent / 100) and then multiplying it by the amount each person has to pay (per_person). This gives the tip amount for each individual.
• Finally, the program adds the calculated tip (tip) to the amount each person has to pay (per_person). This gives the total amount each person needs to pay, including the tip.

bill = Float(input("Enter the total bill amount: "))
people = Int(input("Enter the number of friends: "))
tip_percent = Float(input("Enter the tip percentage: "))

per_person = bill / people
tip = (tip_percent / 100) * per_person
total_per_person = per_person + tip

print(f"Total per person: {total_per_person}")

Explanation:

This program helps calculate the total profit made from producing and selling units of a product.

• First, it asks the user to enter the number of units produced (units_produced), the cost to produce each unit (cost_per_unit_produced), the fixed overhead cost (fixed_costs), and the selling price per unit (selling_price_per_unit).
• It then calculates the total cost (total_cost) by multiplying the number of units (units_produced) by the cost per unit (cost_per_unit_produced) and adding the fixed costs (fixed_costs).
• The total revenue (total_revenue) is calculated by multiplying the number of units (units_produced) by the selling price per unit (selling_price_per_unit).
• Finally, the program finds the profit by subtracting the total cost (total_cost) from the total revenue (total_revenue), and prints out the total profit.

units_produced = Int(input("Enter the number of units produced: "))
cost_per_unit_produced = Float(input("Enter the cost to produce each unit: "))
fixed_costs = Float(input("Enter the fixed overhead cost: "))
selling_price_per_unit = Float(input("Enter the selling price per unit: "))

total_cost = (units_produced * cost_per_unit_produced) + fixed_costs
total_revenue = units_produced * selling_price_per_unit
profit = total_revenue - total_cost

print(f"Total profit: {profit}")

Explanation:

This program calculates the total salary including annual bonus and additional bonus based on years of service.

• First, it asks for the monthly salary (monthly_salary), the annual bonus percentage (annual_bonus_percentage), the additional bonus percentage per year of service (yearly_bonus_additional), and the number of years of service (years_of_service).
• Next, it computes the annual salary (annual_salary) by multiplying the monthly salary (monthly_salary) by 12. Multiplying the monthly_salary by 12 gives the total salary for the whole year.
• The annual bonus is calculated by multiplying the annual salary (annual_salary) by the bonus percentage (annual_bonus_percentage) divided by 100 to convert it to a decimal. This gives the actual bonus amount.
• The additional_bonus is calculated by multiplying the annual salary (annual_salary) by the additional bonus percentage (yearly_bonus_additional) (converted to decimal form by dividing by 100), and then multiplying by the number of years of service (years_of_service) to get the total bonus based on experience.
• Finally, it adds the annual_salary, bonus, and additional_bonus together to determine the total salary (total_salary).

monthly_salary = Float(input("Enter the monthly salary: "))
annual_bonus_percentage = Float(input("Enter the annual bonus percentage (in %): "))
yearly_bonus_additional = Float(input("Enter the additional bonus percentage per year of service (in %): "))
years_of_service = Int(input("Enter the number of years of service: "))

# Calculate annual salary
annual_salary = monthly_salary * 12

# Calculate total bonus
bonus = annual_salary * (annual_bonus_percentage / 100)
additional_bonus = annual_salary * (yearly_bonus_additional / 100) * years_of_service

# Total salary with bonus
total_salary = annual_salary + bonus + additional_bonus

print(f"Total Salary: {total_salary}")

Explanation:

This program calculates the profit made from selling shares after a price increase.

• First, you input the purchase price per share (purchase_price_per_share), the percentage increase in price (price_increase_percentage), and the number of shares bought (number_of_shares_bought).
• The new price per share (new_price_per_share) is calculated by multiplying the purchase_price_per_share by (1 + price_increase_percentage / 100), which adds the price increase to the original price.
• Next, the profit per share (profit_per_share) is calculated by subtracting the original purchase_price_per_share from the new_price_per_share, giving the gain on each share.
• Finally, the total profit (total_profit) is found by multiplying the profit_per_share by the number of shares (number_of_shares_bought), showing the overall profit from all the shares.

purchase_price_per_share = Float(input("Enter the purchase price per share: "))
price_increase_percentage = Float(input("Enter the percentage increase in price: "))
number_of_shares_bought = Int(input("Enter the number of shares bought: "))

new_price_per_share = purchase_price_per_share * (1 + price_increase_percentage / 100)
profit_per_share = new_price_per_share - purchase_price_per_share
total_profit = profit_per_share * number_of_shares_bought

print(f"Total profit: {total_profit}")

Explanation:

This program calculates the total volume of three cylindrical containers by taking user inputs for their radius and height, and then applying the formula for the volume of a cylinder: V = π * r² * h.

• The program asks the user to input the radius and height of three containers. These values are stored in the variables radius_1, height_1, radius_2, height_2, radius_3, and height_3. These inputs are taken as floating point numbers using Float(input()) to allow for decimal values, as the measurements could be non-integer.
• The volume of each cylinder is calculated using the formula V = π * r² * h. In this case, we use an approximate value of π as 3.14159.
  • For the first container, the volume is calculated as volume_1 = pi * (radius_1 ** 2) * height_1, where the radius is squared (radius_1 ** 2), then multiplied by the height (height_1), and finally multiplied by π.
  • Similarly, the volumes for the second and third containers are stored in volume_2 and volume_3, calculated in the same way.

radius_1 = Float(input("Please provide the radius of the first container: "))
height_1 = Float(input("Please provide the height of the first container: "))

radius_2 = Float(input("Please provide the radius of the second container: "))
height_2 = Float(input("Please provide the height of the second container: "))

radius_3 = Float(input("Please provide the radius of the third container: "))
height_3 = Float(input("Please provide the height of the third container: "))

# Volume of cylinder formula: V = π * r^2 * h
pi = 3.14159
volume_1 = pi * (radius_1 ** 2) * height_1
volume_2 = pi * (radius_2 ** 2) * height_2
volume_3 = pi * (radius_3 ** 2) * height_3

total_volume = volume_1 + volume_2 + volume_3

print(f"The total volume of all three containers is: {total_volume}")

Explanation:

This program calculates the total rent collected by a hostel from multiple rooms, based on the number of students paying full rent and half rent.

• The program asks the user to input the rent values, where full_rent stores the rent for a student paying the full amount, and half_rent stores the rent for a student paying half the rent.
• Rooms 1 to 3: These rooms have 4 full rent students and 1 half rent student.
  • The total rent collected from these rooms is calculated by multiplying 4 * full_rent to get the rent from full rent students (full_rent_students_room_1_3) and adding half_rent for the one half rent student (half_rent_students_room_1_3). The total rent for rooms 1 to 3 is stored in total_rent_room_1_3.
• Rooms 4 to 8: These rooms have 3 full rent students and 2 half rent students.
  • Similarly, the rent for these rooms is calculated by multiplying 3 * full_rent for the full rent students (full_rent_students_room_4_8) and 2 * half_rent for the half rent students (half_rent_students_room_4_8). The total rent for rooms 4 to 8 is stored in total_rent_room_4_8.
• Rooms 9 to 10: These rooms have 2 full rent students and 3 half rent students.
  • Again, the rent for these rooms is calculated by multiplying 2 * full_rent for the full rent students (full_rent_students_room_9_10) and 3 * half_rent for the half rent students (half_rent_students_room_9_10). The total rent for rooms 9 to 10 is stored in total_rent_room_9_10.
• After calculating the rent for each set of rooms, the program adds the rents from all the rooms together. The total rent for all rooms is calculated as:
  • total_rent = total_rent_room_1_3 * 3 + total_rent_room_4_8 * 5 + total_rent_room_9_10 * 2. This formula multiplies the rent for each set of rooms by the number of rooms (3 rooms in the first set, 5 rooms in the second set, and 2 rooms in the last set) and adds them to get the total rent.

full_rent = Int(input("Enter the rent for a student paying full rent: "))
half_rent = Int(input("Enter the rent for a student paying half rent: "))

# Calculate rent for the first 3 rooms
full_rent_students_room_1_3 = 4 * full_rent  
half_rent_students_room_1_3 = half_rent      
total_rent_room_1_3 = full_rent_students_room_1_3 + half_rent_students_room_1_3

# Calculate rent for the next 5 rooms
full_rent_students_room_4_8 = 3 * full_rent  
half_rent_students_room_4_8 = 2 * half_rent  
total_rent_room_4_8 = full_rent_students_room_4_8 + half_rent_students_room_4_8

# Calculate rent for the last 2 rooms
full_rent_students_room_9_10 = 2 * full_rent  
half_rent_students_room_9_10 = 3 * half_rent  
total_rent_room_9_10 = full_rent_students_room_9_10 + half_rent_students_room_9_10

# Calculate total rent
total_rent = total_rent_room_1_3 * 3 + total_rent_room_4_8 * 5 + total_rent_room_9_10 * 2

print("Total rent collected by the hostel: ", total_rent)

Explanation:

• The program begins by asking the user to enter the price of each product and the sales target. The price per product is stored in the variable price_per_product, and the sales target is stored in the variable sales_target.
• Then, the program calculates the total value of 4 products (since the 5th one is free). This is done by multiplying the price_per_product by 4, and the result is saved in the variable value_per_5_products.
• Next, the program calculates how many sets of 5 products are needed to reach the sales target. To do this, the program divides the sales_target by the value_per_5_products (the total value of 4 products) and stores the result in the variable products_needed. This gives the number of product sets required to meet or exceed the sales target.
• Finally, the program calculates the total number of products that must be sold, including the free ones. Since each set contains 5 products (4 paid and 1 free), the program multiplies the number of sets (products_needed) by 5. The result is saved in the variable total_products_sold.

price_per_product = Int(input("Enter the price of each product: "))
sales_target = Int(input("Enter the sales target: "))

# Calculate the total value of 4 products (since the 5th one is free)
value_per_5_products = 4 * price_per_product

# Calculate how many sets of 5 products are needed to meet the sales target
products_needed = sales_target / value_per_5_products

# Calculate the total number of products (including free ones)
total_products_sold = products_needed * 5

print("Total products to be sold: ", total_products_sold)