Arithmetic operators

This task builds your understanding of basic arithmetic operations like multiplication and addition using float values. You’ll learn to apply percentages in calculations and practice rounding results for display. It’s also a good opportunity to explore input/output and variable usage in a financial context where precision matters.

• Use input() to get the price and convert it to float
• Calculate tax using price * 0.07
• Add the tax to the original price
• Use round() to format the final result

1. Forgetting to convert input: The value returned by input() is a string. Use float() before calculations.
2. Incorrect rounding: Not using round() can result in long decimal outputs. Always round money values.
3. Using wrong tax formula: Some beginners multiply the price by 0.07 and forget to add it back to the base price.
4. Mixing data types: Be cautious not to mix strings and numbers in print statements without proper formatting.
5. Wrong order of operations: Without parentheses, calculations may not follow the intended order. Use brackets to clarify logic.

To solve this problem, think about how you would calculate tax in real life: first you find the tax, then you add it to the original price.

• Ask the user to enter a base price
• Convert that input into a float number
• Calculate the tax by multiplying the base price by 0.07
• Add the tax to the original price
• Round the total price to 2 decimal places
• Display the result with an informative message

• Ask for the tax rate as a second user input
• Support input of multiple item prices and show total with tax
• Show both tax amount and final price separately

This exercise helps reinforce your understanding of division and modulo operations. You’ll practice distinguishing between float division and integer remainders, which are key for problems like even/odd checks, pagination, or grouping. You’ll also build experience with formatted output and simple validation concepts.

• Use int(input()) for both numbers
• Use / for the division and % for the remainder
• Display both results clearly in your output
• Try dividing numbers where the remainder is not zero

1. Forgetting integer conversion: Input values are strings—convert them to int to perform division.
2. Dividing by zero: Always check that the second number is not zero before performing division to avoid ZeroDivisionError.
3. Confusing / with //: / returns a float, while // returns an integer quotient. This task uses /.
4. Mislabeling outputs: Clearly distinguish between quotient and remainder in your print statements to avoid confusion.
5. Using int for remainder: Remember that % returns an integer even if you divide two floats.

Think about how division works in school: you calculate how many full times one number fits into another, then what’s left over.

• Prompt the user to input two integer numbers
• Use / to get the division result as a float
• Use % to calculate the remainder
• Store both results in variables
• Print both the quotient and the remainder with clear labeling

• Check if the first number is evenly divisible by the second
• Repeat the process for multiple pairs using a loop
• Handle cases where the second number is zero with error messages

This task strengthens your understanding of percent-based arithmetic, float operations, and using parentheses to ensure operator precedence. You’ll also reinforce good habits like rounding and formatted output for real-world calculations. The scenario helps you model retail logic and practice combining inputs in formulas.

• Convert both inputs to float
• Discount formula: total - (total * discount / 100)
• Use round() to display 2 decimal places
• Use descriptive variable names

1. Incorrect discount formula: Ensure you're subtracting the calculated discount from the total, not just applying percentage directly.
2. Type mismatch: Be careful to convert string input to float before performing math operations, or you’ll get errors.
3. Forgetting parentheses: Omitting parentheses in expressions may lead to incorrect order of operations and wrong results.
4. Rounding too early: Don’t round intermediate values—only the final output should be rounded for display.
5. Hardcoded percentages: Always calculate based on user input instead of writing 10% directly.

Imagine this task as calculating the total you’d pay after applying a discount in a store. Think through the percentage calculation logically.

• Prompt the user to input the original total price
• Prompt the user to input the discount percentage
• Convert both inputs to float
• Calculate the discount amount using the correct formula
• Subtract that from the total
• Round the final amount and print a clear message

• Ask the user to enter prices of multiple items and compute total
• Add a minimum threshold before applying the discount
• Format the output as currency with ${}

This exercise helps you build logic around multi-step arithmetic operations and percentage calculations. You’ll use addition, subtraction, and division together with meaningful variable names to model a real-life financial scenario. It also gives you practice in structuring clear output that includes both totals and ratios.

• Prompt the user for all values and convert to float
• Add all expenses together first
• Subtract total expenses from income
• Use (expenses / income) * 100 to find the percentage spent
• Use round() for readable output

1. Not grouping expenses correctly: Forgetting to sum all categories can give misleading results. Always total expenses before using them in calculations.
2. Forgetting to convert inputs: You need to convert all string inputs to float or Python will raise an error during arithmetic.
3. Incorrect percentage logic: Ensure you divide total expenses by income, then multiply by 100—not the other way around.
4. Rounding percentage too early: Always do rounding after completing all calculations to avoid precision loss.
5. Division by zero: Validate that income is not zero to avoid runtime errors when calculating the percentage.

Budgeting is all about tracking what you earn vs. what you spend. Think in terms of totals and balance left at the end of the month.

• Ask the user for monthly income and each expense category
• Convert each input to a float
• Sum all expenses together
• Subtract total expenses from income to get balance
• Calculate percent of income spent
• Print results with clear labels and rounded values

• Add savings as a fixed percentage before calculating leftover money
• Display budget categories as a percentage of total income
• Export results to a formatted string summary

This task demonstrates how to chain arithmetic operations for financial modeling, work with user-defined percentages, and apply compound calculations. You will practice handling decimal precision, structuring logical flow, and using nested arithmetic. This is especially useful for apps that deal with currencies, fees, or commissions.

• Prompt the user for amount and conversion rate, then convert to float
• Apply the rate using amount * rate
• Calculate fee as converted_amount * 0.025
• Use round() for currency formatting
• Show both results clearly with labels

1. Forgetting to subtract the fee: Beginners may only calculate the fee and forget to subtract it from the converted total, resulting in misleading output.
2. Incorrect fee calculation: The fee must be based on the converted amount, not the original input.
3. Over-rounding: Rounding every step can distort accuracy—round only at the final output stage.
4. Mixing rate direction: Be sure the rate provided converts USD to the target currency, not the reverse.
5. Unclear variable names: Always use descriptive names like converted_amount and fee to maintain clarity.

In currency exchange, you first convert, then apply fees. Structure your logic in this order to reflect real-world workflows.

• Prompt user for USD amount and conversion rate
• Convert both to float
• Calculate converted value: usd * rate
• Calculate the fee from the converted amount
• Subtract the fee to get the final amount
• Round and display both values with labels

• Let the user choose the fee percentage
• Add an option for reverse conversion (e.g., EUR to USD)
• Display amounts in both currencies with timestamp and formatting

This challenge teaches you to combine conditional logic with arithmetic operations to model real-world systems like tiered billing. You’ll learn to build step-by-step pricing models and correctly apply rates based on usage brackets. It also deepens your understanding of readable control flow, scalability, and edge case handling.

• Use if, elif, and else statements to check how much power was used
• Start from the top tier and calculate backwards to avoid repetition
• Convert input to float to support decimal usage
• Use cumulative logic: subtract what's already been billed in the previous tiers

1. Applying wrong rates: Ensure that you're only applying the $0.20 rate to units above 300—not to the entire usage.
2. Skipping conditional branches: Missing or misplacing elif can lead to multiple blocks running when only one should.
3. Incorrect tier boundaries: Be precise with where one pricing tier ends and the next begins. Edge values (like 100 or 300) must be handled carefully.
4. Hardcoding totals: Avoid repeating the same logic; use subtraction and cumulative sum techniques instead.
5. Missing type conversion: Always convert input() to float before calculations, or your logic will fail.

Billing with tiers is like stacking charges in layers. You must calculate each layer’s cost only for the units that fall within that layer.

• Prompt the user for total kWh used
• Convert the input to float
• Check which tier the usage falls into
• If usage is over 300, split into 3 parts: first 100, next 200, rest
• Multiply each part by its respective rate
• Sum all three parts and print the total bill

• Allow the user to define custom rate tiers
• Track usage over multiple months and show averages
• Visualize the result using stars or bars per tier