Legal Age Checker: Identify Adults And Minors

by SLV Team 46 views

Hey guys! Today, let's dive into a super practical problem: figuring out whether someone is of legal age (aka an adult) or still a minor based on their age. This is a common task in programming, and we're going to break down how to do it step by step.

Understanding the Problem

At its core, this problem is straightforward. We need to take a person's age as input and then check if that age is greater than or equal to 18 (since 18 is the legal age in many places). If it is, we mark them as an adult; otherwise, they're a minor. Simple enough, right? But let's get into the nitty-gritty.

The main goal here is to process a series of ages, determine whether each person is of legal age, and then output the result. We'll use a loop to iterate through a set number of people (in this case, 75) and check each individual's age.

Keywords: legal age, minor, age verification, adult, programming logic. This process helps in scenarios where age verification is essential, such as accessing restricted content, participating in certain activities, or any situation where legal rights and responsibilities differ based on age.

Code Explanation

Let's walk through the code snippet provided and understand what each part does.

Variable Declaration

VAR
idade, contador:inteiro

Here, we're declaring two integer variables: idade (age) and contador (counter). The idade variable will store the age of each person we're checking, and the contador variable will keep track of the number of people we've processed so far. Think of contador as our little helper, making sure we go through all 75 people.

Looping Through People

Para contador de 1 até 75 faca

This line starts a loop that will run 75 times. In each iteration, the contador variable will increase by one, starting from 1 and going up to 75. This loop allows us to process 75 different people and check their ages.

Getting Input

Escreva ("digite a idade da pessoa ",contador,":")
leia(idade)

Inside the loop, we first display a message asking for the age of the person. The Escreva command (which means "write" in Portuguese) prints a message to the console, prompting the user to enter the age. The message also includes the current value of contador, so we know which person's age we're entering. Then, the leia(idade) command (which means "read" in Portuguese) reads the age entered by the user and stores it in the idade variable.

Checking the Age

Se (idade >=18) ENTAO
Escreval ("Passei, contador ":maior "idade")
senao
Escreval (pessoa, contador,"maioridade")

This is where the magic happens! We use an if statement to check if the age stored in the idade variable is greater than or equal to 18. If it is, we execute the code inside the ENTAO (then) block. If it's not, we execute the code inside the senao (else) block.

  • If the age is 18 or greater: We print a message indicating that the person is of legal age. The Escreval command (which means "write line" in Portuguese) prints a message to the console. The message includes the value of contador and indicates that this person is an adult.
  • If the age is less than 18: We print a message indicating that the person is a minor. Again, the Escreval command prints a message to the console, including the value of contador and indicating that this person is a minor.

Keywords: loop, if statement, variable declaration, user input, age comparison. Understanding these code components is essential for building robust and accurate age verification systems.

Enhancements and Error Handling

While the basic code works, there are several ways we can enhance it to make it more robust and user-friendly.

Input Validation

Right now, the code assumes that the user will always enter a valid integer for the age. But what if the user enters something that's not an integer, like a letter or a symbol? This could cause the program to crash or produce incorrect results. To prevent this, we can add input validation to ensure that the user enters a valid integer.

Here's how we can do it:

  1. Check if the input is an integer: Before reading the input into the idade variable, we can use a function to check if the input is a valid integer. If it's not, we can display an error message and ask the user to enter the age again.
  2. Check if the age is within a reasonable range: Even if the input is an integer, it might not be a valid age. For example, someone might enter a negative number or a very large number. We can add a check to ensure that the age is within a reasonable range (e.g., between 0 and 120). If it's not, we can display an error message and ask the user to enter the age again.

Better Output Messages

The current output messages are pretty basic. We can make them more informative and user-friendly by including more details about the person.

For example, instead of just saying "Person X is of legal age," we could say "Person X, who is Y years old, is of legal age." This gives the user more context and makes the output easier to understand.

Using Functions

As the code gets more complex, it can be helpful to break it down into smaller, more manageable functions. For example, we can create a function that takes an age as input and returns whether the person is of legal age or not.

This makes the code more modular and easier to test. It also allows us to reuse the same logic in multiple places without having to duplicate code.

Keywords: input validation, error handling, functions, code modularity, robust code. Implementing these enhancements ensures that the age verification system is reliable and user-friendly.

Complete Example with Enhancements

Here's a more complete example that includes input validation, better output messages, and the use of functions.

def is_of_legal_age(age):
    return age >= 18

def get_valid_age(person_number):
    while True:
        try:
            age = int(input(f"Enter the age of person {person_number}: "))
            if 0 <= age <= 120:
                return age
            else:
                print("Invalid age. Please enter an age between 0 and 120.")
        except ValueError:
            print("Invalid input. Please enter a valid integer for the age.")


for contador in range(1, 76):
    idade = get_valid_age(contador)
    if is_of_legal_age(idade):
        print(f"Person {contador}, who is {idade} years old, is of legal age.")
    else:
        print(f"Person {contador}, who is {idade} years old, is a minor.")

In this example:

  • We define a function is_of_legal_age that checks if an age is greater than or equal to 18.
  • We define a function get_valid_age that prompts the user to enter an age and validates the input.
  • We use a loop to process 75 people, get their ages using the get_valid_age function, and then check if they are of legal age using the is_of_legal_age function.
  • We print informative messages indicating whether each person is of legal age or a minor.

This example demonstrates how to write more robust and user-friendly code by adding input validation, using functions, and providing better output messages.

Keywords: Python example, age verification system, complete code, user-friendly code, robust application. This comprehensive example provides a clear and practical demonstration of how to build an effective age verification system.

Real-World Applications

Checking whether someone is of legal age has tons of real-world applications. Here are a few examples:

  • Accessing age-restricted content online: Many websites and online services require users to be of legal age to access certain content, such as alcohol-related information or adult content. By checking the user's age, these websites can ensure that they are complying with the law.
  • Purchasing age-restricted products: Retailers need to verify that customers are of legal age before selling them age-restricted products like alcohol, tobacco, or lottery tickets. This can be done by checking the customer's ID or using age verification software.
  • Participating in certain activities: Some activities, like gambling or driving, require participants to be of legal age. Organizations that offer these activities need to verify the age of participants to ensure that they are eligible.
  • Signing contracts: In many jurisdictions, minors are not allowed to enter into legally binding contracts. Therefore, businesses need to verify that their customers are of legal age before they can sign a contract.

Keywords: age-restricted content, online services, age verification, legal compliance, real-world applications. Understanding these applications highlights the importance of accurate and reliable age verification systems.

Conclusion

So, there you have it! We've covered how to check if someone is of legal age using programming logic. We've looked at the basic code, enhancements, and real-world applications. Whether you're building a website, an app, or any other type of software, this is a handy skill to have. Keep practicing, and you'll become a pro in no time! Remember to focus on creating high-quality content and providing value to your readers, and you'll be golden. Cheers, and happy coding!

Keywords: programming logic, age verification, coding skills, software development, conclusion. This comprehensive guide provides a solid foundation for understanding and implementing age verification in various applications.