DEV Community: ElianeS

Brazilian Social Security Benefits - linear search

ElianeS — Fri, 03 Jun 2022 12:59:48 +0000

There are a great deal of benefits provided by the Brazilian Social Security Agency. Each of them has its own set of requirements that it's challenging finding out whether one is entitled to it.
Regardless one's knowledge about legal affairs related to this matter, most people in Brazil have a common sense about these benefits.
In order to help to figure out if one has the right to a given benefit, the program, written in Python3, intends to be a straightforward way to learn about its legal requirements.
For instance: if the user wants to learn what the requirements are to get a retirement pension ('aposentadoria' in Portuguese), all that one should do is typing few letters such as "apo".

After confirming, the user can see all the eight(!) types of retirement pensions available and criteria that should be met.

Hash Map algorithm

I chose a Hash Map data structure to organize the information about the benefits.

A map relates two pieces of information where the inputs (called keys) have a single output (called value) only. There can't be more than one value per key.

In order to keep track of values (=requirements) in memory, an array was created, so each benefit (key) was given an index in the array by using a hashing function.

First of all, a Hash Map class¹ was created to implement an array. Then, two methods to find out the indices (hash and compressor) and another one to assign the key-value pair to an index (assign) were implemented like so:

class HashMap:
    def __init__(self, array_size):
        self.array_size = array_size
        self.array = [None for item in range(array_size)]

    def hash(self, key,count_collisions=0):
        key_bytes = key.encode()
        hash_code = sum(key_bytes)
        return hash_code + count_collisions

    def compressor(self, hash_code):
        return hash_code % self.array_size

    def assign(self, key, value):
        array_index = self.compressor(self.hash(key))
        current_array_value = self.array[array_index]
        if current_array_value is None:
            self.array[array_index] = [key, value]
            return
        if current_array_value[0] == key:
            self.array[array_index] = [key, value]
            return
        number_collisions = 1
        while (current_array_value[0] != key):
            new_hash_code = self.hash(key, number_collisions)
            new_array_index = self.compressor(new_hash_code)
            current_array_value = self.array[new_array_index]
            if current_array_value is None:
                self.array[new_array_index] = [key, value]
                return
            if current_array_value[0] == key:
                self.array[new_array_index] = [key, value]
                return

            number_collisions += 1
        return

Linear Search

Linear Searchis an algorithm used to locate and retrieve information from a list by scanning every item sequentially. If the target is found, the search stops and returns the position (index) in the list where the target value is located. Otherwise, it returns a message that the target is not in the list.

Here is the way the algorithm was implemented:

def linear_search(lista):
    matches = []
    data = []
    while True:
        target_chunk = input("  Digite as iniciais do benefício a pesquisar e pressione <enter>. \n  Sua escolha: ")
        for key, value in lista:
            if (target_chunk in key) or (target_chunk in value.values()):
                matches.append(key)
                data.append(value)
        if len(matches) == 0:
            raise ValueError(f"  Nenhum tópico com as letras {target_chunk} foi encontrado.")
        else:
            break

After the user typed the letters, the program checks whether these letters are part of the benefit's name. If there's a match, the corresponding key is added to a list called matches whereas its value is appended to another list called data.

The program runs recursively until there's only one type of benefit in the matches list.

 if len(matches) > 1:
        print(f"  Com essas letras, as opções são: {matches}")
        linear_search(lista)
    else:
        print(f"  A opção disponível com essas letras é {matches[0]}. Você quer consultar {matches[0]}?"
              f" Digite 'S' para sim.")
        answer = input("  Sua escolha: ")
        if answer == "S":
            os.system("clear")
            print(f"\n  Estes são os dados do benefício escolhido: {matches[0]}")
            if type(list(data[0].values())[0]) is not str:
                for beneficio, item in data[0].items():
                    print("\n ", beneficio.upper())
                    for dado, valor in item.items():
                        print(f"  - {dado}: {valor}")
            else:
                print("\n ", matches[0].upper())
                for dado, valor in data[0].items():
                    print(f"  - {dado}: {valor}")

Finally, the program retrieves the data stored in the data list where beneficio is the key and item is the value.

Main

Putting everything together:

def main():
    os.system('clear')
    welcome_message = "Plano de benefícios da Previdência Social"
    print("\n  " + ((len(welcome_message) + 40) * '=') + '\n  ' + (len(welcome_message) + 40) * '=' + "\n")
    print(("  " + " " * 20) + f"{welcome_message:20}")
    print("\n  " + ((len(welcome_message) + 40) * '=') + '\n  ' + (len(welcome_message) + 40) * '=' + "\n")
    try:
        linear_search(plano_HM.array)
    except ValueError as error_message:
        print("{}".format(error_message))
        linear_search(plano_HM.array)
    while True:
        print()
        again = input("  Gostaria de realizar nova pesquisa? Digite 'S' para sim ou qualquer tecla para sair.\n"
                      '  Sua escolha: ')
        if again == "S":
            os.system("clear")
            linear_search(plano_HM.array)
        else:
            print("  Até a próxima!")
            break
    os.system('exit')

Check it out: video, GitHub

The code was borrowed from Codecademy. ↩

Mortgage Calculator to help determining financial suitability with Python: an OOP approach

ElianeS — Sat, 30 Oct 2021 14:07:00 +0000

Introduction

If one is willing to buy a home, land, or other type of real estate without paying the entire price upfront, may have considered borrowing some money from a bank or other institution.

Mortgage is a type of loan to raise funds to purchase real estate. Sometimes, property's owners may use a mortgage to raise funds as well. The borrower grants the real estate as collateral to ensure that the loan will be paid.

One of the consequences of defaulting on the mortgage for the borrower is losing the property. On the other hand, the lender must follow a procedure in order to seize and sell the property to recoup the debt.

That said, it's crucial for lenders and borrowers assessing the financial suitability of the mortgage program beforehand. A potential borrower can check which property's value he or she can afford and test different terms and interest rates. Lenders can check whether a plan is feasible.

Despite the fact there are several types of mortgage, a loan is satisfied by paying to zero balance over the course of the loan term. Regular payments are divided into principal and interest charged and may include others costs like taxes, fees, and insurance.

The program

One way to implement this calculator is by using classes, which allows splitting the program into 'zones' with some code and data in order to create several objects using the same template.

This is a basic terminal program written with Python that uses fixed-rate mortgage to estimate monthly payments and loan's term, the major variables in a mortgage calculation, along loan's principal and interest rate.

Off the bat, principal and yearly interest rate are provided by the user and stored as attributes of the class Mortgage, since they remain the same for both monthly amount calculus and term calculus.

class Mortgage:
    def __init__(self):
        self.principal = pyip.inputFloat("Type loan's principal: ")
        self.interest_rate = pyip.inputFloat("Type yearly interest rate: ")
        self.interest_rate = self.interest_rate / 100 / 12  # yearly percentage rate divided by 12

The methods defined inside the class Mortgage are in charge of the calculus involved and will be run according to the user option: calculating monthly payment over a provided yearly term or estimating how long it would take to have the loan paid off in full for a given monthly payment.

 def monthly_amount(self):
        self.yearly_term = pyip.inputInt("Type yearly term: ")
        self.yearly_term *= 12 #number of monthly payments
        payment = ((self.interest_rate * self.principal) / ((1 - ((1 + (self.interest_rate)) ** (-self.yearly_term)))))
        return f'Monthly amount payment for ${self.principal:6.2f} in {self.yearly_term} months: ${payment:6.2f}'

    def term(self):
        self.payment = pyip.inputFloat("Type the monthly amount: $")
        term = 0
        balance = self.principal
        while balance > 0:
            balance = balance + (self.interest_rate * balance) - self.payment
            term += 1
        return f"The loan's principal ${self.principal} would take {term} months to be paid."

At the end of the script, an instance of the class is created and a menu is prompted:

mortgage = Mortgage()
print("Choose '1' for monthly amount, '2' for loan's term(years), or '3' to exit.")
choice = pyip.inputMenu(choices=['monthly amount', "loan's term", "quit"], numbered=True)
print('Your choice:', choice)
if choice == 'monthly amount':
    print('=' * (len(mes) + 10))
    print(mortgage.monthly_amount())
    print('=' * (len(mes) + 10))
elif choice == "loan's term":
    print('=' * (len(mes) + 10))
    print(mortgage.term())
    print('=' * (len(mes) + 10))

The module pyinputplus, imported at the beginning of the script as pyip, was used for input validation.

When the script is run in the terminal, the result on the screen will be as such:

A link to the code on GitHub:
https://github.com/ElianeSato/CS_101