Boolean

This task introduces conditional logic based on user input. It reinforces how to take an integer from the user, compare it with a threshold, and make decisions based on Boolean outcomes. You’ll practice using the if statement and see how expressions like age >= 18 return a Boolean that determines which branch of logic executes. This is a foundation for real-world logic like validating forms or controlling access.

• Use input() and cast the value to int.
• Use >= to check if the person is 18 or older.
• Use a basic if...else statement to handle the outcome.

1. Forgetting to convert input to integer: input() returns a string. If you compare a string with an integer, you'll get unexpected results or an error.
2. Using the wrong operator: Beginners sometimes confuse = (assignment) with == (comparison). To check if values are equal, always use ==.
3. Misplacing else: Python relies on indentation. Make sure the else line aligns with the if block correctly.
4. Incorrect message logic: Double-check that the printed message corresponds to the correct condition branch.
5. Testing only one case: Try the program with both underage and eligible ages to validate both paths.

This problem simulates a rule-checking system. Think of it like the logic behind online forms that decide whether you can proceed or not.

1. Ask the user to input their age
2. Convert the input from string to integer
3. Write a Boolean condition to check if age is 18 or more
4. Use an if...else block to decide what to display
5. Print an appropriate message based on the condition

• Ask the user to input their country and apply a different minimum age per region
• Allow the user to re-enter the age if they input a negative number
• Wrap the logic in a function that returns True or False

This task trains you to compare two string values using Boolean equality and implement conditional branching based on the result. It simulates a common UI pattern used in signup forms and authentication flows. You’ll practice user input, string comparison, and using if logic to handle matching versus mismatching scenarios, which is essential for validating user data reliably.

• Use input() twice to collect both entries
• Compare them with the equality operator ==
• Use if...else to check if they are the same or not

1. Not accounting for whitespace: If the user adds a space at the end or beginning, the comparison will fail. Use .strip() to clean input if necessary.
2. Using assignment instead of comparison: = is not the same as ==. Beginners often confuse these in conditional statements.
3. Printing incorrect feedback: Make sure the message aligns with the result of the comparison.
4. Case sensitivity: Passwords like “Secret” and “secret” are different. Mention that if needed.
5. Only printing if they match: Handle both branches (match and mismatch) for clarity.

This kind of logic is used in web forms and applications to check that user inputs match expected values.

1. Ask the user to enter a password and store it
2. Ask the user to repeat the password
3. Compare the two values using ==
4. If they match, print a success message
5. If they don’t, print an error message

• Make the comparison case-insensitive using .lower()
• Count how many times the user failed to match and limit retries
• Use a regular expression to validate password strength (min 8 chars, digits, etc.)

This task shows how to build compound Boolean expressions using or and how different types of input (strings and integers) can be evaluated in a single logical condition. You'll learn to handle user responses, convert types appropriately, and logically connect different branches of a decision-making process - something that frequently occurs in form validation, permissions systems, and user workflows.

• Use input() twice to ask both questions
• Compare the response to the string "yes" using ==
• Convert age input to an integer before comparison
• Combine the conditions using the or operator

1. Using incorrect logic operator: Make sure to use or (not and) since either condition is enough for access.
2. String input misinterpretation: Check for exact string match - "Yes" is not the same as "yes". Use .lower() if needed.
3. Forgetting to convert age to integer: Comparing a string to an integer will fail. Always cast with int().
4. Incorrect block structure: If you don't use parentheses properly, the logic might not behave as expected due to operator precedence.
5. Testing only one path: Validate both "student" and "age over 60" cases independently to confirm logic works for either.

This logic mimics a real-world security system. You're gathering two independent facts and using a rule to decide access.

1. Ask the user: "Are you a student?"
2. Ask the user: "How old are you?"
3. Convert the age to an integer
4. Evaluate: student answer is "yes" OR age is above 60
5. Print the appropriate message based on the result

• Also deny access if the user is under 10, regardless of student status
• Allow access only between 9:00 and 17:00 (simulate with a time variable)
• Use a dictionary to store access rules per category (student, adult, senior)

This task reinforces your understanding of the and operator and how multiple Boolean conditions must be satisfied simultaneously. It reflects real-world login logic where both a valid username and correct password are required. You'll learn how Boolean logic ties into authentication, secure access, and rule-based decision making that must pass several checks before proceeding.

• Use input() twice to collect both values
• Compare each to a known value using ==
• Use and to combine both comparisons in one if statement
• Make sure to use exact case when matching strings

1. Using or instead of and: This would allow a login even if only the username or password matches - a major logic flaw in real systems.
2. Wrong string comparison: Be sure to match the values exactly. "Admin" ≠ "admin". Case matters unless handled explicitly.
3. Skipping braces or indentation: Python’s syntax relies heavily on proper indentation. Without it, your logic will break or behave unpredictably.
4. Incorrect placement of print() statements: Ensure the success or failure message is placed within the correct condition block.
5. Hardcoding user input logic: Don’t forget to store the inputs in variables before comparison.

This exercise simulates login logic used in every authentication system - both inputs must meet criteria at the same time.

1. Prompt the user for username and store it
2. Prompt the user for password and store it
3. Compare both to known values using ==
4. Use and to ensure both are correct
5. Print success or failure depending on result

• Track the number of failed login attempts and lock out after 3 tries
• Ignore case in username using .lower()
• Store valid credentials in a dictionary and validate against them dynamically

This task simulates a compound business rule where multiple independent conditions must be evaluated with and and not. It emphasizes the precision required in logic chaining and introduces common patterns in e-commerce logic - such as mutually exclusive promotions. You’ll learn to interpret input, evaluate ranges and flags, and handle negations in Boolean conditions. This deepens your understanding of conditional architecture in larger applications.

• Make sure to normalize string inputs (e.g., .lower())
• Use float() to convert the purchase total input
• Apply and and not together carefully
• Group conditions in parentheses to avoid precedence issues

1. Incorrect use of not: Negating the wrong expression or not using parentheses can lead to inverted logic. Always check the condition you’re negating.
2. Improper type conversion: Be sure to convert user input to the correct type before comparison, especially for numeric thresholds like $100.
3. Misinterpreting user input: Ensure comparisons like answer == "yes" are case-sensitive unless you handle them with .lower().
4. Operator precedence confusion: Use parentheses around logical expressions when combining and and not to avoid unexpected outcomes.
5. Incomplete condition handling: Failing to test edge cases (like exactly $100, or "Yes" vs "yes") can cause inaccurate validation.

You’re implementing a rule engine that decides who qualifies for a discount. Think of each rule as a filter the user must pass through.

1. Ask if the user is registered (yes/no)
2. Ask for purchase total and convert it to float
3. Ask if it's a holiday sale period (yes/no)
4. Build a Boolean expression: user must be registered and purchase > 100 and it must not be a holiday
5. Display whether the user qualifies for the discount

• Store user data in a dictionary and verify registration by username
• Allow different discount tiers (e.g. over $200 gets 15%)
• Add logic to stack coupons only if approved by an admin flag

This task challenges your ability to aggregate Boolean values and count conditions. It simulates a real-world control system where the logic isn't about a single condition but evaluating the state of a group. You’ll practice conditional grouping, tallying failures, and returning status based on dynamic thresholds - a common pattern in monitoring, diagnostics, and control logic for both software and hardware systems.

• Convert user inputs like "true" or "false" into actual Booleans
• Use a counter to tally how many sensors returned False
• Decide output based on how many faults were counted

1. Improper Boolean conversion: Treating the input as a string without converting will cause logical comparisons to fail. Always map string input to True or False.
2. Not counting correctly: Use a counter or list comprehension to evaluate how many sensors are faulty, rather than using a long chain of if statements.
3. Missing logic branches: Ensure your code handles all three possible outcomes (0, 1, or 2+ faults).
4. Using assignment instead of comparison: Always use == when checking values. = is for assigning, not testing.
5. Failing to normalize input: Capitalization or extra spaces may lead to incorrect matches. Use .strip().lower() when parsing input.

Think of this like a health check routine. You want to determine how bad the situation is by checking how many things went wrong.

1. Prompt the user for 3 sensor statuses ("true" or "false")
2. Convert those inputs into Boolean values
3. Count how many are False using a counter
4. Use conditional logic to determine the correct message to print

• Allow monitoring of more than three sensors (e.g. in a list)
• Store timestamps for when each sensor failed
• Trigger different levels of alerts (email, SMS) based on fault count