Simon Viegas

Adendo inicial: desculpe se estou prolixo de mais, mas a ideia é tentar analisar ponto a ponto alguns detalhes que acho importante. Vou dividir em partes. PARTE 1 Já tá explicado no "adendo" lá na postagem. Veja: No VisualG você utiliza se quiser. Em alguns linguagens famosas, são obrigatórias (faz parte da sintaxe do comando). Eu prefiro utilizar (manter o padrão mais comum, já que "no dia a dia de programador" meio que vai precisar usar mesmo)... já, por exemplo, o @devair1010, prefere sem no VisualG, assim como você fez.. . Seria uma questão de gosto. Ambas as formas eu entendo que estão perfeitamente corretas! Tanto faz! Só para deixar claro: Forma que você utilizou: se x > 10 então escrevaL("X é maior que 10") fimSe Forma que eu gosto e sugiro: se (x > 10) então escrevaL("X é maior que 10") fimSe Qual o certo? Ambas! Tanto faz. PARTE 2 Que massa! Mas será que já está toda certinha? Não estou dizendo que precisa ficar perfeita, mas você tratou dessa questão que cito abaixo? Então, você pulou isso! (Ou me ignorou). Segue trecho do teu código atual: Experimente digitar uma nota 6.7 e uma nota 3.2 e veja o que acontece. Não vai (não deve) exibir nada!, pois não estão em faixa alguma! Está certo o comportamento que ocorre? Resumindo: corrija isso. Inclusive eu também já deu uma solução. Está lá na minha resposta anterior. Aqui entra naquela questão lá de conjuntos. De intervalos abertos e intervalos fechados. Veja: Aqui está pegando "até o 7, com este incluso". Daí é fechado. No próximo, precisaria então pegar no 7 para baixo, ou seja, aberto. Ao juntar uma com a outra, toda a faixa (entre o 6 e 7, inclusos) estará inclusa. PARTE 3 Perfeito! O que eu gosto de comentar sempre que eu posso: foque no problema, e não na solução. Veja: como alguém vai resolver um problema se sequer sabe do que se trata? Parece óbvio, mas é o que mais ocorre. Então você estaria certíssimo. Precisa entender o que ele quer. Se não entendeu, pare para entender. Ah! Sim, também pode ser interessante tentar fazer alguma coisa... como começar a ler as variáveis, como você fez... mas com a ideia de tentar abrir a mente... se vem algo na cabeça que ajude a enter o que o enunciado quer. Vamos lá. Segue o enunciado: Oras! Se os 2 exercícios anteriores foram sobre "estruturas de seleção para definir algo", por que essa questão seria tão diferente (com menu, possível dupla seleção...)? De cara já me parece incoerente!!! Mas ok! Perceba: Questão 1: ler um dado e categoriza esse dado ("diz qual o conceito"). Questão 2: ler um dado e categoriza esse dado ("diz qual classe de nadador") Questão 3: ler diversos dados e depois ler qual a categoria ("qual equipe vai/pode entrar"). Ué!? Aqui ele quer que o próprio usuário defina? Além disso, essas definições têm inclusas algumas regras! Tá confuso para mim!. Mas vamos lá: Como acho que poderia fazer: Acho que poderia entrar nesse mundo do menu... segue opções que imaginei: OPÇÃO 1 Após ter os dados, exibir um menu com apenas as opções que o usuário pode entrar. Por exemplo: se informar "masculino", "altura de 1.60" e "peso de 70 kg", disponibilizaria as opções 1 e 3 (pois ambas serviriam para esse cara). Aí, se tiver mais de uma opção, o usuário selecionaria. Caso tenha só um, ele já entraria na equipe correspondente. Tipo: se o cara informasse 90 kg, ele só poderia entrar na equipe 3. Talvez esse seja uma pouquinho mais complexo. Mas acho que dá para fazer de boa. OPÇÃO 2 Após ter os dados, exibir um menu para que o usuário selecionar qual equipe entrar, mas daí, verifica se ele tem os critérios necessários ou não. ADENDO: observa que AMBAS AS OPÇÕES estão fugindo do escopo, ou seja, entraria na "liberdade poética". Uma outra boa opção seria "perguntar para quem está propondo o enunciado o que raios ele quer". - Entenda o problema; - Procure seguir o enunciado. É preciso fazer o que se pede. Se você for num restaurante e pedir um hambúrguer, seria coerente o garçom entregar um cachorro quente? Segue um esboço para exemplificar a segunda opção: (peguei emprestado a base do @devair1010) algoritmo "Definição de equipes por critérios pré-definidos" // 3 questão) // Elabore um algoritmo que receba o nome e a idade. Sexo, altura e peso. Após // cadastrar as informações deverá ser exibido um menu para o usuário escolher // em qual equipe ele será adicionado, seguindo a ordem: // Para ser da equipe 1: Sexo masculino, altura até 1,70 e até 80kg // Para ser da equipe 2: Sexo feminino , altura até 1,65 e até 70kg // Para ser da equipe 3: Sexo masculino, altura até 1,70 e até 93kg // ou: Sexo feminino , altura até 1,65 e até 70kg var nome, sexo : caractere idade, opcao : inteiro altura, peso : real inicio escreva (" Informe o seu nome: ") leia(nome) escreva (" Informe a sua idade: ") leia(idade) escreva (" Informe o seu sexo: ") leia(sexo) escreva (" Informe a sua altura: ") leia(altura) escreva (" Informe o seu peso: ") leia(peso) escrevaL() escrevaL("Escolha a equipe que deseja entrar") escrevaL(" Equipe 1: Sexo masculino, altura até 1,70 e até 80kg") escrevaL(" Equipe 2: Sexo feminino , altura até 1,65 e até 70kg") escrevaL(" Equipe 3: Sexo masculino, altura até 1,70 e até 93kg") escrevaL(" ou: Sexo feminino , altura até 1,65 e até 70kg") escreva ("==> ") leia(opcao) escrevaL() se ((opcao = 1) E (sexo = "m") E (altura <= 1.70) E (peso <= 80)) então escrevaL("Usuário ", nome, " adicionado à equipe 1 com sucesso") senao escrevaL(nome, ", você não está dentro dos critérios para entrar na equipe 1") fimSe fimAlgoritmo Com dados propositalmente inválidos para equipe 1: Inválido para o sexo. (obs.: TODOS os critérios precisam ser válidos. Se um não for, já não deve adicionar à equipe.) Com dados propositalmente válidos para equipe 1: Está dentro de todos os critérios. Por aí vai. RESUMINDO: Por favor, poste código completo da questão 1 para revisarmos. Depois, tente fazer o exercício 3 e poste o código completo e onde eventualmente está com dúvidas. No aguardo.

@ricardo_br, que top! Daria para colocar a configuração do tipo no próprio console? Algo como, após arrastar, perguntar o tipo.. aí, digitaria, por exemplo, o "txt" ou o que quiser. @Carlos Daniel Fagneli, da forma que está, poderia deixar uma cópia para cada tipo. Exemplo: GerarListaTXT.bat, GerarListaJPG_e_JPEG.bat (imagino que dá para inserir mais de um tipo de uma vez só) etc.

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