Portugol Desenvolver um algoritmo em pseudocodigo

[Vktcs18]

Desenvolver seu algoritmo em pseudocódigo e atender aos seguintes critérios:

1 – Estrutura de Registro para armazenar 100 aparelhos celulares

2 – Um menu que apresente os seguintes módulos (procedimentos / funções)

2.1 – Cadastrar Produtos

2.2 – Listar todos (Aqui liste 3 características armazenadas)

2.3 - Listar 1 produto específico (Aqui liste 3 características armazenadas)

 

Considere as seguintes regras: 

1 - Controlar o cadastro para que não haja códigos idênticos.

2 - Informar ao usuário se produto foi cadastro ou não.

3 - Informar ao usuário que o produto não foi encontrado caso ocorra.

[Visitante]

nesse codigo você deve encontrar parte das estruturas que você precisa.

 

 

algoritmo "parcial"
var
a:vetor[1..2,1..2] de inteiro
i,j , fat , op, levar, res  : inteiro
fim : caracter
la,lb,lc : real
tipo, fácil : caracter


procedimento fatorial
var
a:vetor[1..5] de inteiro
i, j ,fat, cont : inteiro

inicio
escreval (" entre com 5 numeros para calcular o fatorial:")
se ( fácil = "sim" ) entao
   aleatorio 1,10
fimse
para i de 1 ate 5 faca
   leia  (a[i])
fimpara
cont <-1
i <- 1
enquanto ( i <= 5) faca
   fat <- a[i]
   cont <- 1
   enquanto (cont < a[i]) faca
      fat <- fat * cont
      cont <- cont + 1

   fimenquanto

   se ( i <= 5 ) entao
      escreval ("o fatorial de ", a[i], " é: ", fat )
   fimse
   i <- i + 1
fimenquanto
aleatorio off

fimprocedimento



procedimento maiormenor
var
A:vetor [1..10] de real
maior , menor  : real
i : inteiro
inicio
maior <- 0
menor <- 99999
escreval (" digite 10 numeros para mostrar o maior e menor")
se ( fácil = "sim" ) entao
   aleatorio 1,10
fimse
para i de 1 ate 10 faca
   escreval (" entre com o ", i, "º" , "numero")
   leia ( a[i] )
   se ( a [i] > maior ) entao
      maior <- a [i]
   fimse
   se ( a [i] < menor ) entao
      menor <- a [i]
   fimse
fimpara
escreval (" Omenor numero digitado foi " , menor, " e o maior foi", maior )
aleatorio off
fimprocedimento
procedimento ordena

var
numero:vetor[1..10] de real
i, i2 : inteiro
temp : real



inicio
escreval("digite 10 numeros para ordenar")

se ( fácil = "sim" ) entao
   aleatorio 1,10
fimse
para i de 1 ate 10 faca
   leia (numero[i])
fimpara

para i de 1 ate 9 faca
   para i2 de i+1  ate 10 faca
      se (numero[i] > numero [i2]) entao
         temp<- numero[i]
         numero[i] <- numero [i2]
         numero[i2] <- temp
      fimse
   fimpara
fimpara
escreval ("os numeros digitados em ordem crescente são:")
para i de 1 ate 10 faca

   escreva (numero[i] )
fimpara
escreval
aleatorio off
fimprocedimento

procedimento pesquisa
var
nome:vetor[1..6] de caracter
i : inteiro
temp, pesq, resp : caracter
acha : logico



inicio
escreval("digite 6 nomes para ordenar")
se ( fácil = "sim" ) entao
   escreval (" Nomes deve ser digitados manualmente:")
fimse
para i de 1 ate 6 faca
   leia (nome[i])
fimpara

resp <- "sim"
enquanto ( resp = "sim" ) faca
   escreval(" entre com o nome a ser pesquisado:")
   leia (pesq)
   i<- 1
   acha <- falso

   enquanto ( i <= 6) e ( acha = falso) faca
      se ( pesq = nome[i]) entao
         acha <- verdadeiro
      senao
         i <- i + 1
      fimse
   fimenquanto
   se ( acha = verdadeiro ) entao
      escreval ( pesq , "foi localizado na posição: ", i )
   senao
      escreval ( pesq , " não foi localizado")
   fimse
   escreval (" deseja localizar mais nomes? SIM para continuar ou NÂO para sair")
   leia (resp)
   enquanto ( resp <> "sim" ) e ( resp <> "não" ) faca
      escreval (" deseja localizar mais nomes? SIM para continuar ou NÂO para sair")
      leia (resp)
   fimenquanto
fimenquanto

fimprocedimento
procedimento mostrapares

var
a:vetor[1..10] de  inteiro
i : inteiro
inicio
escreval (" entre com 10 numeros para verificar se é par")
se ( fácil = "sim" ) entao
   aleatorio 1,10
fimse
para i de 1 ate 10 faca
   leia (a [i] )
fimpara
para i de 1 ate 10 faca
   se (a [i] mod 2 = 0 ) entao
      escreval ( " o numero " , A [i] , " é par")
   fimse
fimpara
aleatorio off
fimprocedimento
procedimento fibonacci
var
n,an,prox,cont :inteiro
inicio
escreval("este algoritmo se propõe a calcular a série de Filbonacci")
n<-1
an<-1
cont<-1
escreval("sendo que a sequencia começa sempre com os dois primeiros abaixo")
escreval("            começa somando  ","1")
escreval("                       com  ","1")
enquanto (cont<=13) faca
   prox<-n+an
   escreva("somando", an," ")
   an<-n
   n<-prox
   cont<- cont+1
   escreval("ao anterior temos", n)
fimenquanto

fimprocedimento
procedimento somadiagonalprincipal
var
a:vetor[1..3,1..3] de inteiro
i,j,soma : inteiro

inicio
escreval (" entre com uma matriz 3x3 para somar a diagonal principal")
se ( fácil = "sim" ) entao
   aleatorio 1,10
fimse
para i de 1 ate 3   faca
   para j de 1 ate 3 faca
      leia  ( a [i,j])
      se ( i = j ) entao
         soma <- soma + a [i,j]
      fimse
   fimpara
fimpara
escreval (" a matriz digitada foi:")
para i de 1 ate 3 faca
   para j de 1 ate 3 faca
      escreva ( a [i,j] )
   fimpara
   escreval
fimpara
escreval (" a soma da diagonal principal é:" , soma)
aleatorio off
fimprocedimento


procedimento fatorialacimadiagonalprincipal ( n : inteiro ; var res : inteiro )

var
i, cont : inteiro

inicio
cont<-1
fat<-1
enquanto  ( cont <= n) faca
   fat<- fat*cont
   cont<-cont+1
fimenquanto
res <-  fat

fimprocedimento
procedimento mostraimparmatriz

var
mimp:vetor[1..4,1..3] de  inteiro

inicio
escreval (" entre com 12 numeros para verificar se é impar")
se ( fácil = "sim" ) entao
   aleatorio 1,10
fimse
para i de 1 ate 4 faca
   para j de 1 ate 3  faca
      leia (mimp [i,j] )
   fimpara
fimpara

escreval (" a matriz apresentada foi::")
para i de 1 ate 4 faca
   para j de 1 ate 3 faca
      escreva ( mimp [i,j])
   fimpara
   escreval
fimpara

para i de 1 ate 4 faca
   para j de 1 ate 3 faca
      se ( mimp [ i , j ] mod 2 = 1 ) entao
         escreval ( " o numero " , mimp [i,j] , " é impar")
      fimse
   fimpara
fimpara
aleatorio off
fimprocedimento
procedimento mostratipotriangulo   (x ,y , z : real ; var tipo : caracter)
var

inicio

se ( x = y ) e ( y = z )  entao
   tipo <- " equilátero"
senao
   se ( x = y ) ou (x = z) ou ( y = z ) entao
      tipo <- " isosceles"
   senao
      tipo <- "escaleno"
   fimse
fimse





fimprocedimento
procedimento juncao
var
a11:vetor[1..5] de inteiro
b11:vetor[1..4] de inteiro
c11:vetor[1..9] de inteiro
inicio
Escreval (" entre com 5 valores para o vetor "   )
se ( fácil = "sim" ) entao
   aleatorio 1,10
fimse
para i de 1 ate 5 faca
   leia ( a11 [i] )
   c11 [i] <-  a11 [i]
fimpara
escreval ( " entre com 4 valores para o outro vetor"  )
para i de 1 ate 4 faca
   leia ( b11 [i] )
   c11 [i + 5] <- b11 [i]
fimpara
escreval (" A junção dos dois vetores é :")
para i de 1 ate 9 faca
   escreva ( c11 [i])
fimpara
escreval
aleatorio off


fimprocedimento
inicio
repita
   limpatela
   escreval ("1 - Fatorial" )   //Pedir para ler 5 números e mostrar o fatorial.
   escreval ("2 - Maior e Menor")  //Ler 10 números e mostrar o maior e o menor.
   escreval ("3 - Ordenar Números" )    //Ler um vetor com 10 números e ordenar.
   escreval ("4 - Pesquisar" )  //Ler um vetor com 6 nomes e efetuar a pesquisa.
   escreval ("5 - Mostrar Pares")                 //Ler um vetor com 10 números.
   escreval ("6 - Fibonacci"  )
   escreval ("7 - Somar Diagonal Principal" )              //Ler uma matriz 3X3.
   escreval ("8 - Fatorial Acima Diagonal Principal" )     //Ler uma matriz 2X2.
   escreval ("9 - Mostrar Impares na Matriz" )             //Ler uma matriz 4X3.
   escreval ("10 - Verificar qual triângulo e formado")//Isósceles,Esca ou Equi.
   escreval ("11 - Efetuar Junção") //Ler um vetor com 5 posições e outro com 4.
   // Colocar os dois vetores em um terceiro com 9 posições.
   Escreval ("12 - Sair")
   escreval ("Escolha uma opcao")


   leia (op)
   Se ( op <> 12) e  ( op <> 6 ) entao
   escreval ("Gostaria de usar valores aleátorios automaticos para facilitar e alegrar a vida?")
   escreval ("Digite SIM para ativar ou NÂO para desativar")
   leia (fácil)
   enquanto ( fácil <> "não" ) e ( fácil <> "sim" ) faca
      escreval ("Digite SIM para ativar ou NÂO para desativar")
      leia (fácil)
   fimenquanto
   fimse

   enquanto (op < 1 ) ou ( op > 12 )faca
      escreval (" opção inválida, digite algo entre 1 e 12:")
      leia (op)
   fimenquanto

   se ( op = 1 ) entao
      fatorial
   fimse
   se ( op = 2 ) entao
      maiormenor
   fimse
   se ( op = 3 ) entao
      ordena
   fimse
   se ( op = 4 ) entao
      pesquisa

   fimse
   se ( op = 5 ) entao
      mostrapares
   fimse

   se ( op = 6 ) entao
      fibonacci
   fimse

   se ( op = 7 ) entao
      somadiagonalprincipal
   fimse

   se ( op = 8 ) entao
      escreval (" entre com os valores da matriz 2x2")
      se ( fácil = "sim" ) entao
         aleatorio 1,10
      fimse
      para i de 1 ate 2 faca
         para j de 1 ate 2 faca
            leia ( a [i,j])
         fimpara
      fimpara
      levar <- a [ 1 , 2 ]
      fatorialacimadiagonalprincipal (levar , res)
      aleatorio off
      escreval (" a matriz apresentada foi::")
      para i de 1 ate 2 faca
         para j de 1 ate 2 faca
            escreva ( a [i,j])
         fimpara
         escreval
      fimpara
      escreval ( " o fatorial acima da diagonal principal é" , fat)

   fimse
   se ( op = 9 ) entao
      mostraimparmatriz
   fimse


   se ( op = 10 ) entao

      escreval(" Entre com os lados para determinar o tipo de triangulo")

      se ( fácil = "sim" ) entao
         aleatorio 1,10
      fimse
      escreval(" entre com o lado A")
      leia (la)
      escreval(" entre com o lado B")
      leia (LB)
      escreval (" entre com o lado C")
      LEIA (LC)
      aleatorio off
      enquanto ( la > lb + lc) ou ( lb > la + lc ) ou ( lc > la + lb ) faca
         escreval (" essas medidas não formam um triangulo")
         escreval (" digites os lados A,B e C novamente:")
         leia (la)
         leia (lb)
         leia (lc)
      fimenquanto

      mostratipotriangulo  ( la , lb , lc , tipo)

      escreval (" as medidas correspondem a um triangulo:", tipo)

   fimse

   se ( op = 11 ) entao
      juncao
   fimse

   se ( op = 12 ) entao
      escreval ( " tenha um bom dia.")
      escreval
      escreval ( " Saindo...")

      escreval
   fimse




   se ( op <> 12 )entao

   escreval (" deseja continuar? Digite não para sair.")
   leia (fim)
   enquanto ( fim <> "não") e ( fim <> "sim" ) faca
      escreval ("digite NÂO para sair e SIM para continuar")
      leia (fim)
   fimenquanto
   senao
   fim <- "não"
   fimse
ate fim = "não"
fimalgoritmo