Scenario-Based Coding Questions on Nested If-else in Python

Explanation:
This program calculates the shipping cost for a gift based on its weight and the destination.

• The user is first prompted to input the gift’s weight using weight = float(input("Enter the weight of the gift (kg): ")). The float() function treats the input as a decimal number.
• Next, the program asks for the shipping destination and stores it in destination variable.
• The program checks if the gift’s weight is less than 5 kg using if weight < 5:.
  • If the weight is less than 5 kg and the destination is "international" (checked using if destination == "international":), the program prints print("Shipping cost: $15"), indicating a lower shipping cost for lightweight international packages.
  • If the weight is less than 5 kg but the destination is not "international" (assumed to be "local"), it prints print("Shipping cost: $5"), assigning a smaller fee for lightweight local deliveries.
• Else, if the weight is not less than 5 kg (i.e., the gift is heavier), the program moves to the else block for the weight.
  • Within this block, if the destination is "international" (checked using if destination == "international":), it prints print("Shipping cost: $30"), indicating a higher shipping fee for heavy international packages.
  • If the destination is "local", it prints print("Shipping cost: $10"), setting a reduced cost for heavy packages shipped locally.

weight = float(input("Enter the weight of the gift (kg): "))
destination = input("Enter the destination (local, international): ")

if weight < 5:
    if destination == "international":
        print("Shipping cost: $15")
    else:
        print("Shipping cost: $5")
else:
    if destination == "international":
        print("Shipping cost: $30")
    else:
        print("Shipping cost: $10")

Explanation:
This program analyzes the user’s health based on their weight, height, age, and activity level and suggests a personalized health plan according to the Body Mass Index (BMI).

• The program starts by asking the user for their weight in kilograms (weight) and their height in meters (height).The float() function used here treats the input as a decimal number.
• It then asks for the user’s age (age) and their activity level (activity_level). The int() function used for the age variable treats the input as an integer whereas the activity_level is treated as a string.
• The BMI is calculated using the formula bmi = weight / (height ** 2) determines whether the user is underweight, healthy, or overweight.
• If BMI > 25:
  • The program further checks if the user’s age is between 30 and 50 and if their activity level is "Low" (if 30 <= age <= 50 and activity_level == "Low":).
    • If true, it calculates a target weight using the formula 22 * (height ** 2) and suggests a weight-loss boot camp.
  • If the conditions are not met, the program suggests a general health boost plan with daily brisk walks and dietary changes
• Else, if 18.5 <= BMI <= 25:
  • The program checks if the activity level is "High" (if activity_level == "High":).
    • If true, it suggests a muscle gain challenge and prints Muscle Gain Challenge. Build strength and gain muscle with intense workouts! along with the recommended calories.
  • If the activity level is not "High", the program suggests a general health boost plan with moderate exercises and recommends standard maintenance calories (calories_needed = 2000).
• If BMI < 18.5:
  • The program checks if the user’s age is less than 25 or if their activity level is "Very High" (if age < 25 or activity_level == "Very High":).
    • If true, it calculates the required weight using the formula 20 * (height ** 2) and suggests a weight gain plan. It also recommends higher calories (calories_needed = 3000).
  • If these conditions are not met, the program suggests a health boost plan focusing on protein-rich foods and light exercises and recommends slightly more calories (calories_needed = 2500).
• Otherwise, if none of the above conditions are met, the program suggests a general health boost plan to stay active and healthy. It sets the recommended calories to calories_needed = 2200.

weight = float(input("Enter your weight in kg: "))
height = float(input("Enter your height in meters: "))
age = int(input("Enter your age: "))
activity_level = input("Enter activity level (Low/Moderate/High/Very High): ")

# Calculate BMI 
bmi = weight / (height ** 2)

if bmi > 25:
    if 30 <= age <= 50 and activity_level == "Low":
        target_weight = 22 * (height ** 2)  # Calculate target weight for weight loss
        print(f"Weight Loss Bootcamp. Target weight: {target_weight:.2f} kg. Start with cardio and light exercises!")
    else:
        print("Health Boost Plan. Try daily brisk walks and small changes to your diet!")
elif 18.5 <= bmi <= 25:
    if activity_level == "High":
        print("Muscle Gain Challenge. Build strength and gain muscle with intense workouts!")
        calories_needed = 2500  # Higher calories for muscle gain
        print(f"Recommended calories: {calories_needed} per day.")
    else:
        print("Health Boost Plan. Stay active with moderate exercises like jogging or cycling!")
        calories_needed = 2000  # Standard maintenance calories
        print(f"Recommended calories: {calories_needed} per day.")
elif bmi < 18.5:
    if age < 25 or activity_level == "Very High":
        required_weight = 20 * (height ** 2)  # Calculate target weight for weight gain
        print(f"Weight Gain Plan. Target weight: {required_weight:.2f} kg. Focus on muscle building and nutrient-rich foods!")
        calories_needed = 3000  # Higher calories for weight gain
        print(f"Recommended calories: {calories_needed} per day.")
    else:
        print("Health Boost Plan. Eat more protein-rich foods and try light exercises!")
        calories_needed = 2500  # Slightly more for healthy weight gain
        print(f"Recommended calories: {calories_needed} per day.")
else:
    print("Health Boost Plan. Stay fit, eat healthy, and make every move count!")
    calories_needed = 2200  # Standard calories for general health
    print(f"Recommended calories: {calories_needed} per day.")

Explanation:
This program helps suggest a study plan based on the user’s chosen subject and the amount of time left for preparation.

• It begins by asking for the subject, which can be “Math,” “History,” or any other subject entered as “Other.” stored in the variable subject.
• Then it asks how much time is left for preparation, with options “Less than a week” or “More than a week,” stored in the variable time.
• The program then uses a series of if-elif conditions to determine the appropriate study plan.
• If the subject is “Math,” it checks the value of time.
  • If the user has “Less than a week,” it suggests focusing on practicing problems to strengthen problem-solving skills and prints "Suggested Plan: Practice Problems."
  • If the time left is “More than a week,” it advises reviewing concepts for better understanding and outputs "Suggested Plan: Concept Reviews."
• If the subject is “History,” the program again evaluates the time.
  • For “More than a week,” it recommends preparing detailed notes for in-depth understanding and prints "Suggested Plan: Detailed Notes."
  • If the time is “Less than a week,” it suggests focusing on memorization techniques for retaining key facts and dates, displaying "Suggested Plan: Memorization Techniques."
• For any subject other than “Math” or “History,” the program handles it under the “Other” category.
  • If the user has “More than a week,” it advises thorough study and outputs "Suggested Plan: Thorough Study."
  • For “Less than a week,” it recommends quick revision and prioritization of essential topics, printing "Suggested Plan: Quick Revision."

subject = input("Enter your subject (Math/History/Other): ")
time = input("How much time is left (Less than a week/More than a week)? ")

if subject == "Math":
    if time == "Less than a week":
        print("Suggested Plan: Practice Problems.")
    else:
        print("Suggested Plan: Concept Reviews.")
elif subject == "History":
    if time == "More than a week":
        print("Suggested Plan: Detailed Notes.")
    else:
        print("Suggested Plan: Memorization Techniques.")
else:
    if time == "More than a week":
        print("Suggested Plan: Thorough Study.")
    else:
        print("Suggested Plan: Quick Revision.")

Explanation:
This program helps you choose a savings or investment plan based on your income, age, and spending habits.

• It asks for three things: your monthly income (income), your age (age), and your spending habits (spending_habits), which can be “High,” “Moderate,” or “Low”to suggest the best plan for the user.
• If your income is less than $2000 and your age is between 20 and 40, it checks your spending_habits.
  • If the spending habits are “High”, it will suggest a Basic Savings Plan and calculate how much you need to save each month to reach $10,000 in 24 months using the formula 10000 / 24 .
  • If the spending habits are not “High”, it will suggest a Flexible Budget Plan instead.
• Else, if the income is between $2000 and $5000, it checks if the spending_habits are “Moderate”.
  • If yes, it calculates 20% of your income using the formula income * 0.2 and suggests a Standard Savings Plan with the monthly savings target displayed.
  • If the spending habits are not “Moderate”, it will recommend the Flexible Budget Plan.
• If the income is greater than $5000, it checks if your age is below 30 or if your spending_habits are “Low”.
  • If either of these is true, it suggests an Aggressive Investment Plan and calculates how much you could save after 5 years using the formula income * 0.3 * (1.1 ** 5)showing the savings grow with a 10% annual increase.
  • If neither condition is met, it will suggest the Flexible Budget Plan.
• The program uses nested if-else statements to choose the right plan using simple math operations like division (/), multiplication (*), and exponentiation (**) to calculate the savings needed for each plan. It then displays the plan and the amounts, formatted to two decimal places for clarity.

income = float(input("Enter your monthly income in dollars: "))
age = int(input("Enter your age: ").strip())
spending_habits = input("Enter your spending habits (High/Moderate/Low): ")

if income < 2000:
    if 20 <= age <= 40:
        if spending_habits == "High":
            monthly_savings = 10000 / 24
            print(f"Basic Savings Plan. Monthly savings required: ${monthly_savings:.2f}.")
        else:
            print("Flexible Budget Plan. Explore tips to improve your savings.")
    else:
        print("Flexible Budget Plan. Explore tips to improve your savings.")
elif 2000 <= income <= 5000:
    if spending_habits == "Moderate":
        savings_target = income * 0.2
        print(f"Standard Savings Plan. Monthly savings target: ${savings_target:.2f}.")
    else:
        print("Flexible Budget Plan. Explore tips to improve your savings.")
elif income > 5000:
    if age < 30 or spending_habits == "Low":
        projected_savings = income * 0.3 * (1.1 ** 5)
        print(f"Aggressive Investment Plan. Projected savings after 5 years: ${projected_savings:.2f}.")
    else:
        print("Flexible Budget Plan. Explore tips to improve your savings.")
else:
    print("Flexible Budget Plan. Explore tips to improve your savings.")

Explanation:
This program is designed to assign a letter grade based on the user’s score.

• The program first asks the user to input their score as an integer (using the int() and input() functions).
• It then uses a series of nested conditional statements to determine the grade.
• The program first checks if the score is greater than or equal to 90.
  • If true, it prints "Your grade is: A", since a score of 90 or above qualifies for an A grade.
  • If the score is below 90, it moves to the next check.
• The next condition checks if the score is greater than or equal to 75.
  • If true, it prints "Your grade is: B", as scores between 75 and 89 receive a B grade. I
  • f the score is still below 75, the program proceeds to the next condition.
• Next, the program checks if the score is greater than or equal to 60.
  • If true, it prints "Your grade is: C", indicating a C grade for scores between 60 and 74.
  • If the score is less than 60, the program checks if the score is greater than or equal to 50.
• If the score is greater than or equal to 50, it prints "Your grade is: D", as scores between 50 and 59 receive a D grade.
• If the score is below 50, the program finally prints "You failed!", indicating that the user did not pass.

score = int(input("Enter your score: "))

if score >= 90:
    print("Your grade is: A")
else:
    if score >= 75:
        print("Your grade is: B")
    else:
        if score >= 60:
            print("Your grade is: C")
        elif score >= 50:
          	print("Your grade is: D")
        else:
            print("You failed!")

Explanation:
The program calculates the final price for an internet plan based on the data usage, location (local or international), and autopay preference, with different charges for each condition.

• In this program, the user is prompted to input their data usage, location, and whether they want to enable autopsy.
• First, the program checks if the user’s data_usage is less than 50 GB.
  • If it is, the user is assigned the “Basic Plan” with a fixed price of $20. No further calculations are needed in this case.
• If the data_usage is between 50 and 100 GB, the user is assigned the “Standard Plan.”
• The program then checks if the location is “local” or “international.”
  • If the location is local and the user has selected autopay (“yes”), a 10% discount is applied to the base_price_standard, resulting in a lower price.
    • If autopay is not selected (“no”), a processing fee of $10 is added to the base_price_standard.
  • If the location is international, an international surcharge of $15 is added to the base_price_standard.
• If the data_usage exceeds 100 GB, the user is assigned the “Premium Plan.”
  • If the location is “local” and autopay is enabled (“yes”), no extra fees are applied, and the user is charged the base price.
    • If autopay is disabled (“no”), a processing fee of $10 is added to the base_price_premium.
  • If the location is “international,” an international surcharge of $25 is added to the base_price_premium.
• The program then prints out the final price after applying any discounts or additional charges.

data_usage = int(input("Enter your data usage in GB: "))
location = input("Enter your location (local, international): ")
autopay = input("Do you want autopay? (yes/no): ")

# Initialize variables for prices
base_price_standard = 50
base_price_premium = 100
international_surcharge_standard = 15
international_surcharge_premium = 25
processing_fee = 10
discount_rate = 0.1

if data_usage < 50:
    print("Your internet plan: Basic Plan")
    print("Price: $20")
else:
    if 50 <= data_usage <= 100:  # Standard Plan
        print("Your internet plan: Standard Plan")
        if location == "local":
            if autopay == "yes":
                final_price = base_price_standard * (1 - discount_rate)
                print("Discount applied: 10%")
            else:
                final_price = base_price_standard + processing_fee
                print("Processing fee applied: $10")
        else:  # International
            final_price = base_price_standard + international_surcharge_standard
            print("International surcharge applied: $15")
        print(f"Final price: ${final_price:.2f}")
    else:  # Premium Plan
        print("Your internet plan: Premium Plan")
        if location == "local":
            if autopay == "no":
                final_price = base_price_premium + processing_fee
                print("Processing fee applied: $10")
            else:
                final_price = base_price_premium
        else:  # International
            final_price = base_price_premium + international_surcharge_premium
            print("International surcharge applied: $25")
        print(f"Final price: ${final_price:.2f}")

• In this program, the user is asked to input their age and whether they are a student and store them in age and is_student respectively.
• The base ticket price is set at $20.
• If the age is less than 12, the user receives a 50% discount on the ticket price.
• If the age is between 12 and 18 (exclusive), the discount depends on whether the user is a student:
  • Then it checks if the user is a student, then they receive a 30% discount.
  • Else, if the user is not a student, there is no discount.
  • If the age is 18 or older, the discount is again based on student status:
    • If the user is a student, they receive a 10% discount.
    • If the user is not a student, there is no discount.
• The final price is calculated by multiplying the base price by the factor (1 - discount).The (1 - discount) calculates the portion of the base price to be paid after subtracting the discount percentage.
• Lastly, the final ticket price is printed with the calculated discount.

age = int(input("Enter your age: "))
is_student = input("Are you a student? (yes/no): ")

ticket_price = 20  #Base Price for ticket

if age < 12:
    discount = 0.5
elif 12 <= age < 18:
    if is_student == "yes":
        discount = 0.3
    else:
        discount = 0
else:
    if is_student == "yes":
        discount = 0.1
    else:
        discount = 0

final_price = ticket_price * (1 - discount)
print(f"Your ticket price is: ${final_price:.2f}")

Explanation:
This program calculates the annual tax based on the user’s income, marital status, and number of children.

• For the program to begin, the user enters their annual income, marital status (yes/no), and the number of children.
• If the income is less than $20,000, then no tax is applied (tax_rate = 0).
• For an income between $20,000 and $50,000, the base tax rate is 5% (tax_rate = 0.05).
  • If the user has one or more children, the tax rate is reduced by 2% (tax_rate -= 0.02).
• For an income above $50,000, the base tax rate is 10% (tax_rate = 0.1).
  • If the user is married, the tax rate is reduced by 3% (tax_rate -= 0.03).
• Then the annual tax is calculated as income * tax_rate.
• Finally, the calculated annual tax is displayed with two decimal places using annual_tax:.2f.

income = float(input("Enter your annual income: "))
is_married = input("Are you married? (yes/no): ")
children = int(input("Enter the number of children: "))

tax_rate = 0

if income < 20000:
    tax_rate = 0
elif 20000 <= income <= 50000:
    tax_rate = 0.05
    if children > 0:
        tax_rate -= 0.02
else:
    tax_rate = 0.1
    if is_married == "yes":
        tax_rate -= 0.03

annual_tax = income * tax_rate
print(f"Your annual tax is: ${annual_tax:.2f}")

Explanation:
This program calculates the electricity bill based on the user’s usage, senior citizen status, and late payment history.

• The user inputs their electricity usage in units (usage), whether they are a senior citizen (senior_citizen as “yes” or “no”), and if they have late payments (late_payment as “yes” or “no”).
• For usage <= 100, the bill is calculated as bill = usage * 0.5, with a 10% discount applied for senior citizens (bill *= 0.9).
• For usage between 101 and 200,
• the first 100 units are charged at $0.50 per unit, additional units at $0.75 per unit, and if the user is not a senior citizen and has late payments, a $10 a surcharge is added (bill += 10).
• For usage > 200, the first 100 units are charged at $0.50 per unit, the next 100 at $0.75 per unit, and units above 200 at $1.00 per unit.
• If there are no late payments or usage < 300, a $20 discount is applied (bill -= 20).
• Finally, the total bill is displayed, formatted to two decimal places ({bill:.2f}).

usage = int(input("Enter your electricity usage (in units): "))
senior_citizen = input("Are you a senior citizen? (yes/no): ")
late_payments = input("Do you have late payments? (yes/no): ")

bill = 0

if usage <= 100:
    bill = usage * 0.5
    if senior_citizen == "yes":
        bill *= 0.9  # 10% discount
else:
    if usage <= 200:
        bill = (100 * 0.5) + ((usage - 100) * 0.75)
        if senior_citizen != "yes" and late_payments == "yes":
            bill += 10  # $10 surcharge
    else:
        bill = (100 * 0.5) + (100 * 0.75) + ((usage - 200) * 1.0)
        if late_payments == "no" or usage < 300:
            bill -= 20  # $20 discount

print(f"Total bill: ${bill:.2f}")

Explanation:

• This program decides the “next move” based on four inputs: the amount stolen (stolen_amount), the type of getaway vehicle (getaway_vehicle as “car,” “bike,” or “none”), whether it is nighttime (is_night as “yes” or “no”), and whether the police are nearby (police_nearby as “yes” or “no”).
• For stolen_amount > 50000,
  • if the getaway_vehicle is “car” and police_nearby is “no,” the suggestion is "Escape on the highway."
  • Otherwise, it suggests "Hide in a nearby alley."
• For stolen_amount between 10000 and 50000,
  • if is_night is “yes” and police_nearby is “no,” the suggestion is "Escape through the main road."
  • Otherwise, it recommends "Hide in an abandoned house."
• For stolen_amount < 10000,
  • if there is no getaway_vehicle, the program suggests "Blend in with the crowd."
  • Otherwise, it recommends "Take a bus to a different city." Based on these conditions, the program outputs the most suitable “next move.”

amount_stolen = int(input("Enter the amount stolen: "))
vehicle = input("Enter the type of getaway vehicle (car/bike/none): ")
nighttime = input("Is it nighttime? (yes/no): ")
police_nearby = input("Are the police nearby? (yes/no): ")

if amount_stolen > 50000:
    if vehicle == "car" and not police_nearby:
        print("Next move: Escape on the highway.")
    else:
        print("Next move: Hide in a nearby alley.")
elif 10000 <= amount_stolen <= 50000:
    if not police_nearby and nighttime:
        print("Next move: Escape through the main road.")
    else:
        print("Next move: Hide in an abandoned house.")
else:  # amount_stolen < 10000
    if vehicle == "none":
        print("Next move: Blend in with the crowd.")
    else:
        print("Next move: Take a bus to a different city.")

Explanation:

• This program calculates the total reward points for heroes based on the mission_type, successful_missions, and hero_rank.
• It starts with a base reward of 500 points for all missions.
• For mission_type, high-risk missions add a 50% bonus if successful_missions >= 3; otherwise, no bonus is given.
• For low-risk missions, if successful_missions < 3, the reward is reduced by 20%; otherwise, no changes are made.
• Medium-risk missions do not alter the reward.
• The hero_rank also impacts the reward: veterans earn an extra 200 points for high-risk or medium-risk missions,
• while rookies get a flat 100 points for low-risk missions, regardless of other calculations.
• Additionally, if successful_missions > 5, a loyalty bonus of 150 points is added.
• The program calculates and displays the total reward points based on these conditions.

mission_type = input("Enter the mission type (high-risk/medium-risk/low-risk): ")
missions = int(input("Enter the number of successful missions: "))
hero_rank = input("Enter your hero rank (rookie/veteran): ")

reward_points = 500  # Base reward for all missions

if mission_type == "high-risk":
    if missions >= 3:
        reward_points *= 1.5  # 50% bonus 
    else:
        reward_points *= 1  # No bonus for high-risk if less than 3 missions completed
elif mission_type == "low-risk":
    if missions < 3:
        reward_points *= 0.8  # 20% penalty f
    else:
        reward_points *= 1  # No penalty
else:
    reward_points *= 1  # No change for medium-risk or unknown mission types

# Bonus for veteran heroes
if hero_rank == "veteran":
    if mission_type in ["high-risk", "medium-risk"]:
        reward_points += 200 

# Rookie bonus for low-risk missions
if hero_rank == "rookie":
    if mission_type == "low-risk":
        reward_points = 100  # Flat reward 

if missions > 5:
    reward_points += 150  # Loyalty bonus

print(f"Reward points: {reward_points}")

Explanation:
This program calculates the power consumption for time travel based on three factors: the era you’re traveling to, the number of travelers, and their role.

• First, the program asks user to input the era, the number of travelers, and their role.
• The base power usage is set to 100, which is the starting point for the calculation.
• Next, the program checks the era you choose:
  • If the era is future, and there are 3 or more travelers, it increases power usage by 70% (power_usage *= 1.7).
    • After that, if the travelers are scientists, it adds an additional 20% increase (power_usage *= 1.2), as scientists need more energy in the future for their research.
  • If the era is past, and there are fewer than 4 travelers, the power usage is decreased by 40% (power_usage *= 0.6), making it easier to travel to the past with fewer people.
    • If the travelers are historians, an additional 10% reduction is applied (power_usage *= 0.9), as historians need less power.
  • If the era is distant past, and there are fewer than 3 travelers, the power usage is reduced by 50% (power_usage *= 0.5).
    • The program also checks if the role is artifacts, if valid, it adds a 10% increase for carrying artifacts (power_usage *= 1.1).
• After that, the program checks if there are more than 5 travelers.
  • If yes, it adds 30% more power usage (power_usage *= 1.3), as more people require more energy.
  • Then, if the role of the travelers is vips, an additional 15% increase is applied to the power usage (power_usage *= 1.15), because VIPs require extra resources for their luxury.
• Finally, the program calculates the percentage change in power usage by subtracting the initial value (100) from the updated value of power usage. This percentage shows how much more or less power is needed for the trip.
• The result is printed, showing how much more or less power is consumed, formatted to two decimal places.

era = input("Enter the era (future/past/distant past): ")
travelers = int(input("Enter the number of travelers: "))
role = input("Are the travelers scientists/historians/vips/none? ")

power_usage = 100  # Base power usage

if era == "future":
    if travelers >= 3:
        power_usage *= 1.7  # 70% more for future with 3+ travelers
        if role == "scientists":
            power_usage *= 1.2  # Additional 20% for scientists
elif era == "past":
    if travelers < 4:
        power_usage *= 0.6  # 40% less for past with fewer than 4 travelers
        if role == "historians":
            power_usage *= 0.9  # Additional 10% decrease for historians
elif era == "distant past":
    if travelers < 3:
        power_usage *= 0.5  # 50% less for distant past with fewer than 3 travelers
        if role == "artifacts":
            power_usage *= 1.1  # Additional 10% for carrying artifacts

if travelers > 5:
    power_usage *= 1.3  # 30% more for more than 5 travelers
    if role == "vips":
        power_usage *= 1.15  # Additional 15% for VIPs

percentage_change = power_usage - 100
print(f"Power consumption: {percentage_change:.2f}% more")

Explanation:

Explanation:
The program provides a fruit recommendation based on the user’s taste, texture, and calorie preference.

• The program begins by asking for the user’s taste preference (taste = input("Enter your taste preference (sweet/sour): ")), texture preference (texture = input("Enter your texture preference (soft/crunchy): ")), and whether they are looking for low-calorie options (low_calorie = input("Are you looking for low-calorie options? (yes/no): ")).
• The program then checks if the taste is “sweet” (if taste == "sweet":).
• If it is, the program checks the texture preference (if texture == "soft":).
  • If the texture is soft, it checks if the user wants low-calorie options (if low_calorie == "yes":).
    • If the answer is “yes”, the program suggests Watermelon with 30 calories.
    • If the answer is “no”, it suggests Mango with 100 calories.
  • If the texture is crunchy, the program suggests Apple with 52 calories.
• If the taste is “sour” (elif taste == "sour":), the program again checks the texture.
  • If the texture is soft, it suggests Kiwi with 42 calories.
  • If the texture is crunchy, the program checks if the user is looking for low-calorie options again.
    • If “yes”, it recommends Green Apple with 50 calories.
    • If “no”, it suggests Pineapple with 82 calories.
• Finally, the program prints the recommended fruit and the calories of the selected fruit.

taste = input("Enter your taste preference (sweet/sour): ")
texture = input("Enter your texture preference (soft/crunchy): ")
low_calorie = input("Are you looking for low-calorie options? (yes/no): ")

if taste == "sweet":
    if texture == "soft":
        if low_calorie == "yes":
            fruit = "Watermelon"
            calories = 30
        else:
            fruit = "Mango"
            calories = 100
    elif texture == "crunchy":
        fruit = "Apple"
        calories = 52
elif taste == "sour":
    if texture == "soft":
        fruit = "Kiwi"
        calories = 42
    elif texture == "crunchy":
        if low_calorie == "yes":
            fruit = "Green Apple"
            calories = 50
        else:
            fruit = "Pineapple"
            calories = 82

print(f"Recommended Fruit: {fruit}")
print(f"Calories: {calories}")