Numeric

This task teaches numeric input handling, float arithmetic, and using formulas in real-world situations. You'll also learn to output calculations in a user-friendly format with units and labels.

• Use input() and convert the value to float.
• Use parentheses to ensure the formula is calculated correctly.
• Add a degree symbol (°) to the output string for clarity.
• Use round() if the result has too many decimal places.

1. Using integer division: If you use // instead of /, you’ll lose the decimal part and get incorrect results. Always use / for floating-point division.
2. Forgetting type conversion: You must convert the input string to float before using it in arithmetic, otherwise Python will raise a TypeError.
3. Incorrect formula order: Skipping parentheses can lead to wrong results due to operator precedence. Always write it as (C × 9/5) + 32.
4. Unclear output formatting: Output like “32.0” is fine, but “32.0000001” looks messy. Use round() or format() for better presentation.
5. Not labeling units: Just printing “32” without context can confuse users. Include “°C” and “°F” in your messages.

You're building a converter tool that many people use daily. Think clearly about input, computation, and readable output.

1. Prompt the user to enter the temperature in Celsius
2. Convert that input to a float value
3. Apply the Fahrenheit formula: (C × 9/5) + 32
4. Format the result to 1 or 2 decimal places
5. Print a message that includes both Celsius and Fahrenheit values

• Let the user choose whether to convert from Celsius to Fahrenheit or vice versa.
• Allow repeated conversions in a loop until the user types "exit".
• Display warning messages for extremely high or low values.

This task strengthens your understanding of integer division (//) and modulo (%). You’ll also practice breaking down one number into multiple components and formatting the result into a human-readable sentence.

• Use // to get the number of full hours.
• Use % to get the remaining minutes.
• Convert the input to an integer before doing math.
• Handle the case where minutes are less than 60 or exactly divisible by 60.

1. Using float division instead of integer division: If you divide with /, you'll get decimal results like “2.25 hours”, which doesn’t match the expected format.
2. Not using modulo: Beginners often forget that % gives the remainder - it’s essential for calculating leftover minutes.
3. Input not converted: If you try to use math on the input string, you’ll get a TypeError. Always convert to int.
4. Unclear output formatting: Printing “2 15” isn’t useful. Make sure to label your output with “hours” and “minutes”.
5. Not handling edge cases: If the input is 0, your output should still be valid and understandable.

You're simulating a basic time calculator. Your program must divide total minutes into hour-sized chunks and show what’s left.

1. Ask the user to enter the total number of minutes
2. Convert the input to int
3. Calculate hours using // 60
4. Calculate leftover minutes using % 60
5. Print the result in the format: “X hours and Y minutes”

• Accept total time in seconds and convert to hours, minutes, and seconds.
• Support pluralization: “1 hour” vs. “2 hours”.
• Let the user choose output format: total minutes, HH:MM, or plain English.

This task strengthens your ability to work with floating-point numbers, use formulas, and provide user-friendly numerical output. You’ll also learn to combine math with logic by interpreting results into health categories using conditional statements.

• Convert user input using float()
• Use parentheses in the BMI formula to ensure correct order of operations
• Use round(bmi, 1) to format the result
• Compare the result to known BMI ranges (e.g., <18.5 is underweight)

1. Using int() instead of float(): Height values like 1.75 must be floats, not integers. Rounding down to int leads to inaccurate BMI results.
2. Incorrect use of parentheses: Missing parentheses in the denominator can result in calculating weight / height * height instead of squaring height.
3. No interpretation of result: Just printing a number doesn’t help the user. Add a message like “Your BMI is 22.4 – Normal weight.”
4. Division by zero: If height is 0 or empty, this will crash the program. Always validate input before dividing.
5. Too many decimals: Printing 17.8429429 makes the output less readable. Round it!

This is a formula-based task with interpretation. Follow it step by step and then add logic to turn a number into a helpful message.

1. Ask the user for weight in kilograms and convert to float
2. Ask for height in meters and convert to float
3. Use the formula weight / (height * height) to calculate BMI
4. Round the result to one decimal place
5. Use if / elif / else to categorize the result
6. Print a final message with the value and category

• Allow the user to enter weight in pounds and convert it to kg
• Use the decimal module for more precise rounding
• Suggest ideal weight range based on BMI 18.5–24.9

This task teaches how to use formulas in real-world settings, how to combine numeric values meaningfully, and how to handle input from multiple steps. You also gain practice formatting numeric output with precision and clarity.

• Convert all three inputs to float or int
• Use the formula exactly as written - don’t forget to divide by 1000 to get kWh
• Use round() to avoid long decimal outputs
• Label your final result clearly, including the unit (kWh)

1. Forgetting to divide by 1000: If you don’t convert from watt-hours to kilowatt-hours, your result will be 1000x too high.
2. Unlabeled units: Printing “5.4” without saying “kWh” is unclear. Always include units in technical results.
3. Not converting to numbers: User input via input() is a string - convert it or your math will fail.
4. Messy output: Numbers like 5.2345543244 kWh are hard to read. Format to one or two decimals for clarity.
5. Bad variable names: Using a, b, c instead of descriptive names makes your code harder to follow. Use names like watts, hours, days.

You’re simulating a basic calculator tool - follow each step and then refine the result into a user-friendly format.

1. Prompt the user to enter wattage of the device
2. Prompt for hours per day it runs
3. Prompt for number of days
4. Convert all values to float or int
5. Apply the formula: (watts × hours × days) / 1000
6. Round the result
7. Print the result with unit: “Total consumption: 6.5 kWh”

• Let the user enter cost per kWh and calculate total cost
• Handle multiple devices using a loop
• Allow switching between kWh and Wh output

This exercise teaches multi-variable arithmetic, exponentiation, and precise output formatting. It also exposes students to financial computation and using real-world formulas. You'll get familiar with translating mathematical notation into Python code.

• Convert percentage interest rate to decimal and then divide by 12
• Use ** for exponentiation
• Watch out for parentheses - they are critical in this formula
• Round the final monthly payment to 2 decimal places

1. Using wrong interest rate format: Don’t forget to divide the rate by 100 and then by 12. Using the full percentage directly leads to inflated results.
2. Missing parentheses: The formula has several nested operations. Skipping parentheses can lead to unexpected values, especially in exponentiation and division.
3. Incorrect number of months: Many people forget to multiply years by 12 when calculating total payments.
4. Floating-point precision issues: Use round() to avoid messy output like 523.441987653.
5. Hardcoding values for testing but forgetting to replace them: Always remove test values and use real input when finalizing the script.

Think like a financial advisor. You're building a tool that should accept details and compute results clearly and reliably.

1. Ask the user for loan amount, interest rate (as percentage), and term in years
2. Convert interest rate to monthly decimal format
3. Calculate total number of payments as term * 12
4. Apply the loan formula step by step
5. Round the monthly payment to two decimal places
6. Print a formatted message: “Your monthly payment is $___”

• Allow the user to calculate total paid over the life of the loan
• Include error handling if inputs are missing or non-numeric
• Accept multiple loans and compare payment results

This task helps you break a number into brackets, apply different formulas based on conditions, and compute results with multiple paths. It also includes calculating percentage rates - a key numeric skill.

• Use if, elif, else to separate tax brackets
• Only apply taxes to the amount over the bracket thresholds
• Use round() for the final tax and effective rate
• Test your logic with various income levels (below 10k, between 10–50k, above 50k)

1. Applying tax to the full income: Beginners often forget to tax only the portion above each threshold. Don’t apply 10% to the full income if it’s $45,000 - just the part over $10,000.
2. Incorrect bracket order: Check from top-down, or bottom-up consistently. Make sure your if conditions don’t overlap.
3. Wrong effective rate calculation: It must be (tax / income) × 100, not the other way around.
4. Division by zero: Always check that income isn’t zero before computing percentage.
5. Messy output formatting: Output like “tax=3292.33333333” is hard to read. Round and label your results clearly.

Simulate a tax advisor's brain: check each range, apply the correct logic, and combine the results.

1. Ask the user to enter their annual income
2. Check which bracket the income falls into
3. Apply 0% tax if under 10,000
4. If between 10,001–50,000, apply 10% to the income over 10,000
5. If over 50,000, apply 10% to 40,000 and 20% to income over 50,000
6. Sum the tax and calculate the effective rate as (tax / income) × 100
7. Round the results and print a clear summary

• Add more tax brackets (e.g., 30% above 100,000)
• Ask the user for marital status and apply different thresholds
• Provide a full breakdown of bracket-by-bracket taxation