Simon Viegas

Seria bom especificar qual o erro, mas vamos lá... Uma dica inicial é: não tente fazer todo o programa de uma vez. Vá fazendo por partes e testando. Vou exemplificar utilizando essa técnica, veja: Montando um esboço inicial: algoritmo "Questão 1" //Escrever um algoritmo que leia uma nota e mostre o conceito equivalente. //Suponha a seguinte tabela de conversão //Nota Conceito //7 a 10 A //4 a 6 B //1 a 3 C //0 REPROVADO var nota : real inicio escreva (" Informe a nota: ") leia(nota) escreval(" Nota informada: ", nota:1:2) fimAlgoritmo Daí testa para ver se está lendo certinho... Teste bem bobo. Só para ir pegando o ritmo mesmo. Adicionando uma verificação: var nota1 : real inicio escreva (" Informe a nota: ") leia(nota1) se (nota1> =7 ou <=10) então escreval (" Conceito A") fimSe fimAlgoritmo Testando: Oras! se está com erro nessa linha, para que raios eu continuaria implementando o resto? Entende? Tenta entender e corrige logo. Tá. Aqui temos vários errinhos. 1. precisa especificar a comparação para cada valor, ou seja, seria algo como: se (nota1 > =7 OU nota1 <= 10) então 2. o operador relacionado é junto, ou seja, ">=". Sem espaço entre eles: se (nota1 >=7 OU nota1 <= 10) então 3. por fim, precisa explicitar a separação das sentenças, no caso, utilizando os "(): se ((nota1 >= 7) OU (nota1 <= 10)) então Adendo: esse par de parênteses externos são facultativos. Eu particularmente prefiro assim. OK! A sintaxe está correta agora, vamos testar a lógica: Opa! 5 não é maior que 7 e menor que 10... tem algo errado aí! Ah! ali não é OU, mas sim E. se ((nota1 >= 7) E (nota1 <= 10)) então Testei com alguns valores, como 5, 7, 9 e 10.. todos deram certo! Pronto. Agora implementa mais alguma coisa. Segue por enquanto onde estaria: algoritmo "Questão 1" //Escrever um algoritmo que leia uma nota e mostre o conceito equivalente. //Suponha a seguinte tabela de conversão //Nota Conceito //7 a 10 A //4 a 6 B //1 a 3 C //0 REPROVADO var nota : real inicio escreva (" Informe a nota: ") leia(nota) se (nota >= 7) E (nota <= 10) então escreval (" Conceito A") senao se ((nota >= 4) E (nota <= 6)) então escreval (" Conceito B") fimSe fimSe fimAlgoritmo Testei com outros diversos valores e passaram de boa... parece tudo certo. Mas ué!? Resolvi testar com 6.5 e não funcionou? Essa nota existe! Deveria dar "Conceito B", mas não deu! Consegue identificar o que está errado? Daí deixo para você parar para corrigir isso e depois implementar o "Conceito C". Dica: você precisa incluir os valores entre 6 e 7, correto?. Logo, poderia utilizar "nota < 7", em vez de "nota <= 6". Percebe a diferença? No aguardo.

Complementado: 1# Sobre inicialização das variáveis Faltou inicializar o TOTMED. Pois pau que dá em Chico dá em Francisco..., ou seja, é necessário manter a coerência no código. Já que iniciou um, teria que inicializar os outros caos semelhantes. Exemplo: TOTMED <- 0.0 Obs.: o VisualG já inicializa as variáveis globais automaticamente, ou seja, o desenvolvedor da "IDE" VisualG já programou o "compilador" para fazer isso por nós. As variáveis numéricas já ficam com "0" ao rodar o programa. Experimente criar um variável e depois já exibir o seu valor na tela. Desta forma, não seria necessário reinicializá-las com 0, certo?... Entretanto, como esse comportamento não é comum em outras linguagens de programação*, não vejo problemas em deixar assim. Seria o que chamaríamos de "boa prática". 2# Sobre cálculos de médias Você está calculando a médias N vezes, mas só precisa calcular uma vez só!!! Não? Logo, o cálculo da média poderia ficar após o fimPara. 3# Sobre os casos Creio que meio que dependeria do enunciado... Mas de um modo geral, o 0 seria nulo E seria múltiplo de 5 ao mesmo tempo, certo? Logo, o código estaria parcialmente correto... Só faltou considerar que o 0 também é par! Daí, uma alternativa seria adicionar a verificação do zero também dentro do se do par, o que me pareceria deixar código redundante; outra poderia simplesmente deixa 3 se separados. Exemplo: se (N = 0) então TOTNUL <- TOTNUL + 1 fimSe se (N % 5 = 0) então TOTDIV <- TOTDIV + 1 fimSe se (N % 2 = 0) então TOTPAR <- TOTPAR + N fimSe Segue uma demonstração de resultado: (deixei com 3 valores para ficar mais simples) PS: lembrando que o 0 é par. Daí, 10 + 0 = 10... Mas ele está sendo somando.

Ah! Sim! Perfeito! Seria apenas para o 44. Sobre o 45: Aqui existiu duas soluções distintas: uma invertendo trocando os valores iniciais e finais entre si, outra solução foi utilizando o inverso oposto do incremento. As duas formas ficaram interessantes e acho que válidas... O enunciando não me deixou muito claro também, mas para mim fez mais sentido trocar os valores mesmo (como o primeiro código do @devair1010), pois um incremento negativo deixaria de ser incremento, estaria virando um "decremento"... sei lá... Mas a ideia foi muito boa! PS: Nesse primeiro código, como o intervalo se mostrou fechado para o valor inicial, me faz mais sentido que o final também seja fechado. Exemplo: De: Para: enquanto inicioV <= fimV faca Ou seja: incluindo o valor final de poder está no intervalo. Se digitou 1, 9 e 2, vai sair 1, 3, 5, 7 e 9 (em vez de 1, 3, 5 e 7).

@Beatriz Dorin, o código ficou muito bom! Apenas faltou contextualizar melhor... como também inserir o enunciado completo na postagem. Adendo: Como o 0 (zero) é o elemento neutro da adição, essas operações são desnecessárias... (modo sutil de dizer "inúteis", rs). Basta apagar essas duas linhas. Ah! E no "nome do programa", pode inserir espaços... Ex.: Algoritmo "Seletor de Pessoas"

Tentar resumir... Tem dois ponto centrais: primeiro que seria inicializar o menorF, já que ela que para as mulheres... e compararia a idade com ela, ou seja, a idade tem que ser menor que a idade das mulheres, e não a geral. Segundo: se estiver se referindo a inicializar com um valor alto... se é gambiarra ou não, teria que parar para analisar melhor... me parece gambiarra mesmo, mas é bem comum e é em partes lógico. Uma forma de contornar isso seria "atribuir o primeiro valor como sendo o inicial menor". Exemplifico abaixo. Entendo que essa verificação é desnecessária para o contexto. Basicamente a sugestão seria apenas se atentar ao enunciado, ou seja, nele não fala nada de "regras de negócios". Tipo: e se digitar o sexo alguma coisa que não seja "M" ou "F"? E se digitar letras para idade? Existem outros pontos que precisariam ser abordados... Basicamente devem-se supor que os dados devem ser inseridos corretamente... Daí, poderia, se quiser, fazer um outro programa "mais sofisticado" a parte... com essas "melhorias"... Segue um exemplo base: algoritmo "Aqui um nome para o programa" //Crie um programa que leia o sexo e a idade de várias pessoas. O programa vai //perguntar se o usuário quer continuar ou não a cada pessoa. No final, mostre: //a) qual é a maior idade lida //b) quantos homens foram cadastrados //c) qual é a idade da mulher mais jovem //d) qual é a média de idade entre os homens var sexo, resp : caractere idade, contM, maiorIdade, menorIdadeF, somaIdadeM : inteiro mediaIdadeM : real inicio repita escreva ("Qual é seu sexo M/F? ") leia(sexo) escreva ("Qual é sua idade? ") leia(idade) se (idade > maiorIdade) então maiorIdade <- idade fimSe se (sexo = "M") então contM <- contM + 1 somaIdadeM <- somaIdadeM + idade senao se (sexo = "F") então se ((menorIdadeF = 0) OU (idade < menorIdadeF)) então menorIdadeF <- idade fimSe fimSe fimSe escreva ("Quer continuar S ou N? ") leia(resp) ate (resp = "N") se (contM > 0) então //requisito matemático (se for zero o mundo explode) mediaIdadeM <- somaIdadeM / contM fimSe escrevaL(" A maior idade é: ", maiorIdade:1) escrevaL(" São ", contM:1, " homens") escrevaL(" A menor idade feminina é ", menorIdadeF:1) escrevaL(" A média da idade dos homens é ", mediaIdadeM:1) fimAlgoritmo Adendo Exemplo de problemas com dados incorretos: O "j" não é um tipo de sexo. Zero é plural? Se for um... vai ficar com "são" também.. ou seja: tudo isso seriam detalhes que iriam ALÉM do enunciado..., já que não é pedido para se preocupar com esses "detalhes". Como citado: pressupõem que os dados serão inseridos corretamente. PS: observem que "verificar se existem homens" antes de calcular a média é implicitamente necessário, pois caso contrário, vai travar o programa! Computador não sabe dividir por zero muito bem.

Eu faria algo assim: algoritmo "Contador com incremento" // Função: Conta do número inicial ao final com incremento // Autor : Simon Viegas // Data : 30/01/2023 //44) Crie um algoritmo que leia o valor inicial da contagem, o valor final e //o incremento, mostrando em seguida todos os valores no intervalo: Ex: Digite //o primeiro Valor: 3 Digite o último Valor: 10 | Digite o incremento: 2 | //Contagem: 3 5 7 9 Acabou! var valorInicial, valorFinal, incremento : inteiro i : inteiro inicio escreva ("Digite o primeiro valor: ") leia(valorInicial) escreva ("Digite o último valor: ") leia(valorFinal) escreva ("Digite o incremento: ") leia(incremento) para i de valorInicial ate valorFinal passo incremento faca escreva (i) fimPara escreval(" Acabou!") fimalgoritmo

@ALoneW, basta se atentar a lógica da coisa... veja: Basicamente observe que essas condições "NÃO são excludentes entre si". Por exemplo: TODAS as pessoas que tem 100kg, também tem 90kg... certo? . Entende? Um senão seria como um "oh! só veja daqui em diante se o que já veio antes não foi aceito". (Isso levando em consideração uma cadeia. No caso, esses 3 se funcionam como se fossem uma estrutura só. Resumidamente: nessa ordem que colocou NUNCA vai entrar na 3º se, pois sempre antes vai entrar no 1º. Tente seguir os passos.. veja: "digitei 101 (kg) e 1.92 (m)... vai cair no primeiro se... 101 é maior que 90? Sim!. P90 é atualizado. Vai pro fim da cadeia (pois pra isso que serve o senão...) e executa lá a atualização do cont. que está depois da cadeia. Dica: vá pressionando F8 e seguindo o fluxo do VisualG. Tem algumas formas de contornar esse problema... mas enfrente-o (em vez de já darmos uma solução). Entenda o que está ocorrendo, entenda como funciona a estrutura em cadeia que montou... e implemente uma solução válida. No aguardo.

@Isabella Borges da Silva, poderia fazer o programa aos poucos. Faça um programa que leia dois números inteiros e imprima todos os números inteiros entre o primeiro e segundo. Só isso.

@Casca Grossa, um ponto que poderia ser evitado seria essa repetição de códigos (dos escolha).

Um outro exemplo: algoritmo "maior e menor" var num, maior, menor : inteiro primeiro : logico inicio primeiro <- VERDADEIRO repita escreva ("Digite o numero: ") leia(num) se num <> 0 então se primeiro então maior <- num menor <- num primeiro <- FALSO senao se(num > maior) então maior <- num senao se menor > num então menor <- num fimSe fimSe fimSe fimSe ate num = 0 se maior <> 0 então escrevaL( "Maior -> ", maior:1) escrevaL( "Menor -> ", menor:1) senao escrevaL("Nenhum valor diferente de 0 foi informado") fimSe fimalgoritmo

@Rafael Cezar, a ideia ficou muito boa, mas teu algoritmo não atende ao requisito do problema. Em nenhum momento do teu algoritmo está sendo tratada a "não repetição de valores", ou seja, é possível que valores se repitam. Exemplo para demonstrar: Outro ponto é que o laço de repetição para "já controla a sua varável de controle"... ou seja, não precisa/não deve ficar atualizando ela dentro do laço. Em vez de: Seria algo como: para i de 0 ate 9 Faca numero[i] <- RandI(100) fimPara Observe que deixei o i para ser usado como controle... mas tanto faz... se utilizar c, r, girafa, dkadkwkdw, ou qualquer nome válido. O ponto aqui que a variação dessa variável será justamente a variação das posições do vetor, logo, poder ser usado diretamente no vetor. Sobre: Então, quem armazena o valor é o vetor... a variável i serve apenas para controlar a posição do vetor. Seu código simplifica poderia ficar assim: algoritmo "Número Aleatório Vetor" var numero: vetor[0..9] de Inteiro i, c, r: Inteiro inicio para i de 0 ate 9 Faca numero[i] <- RandI(100) fimPara para i de 0 ate 9 Faca escreval(numero[i]) fimPara fimAlgoritmo

Só faltou comentar em qual parte não está conseguindo... Caso deseje, por favor, poste o código que tentou fazer e onde está com dúvidas... assim tentar entender o que poderia está errado lá e aproveitar para "aprender com os erros"... Aproveitando a sugestão de código enviado pelo @devair1010, segue: Sobre a execução (utilização) dos métodos que o@Leonan sm deseja..., inseri comentários no próprio código, vejam: Resumindo: Ou criaria cópias de vetores para enviar separadamente para cada função; Ou ajustaria as funções para retornarem um vetor ordenada... sem mexer no vetor original. Em relação à semântica do nome da variável, seria tipo deixar apenas "numeros"... ou seja, o vetor ora estaria fora de ordem, ora estaria ordenado... mas deixando "_ale" fica sugerindo que ainda está ordenado... Só para exemplificar: Por fim, esse código abaixo não é Bubble Sort. Veja por exemplo aqui (https://en.wikipedia.org/wiki/Bubble_sort) e compare. Seria semelhante... mas não é a mesma coisa... (entra na questão da semântica, ou seja, a ideia que "o nome das coisas meio que precisam representar aquilo que ele é").

ADENDO: o comando retorne no VisualG não finaliza o fluxo da função, ou seja, o programa continua seguindo o fluxo normalmente até chegar no fimFuncao. Nas maiorias das principais linguagens de programação, como javascript, existe o comando análogo return... este sim já finaliza, ou seja, ao executar o return, seria como se automaticamente também já executasse o "fimFuncao". O que isso muda? Se o VisualG "fosse como os outros", poderia fazer algo assim: funcao Adicionar (elemento: inteiro) : logico inicio se (Cheia()) então retorne FALSO //não vai funcionar corretamente, pois vai continuar //e acabar retornando o VERDADEIRO lá de baixo fimSe topo <- topo + 1 pilha[topo] <- elemento retorne VERDADEIRO fimFuncao Entende? Ali no topo, seria como uma "regra de validação". Se tiver cheia, iria executar o retorno, e a função iria já finalizar... Fica mais simples e elegante. Se não tiver cheia, vai pular e continuar normalmente... Para testar, vá pressionando F8... e acompanhando linha a linha o que está sendo executado... ADENDO 2: não! Você não pode colocar um fimFuncao dentro do se. Algo como: funcao Adicionar (elemento: inteiro) : logico inicio se (Cheia()) então retorne FALSO fimFuncao //não pode fazer isso! fimSe topo <- topo + 1 pilha[topo] <- elemento retorne VERDADEIRO fimFuncao ADENDO 3: da mesma forma... NÃO! NÃO PODE colocar fimAlgoritmo em qualquer outra parte do código. Se fizer isso, vai rodar, pois o VisualG é problemático e o código meio que é "interpretado". (Não tem um mecanismo de compilação para apontar o erro.)

Isso. A cada ciclo é gerado apenas um valor, daí fica complicado tentar gerar dois valores ao mesmo tempo. Você precisa entender primeiramente o cerne do problema (o que é uma Sequencia de Fibonacci?), daí tentar entender o algoritmo que gera essa sequência. Por fim, criar um algoritmo que gera determinada sequência ("gerar os 15 primeiros números da Sequencia de Fibonacci"), ou seja, atender ao enunciado... RESUMO - entender o que é Sequência de Fibonacci. Se te perguntar o que é você sabe responder? - saber gerar uma Sequência de Fibonacci. Se te perguntar, você sabe gerar uma? - atender aos requisitos do enunciado. Você precisa gerar um código que faça aquilo que está sendo pedido. (Isso vale para qualquer enunciado, vale para qualquer problema, ou seja, precisa ser feito aquilo que foi pedido para ser feito)

Basicamente está declarando as funções com uma sintaxe errada. Vejam um exemplo de como deveria ser aqui: https://www.apoioinformatica.inf.br/produtos/item/18-funcoes Resumidamente: no VisualG, o retorno é pelo comando retorne (Ex.: retorne VERDADEIRO) . Diferente do Pascal (pai do VisualG), onde o retorno é na própria função mesmo. (Ex.: vazia := true). Para ajudar a identificar melhor, remova o limpaTela() e veja que já dá problema na hora de empilhar. Exemplo para o Adicionar(): funcao Adicionar (elemento: inteiro) : logico inicio se (Cheia()) então retorne FALSO senao topo <- topo + 1 pilha[topo] <- elemento retorne VERDADEIRO fimSe fimFuncao Exemplo para o Cheia(): funcao Cheia() : logico inicio se (topo >= LIM) então retorne VERDADEIRO senao retorne FALSO fimse fimFuncao Por aí vai.

@paulogomes.84, tente fazer algo. Poste o que já conseguiu fazer e onde está com dúvidas.

@paulogomes.84, só fazer o que eu sugeri. Vá fazendo aos poucos. Vai e lê a quantidade. É isso. Ele tá pedindo a "quantidade de alunos do sexo masculino e a quantidade de alunos do sexo feminino", ou seja, para cada aluno você vai precisar ler o seu respectivo sexo. Fica implícito. Precisa ir exercitando a abstração. Por aí vai... A dica geral é ir fazendo aos poucos.. NUNCA tente fazer tudo de uma vez. Exemplo inicial: algoritmo "Gerenciar até 50 números em um vetor" // Disciplina : Astrofísica // Professor : Mestre Picapau // Autor(a) : Fulano de Tal // Data atual : 14/11/2022 //[ignorado]Considerando as informações apresentadas no gráfico [/ignorado], //elabore um algoritmo utilizando a ferramenta VisualG para: //a) Leia a quantidade de alunos matriculados em cursos de graduação em 2017. //b) Após leitura das informações mostre as classificações conforme a //quantidade de alunos: //i. do sexo masculino e feminino. //ii. modalidade de matricula dos alunos nas respectivas modalidades de ensino. //iii. quantidade de universidades públicas e provadas que participaram da amostra. var qtdAlunos : inteiro inicio escrevaL("Relatório de Alunos 2017") escrevaL("") escreva ("Quantidade alunos ") leia(qtdAluno) fimAlgoritmo Pronto.. já resolvi o primeiro requisito! Ou não? Vamos pro segundo... Vendo o sexo: ... var qtdAlunos : inteiro i : inteiro sexo : caractere inicio escrevaL("Relatório de Alunos 2017") escrevaL("") escreva ("Quantidade alunos ") leia(qtdAlunos) para i de 1 ate qtdAlunos faca escreva ("Sexo do aluno ", i:1, ": ") leia(sexo) fimPara fimAlgoritmo Calculando a quantidade por sexo: var qtdAlunos : inteiro i : inteiro sexo : caractere qtdSexoMasculino, qtdSexoFeminimo : inteiro inicio qtdSexoMasculino <- 0 qtdSexoFeminimo <- 0 escrevaL("Relatório de Alunos 2017") escrevaL("") escreva ("Quantidade alunos ") leia(qtdAlunos) para i de 1 ate qtdAlunos faca escreva ("Sexo do aluno ", i:1, ": ") leia(sexo) se (sexo = "M") então qtdSexoMasculino <- qtdSexoMasculino + 1 fimSe se (sexo = "F") então qtdSexoFeminimo <- qtdSexoFeminimo + 1 fimSe fimPara fimAlgoritmo No painel do VisualG já dá para verificar se está lendo corretamente: Mas uma boa forma de verificar é exibir os valores na tela... ainda mais que vai precisar exibir de qualquer forma. Exemplo: ... fimSe fimPara escrevaL("") escrevaL("Quantidade Masculino: ", qtdSexoMasculino:1) escrevaL("Quantidade Feminino : ", qtdSexoFeminino:1) fimAlgoritmo O "i" tá praticamente todo feito... só ir ajustado os detalhes, caso necessário. Daí, montem todo código acima e adicione um próximo item. Exemplo: Será basicamente a mesma coisa... Mas lembre-se: não tente fazer tudo de uma vez. Adiciona só uma coisa nova e vai ajustando. Caso queira ajustar alguma coisa que já foi feita, idem: para para ajustar somente uma coisa... testa até ficar bom e avança mais um pouco. No aguardo.

@paulogomes.84, a mesma sugestão:

"Um" erro? Aí não ajuda! Qual erro está dando? Adendo: Para adiantar... não lembro se o VisualG aceita "procedimento dentro de procedimento". Daí, deixe separados.. (não vai fazer diferença). Exemplo: Algoritmo "Procedimentos" // Disciplina : Algoritmos // Professor : Livro Algoritmos // Descrição : Excercios do Livro // Autor(a) : Lorenzo Nunez // Data atual : 10/11/2022 Const fim = 10 Var vetA: vetor[1..fim] de caractere Procedimento Entrada Var i: inteiro Inicio para i de 1 ate fim faca escreva("Digite o",i,"º: ") //leia(vetA[i]) vetA[i] <- Carac(Asc("A") + RandI(9)+1) escrevaL(vetA[i]) fimpara Fimprocedimento Procedimento Troca (var a, b: caractere) Var x: caractere Inicio x <- a a <- b b <- x Fimprocedimento Procedimento Ordenacao Var i, j: inteiro Inicio para i de 1 ate fim-1 faca para j de i+1 ate fim faca se (vetA[i] > vetA[j]) então Troca(vetA[i],vetA[j]) fimse fimpara fimpara Fimprocedimento Procedimento Processamento Inicio Ordenacao() Fimprocedimento Procedimento Saida Var i: inteiro Inicio para i de 1 ate fim faca escreval("[",vetA[i]," ]") fimpara Fimprocedimento Inicio // Seção de Comandos, procedimento, funções, operadores, etc... Entrada() Processamento() Saida() Fimalgoritmo

@Laura Tchaly, conseguiu avançar?

@paulogomes.84, poste o que já conseguiu fazer e onde está com dúvidas.

A cada ciclo só é gerado um valor. Exemplo: algoritmo "Sequência de Fibonacci" // Descrição : mostrar os 15 primeiros valores da Sequência de Fibonacci var v1, v2, novotermo, cont: inteiro inicio escreval("========================") escreval(" Sequência de Fibonacci") escreval("========================") escreval("") v1 <- 0 v2 <- 1 escreva (v1) escreva (v2) para cont <- 3 ate 15 faca novotermo <- v1 + v2 escreva (novotermo) v1 <- v2 V2 <- novoTermo fimPara fimAlgoritmo - imprime o 0 - imprime o 1 - durante total vezes -2 -- gera o próximo termo -- imprime o próximo termo -- atualiza o primeiro termo -- atualiza o segundo termo - finaliza o programa

@Laura Tchaly, tente fazer primeiro lá o outro algoritmo em

@Laura Tchaly, é sempre bom tentar fazer algo e postar onde está com dúvidas. Mas vamos lá... Uma sugestão é deixar o enunciado no próprio código... Assim fica mais fácil para consultar. Exemplo: algoritmo "Gerenciar até 50 números em um vetor" // Disciplina : // Professor : // Autor(a) : Laura Tchaly // Data atual : 05/11/2022 //Faça um programa, utilizando o VisuALG, que armazene 50 números em um vetor. //O programa terá a opção de adicionar, buscar, ordenar ou remover os dados. O //programa deverá ter as seguintes condições: //ADICIONAR //Somente adicione números com as seguintes faixas: //Faixa 1 -> Entre 1 e 20 (inclusos) //Faixa 2 -> Entre 50 e 60 (inclusos) //Faixa 3 - Entre 100 e 120 (inclusos) //Não adicione números que estão fora das faixas //Eftuar uma pesquisa para saber se o número existe ou não no vetor //Se existir, informar que o número já se encontra presente no vetor e não //adicione //Caso não exista, verifique se o vetor está ou não lotado antes de inserir //PESQUISAR: //O usuário poderá escolher entre a pesquisa sequencial ou binária //Se a pesquisa binária for selecionada, informe que o vetor deve estar //ordenado e deixe o usuário escolher a ordenação antes de efetuar a pesquisa //ORDERNAR: //O usuário poderá escolher qual o método de ordenação desejado: BubbleSort ou //Insertion Sort. //Se o vetor já estiver ordenado, informe para o usuário e não faça a ordenação var inicio fimAlgoritmo Daí, recomendado se aprofundar no enunciado. Ler e reler várias vezes. Assimile que precisa fazer. Não é muito sensato tentar resolver um problema do qual não sabe do que se trata. Daí, tentar abstrair o problema maior (resultado final completo) em problemas menores ou mesmo mais simplificados... por exemplo... em vez se seguir todas essas regras, inicialmente poderia criar estruturas mais simples, como apenas ler números quaisquer e exibir depois esses números na tela . . . var numeros : vetor[1..5] de inteiro i : inteiro inicio //aqui coloque para ler 5 números //aqui coloque para exibir esses 5 números lidos fimAlgoritmo Sugiro inicialmente fazer isso. Aos pouco vá adicionado novas funcionalidades. Não tente fazer tudo de uma vez. Vá adicionando coisas bem simples... no final vai ficando mais "complexo" naturalmente. No aguardo

Se a referência for VisualG, precisa ter as quebras de linhas entre os comandos (não integrados). Ex.: algoritmo "Tabela de preços" var codigo : inteiro inicio escreva ("Digite o codigo do produto: ") leia(codigo) escolha codigo caso 1 escreval("Maçã R$ 1,90") caso 2 escreval("Laranja R$ 1,45") caso 3 escreval("Abacaxi R$ 2,79") outrocaso escreval("Produto inexistente" ) fimEscolha fimAlgoritmo Ou seja: todas essas linhas acima precisam estar separadas (por linhas). Duas ou mais não podem ser agrupadas em uma linha só. Como notório, "escolha codigo" faz parte de uma estrutura só... e nesse caso ocorre o contrário: precisam estar na mesma linha... isso é devido às características dessa "linguagem" ou mesmo por limitação técnica. Um exemplo utilizando laço de repetição: algoritmo "Tabela de preços" var codigo : inteiro inicio repita escreva ("Digite o codigo do produto (ou 0 para sair): ") leia(codigo) se (codigo <> 0) então escolha codigo caso 1 escreval("Maçã R$ 1,90") caso 2 escreval("Laranja R$ 1,45") caso 3 escreval("Abacaxi R$ 2,79") outrocaso escreval("Produto inexistente" ) fimEscolha fimSe ate (codigo = 0) fimAlgoritmo