TRABALHO LÓGICA DE PROGRAMAÇÃO E ALGORITMOS

Prévia do material em texto

CENTRO UNIVERSITÁRIO INTERNACIONAL UNINTER
ESCOLA SUPERIOR POLITÉCNICA
ANÁLISE E DESENVOLVIMENTO DE SISTEMAS
LÓGICA DE PROGRAMAÇÃO E ALGORITMOS
ATIVIDADE PRÁTICA
NOME ALUNO: GABRIEL PEREIRA DA FONSECA – RU: 3356131
NOME PROFESSOR: VINICIUS POZZOBON BORIN
CAXIAS DO SUL - RS
ANO DO PROJETO
2021
EXERCÍCIO 1:
Escreva um programa que leia o nome de um lutador e seu peso. Em seguida, informe a
categoria a que pertence o lutador, conforme a Tabela a seguir (note que a tabela foi criada
para efeito deste exercício e não condiz com qualquer categoria de luta). A saída do
programa deve exibir na tela uma frase com o padrão descrito a seguir: Nome fornecido:
Pepe Jordão Peso fornecido: 73.4 Frase a ser exibida: O lutador Pepe Jordão pesa 73,4 kg
e se enquadra na categoria Ligeiro.
Nome= str(input('NOME DO LUTADOR: ')).title()
Peso= int(input('PESO: '))
if Peso < 65:
print(f'O lutador {Nome} pesa {Peso}Kg e se enquadra na categoria PENA.')
elif 65 <= Peso < 72:
print(f'O lutador {Nome} pesa {Peso} e se enquadra na categoria LEVE.')
elif 72 <= Peso < 79:
print(f'O lutador {Nome} pesa {Peso} e se enquadra na categoria LIGEIRO.')
elif 79 <= Peso < 86:
print(f'O lutador {Nome} pesa {Peso} e se enquadra na categoria MEIO MÉDIO.')
elif 86 <= Peso < 93:
print(f'O lutador {Nome} pesa {Peso} e se enquadra na categoria MÉDIO.')
elif 93 <= Peso < 100:
print(f'O lutador {Nome} pesa {Peso} e se enquadra na categoria MÉDIO PESADO.')
else:
print(f'O lutador {Nome} pesa {Peso} e se enquadra na categoria PESADO.')
LINHA 1 : Comando input para aplicar o nome do lutador, definido como uma string e
imprimindo como um nome através do comando title.
LINHA 2 : Comando input para aplicar o peso do lutador, definido como um inteiro.
LINHA 3 a 12: Comando para impor uma condição. Caso o peso do lutador esteja dentro
das condições, ele imprimirá a mensagem informando a categoria de acordo com o peso
informado.
LINHA 13: Caso o lutador tenha mais de 100 kgs, ele imprimirá que sua categoria se
enquadra na dos pesados.
EXERCÍCIO 2:
Escreva um programa que receba como parâmetro de entrada um número inteiro de 5
dígitos no intervalo fechado [10000, 30000] que represente códigos de produtos vendidos
em uma loja. Crie uma função para validar os dados de entrada, obrigando o usuário a
respeitar o intervalo e o tipo de dado (inteiro). Crie uma função que calcule e retorne o dígito
verificador do código, utilizando a regra de cálculo explicada a seguir. Por exemplo,
considere o código 21853, em que cada dígito é multiplicado por um peso começando em 2,
os valores obtidos são somados, e do total obtido calcula-se o resto de sua divisão por 7.
numero= int(input('CÓDIGO DO PRODUTO: '))
n= str(numero)
peso= int(23456)
p= str(peso)
d1= (numero // 10000 % 10) * 2
d2= (numero // 1000 % 10) * 3
d3= (numero // 100 % 10) * 4
d4= (numero // 10 % 10) * 5
d5= (numero // 1 % 10) * 6
soma= d1 + d2 + d3 + d4 + d5
div= soma / 7
nroin= int(div * 10 % 10)
while numero > 50000 or numero < 30000 or numero == str(''):
numero = int(input('CÓDIGO DO PRODUTO:'))
if numero > 30000 or numero < 50000:
print(f'DIGITO {n[0]} {n[1]} {n[2]} {n[3]} {n[4]}')
print(f'PESO {p[0]} {p[1]} {p[2]} {p[3]} {p[4]}')
print(f'MULTIPLICAÇÃO {d1} {d2} {d3} {d4} {d5} ')
print(f' SOMA={soma} ')
print(f' RESTO DE {soma} por 7 = {nroin}')
print(f'{numero}-{nroin}')
LINHA 1 : comando para receber um número inteiro.
LINHA 2 : comando para tornar o inteiro recebido em string, possibilitando a manipulação da
variável e fazendo a impressão do número recebido separado em dígitos, mostrado na linha
16.
LINHA 3 : definido uma variável chamada ‘peso’ como um número inteiro.
LINHA 4 :comando para tornar o inteiro da variável peso em string, possibilitando a
manipulação e fazendo a impressão do número recebido separado em dígitos, mostrado na
linha 17.
LINHA 5 a 9: não existe comando para manipular inteiros no Python, nesse caso foi criado
variáveis para separar cada dígito do código recebido através de uma função, onde ela
divide o código de acordo com a sua posição no sistema decimal, por exemplo, o primeiro
dígito que faz parte da dezena de milhar, logo é feita a divisão por 10000, já o segundo
dígito faz parte da unidade de milhar, sendo divido por 1000 e assim sucessivamente até a
última unidade. A divisão ocorre com o comando // que divide o dividendo trazendo
somente o quociente inteiro e o seu resultado será dividido por 10 com o comando ‘%’,
resultando no resto da divisão que será cada dígito recebido na linha 1. No final da função,
o resultado será multiplicado por cada dígito correspondente da variável ‘peso’.
LINHA 10: variável criada para somar os resultados das multiplicações das variáveis dígito a
dígito.
LINHA 11: variável de divisão do resultado da soma.
LINHA 12: variável definida como inteiro para trazer como resultado, o primeiro número do
resto da divisão da linha 11.
LINHA 13: condição para receber entrada somente números do determinado intervalo, caso
não seja, o algoritmo irá solicitar novamente até atender o requisito.
LINHA 14: quando recebido um número dentro do intervalo requisitado, o programa irá
prosseguir para o resultado.
LINHA 15 a 21: comando para imprimir os dígitos do número recebido, dígitos do peso,
resultado da multiplicação, resultado da soma, resto da divisão e do número recebido com o
dígito verificador.
EXERCÍCIO 3
Considere o seguinte conjunto de dados: Nome + (N1, N2, N3, N4). Nome representa o
nome de um aluno e deve ser usado como chave. Já N1, N2, N3, N4 representam as notas
de provas desse aluno. Utilize uma estrutura de dicionário com listas para resolver este
exercício. Escreva um programa que leia os dados de N alunos e apresente na tela se
foram aprovados ou reprovados. O critério que garante a aprovação é que a média
aritmética das 4 notas seja maior ou igual 7,0. O valor de N é a quantidade de alunos, e
esse valor deve ser lido do teclado no começo do programa. Faça um laço de repetição
para a leitura destes N alunos. As notas devem ser exibidas ao final do programa com uma
casa decimal de precisão.
listas = list()
qtade = int(input('Quantidade de alunos avaliados: '))
while qtade <= 0:
qtade = int(input('Quantidade de alunos avaliados: '))
if qtade > 0:
for i in range(1, qtade + 1):
nome = (str(input(f'Nome do {i}º aluno: ')).title())
notas = [nome]
media = 0
for j in range(4):
n = float(input(f'Resultado da {j+1}ª nota: '))
media = media + n / 4
notas.append(n)
notas.append(media)
listas.append(notas)
print('Notas dos alunos:')
print('=-'*60)
print(f'{"Nome":<30}{"NOTA 1":<15}{"NOTA 2":<15}{"NOTA 3":<15}{"NOTA
4":<15}{"MÉDIA":<15}{"RESULTADO":<15}')
for i in range(qtade):
p = f'{listas[i][0]:<15}'
for q in range(1, 5):
n1 = f'{listas[i][1]:<15}'
n2 = f'{listas[i][2]:<15}'
n3 = f'{listas[i][3]:<15}'
n4 = f'{listas[i][4]:<15}'
d = f'{listas[i][5]:<15.1f}'
if listas[i][5] >= 7:
resultado = str('\033[1;32mAPROVADO\033[m')
else:
resultado = str('\033[31mREPROVADO\033[m')
print(f'{p:<30}{n1:<15}{n2:<15}{n3:<15}{n4:<15}{d:<15}{resultado:<15}')
LINHA 1: aplicado o comando de abertura de uma lista com a variável chamada ‘listas’.
LINHA 2: input solicitando a quantidade de alunos a serem avaliados.
LINHA 3 a 4: loop aplicado para quando a quantidade de alunos informada for menor ou
igual a zero, o algoritmo solicitará o input da linha 2.
LINHA 5 a 6: condição criada para quando a quantidade informada atender o requisito do
comando while, será executado um laço de repetição no intervalo de 1 a N (quantidade
aplicada na linha 2), aplicado soma de mais um intervalo para fechar a quantidade correta.
LINHA 7: input solicitando o nome dos alunos, dentro do intervalo. Comando title para
imprimir o nome com letra inicial maiúscula.
LINHA 8: criado outra lista chamada notas, aplicando dentro dela, os nomes dos alunos
recebidos.
LINHA 9: variável média criada, atribuindo o valor 0.
LINHA 10 a 11: criado laço derepetição no intervalo de 1 a 4, para que o algoritmo solicite
as 4 notas para cada aluno, variável n para receber as notas.
LINHA 12: função para cálculo da média das notas.
LINHA 13: comando aplicado para inserir as variáveis n dentro da lista ‘notas’.
LINHA 14: comando para aplicar a variável ‘media’ para dentro da lista ‘notas’
LINHA 15: comando para aplicar a lista ‘notas’ dentro da lista ‘listas’.
LINHA 16 e 17: imprime uma mensagem de informativo.
LINHA 18: formatado strings para um modelo de tabela são elas: nome, notas, média e
resultado final. O comando :<15 se refere como eles ficarão posicionados, < para a
esquerda e 15 sendo o limite de caracteres.
LINHA 19 a 20: laço de repetição definindo os nomes recebidos como uma variável p, o que
facilitará no momento da impressão dos resultados. Como o nome dentro da lista consta na
posição 0, para imprimi-la, é aplicado o comando listas[i][0].
LINHA 21 a 25: laço de repetição definindo as notas recebidas como variáveis de n1 a n4,
aplicando suas posições dentro das listas.
LINHA 26: definido uma variável ‘d’ como a posição da média dentro da lista.
LINHA 27: criado uma condição para quando a média for maior ou igual a 7.
LINHA 28: se a média for maior ou igual a 7, a variável resultado será igual a string
‘APROVADO’, configurado cor da fonte como verde.
LINHA 29 a 30: caso a média for menor, a variável resultado será igual a string
‘REPROVADO’, configurado cor da fonte como vermelho.
LINHA 31: impressão dos resultados, aplicando as variáveis sendo formatadas iguais as
strings impressas na linha 18, ficando no formato de tabela.
EXERCÍCIO 4:
Leia e armazene em um dicionário o nome, a idade e o número do telefone de seus
contatos, sendo que a chave deve ser o nome. Ao digitar uma string vazia para o nome, o
programa interrompe a leitura e se encerra. Apresente na tela os dados lidos em ordem
alfabética pelo nome dos contatos. Uma possível solução de ordenar alfabeticamente é usar
o método sort. Em seguida, armazene os contatos em outros dois dicionários, utilizando
como critério a idade: menores de 18 anos em um e os maiores em outro dicionário,
eliminando o original. Apresente na tela os dois dicionários resultantes da separação.
Imprima na tela um teste do seu programa usando como primeiro cadastro o seu nome,
como telefone o seu RU, e como idade os dois últimos dígitos do seu RU.
lista = []
dados = dict()
lista18 = []
lista_de_menor = []
dados['nome'] = str(input('Nome: ')).title()
while dados['nome'] != '':
dados['idade'] = int(input('Idade: '))
dados['telefone'] = int(input('Telefone: '))
lista.append(dados.copy())
dados['nome'] = str(input('Nome: ')).title()
ordenar = sorted(lista, key=lambda row: row['nome'])
print(f'\033[1;35m{"":<15}{"LISTA TELEFÔNICA"}\033[0;0m')
print('-=' * 25)
print('\033[1;35mGERAL\033[0;0m')
print(f'\033[34m{"NOME":<25}{"IDADE":<10}{"TELEFONE":<10}\033[0;0m')
for contatos in ordenar:
print(f'{contatos["nome"]:<25}{contatos["idade"]:<10}{contatos["telefone"]:<10}')
if contatos['idade'] >= 18:
lista18.append(contatos.copy())
if contatos['idade'] < 18:
lista_de_menor.append(contatos.copy())
print('-=' * 25)
print('\033[1;35mCONTATOS MAIORES DE IDADE\033[0;0m')
print(f'\033[34m{"NOME":<25}{"IDADE":<10}{"TELEFONE":<10}\033[0;0m')
for contatos1 in lista18:
print(f'{contatos1["nome"]:<25}{contatos1["idade"]:<10}{contatos1["telefone"]:<10}')
print('-=' * 25)
print('\033[1;35mCONTATOS MENORES DE IDADE\033[0;0m')
print(f'\033[34m{"NOME":<25}{"IDADE":<10}{"TELEFONE":<10}\033[0;0m')
for contatos1 in lista_de_menor:
print(f'{contatos1["nome"]:<25}{contatos1["idade"]:<10}{contatos1["telefone"]:<10}')
LINHA 1: criado uma variável chamada ‘lista’ sendo uma lista vazia.
LINHA 2: criado uma variável chamada ‘dados’ sendo um dicionário vazio.
LINHA 3: criado uma variável chamada ‘lista18’ sendo uma lista vazia, onde será
acondicionado os dados referentes aos contatos maiores de 18 anos.
LINHA 4: criado uma variável chamada ‘lista_de_menor’ sendo uma lista vazia, onde será
acondicionado os dados referentes aos contatos menores de 18 anos.
LINHA 5: definido a key ‘nome’ para o dicionário ‘dados’ e o value será o input que o usuário
inserir no programa, com o comando title, tornando a string com sua primeira letra em
maiúsculo.
LINHA 6: condição aplicada para o programa executar o restante dos inputs caso o input
recebido para o valor da key ‘nome’ seja diferente de uma string vazia.
LINHA 7: definido key ‘idade’ para o dicionário ‘dados’’ e o value será o input que o usuário
inserir no programa.
LINHA 8: definido key ‘telefone’ para o dicionário ‘dados’’ e o value será o input que o
usuário inserir no programa.
LINHA 9: comando para inserir o dicionário dentro da lista.
LINHA 10: início do ciclo novamente referente a linha 5.
LINHA 11: criado variável chamada ‘ordenar’, com função sorted para a lista, onde se
encontram os dicionários. Função lambda foi criada para definir uma função anônima para
ordenar a lista pela ordem alfabética, tomando referência pela key ‘nome’ presente na lista.
LINHA 12: print de cabeçalho para a impressão da lista.
LINHA 13: print de uma divisória da tabela.
LINHA 15: print das colunas nome, idade e telefone.
LINHA 16: comando for para um laço de repetição dentro da variável ‘ordenado’, no qual a
lista se encontra nesta variável e está ordenada alfabeticamente.
LINHA 17: print do nome, idade e telefone de todos contatos que estão dentro do dicionário,
de forma individual, para que seja feita uma formatação adequada.
LINHA 18 e 19 : condição aplicada para que caso os contatos que se encontram na lista
apresentarem a idade maior ou igual a 18 anos, ele irá adicionar este contato na lista
'lista18'.
LINHA 20 e 21: condição aplicada para que se os contatos que se encontram na lista,
apresentarem a idade menor que 18 anos, ele irá adicionar este contato na lista
‘lista_de_menor’.
LINHA 22: print de uma divisória para o código.
LINHA 23: print de uma string definindo um título para o trecho da lista onde se encontram
os contatos maiores de idade.
LINHA 24: print das colunas nome, idade e telefone.
LINHA 25: comando for para um laço de repetição no qual ele percorre todas as
informações dentro da lista ‘lista18’.
LINHA 26: print do nome, idade e telefone de todos contatos que estão dentro do dicionário,
na lista ‘lista18’, de forma individual, para que seja feita uma formatação adequada.
LINHA 27: print de uma divisória para o código.
LINHA 28: print de uma string definindo um título para o trecho da lista onde se encontram
os contatos menores de idade.
LINHA 29: print das colunas nome, idade e telefone.
LINHA 30: comando for para um laço de repetição no qual ele percorre todas as
informações dentro da lista ‘lista_de_menor’.
LINHA 31: print do nome, idade e telefone de todos contatos que estão dentro do dicionário,
na lista ‘lista_de_menor’, de forma individual, para que seja feita uma formatação adequada.