Algoritmo - Atividade 11

Eai Maurício, fiz o algoritmo, gostaria que voce corrigisse pra mim.

eu fiz uma rotina enquanto faca utilizando variavel inteiro, pois não sei usar o logico para condição SIM OU NAO ainda.

algoritmo "calculadora - Lauro Calc - V 1.0"
// Função :
// Autor :  Lauro Luiz da Conceição
// Data : 18/5/2008 término : às 04:00 hs da manhã.
// Seção de Declarações
var
valor:vetor[1..5]de real // variavel vetor com cinco posições para receber os valores para calculo
result:vetor[1..5]de real // variavel vetor com cinco posições para operação
opera:vetor[1..5]de caractere // variavel para receber o sinal de operação
multip,oper,opcao:caractere // variavel que representa o sinal da operação
vtreta,vtpos,posic2:inteiro    // variavel para acolher os valores digitados para calculo
logic:inteiro

inicio
logic<-1
enquanto logic<3 faca
   vtreta<-1
   vtpos<-1
   posic2<-2
   escreval (" ")
   escreval (" PROGRAMA LAURO CALC - V 1.0")
   escreval ("_____________________________________________________________________________")
   escreval (" ")
   escreval ("   Informe os valores para calculos até cinco posições ")
   para vtreta de 1 ate 5 faca
      escreval (" ")
      escreva ("=> ",vtreta,"º valor para calculo : ")
      leia(valor[vtreta])
   fimpara
   escreval (" ")
   escreval ("------------------------------------------------------")
   escreval ("Utilize apenas os sinais /, *, - ou + no campo abaixo:")
   para vtpos de 1 ate 4 faca
      escreval ("------------------------------------------------------")
      escreva  ("Qual e a operação da ",vtpos,"ª para ",posic2,"ª posição: ")
      leia(opera[vtpos])
      posic2<-posic2+1
   fimpara
   escolha opera[1]
   caso="/"
      result[1]<-(valor[1]/valor[2])
   caso="+"
      result[1]<-(valor[1]+valor[2])
   caso="-"
      result[1]<-(valor[1]-valor[2])
   caso="*"
      result[1]<-(valor[1]*valor[2])
   outrocaso
      escreval ("O sinal de operação ",opera[vtpos]," Inexistente")
      interrompa
   fimescolha
   escolha opera[2]
   caso="/"
      result[2]<-(result[1]/valor[3])
   caso="+"
      result[2]<-(result[1]+valor[3])
   caso="-"
      result[2]<-(result[1]-valor[3])
   caso="*"
      result[2]<-(result[1]*valor[3])
   outrocaso
      escreval ("O sinal de operação ",opera[vtpos]," Inexistente")
      interrompa
   fimescolha
   escolha opera[3]
   caso="/"
      result[3]<-(result[2]/valor[4])
   caso="+"
      result[3]<-(result[2]+valor[4])
   caso="-"
      result[3]<-(result[2]-valor[4])
   caso="*"
      result[3]<-(result[2]*valor[4])
   outrocaso
      escreval ("O sinal de operação ",opera[vtpos]," Inexistente")
      interrompa
   fimescolha
   escolha opera[4]
   caso="/"
      result[4]<-(result[3]/valor[5])
   caso="+"
      result[4]<-(result[3]+valor[5])
   caso="-"
      result[4]<-(result[3]-valor[5])
   caso="*"
      result[4]<-(result[3]*valor[5])
   outrocaso
      escreval ("O sinal de operação ",opera[vtpos]," Inexistente")
      interrompa
   fimescolha
   limpatela
   escreval (" ")
   escreval (" PROGRAMA LAURO CALC - V 1.0")
   escreval ("_____________________________________________________________________________")
   escreval (" ")
   escreval ("   Como Foi Calculado os Valores Nas Seguintes Posições ")
   escreval (" ")
   escreval ("Expressão Numérica do Calculo => (",valor[1],opera[1],valor[2],")",opera[2],"(",valor[3],")",opera[3],"(",valor[4],")",opera[4],"(",valor[5],") = ")
   escreval (" ")
   escreval ("(",valor[1],opera[1],valor[2],") = ",result[1])
   escreval ("(",result[1],opera[2],valor[3],") = ",result[2])
   escreval ("(",result[2],opera[3],valor[4],") = ",result[3])
   escreval ("(",result[3],opera[4],valor[5],") = ",result[4])
   escreval ("_____________________________________________________________________________")
   escreval ("")
   escreval ("")
   escreval ("")
   escreval ("")
   escreval ("-----------------------------------------------------------------------------")
   escreval ("Resultado do Calculo é => ",result[4])
   escreval ("-----------------------------------------------------------------------------")
   escreval (" ")
   escreval (" ")
   escreva (" Deseja Realizar outro Calculo Sim ou Não - use S OU N ? :")
   leia (opcao)
   se opcao="S" entao
      escreval ("")
      logic<-1
   senao
      logic<-6
     fimse
     limpatela
  fimenquanto
//Lauro Luiz RA 955698-2 REDE-UNIP ")
fimalgoritmo // fim de algoritmo

Maurício,

Verifiquei após postar o algoritmo que a variável acima RESULT:VETOR[1..5]DE REAL  foi criada com 5 posições para receber os resultados dos calculos.

porém eu só usei quatro posicões dentro do vetor, não sei se da erro, porque no teste não deu. mas o certo é :

RESULT:VETOR[1..4]DE REAL.

Valeu

Lauro Luiz RA 955698-2 REDE -UNIP

E ai Mauricio,

Eu estou incluindo novo algoritmo desta atividade, pois detectei que o meu algoritmo acima pede necessariamente que seja digitado as cinco posições com valores, e não de 2 a 5, como você pediu. Diante disso eu fiz outro algoritmo que pede a quantidade de valores a serem calculados, a estrutura é cheia de frescura, mas consegui incluir conforme pede esta atividade.

algoritmo "calculadora - Lauro Calc - V 2.0"
// Função :
// Autor :  Lauro Luiz da Conceição
// Data : 18/5/2008
// Seção de Declarações
var

vento1:vetor[1..5]de real
vento2:vetor[1..5]de real
vet3_car:vetor[1..4]de caracter
ret_sn:literal
par_vt1,par_vt2,par_vt3:inteiro
opp_1,opp_2,opp_3,opp_4,enq_fac:inteiro

inicio
par_vt1<-1
par_vt2<-1
par_vt3<-1
enq_fac<-1
opp_2<-1
enquanto enq_fac<2 faca
   limpatela
   escreval (" ")
   escreval ("                     APLICATIVO LAURO CALC - V.2")
   escreval (" Lauro Luiz                                            Profº Mauricio Junior ")
   escreval ("_____________________________________________________________________________")
   escreval (" ")
   escreva ("Quantos Números (de 2 à 5) Você Ké Calcular ? => ")
   leia(opp_1)
   opp_4<-opp_1
   escolha opp_1
   caso=2,3,4,5
      escreval ("")
      escreval ("")
      opp_3<-opp_1-1
      para par_vt1 de 1 ate opp_1 faca
         escreval ("")
         escreva (" Insira o ",par_vt1,"º Número => ")
         leia(vento1[par_vt1])
      fimpara
   outrocaso
      limpatela
      interrompa
   fimescolha
   limpatela
   escreval ("")
   escreval ("                  APLICATIVO LAURO CALC - V.2")
   escreval (" Lauro Luiz                                           Profº Mauricio Junior")
   escreval ("___________________________________________________________________________")
   escreval ("")
   escreval ("Escolha a Operação a ser Realizada Abaixo:")
   par_vt2<-1
   escreval ("")
   escreval ("------------------------------------------")
   escreval (par_vt2,"ª posição contém o valor => ",vento1[par_vt2])
   para par_vt3 de 1 ate opp_3 faca
      par_vt2<-par_vt2+1
      escreva ("Operação :( /,*,-,+ ) => ")
      leia (vet3_car[par_vt3])
      escreval ("-------------------------------------------")
      escreval (par_vt2,"ª posição contém o valor => ",vento1[par_vt2])
      escreva ("")
   fimpara
   escolha vet3_car[1]
   caso ="/"
      vento2[1]<-vento1[1]/vento1[2]
   caso ="*"
      vento2[1]<-vento1[1]*vento1[2]
   caso ="+"
      vento2[1]<-vento1[1]+vento1[2]
   caso ="-"
      vento2[1]<-(vento1[1]-vento1[2])
   fimescolha
   escolha vet3_car[2]
   caso ="/"
      vento2[2]<-vento2[1]/vento1[3]
   caso ="*"
      vento2[2]<-vento2[1]*vento1[3]
   caso ="+"
      vento2[2]<-vento2[1]+vento1[3]
   caso ="-"
      vento2[2]<-vento2[1]-vento1[3]
   fimescolha
   escolha vet3_car[3]
   caso ="/"
      vento2[3]<-vento2[2]/vento1[4]
   caso ="*"
      vento2[3]<-vento2[2]*vento1[4]
   caso ="+"
      vento2[3]<-vento2[2]+vento1[4]
   caso ="-"
      vento2[3]<-vento2[2]-vento1[4]
   fimescolha
   escolha vet3_car[4]
   caso ="/"
      vento2[4]<-vento2[3]/vento1[5]
   caso ="*"
      vento2[4]<-vento2[3]*vento1[5]
   caso ="+"
      vento2[4]<-vento2[3]+vento1[5]
   caso ="-"
      vento2[4]<-vento2[3]-vento1[5]
   fimescolha
   limpatela
   escreval ("")
   escreval ("                     APLICATIVO LAURO CALC - V.2")
   escreval (" Lauro Luiz                                             Profº Mauricio Junior ")
   escreval ("_____________________________________________________________________________")
   escreval ("")
   escreval ("Resultado da Operação Matemática Abaixo:")
   escreval ("----------------------------------------")
   par_vt1:=1
   para par_vt1 de 1 ate opp_4 faca
      escreval ("")
      escreval (par_vt1,"ª posição => ",vento1[par_vt1])
   fimpara
   escreval ("")
   escreval ("")
   escolha opp_4
   caso =2
      escreval ("---------------------------------------------------------------------------")
      escreval (" Expressão Numérica => (",vento1[1]," )",vet3_car[1],"(",vento1[2]," )")
      escreval ("")
      escreval ("O resultado do Calculo é => ",vento2[1])
   caso =3
      escreval ("---------------------------------------------------------------------------")
      escreval (" Expressão Numérica => (",vento1[1]," )",vet3_car[1],"(",vento1[2]," )",vet3_car[2],"(",vento1[3]," )")
      escreval ("")
      escreval ("O resultado do Calculo é => ",vento2[2])
      escreval ("")
   caso =4
      escreval ("---------------------------------------------------------------------------")
      escreval (" Expressão Numérica => (",vento1[1]," )",vet3_car[1],"(",vento1[2]," )",vet3_car[2],"(",vento1[3]," )",vet3_car[3],"(",vento1[4]," )")
      escreval ("")
      escreval ("O resultado do Calculo é => ",vento2[3])
      escreval ("")
   caso =5
      escreval ("---------------------------------------------------------------------------")
      escreval (" Expressão Numérica => (",vento1[1]," )",vet3_car[1],"(",vento1[2]," )",vet3_car[2],"(",vento1[3]," )",vet3_car[3],"(",vento1[4]," )",vet3_car [4],"(",vento1[5]," )")   // continuação da linha anterior
      escreval ("")
      escreval ("O resultado do Calculo é => ",vento2[4])
      escreval ("")
   fimescolha
   escreval ("")
   escreval ("------------------------------------------------------------------------------")
   escreva ("Realizar outro Calculo Sim / Não - use S OU N ? :")
   leia (ret_sn)
   escreval ("")
   se ret_sn="S" entao
      escreval ("")
      enq_fac<-1
      par_vt1<-1
   senao
      enq_fac<-2
   fimse
   limpatela
fimenquanto
fimalgoritmo // fim de algoritmo Lauro Luiz RA 955698-2 REDE-UNIP ")

Ola Professor.

Estou tendo muito dificuldade nesse exercício. poderia disponibilizar algum material teórico

Grato

Marcio Paulo

Maurício,

Não consegui fazer rodar.

Espero aprender na próxima aula.

Mauricio,

Também estou com dificuldades.

Mauricio, não adianta, por mais que eu tente, não consigo resolver esse algoritmo.

Virgínia

Boa noite Mauricio!

Não tenho a menor noção de como realizar este exercício(11). Espero aprender.

Um abraço.

OLA MAURICIO! EU NAO ESTOU TAMBEM NAO ESTOU MUITO DIFRENTE,, ESSE TA COMPLICADO,,, TENTEI FAZER SEM VETOR COM

AS OPÇOES CASO, E SEM LIMITES DE NUMEROS MAS TAMBEM NAO CONSIGUIR RODAR... MAS CONTINUAREI TENTANDO

ABRAÇOS,,,

Maurício, gozação tem hora. acho que se a resposta desse exercício é essa que o nosso colega apresentou aí, eu te pergunto: Qdo foi que vc deu alguma sintaxe desse tamanho ou algum exercicio similar. Ainda assim estou tentando entender o que ele fêz. Na próxima aula quero saber se o nosso colega atua em alguma área de programação ou se ele aprendeu isso nessas poucas aulas que tivemos com vc. Se foi só com as suas aulas eu tiro o chapéu pra ele (e pra vc).

grato,

Paulo Roberto

Olá, Maurício!

Fiz o exercício, porém, com o auxílio de um amigo.

A divisão não compilou, pode me ajudar?

algoritmo "Calculadora"
// Função :
// Autor : Jerry
// Data : 25/5/2008
// Seção de Declarações
var
a:inteiro
contador:inteiro
Qvalores:inteiro
B:vetor[1..5]de inteiro
aux:inteiro
inicio
// Seção de Comandos
escreval("Que deseja? (1)soma,(2)sub,(3)mult,(4)div")
leia(a)
escolha a
----------------------------------------------------
//Soma
caso=1
contador<-1

escreval("Quantos valores a serem somados?")
leia(Qvalores)
escreval("Digite os valores a serem somados")
//Loop
para contador de 1 ate Qvalores faca
leia(B[contador])
fimpara
contador<-1
aux<-B[1]
//Loop
para contador de 1 ate Qvalores faca
aux<-B[contador+1]+aux
se contador=Qvalores entao
interrompa
fimse
fimpara
escreval("Total",aux)
----------------------------------------------------
//Subtração
caso=2
contador<-1

escreval("Quantos valores a serem subtraídos?")
leia(Qvalores)
escreval("Digite os valores a serem subtraídos")
para contador de 1 ate Qvalores faca
leia(B[contador])
fimpara
contador<-1
aux<-B[1]
para contador de 1 ate Qvalores faca
aux<-B[contador+1]-aux
se contador=Qvalores entao
interrompa
fimse
fimpara
escreval("Total",aux)
----------------------------------------------------
//Multiplicação
caso=3
contador<-1

escreval("Quantos valores a serem multiplicados?")
leia(Qvalores)
escreval("Digite os valores a serem multiplicados")
para contador de 1 ate Qvalores faca
leia(B[contador])
fimpara
contador<-1
aux<-B[1]
para Qvalores de contador ate Qvalores faca
aux<-B[contador+1]*(aux)
se contador=Qvalores entao
interrompa
fimse
fimpara
escreval("Total",aux)
---------------------------------------------------
//Divisão
caso=4
contador<-1

escreval("Quantos valores a serem Divididos?")
leia(Qvalores)
escreval("Digite os valores a serem Divididos")
para contador de 1 ate Qvalores faca
leia(B[contador])
fimpara
contador<-1
aux<-B[1]
para Qvalores de contador ate Qvalores faca
aux<-B[contador+1]/(aux)
se contador=Qvalores entao
interrompa
fimse
fimpara
escreval("Total",aux)
outrocaso
escreva("Sinto muito,sou limitado as 4 operações básicas.")
fimescolha
fimalgoritmo

SEGUE....

algoritmo "EU FIZ SOZINHO, TO FICANDO BOM NISSO!"
// Função :  CALCULADORA
// Autor :   Eu sozinho, sozinho, sozinho.... hehehe...
// Data : 31/5/2008
// Seção de Declarações
var
vet:vetor [1..5] de inteiro
x, y:inteiro
inicio
escreval(" Bem vindo a calculadora!")
escreval(" Digite qual a função desejada.")
escreva(" (1)somar, (2)subtrair, (3)multiplicar, (4)dividir, (0)Para SAIR: ")
leia (y)
escolha y
// SOMAR
caso 1
escreva(" Digite quantos numeros quer somar: ")
Leia(x)
       para x de 1 ate x faca
       escreva(" Agora digite os numeros: ")
       leia (vet[x])
       fimpara
              funcao somar: real
                     var total: real
                     inicio
                           para x de 1 ate x faca
                           total <- total + vet[x]
                           fimpara
                           retorne total
              fimfuncao
escreva(" O Total da soma é: ",somar)
//SUBTRAIR
caso 2
escreva(" Digite quantos numeros quer subtrair: ")
Leia(x)
       para x de 1 ate x faca
       escreva(" Agora digite os numeros: ")
       leia (vet[x])
       fimpara
              funcao subtrair: real
                     var total: real
                     inicio
                           para x de 1 ate x faca
                           total <- total - vet[x]
                           fimpara
                           retorne total
              fimfuncao
escreva(" O Total da subtração é: ",subtrair)
//MULTIPLICAR
caso 3
vet[1] <- 1      //FOI ADICIONADO O VALOR 1 PARA QUANDO O USUARIO NÃO DIGITAR OS 5 VALORES
vet[2] <- 1      //O RESULTADO NÃO SEJA = 0 NA MULTIPLICAÇÃO.
vet[3] <- 1
vet[4] <- 1
vet[5] <- 1
escreva(" Digite quantos numeros quer multiplicar: ")
Leia(x)
       para x de 1 ate x faca
       escreva(" Agora digite os numeros: ")
       leia (vet[x])
       fimpara
              funcao multi: real
                     var total: real
                     inicio
                           total <- 1 // SENÃO VAI DAR ZERO SEMPRE
                           para x de 1 ate x faca
                           total <- total * vet[x]
                           fimpara
                           retorne total
              fimfuncao
escreva(" O Total da multiplicação é: ",multi)
//DIVIDIR
caso 4
vet[1] <- 1      //FOI ADICIONADO O VALOR 1 PARA QUANDO O USUARIO NÃO DIGITAR OS 5 VALORES
vet[2] <- 1      //SENÃO DARÁ ERRO.
vet[3] <- 1
vet[4] <- 1
vet[5] <- 1
escreva(" Digite quantos numeros quer dividir: ")
Leia(x)
       para x de 1 ate x faca
       escreva (" Agora digite os numeros: ")
       leia (vet[x])
       fimpara
              funcao divi: real
                     var total: real
                     inicio
                           total <- vet[1] / vet[2]
                           total <- total / vet[3]
                           total <- total / vet[4]
                           total <- total / vet[5]
                           retorne total
              fimfuncao
escreva(" O Total da divisão é: ",divi)
caso 0
interrompa
outrocaso
         escreval(" Desculpe! Somente as 4 operações basicas: + - * /")
fimescolha
fimalgoritmo

Pô tira uma dessas respostas aí em cima.... na hora que respondi deu pau.... como nao sabia se tinha gravado respondi outra vez....

Mas EU FIZ SOZINHO..... MASSSSSAAAAAA...............

[]'s

Marcio

algoritmo "cal"
// Função :
// Autor :
// Data : 6/6/2008
// Seção de Declarações
var
valor:vetor[1..5]de real // variavel vetor com cinco posições para receber os valores para calculo
result:vetor[1..5]de real // variavel vetor com cinco posições para operação
opera:vetor[1..5]de caractere // variavel para receber o sinal de operação
multip,oper,opcao:caractere // variavel que representa o sinal da operação
vtreta,vtpos,posic2:inteiro    // variavel para acolher os valores digitados para calculo
logic:inteiro

inicio
logic<-1
enquanto logic<3 faca
   vtreta<-1
   vtpos<-1
   posic2<-2
   escreval ("   Informe os valores para calculos até cinco posições ")
   para vtreta de 1 ate 5 faca
      escreval (" ")
      escreva ("=> ",vtreta,"º valor para calculo : ")
      leia(valor[vtreta])
   fimpara
   escreval (" ")
   escreval ("------------------------------------------------------")
   escreval ("Utilize apenas os sinais /, *, - ou + no campo abaixo:")
   para vtpos de 1 ate 4 faca
      escreval ("------------------------------------------------------")
      escreva  ("Qual e a operação da ",vtpos,"ª para ",posic2,"ª posição: ")
      leia(opera[vtpos])
      posic2<-posic2+1
   fimpara
   escolha opera[1]
   caso="/"
      result[1]<-(valor[1]/valor[2])
   caso="+"
      result[1]<-(valor[1]+valor[2])
   caso="-"
      result[1]<-(valor[1]-valor[2])
   caso="*"
      result[1]<-(valor[1]*valor[2])
   outrocaso
      escreval ("O sinal de operação ",opera[vtpos]," Inexistente")
      interrompa
   fimescolha
   escolha opera[2]
   caso="/"
      result[2]<-(result[1]/valor[3])
   caso="+"
      result[2]<-(result[1]+valor[3])
   caso="-"
      result[2]<-(result[1]-valor[3])
   caso="*"
      result[2]<-(result[1]*valor[3])
   outrocaso
      escreval ("O sinal de operação ",opera[vtpos]," Inexistente")
      interrompa
   fimescolha
   escolha opera[3]
   caso="/"
      result[3]<-(result[2]/valor[4])
   caso="+"
      result[3]<-(result[2]+valor[4])
   caso="-"
      result[3]<-(result[2]-valor[4])
   caso="*"
      result[3]<-(result[2]*valor[4])
   outrocaso
      escreval ("O sinal de operação ",opera[vtpos]," Inexistente")
      interrompa
   fimescolha
   escolha opera[4]
   caso="/"
      result[4]<-(result[3]/valor[5])
   caso="+"
      result[4]<-(result[3]+valor[5])
   caso="-"
      result[4]<-(result[3]-valor[5])
   caso="*"
      result[4]<-(result[3]*valor[5])
   outrocaso
      escreval ("O sinal de operação ",opera[vtpos]," Inexistente")
      interrompa
   fimescolha
   limpatela
   escreval (" ")
   escreval ("_____________________________________________________________________________")
   escreval (" ")
   escreval ("   Como Foi Calculado os Valores Nas Seguintes Posições ")
   escreval (" ")
   escreval ("Expressão Numérica do Calculo => (",valor[1],opera[1],valor[2],")",opera[2],"(",valor[3],")",opera[3],"(",valor[4],")",opera[4],"(",valor[5],") = ")
   escreval (" ")
   escreval ("(",valor[1],opera[1],valor[2],") = ",result[1])
   escreval ("(",result[1],opera[2],valor[3],") = ",result[2])
   escreval ("(",result[2],opera[3],valor[4],") = ",result[3])
   escreval ("(",result[3],opera[4],valor[5],") = ",result[4])
   escreval ("_____________________________________________________________________________")
   escreval ("")
   escreval ("")
   escreval ("")
   escreval ("")
   escreval ("-----------------------------------------------------------------------------")
   escreval ("Resultado do Calculo é => ",result[4])
   escreval ("-----------------------------------------------------------------------------")
   escreval (" ")
   escreval (" ")
   escreva (" Deseja Realizar outro Calculo Sim ou Não - use S OU N ? :")
   leia (opcao)
   se opcao="S" entao
      escreval ("")
      logic<-1
   senao
      logic<-6
     fimse
     limpatela
  fimenquanto
fimalgoritmo // fim de algoritmo

Algoritmo "calculadora"
// Autor : Thallyson Pereira Torres

// Data : 19/05/2008
var valor:vetor[1..5]de real
    resultado:vetor[1..5]de real
    operacao:vetor[1..4] de caractere
    opcao: caractere
    posicao1, posicao2, posicao3:inteiro
    n_1, n_3, n_4:inteiro
inicio
repita
   limpatela
   posicao3<-1
   posicao1<-1
   posicao2<-1
   Escreval("_________________________________________________________________________________")
   Escreval(" ")
   Escreva("Quantos valores você deseja caucular (máximo 5 valores)? ")
   Leia(n_1)
   n_4<-n_1
   escolha n_1
   caso=2,3,4,5
      Escreval("_________________________________________________________________________________")
      Escreval(" ")
      n_3<-n_1-1
      Para posicao1 de 1 ate n_1 faca
         Escreval ("")
         Escreva ("Insira o ",posicao1,"º número: ")
         Leia(valor[posicao1])
      Fimpara
   Outrocaso
      Limpatela
      Interrompa
   Fimescolha
   Escreval("_________________________________________________________________________________")
   Escreval("Escolha a operação matemática (/,*,+,-): ")
   Escreval("  ",valor[posicao2])
   Para posicao3 de 1 ate n_3 faca
      posicao2<-posicao2+1
      Leia (operacao[posicao3])
      Escreval("  ",valor[posicao2])
   Fimpara
   Escolha operacao[1]
      caso ="/"
         resultado[1]<- valor[1]/valor[2]
      caso ="*"
         resultado[1]<- valor[1]*valor[2]
      caso ="+"
         resultado[1]<- valor[1]+valor[2]
      caso ="-"
         resultado[1]<- valor[1]-valor[2]
   fimescolha
   Escolha operacao[2]
      caso ="/"
         resultado[2]<- resultado[1]/valor[3]
      caso ="*"
         resultado[2]<- resultado[1]*valor[3]
      caso ="+"
         resultado[2]<- resultado[1]+valor[3]
      caso ="-"
         resultado[2]<- resultado[1]-valor[3]
   fimescolha
   Escolha operacao[3]
      caso ="/"
         resultado[3]<- resultado[2]/valor[4]
      caso ="*"
         resultado[3]<- resultado[2]*valor[4]
      caso ="+"
         resultado[3]<- resultado[2]+valor[4]
      caso ="-"
         resultado[3]<- resultado[2]-valor[4]
   fimescolha
   Escolha operacao[4]
      caso ="/"
         resultado[4]<- resultado[3]/valor[5]
      caso ="*"
         resultado[4]<- resultado[3]*valor[5]
      caso ="+"
         resultado[4]<- resultado[3]+valor[5]
      caso ="-"
         resultado[4]<- resultado[3]-valor[5]
   fimescolha
   escreval("  ___")
   escolha n_4
   caso =2
      escreval("  ", resultado[1])
   caso =3
      escreval("  ", resultado[2])
   caso =4
      escreval("  ", resultado[3])
   caso =5
      escreval("  ", resultado[4])
   fimescolha
   Escreval("_________________________________________________________________________________")
   Escreva("Gostaria de realizar outro calculo (s/n)? ")
   leia (opcao)
ate opcao = "n"
fimalgoritmo