*Caso alguém se interesse em estudar algoritmos:

 
# Algoritmos – Lógica para desenvolvimento de programação
**Autores:**
José Augusto N. G. Manzano, Jayr Figueiredo de Oliveira
Segunda edição, Érica, 1996.
## Resumo  
(Escreva aqui um resumo do livro, tópicos principais, o que aprendeu)
algoritmo(pesquisa)
  nomes[1..10]=(abel, ziraldo, ..., cátia)
  i integer
  f integer
  
  f=length(nomes)
  leia input (pessoa)
  
  para i de 1 até f passo 1:
    se (pessoa==nomes[i]):
      imprima (i)
      #interrompe a busca
      captura ESC=TRUE
    fimse;
    
    se (ESC=TRUE):
      #interrompe a busca
      i=f+1
    fimse;
  fimpara;
fimalg;
*************************************
import keyboard  # biblioteca externa

nomes = ["abel", "bia", "joão", "cátia", "danilo", "edna", "fernando", "guilherme", "lucas", "ziraldo"]
pessoa = input("Digite o nome a buscar: ")

for i, nome in enumerate(nomes):
    if keyboard.is_pressed('esc'):
        print("Busca cancelada pelo usuário.")
        break

    if nome == pessoa:
        print(f"Nome encontrado na posição {i}")
        break

algoritmo pesquisa
  nomes ← [“abel”, “bia”, “joão”, ..., “ziraldo”]
  leia pessoa
  ESC ← FALSO

  para i de 1 até comprimento(nomes) faça
    se tecla_pressionada() = ESC então
      escreva "Busca cancelada pelo usuário"
      ESC ← VERDADEIRO
      pare
    fimse

    se nomes[i] = pessoa então
      escreva "Nome encontrado na posição ", i
      pare
    fimse
  fimpara
fimalgoritmo
*********************************************************
*pesquisa binária: lista ordenada
algoritmo(pesquisa):
  i integer
  nomes conjunto[1..10] de caracteres
  
  nomes[1..10]<-("abel", "bernardo", ..., "zózimo")
  pessoa<-input("digite um nome:")
  
  se carac(pessoa,1)<=nomes[length(nomes)/2][1]:
    para i de 1 até length(nomes)/2:
      se nomes[i]==pessoa:
        imprima("nome existe", posição)
      fimse;
    fimpara;
    texto<-pessoa
  senão:
    para i de length(nomes)/2 até length(nomes):
      se nomes[i]==pessoa:
        imprima("nome existe", posição)
      fimse;
    fimpara;
    texto<-pessoa
  fimse;
  
  se texto=="":
    imprima("nome não listado")
  fimse;
fimalg;

algoritmo(pesquisa):
  i, meio, n integer
  nomes vetor[1..10] de texto
  encontrado booleano

  nomes[1..10] <- ("abel", "bernardo", "carla", "danilo", "elisa", "fabio", "giovana", "henrique", "yara", "zózimo")
  n <- length(nomes)
  meio <- n / 2
  pessoa <- input("Digite um nome:")
  encontrado <- falso

  se pessoa <= nomes[meio]:
    para i de 1 até meio:
      se nomes[i] == pessoa:
        imprima("nome existe na posição", i)
        encontrado <- verdadeiro
        pare
      fimse;
    fimpara;
  senão:
    para i de meio + 1 até n:
      se nomes[i] == pessoa:
        imprima("nome existe na posição", i)
        encontrado <- verdadeiro
        pare
      fimse;
    fimpara;
  fimse;

  se não encontrado:
    imprima("nome não listado")
  fimse;
fimalg;
***************************************************************
algoritmo(pesquisa_binaria):
  #declaração de variáveis
  i, meio, comeco, final integer
  nomes vetor[1..10] de texto
  encontrado booleano
  continua texto
  
  #inicialização de variáveis
  nomes[1..10]=("abel", "bernardo", "carla", "danilo", "elisa", "fabio", "giovana", "haroldo", "ursula", "zozimo")
  meio <- inteiro(length(nomes)/2)
  comeco <- 1
  final <- length(nomes)
  encontrado <- falso
  continua <- "S"
  
  #início
  pessoa <- input("Digite um nome:")
  enquanto (continua=="S"):
    enquanto (encontrado==falso) e (comeco<=final):
      se (pessoa==nomes[meio]):
        encontrado <- verdadeiro
      senão:
        se (pessoa<nomes[meio]):
          final <- meio-1
        senão:
          comeco <- meio+1
        fimse;
      fimse;
      meio <- inteiro((comeco+final)/2)
    fimenquanto;
    
    se (encontrado==verdadeiro):
      imprima("nome %pessoa encontrado:", meio)
    senão:
      imprima("nome %pessoa não listado")
    fimse;
    
    continua <- maiusculo(input("Continuar ou parar: S, N"))
    se (continua=="S") or (continua==""):
      continua <- "S"
      encontrado <- falso
      comeco <- 1
      final <- length(nomes)
      meio <- inteiro(final/2)
    senão:
      pare
    fimse;
  fimenquanto;
fimalg;
*********************************************
algoritmo(listagem_ordenada): 6,8 - 9,1
  agenda: vetor[10, 5] de caracter
  i, j, a, e, u, v, c: inteiro
  transf: vetor[5] de caracter
  nome, endereco, cep, bairro, telefone: inteiro
  linha: texto
  
  #inicialização de variáveis
  u <- 10
  v <- 5
  a <- 1
  e <- 1
  nome <- 1
  endereco <- 2
  cep <- 3
  bairro <- 4
  telefone <- 5
  linha <- ""
  
  #cadastro
  para i de 1 até u:
    para j de 1 até v:
      escolha j:
        caso nome: agenda[i,j] <- leia("nome:")
        caso endereco:agenda[i,j] <- leia("endereço:")
        caso cep: agenda[i,j] <- leia("CEP:")
        caso bairro: agenda[i,j] <- leia("bairro:")
        caso telefone: agenda[i,j] <- leia("telefone:")
      fimescolha;
    fimpara;
  fimpara;
  
  #ordenação
  enquanto (a<=u):
    e<-a+1
    enquanto (e<=u):
      se (agenda[a,1]>agenda[e,1]):
        para c de 1 até v:
          transf[c]<-agenda[a,c]
        fimpara;
        para c de 1 até v:
          agenda[a,c]<-agenda[e,c]
        fimpara;
        para c de 1 até v:
          agenda[e,c]<-transf[c]
        fimpara;
      fimse;
      e <- e+1
    fimenquanto;
    a <- a+1
  fimenquanto;
  
  #apresentar
  para i de 1 até u:
    para j de 1 até v:
      linha <- linha+", "+texto(agenda[i,j])
    fimpara;
    imprima(linha)
  fimpara;
fimalg;
**********************************1
algoritmo(listagem_ordenada):
  tipo Pessoa:
    nome: caracter
    endereco: caracter
    cep: caracter
    bairro: caracter
    telefone: caracter
  
  agenda: vetor[10] de Pessoa
  i, j: inteiro
  temp: Pessoa
  
  # cadastro
  para i de 1 até 10:
    agenda[i].nome <- input("Nome:")
    agenda[i].endereco <- input("Endereço:")
    agenda[i].cep <- input("CEP:")
    agenda[i].bairro <- input("Bairro:")
    agenda[i].telefone <- input("Telefone:")
  fimpara

  # ordenação por nome
  para i de 1 até 9:
    para j de i+1 até 10:
      se agenda[i].nome > agenda[j].nome então
        temp <- agenda[i]
        agenda[i] <- agenda[j]
        agenda[j] <- temp
      fimse
    fimpara
  fimpara

  # exibição
  para i de 1 até 10:
    imprima("Nome: " + agenda[i].nome + ", Endereço: " + agenda[i].endereco + ", CEP: " + agenda[i].cep + ", Bairro: " + agenda[i].bairro + ", Telefone: " + agenda[i].telefone)
  fimpara
fimalg
*********************************2
algoritmo(listagem_ordenada):
  agenda: vetor[10, 5] de caracter
  i, j, a, e, u, v, c: inteiro
  transf: vetor[5] de caracter
  nome, endereco, cep, bairro, telefone: inteiro
  linha: caracter
  
  #inicialização de variáveis
  u <- 10
  v <- 5
  a <- 1
  e <- 1
  nome <- 1
  endereco <- 2
  cep <- 3
  bairro <- 4
  telefone <- 5
  
  #cadastro
  para i de 1 até u:
    para j de 1 até v:
      escolha j:
        caso nome: agenda[i,j] <- input("nome:")
        caso endereco: agenda[i,j] <- input("endereço:")
        caso cep: agenda[i,j] <- input("CEP:")
        caso bairro: agenda[i,j] <- input("bairro:")
        caso telefone: agenda[i,j] <- input("telefone:")
      fimescolha;
    fimpara;
  fimpara;
  
  #ordenação
  enquanto (a <= u):
    e <- a + 1
    enquanto (e <= u):
      se (agenda[a,1] > agenda[e,1]):
        para c de 1 até v:
          transf[c] <- agenda[a,c]
        fimpara;
        para c de 1 até v:
          agenda[a,c] <- agenda[e,c]
        fimpara;
        para c de 1 até v:
          agenda[e,c] <- transf[c]
        fimpara;
      fimse;
      e <- e + 1
    fimenquanto;
    a <- a + 1
  fimenquanto;
  
  #apresentar
  para i de 1 até u:
    linha <- ""
    para j de 1 até v:
      linha <- linha + ", " + agenda[i,j]
    fimpara;
    imprima(linha)
  fimpara;
fimalg;
***************************************9,5
*8 alunos, 4 notas para cada, média individual, média da turma,
*ordenado por aluno com médias, 2 vetores,
*baseado em antigas linguagens de programação (mas sem seguir os verbetes)
*como se fosse uma listagem de final de ano, cujas notas não mais importam guardar
algoritmo(medias_ordenadas):
  nota: vetor[1..8,1..4] de real
  media: vetor[1..8] de real
  aluno: vetor[1..8] de caracter
  soma_nt, soma_md, media_md, v_temp: real
  i, j, atual, seguinte: inteiro
  al_atual: caracter
  
  #cadastra alunos, notas e gera a média
  soma_md <- 0
  para i de 1 até 8:
    soma_nt <- 0
    imprima("aluno",i)
    aluno[i] <- leia("abel") #nomes variam
    para j de 1 até 4:
      imprima("nota",j)
      nota[i,j] <- leia(valor1) #valores variam
      soma_nt <- soma_nt+nota[i,j]
    fimpara;
    media[i] <- soma_nt/4
    soma_md <- soma_md+media[i]
  fimpara;
  
  #ordena alunos e suas respectivas médias
  para atual de 1 até 7:
    para seguinte de (atual+1) até 8:
      se (aluno[atual]>aluno[seguinte]):
        al_atual <- aluno[atual]
        aluno[atual] <- aluno[seguinte]
        aluno[seguinte] <- al_atual
        
        v_temp <- media[atual]
        media[atual] <- media[seguinte]
        media[seguinte] <- v_temp
      fimse;
    fimpara;
  fimpara;
  media_md <- soma_md/8
  
  #lista ou apresenta os alunos e suas médias
  para i de 1 até 8:
    imprima(aluno[i],": ", media[i]
  fimpara;
  
  imprima(media_md)

fimalg;
****************************************************
def medias_ordenadas():
    nota = [[0.0 for _ in range(4)] for _ in range(8)]
    media = [0.0 for _ in range(8)]
    aluno = ['' for _ in range(8)]
    soma_md = 0.0

    # Cadastro dos alunos e notas
    for i in range(8):
        print(f"Aluno {i + 1}:")
        aluno[i] = input("Nome: ")
        soma_nt = 0.0
        for j in range(4):
            nota_entrada = float(input(f"Nota {j + 1}: "))
            nota[i][j] = nota_entrada
            soma_nt += nota_entrada
        media[i] = soma_nt / 4
        soma_md += media[i]
    
    # Ordenação alfabética (nomes + médias)
    for atual in range(7):
        for seguinte in range(atual + 1, 8):
            if aluno[atual] > aluno[seguinte]:
                # troca nomes
                aluno[atual], aluno[seguinte] = aluno[seguinte], aluno[atual]
                # troca médias
                media[atual], media[seguinte] = media[seguinte], media[atual]
    
    # Média geral
    media_md = soma_md / 8

    # Exibição
    print("\n--- Boletim Final ---")
    for i in range(8):
        print(f"{aluno[i]}: {media[i]:.2f}")
    print(f"\nMédia da turma: {media_md:.2f}")
#########################################################
algoritmo(usar_registro):
  tipo
    BIMESTRE = vetor[1..4] de real
    CAD_ALUNO = registro
                      NOME : caracter
                      NOTA : bimestre
                fim_registro
                
  var
    aluno : vetor[1..8] de cad_aluno
    i, j : inteiro
    
  para i de 1 até 8:
    aluno[i].nome <- "pessoa" #nome genérico
    para j de 1 até 4:
      aluno[i].nota[j] <- valor #valor genérico
    fim_para;
  fim_para;
fim_alg;
**************************************************************
algoritmo "usar_registro"

  tipo
    BIMESTRE = vetor[1..4] de real

    CAD_ALUNO = registro
      nome: caractere
      nota: BIMESTRE
    fimregistro

  var
    aluno: vetor[1..8] de CAD_ALUNO
    i, j: inteiro

  início
    para i de 1 até 8 faça
      aluno[i].nome <- "Pessoa"
      para j de 1 até 4 faça
        aluno[i].nota[j] <- 7.5
      fimpara
    fimpara

fimalgoritmo
***************************9,63
*algoritmo para receber o nome de 8 alunos,
4 notas para cada aluno e ordenar por
nome de aluno.

algoritmo "ordenar_alunos"

tipo
  BIMESTRE = vetor[1..4] de real
  CAD_ALUNO = registro
    nome : caractere
    nota : BIMESTRE
  fimregistro
  
var
  aluno : vetor[1..8] de CAD_ALUNO
  i,j,atual,proximo : inteiro
  troca : CAD_ALUNO
  
inicio

  //cadastro de aluno e notas
  para i de 1 até 8 faça
    leia aluno[i].nome
    para j de 1 até 4 faça
      leia aluno[i].nota[j]
    fimpara
  fimpara
  
  //ordena alunos alfabeticamente
  para atual de 1 até 7 faça
    para proximo de (atual+1) até 8 faça
      se (aluno[atual].nome > aluno[proximo].nome) então
        troca <- aluno[atual]
        aluno[atual] <- aluno[proximo]
        aluno[proximo] <- troca
      fimse
    fimpara
  fimpara
  
  //lista alunos ordenadamente
  para i de 1 até 8 faça
    imprima aluno[i].nome
    
    para j de 1 até 4 faça
      imprima aluno[i].nota[j]
    fimpara
  fimpara

fim
fimalg
********************************************
algoritmo "calculadora":
  var
    operacao : inteiro
    x,y : real
    
  #operações aritiméticas
  procedimento soma()
    início
      digitacao()
      escreval("Soma: ", x+y)
    fim
  fimprocedimento
  
  procedimento subtracao()
    início
      digitacao()
      escreval("Subtração: ", x-y)
    fim
  fimprocedimento
  
  procedimento multiplicacao()
    início
      digitacao()
      escreval("Multiplicação: ", x*y)
    fim
  fimprocedimento
  
  procedimento divisao()
    início
      digitacao()
      se (y<>0) então
        escreval("Divisão: ", x/y)
      senão
        enquanto (y==0) faça
          escreval("Não pode dividir por zero. Digite y: ")
          leia(y)
        fimenquanto
        
        escreval("Divisão: ", x/y)
      fimse
    fim
  fimprocedimento
  
  procedimento digitacao()
    início
      escreva("Digite x: ")
      leia(x)
      escreva("Digite y: ")
      leia(y)
    fim
  fimprocedimento
  
  {programa principal}
  início
    operacao <- 0  #garante entrada no loop
    enquanto (operacao<5) faça
      se (operacao>0) então
        escreval("1 - soma")
        escreval("2 - subtração")
        escreval("3 - multiplicação")
        escreval("4 - divisão")
        escreval("5 - sair")
      
        escreva("Escolha uma operação: ")
        leia(operacao)
        escolha operacao:
          caso 1:
            soma()
          caso 2:
            subtracao()
          caso 3:
            multiplicacao()
          caso 4:
            divisao()
        fimescolha
      senão
        escreva("Digite um valor entre 1 e 5.")
      fimse
    fimenquanto
  fim
fimalg
****************************************************
Término do livro Algoritmos
(José Augusto N. G. Manzano, Jayr Figueiredo de Oliveira)
algoritmo "calculadora"
  var
    x,y,z : real
    operacao : inteiro
  
  #sub-rotinas
  #entrada dos valores a calcular
  procedimento digitacao()
    início
      escreva("Digite x: ")
      leia(x)
      escreva("Digite y: ")
      leia(y)
    fim
  fimprocedimento
  
  #define o tipo de cálculo a realizar
  função calculo(a,b: real, operador: caractere):real
    início
      escolha operador
        caso "+": calculo <- a+b
        caso "-": calculo <- a-b
        caso "*": calculo <- a*b
        caso "/": calculo <- a/b
      fimescolha
    fim
  fimfunção
  
  #apresentação do valor calculado
  procedimento retorno()
    início
      escreva("Resultado da operação=", z)
    fim
  fimprocedimento
  
  #operações aritméticas
  procedimento soma()
    início
      digitacao()
      z <- calculo(x,y,"+")
      retorno()
    fim
  fimprocedimento
  
  procedimento subtracao()
    início
      digitacao()
      z <- calculo(x,y,"-")
      retorno()
    fim
  fimprocedimento
  
  procedimento multiplicacao()
    início
      digitacao()
      z <- calculo(x,y,"*")
      retorno()
    fim
  fimprocedimento
  
  procedimento divisao()
    início
      digitacao()
      
      enquanto (y==0) faça
        escreva("Impossível divisão por 0. Digite y: ")
        leia(y)
      fimenquanto
      
      z <- calculo(x,y,"/")
      retorno()
    fim
  fimprocedimento
  
  procedimento menu()
    inicio
      escreval("1 - soma")
        escreval("2 - subtração")
        escreval("3 - multiplicação")
        escreval("4 - divisão")
        escreval("5 - sair")
      
        escreva("Escolha uma operação: ")
    fim
  fimprocedimento
  
  {programa principal}
  início
    operacao <- 0  #garante entrada no loop
    enquanto (operacao<5) faça
        menu()        #apresentação do menu
        leia(operacao)
        
      se (operacao>=1 e operacao<=5) então
        escolha operacao:
          caso 1:
            soma()
          caso 2:
            subtracao()
          caso 3:
            multiplicacao()
          caso 4:
            divisao()
          caso 5:
            escreval("Avisarei que encerro!")
            escreva("Isso fique bem claro!")
        fimescolha
      senão
        escreval("Digite um valor entre 1 e 5.")
      fimse
    fimenquanto
    
  fim
fimalg
******************************************************