Scribd
Carregar
8 visualizações7 páginas

P 2 Jeandro

a

Enviado por

cuecagames40
Direitos autorais
© © All Rights Reserved
Levamos muito a sério os direitos de conteúdo. Se você suspeita que este conteúdo é seu, reivindique-o aqui.
Formatos disponíveis
Baixe no formato TXT, PDF, TXT ou leia on-line no Scribd
8 visualizações7 páginas

P 2 Jeandro

a

Enviado por

cuecagames40
Direitos autorais
© © All Rights Reserved
Levamos muito a sério os direitos de conteúdo. Se você suspeita que este conteúdo é seu, reivindique-o aqui.
Formatos disponíveis
Baixe no formato TXT, PDF, TXT ou leia on-line no Scribd
Você está na página 1/ 7

Algoritmo "Lanchonete"

1)
// Declaração dos registros e variáveis globais
Tipo
Produto = Registro
codigo: inteiro
nome: caractere
valor: real
quantidade: inteiro
FimRegistro
FimTipo

Var
produtos: vetor[1..100] de Produto
total_produtos: inteiro

// Procedimento para cadastrar produtos


Procedimento cadastrar_produto()
Var
novo_produto: Produto
Inicio
se total_produtos = 100 entao
escreval("Estoque cheio! Não é possível cadastrar mais produtos.")
retorne
fimse

total_produtos <- total_produtos + 1


escreva("Digite o código do produto: ")
leia(novo_produto.codigo)
escreva("Digite o nome do produto: ")
leia(novo_produto.nome)
escreva("Digite o valor do produto: ")
leia(novo_produto.valor)
escreva("Digite a quantidade do produto: ")
leia(novo_produto.quantidade)

produtos[total_produtos] <- novo_produto


escreval("Produto cadastrado com sucesso!")
FimProcedimento

// Função para realizar uma venda


Funcao realizar_venda(): real
Var
codigo_venda, i, indice: inteiro
total_venda: real
venda: vetor[1..100] de Produto
total_vendas: inteiro
Inicio
total_venda <- 0
total_vendas <- 0
enquanto codigo_venda <> -1 faca
escreval("Digite o código do produto para venda (-1 para finalizar): ")
leia(codigo_venda)
se codigo_venda = -1 entao
saia
fimse

indice <- -1
para i de 1 ate total_produtos faca
se produtos[i].codigo = codigo_venda entao
indice <- i
saia
fimse
fimpara

se indice = -1 entao
escreval("Produto não encontrado!")
senao
escreva("Digite a quantidade a ser vendida: ")
leia(venda[total_vendas + 1].quantidade)

se venda[total_vendas + 1].quantidade > produtos[indice].quantidade


entao
escreval("Quantidade em estoque insuficiente!")
senao
produtos[indice].quantidade <- produtos[indice].quantidade -
venda[total_vendas + 1].quantidade
venda[total_vendas + 1] <- produtos[indice]
total_venda <- total_venda + (venda[total_vendas + 1].valor *
venda[total_vendas + 1].quantidade)
total_vendas <- total_vendas + 1
escreval("Produto adicionado à venda.")
fimse
fimse
fimenquanto

realizar_venda <- total_venda


FimFuncao

// Função para ordenar produtos pelo código


Procedimento ordenar_produtos()
Var
i, j: inteiro
temp: Produto
Inicio
para i de 1 ate total_produtos - 1 faca
para j de 1 ate total_produtos - i faca
se produtos[j].codigo > produtos[j + 1].codigo entao
temp <- produtos[j]
produtos[j] <- produtos[j + 1]
produtos[j + 1] <- temp
fimse
fimpara
fimpara
escreval("Produtos ordenados pelo código!")
FimProcedimento

// Procedimento para exibir o menu


Procedimento menu()
Var
opcao: inteiro
Inicio
repita
escreval("MENU")
escreval("1. Cadastrar Produto")
escreval("2. Realizar Venda")
escreval("3. Ordenar Produtos")
escreval("4. Sair")
escreva("Digite a opção desejada: ")
leia(opcao)

escolha opcao
caso 1
cadastrar_produto()
caso 2
escreval("Total da venda: R$", realizar_venda())
caso 3
ordenar_produtos()
caso 4
escreval("Saindo do programa...")
outrocaso
escreval("Opção inválida! Tente novamente.")
fimescolha
ate opcao = 4
FimProcedimento

// Programa principal
Inicio
total_produtos <- 0
menu()
Fimalgoritmo
---------------------------------------
2)
Algoritmo "DecimalParaBinario"
Var
n: inteiro

// Função recursiva para converter decimal para binário


Funcao decimalParaBinario(n: inteiro): caractere
Var
quociente: inteiro
resto: inteiro
resultado: caractere
Inicio
// Caso base: quando n é 0
se n = 0 entao
decimalParaBinario <- "0"
senao
// Caso base: quando n é 1
se n = 1 entao
decimalParaBinario <- "1"
senao
// Calcula quociente e resto
quociente <- n / 2
resto <- n % 2

// Chama a função recursivamente e concatena o resultado


resultado <- decimalParaBinario(quociente) +
inteiroParaCaractere(resto)
decimalParaBinario <- resultado
fimse
fimse
FimFuncao

// Programa principal
Inicio
escreva("Digite um número decimal: ")
leia(n)
escreval("O número ", n, " em binário é: ", decimalParaBinario(n))
Fimalgoritmo
--------------------------------------------
4
Algoritmo "DecimalParaBinario_ParteA"
Var
n: inteiro

// Função recursiva para converter decimal para binário e escrever na tela


Procedimento decimalParaBinario(n: inteiro)
Var
quociente: inteiro
resto: inteiro
Inicio
se n > 0 entao
quociente <- n / 2
resto <- n % 2
decimalParaBinario(quociente)
escreva(resto)
fimse
FimProcedimento

// Programa principal
Inicio
escreva("Digite um número decimal: ")
leia(n)
se n = 0 entao
escreval("0")
senao
decimalParaBinario(n)
fimse
Fimalgoritmo

b)
Algoritmo "DecimalParaBinario_ParteB"
Var
n: inteiro

// Função recursiva para converter decimal para binário e retornar como inteiro
Funcao decimalParaBinarioRetorna(n: inteiro): inteiro
Var
quociente, resto: inteiro
resultado: inteiro
Inicio
se n = 0 entao
decimalParaBinarioRetorna <- 0
senao
quociente <- n / 2
resto <- n % 2
resultado <- decimalParaBinarioRetorna(quociente) * 10 + resto
decimalParaBinarioRetorna <- resultado
fimse
FimFuncao

// Programa principal
Inicio
escreva("Digite um número decimal: ")
leia(n)
escreval("O número ", n, " em binário é: ", decimalParaBinarioRetorna(n))
Fimalgoritmo
------------------------------
5)
Algoritmo "OrdenacaoVetorRA"
Var
vetor: vetor[1..10] de inteiro
n, i, j: inteiro

// Procedimento para imprimir o vetor


Procedimento imprimeVetor(v: vetor de inteiro, n: inteiro)
Var
i: inteiro
Inicio
para i de 1 ate n faca
escreva(v[i], " ")
fimPara
escreval()
FimProcedimento

// Procedimento Insertion Sort


Procedimento insertionSort(v: vetor de inteiro, n: inteiro)
Var
i, j, chave: inteiro
Inicio
para i de 2 ate n faca
chave <- v[i]
j <- i - 1
enquanto (j > 0) e (v[j] > chave) faca
v[j + 1] <- v[j]
j <- j - 1
fimEnquanto
v[j + 1] <- chave
escreva("Passo ", i - 1, ": ")
imprimeVetor(v, n)
fimPara
FimProcedimento

// Procedimento Selection Sort


Procedimento selectionSort(v: vetor de inteiro, n: inteiro)
Var
i, j, min, temp: inteiro
Inicio
para i de 1 ate n - 1 faca
min <- i
para j de i + 1 ate n faca
se v[j] < v[min] entao
min <- j
fimSe
fimPara
temp <- v[i]
v[i] <- v[min]
v[min] <- temp
escreva("Passo ", i, ": ")
imprimeVetor(v, n)
fimPara
FimProcedimento

// Procedimento Bubble Sort


Procedimento bubbleSort(v: vetor de inteiro, n: inteiro)
Var
i, j, temp: inteiro
Inicio
para i de 1 ate n - 1 faca
para j de 1 ate n - i faca
se v[j] > v[j + 1] entao
temp <- v[j]
v[j] <- v[j + 1]
v[j + 1] <- temp
fimSe
fimPara
escreva("Passo ", i, ": ")
imprimeVetor(v, n)
fimPara
FimProcedimento

// Programa principal
Inicio
vetor[1] <- 1
vetor[2] <- 2
vetor[3] <- 3
vetor[4] <- 4
vetor[5] <- 5
vetor[6] <- 6
vetor[7] <- 2
vetor[8] <- 7
vetor[9] <- 8
vetor[10] <- 3

n <- 10

escreval("Vetor original:")
imprimeVetor(vetor, n)

escreval("Ordenacao por Insertion Sort:")


insertionSort(vetor, n)

// Resetando o vetor para a ordenação Selection Sort


vetor[1] <- 1
vetor[2] <- 2
vetor[3] <- 3
vetor[4] <- 4
vetor[5] <- 5
vetor[6] <- 6
vetor[7] <- 2
vetor[8] <- 7
vetor[9] <- 8
vetor[10] <- 3

escreval("Ordenacao por Selection Sort:")


selectionSort(vetor, n)

// Resetando o vetor para a ordenação Bubble Sort


vetor[1] <- 1
vetor[2] <- 2
vetor[3] <- 3
vetor[4] <- 4
vetor[5] <- 5
vetor[6] <- 6
vetor[7] <- 2
vetor[8] <- 7
vetor[9] <- 8
vetor[10] <- 3

escreval("Ordenacao por Bubble Sort:")


bubbleSort(vetor, n)
Fimalgoritmo

Você também pode gostar

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy