Simon Viegas

Desculpe a demora... tive uma reunião de "emergência"... Vamos lá: 1- Só um detalhe: inverta a atualização do código. Algo assim: qtd <- qtd +1 escreva ("Digite o código do produto: ") leia (cadprod[qtd].codigo) escreva ("Digite o nome do produto: ") leia (cadprod[qtd].item) escreva ("Memória ram: ") leia (cadprod[qtd].memo) escreva ("Armazenamento Interno: ") leia (cadprod[qtd].arm) escreva ("Tamanho da tela: ") leia (cadprod[qtd].tela) Muito mais simples atualizar antes e usar o atualizado. 2- Sobre uso de programas Rpz, eu até via essa parte... mas acho complicado, rs. Se "visualizando" os resultados já está difícil assimilar os conteúdos, sem a ferramenta, piorou... Caso já tenha passado do prazo, não tem problema! Você pode ainda terminar esse programa e depois entregar (ou não)... a ideia está no aprendizado que vem no caminho... mesmo que não valha nota! Sobre qual a parte. Seria algo aqui: escreva ("Digite o código do produto: ") leia (cadprod[qtd].codigo) //aqui uma estrutura de repetição que vai ficar repetindo até que o código informado não exista escreva ("Digite o nome do produto: ") leia (cadprod[qtd].item) escreva ("Memória ram: ")

Então, é um misto retroalimentado: para saber como fazer, você precisa ter experiência; para ter experiência, você precisa ir sabendo como fazer; que para saber como fazer precisa de experiência... um ciclo infinito e paradoxal. Daí, simplesmente vai fazendo... uma hora ficha cai. Você precisaria fazer isso: Uma função é um procedimento que, ao mesmo tempo, é como uma espécie de variável: Repare ali que tem :inteiro. E, apenas, que dentro da função utilizam-se o comando retorne para salvar o valor que deseja que fique na função. Por isso, que ao usar: O p vai vai receber o valor que definiu lá no retorne dentro da função... aí, pelo contexto, existiu uma lógica antes, de modo que "vai ser retornar OU o valor da posição, OU -1 caso não encontre o código. Mas o papel da função é esse: "fazer algo e retornar nela mesmo um valor". Apenas estamos utilizando essa característica de retornar algo de uma forma útil para o contexto. Mas relaxe... uma hora entende. Esse conceito depois visto universalmente em outras linguagens... essa base muito parecida em qualquer linguagem. O VisualG está sendo apenas um mecanismo mais amigável, sobretudo em está em Português.

Funciona assim... o que um procedimento faz? A função é exatamente* a mesma coisa!! Igualzinho*... o que muda é que as funções tem TAMBÉM a característica de retornar algo nela mesma... ela funciona como uma pseudovariável. Então, ao "entender como as funções funcionam", eu idealizei que poderia criar uma para que ela retorne a posição do código que passei por parâmetro "nela mesma", logo, usei p para "copiar a resposta". Resumidamente: p vai ter OU o valor da posição onde o código está, OU p vai ter -1, que para o contexto representa que não encontrou o código. Quando fazemos : x <- RaizQ(49) Já identificamos que RaizQ() é uma função, pois se fosse procedimento, não traria nada nela mesma. Essa função não vai lá e mostra na tela "A raiz de 49 é 7". Não, ela foi feita de modo que ao passar um número por parâmetro (49), ela vai lá (sei não como) calcular a raiz de 49 e retornar 7 nela mesma... logo, x vai ficar com 7. As funções e procedimento fazem o que o programador quiser fazer... apenas essa função foi idealizada assim... "recebe um valor por parâmetro e devolve raiz quadrada desse valor nela mesma". Obs.: nada impediria dessa função também escrever na tela..."A raiz de 49 é 7". Pode, se quiser... poderia também retornar qualquer valor... apenas foi definido para retornar um valor real que, para o contexto, é a raiz do valor passado no parâmetro... Retornar um valor nela mesma é uma propriedade de funções... elas conseguem fazer isso. Já retornar um valor que faça sentido para nós, seria apenas uma "coincidência". Não tem que ser assim, apenas foi programado por alguém para ser assim. E podemos "reaproveitar" o uso dessa função apenas chamando ela (entra naquela questão de reaproveitação).

@Igornascimento, sugiro fazer assim: crie uma função para localizar a posição que está o item desejado. Essa função vai OU retornar a posição onde está o item, OU algum valor que representa que não encontrou, por exemplo -1; para pesquisa, você chama essa função, passando por parâmetro o código que deseja pesquisar. Se a função não retornar -1 (ou o valor escolhido), então a função achou o item. Logo, utilize essa posição que foi retornada para acessar a posição desejada e assim exibir os dados; para não deixar repetir, é análogo, você chama essa função, passando por parâmetro o código que deseja pesquisar. Se a função não retornar -1 (ou o valor escolhido), então a função achou o item. Logo, esse código já está cadastrado, daí você pede para informar outro código. Se retornar -1 é porque esse código (tecnicamente) não existe. Essa função para buscar a posição eu já informei.. segue: Para usar a função, segue também o exemplo dado: Obs.: nesse exemplo acima a posição dos "[]" acho que está errado (seria depois de codProd), mas tanto faz!!! O cerne é que: você vai tentar localizar o valor da posição e vai utilizar a resposta como desejar. Para pesquisa, usa para posicionar o vetor para exibir os dados... para cadastrar, vai utilizar para saber se já existe ou não. Qualquer dúvida é só postar. ADENDO: vou deixar o fórum aberto aqui. Ao responder, aguarde também um pouco... que aí tentamos responder um ao outro mais rapidamente. No aguardo. ADENDO 2: Só para frisar. Funções e Procedimento são exatamente* a mesma coisa!!! Não* tem diferenças entre eles!!! É apenas uma estrutura que pode ser invocada em outras partes do código... serve tanto para facilitar a repetição, por exemplo, como você precisaria localizar a posição tanto para pesquisa, tanto para evitar cadastro duplicado, ter uma função ou procedimento vai servir para reaproveitar... caso contrário, teria que "copiar a lógica em ambos as partes"... evita redundância. Tanto serve para organizar... seu programa não precisaria de funções ou procedimento, apenas fica mais organizado separar cada uma das partes em "blocos" diferentes... imagine aí como iria ficar "bagunçado" lá o menu com um mondo de código dentro de cada caso? A "novidade aí na função" é que está utilizando parâmetro... mas isso NÃO tem nada a ver que está utilizando função em vez de procedimento, apenas porque faz mais sentido informar qual o código que deseja por parâmetro, em vez de ler dentro da função. Poderia ser assim: funcao buscaPosicaoItem(): inteiro var i: inteiro resultado: inteiro cod: inteiro inicio escreval("Digite o Código do Item que deseja pesquisar (ex: 91): ") leia(cod) resultado <- -1 para i de 1 ate codItem faca se (cod = cadprod.codigo[i]) entao resultado <- i fimse fimPara retorne resultado fimFuncao Aí, na parte de pesquisar não precisar ler o código: cod: inteiro p: inteiro inicio p <- buscaPosicaoItem() //<-- aqui a função vai retornar OU a posição do item OU -1 se (p = -1) entao //aqui verifica se não encontrou escreval("Código não encontrado") Por que código estaria lendo dentro da função.. isso apenas tem a ver com organização.. eu acho melhor da outra forma... a função simplesmente recebe o valor de fora. Ela fica voltada apenas no seu papel: tentar encontrar a posição. Já "ler o código", deixo isso para a parte que precisa dessa posição, sacou? ADENDO 3: Faça o código ao seu tempo... caso deseje, te ajudamos a refatorar todo o código... se puder e quiser, acho que dá tempo também... aí vai revisando cada uma das características. A medida que vai aprendendo/assimilando, todo e qualquer programa pode ir seguindo os mesmos princípios, onde cada vez mais você apenas se preocupará com as lógicas, e cada vez menos com as sintaxe da linguagem e/ou padrões de organização de estruturas

@Matheus Dutra e @VISUALG, esse código abaixo já seria uma resposta completa para o primeiro exercício: Para rodar, lá no VisualG, pressiona F9; ou, caso queira ir percorrendo linha a linha, ir pressionando F8. Recomendo baixar e utilizar a versão 3.0.6.5. É a versão mais estável!! (em detrimento da 3.0.7.0). Link para download: https://sourceforge.net/projects/visualg30/files/VISUALG3_REV60.rar/download Só baixar e descompactar. Não precisa instalar nada. Aí deixa a pasta no lugar desejado: Adendo: eu deixo preparado para ficar guardado num Drive Virtual. No caso escolhi o OneDrive. Exemplo: C:\Users\simon.viegas\OneDrive\Simon\_My Portable\_Programação\VisualG v3.0.6.5 Pronto! Fica disponível para quando precisar e e mais fácil para gerenciar entre computadores. (Só sincronizar o OneDrive ou ir lá e baixar.) @VISUALG, tente fazer o segundo e poste o código completo aqui.

@joao031029, por favor: qual programa está utilizando para editar e compilar o código? poste o código completo para revisarmos e também servir de base para outros visitantes. No aguardo.

Criei um novo tópico, já que se trata de outro exercício. Qual programa está utilizando para editar e compilar o código? Por favor, poste o código completo que já fez e onde está com dúvidas. No aguardo

O VisualG também utiliza um "Portugol" ("português estruturado"... que é uma pseudolinguagem)... mas a sintaxe é diferente do utilizado, por exemplo, num Portugol Studio da vida... Aqui, o Portugol meio que seria uma tentativa de tradução do Pascal / Delphi... Como no exemplo que postei mais acima, muda algumas coisas... Por exemplo: - o tipo da variável fica depois, em vez de antes; - para criar um "bloco de comandos" é basicamente utilizado "inicio" + "fimAlgumCoisa", em vez de "{" "}"; Entre outras diferenças.. Mas a base é bem semelhante.

@Matheus Dutra, creio que o "\n" não funciona no VisualG.

Você precisa fazer alguma coisa... aplique o básico do que já aprendeu; assista vídeos sobre Portugol e VisualG. Refaça exemplos prontos da internet etc. Vamos lá: Sobre: Sugiro, para todo e qualquer programa, ir fazendo o programa aos poucos. Primeiramente você precisa entender o enunciado. Como se calcula uma área de um ambiente? Oh! Lá! Tem tudo no enunciado... se tiver dúvidas, pesquise na internet como se calcula uma área... (Isso não tem nada a ver com a implementação do código em si, mas apenas para se familiarizar com o problema.) Exemplo de implementação inicial: algoritmo "Exercício 01" // Disciplina : [Linguagem e Lógica de Programação] // Professor : Antonio Carlos Nicolodi // Descrição : Aqui você descreve o que o programa faz! (função) // Autor(a) : Nome do(a) aluno(a) // Data atual : 09/06/2021 //1)Escreva algoritmo que calcule a Área de um ambiente (Largura X Altura), // imprimindo o resultado. var inicio fimAlgoritmo Daí vai dando continuidade... algoritmo "Exercício 1" // Disciplina : [Linguagem e Lógica de Programação] // Professor : Antonio Carlos Nicolodi // Descrição : Aqui você descreve o que o programa faz! (função) // Autor(a) : Nome do(a) aluno(a) // Data atual : 09/06/2021 //1)Escreva algoritmo que calcule a Área de um ambiente (Largura X Altura), // imprimindo o resultado. var largura, altura: real inicio escreval("Infome os dados do ambiente") escreva ("Largura: ") leia(largura) escreva ("Altura: ") leia(altura) fimAlgoritmo Vai rodando (F9) e vendo como vai ficando e vai ajustando... vai dando continuidade... algoritmo "Exercício 1" // Disciplina : [Linguagem e Lógica de Programação] // Professor : Antonio Carlos Nicolodi // Descrição : Aqui você descreve o que o programa faz! (função) // Autor(a) : Nome do(a) aluno(a) // Data atual : 09/06/2021 //1)Escreva algoritmo que calcule a Área de um ambiente (Largura X Altura), // imprimindo o resultado. var largura, altura: real areaAmbiente: real inicio escreval("Infome os dados do ambiente") escreva ("Largura: ") leia(largura) escreva ("Altura: ") leia(altura) areaAmbiente <- largura * altura escreval("Área do ambiente: ", areaAmbiente:1:3, " m²") fimalgoritmo Basicamente poderia ser isso para esse exercício. Caso necessário, faça ajustes. Pronto! Caso deseja, refaça o programa do zero... vá lendo e redigitando esse código acima... vá mudando uma coisa ali e aqui... vá fazendo testes... Depois, tente fazer o segundo seguindo essa mesma base acima. Qualquer dúvida é só postar.

Sobre: Do que eu lembrava, sequer funcionava use de vetores de registros no VisualG... mas parece que está funcionando bem! Sobre: Vide: Oh! Lá, o nome está diferente. Outras coisas: - se você definiu a função para receber um valor inteiro, você precisa passar esse valor, caso contrário, retire esse parâmetro; - você declarou como função, mas não está utilizando o retorno dessa função para nada, ou seja: simplesmente utilize um procedimento em vez de função. Sobre: Você tentou fazer isso como?

@RenanMusico, o segredo é: sempre mantenha seu código indentado. Vide: programa { inclua biblioteca Texto --> txt inclua biblioteca Util --> ut inclua biblioteca Arquivos --> arq funcao inicio() { jogo() } funcao jogo() { inteiro indice, auxiliar, tamanho cadeia entrada cadeia linha, letra,formar_palavra[100] logico acertou, repetiu inteiro acertos,erros inteiro arquivo = arq.abrir_arquivo("./jogo.txt", arq.MODO_LEITURA) linha = arq.ler_linha(arquivo) tamanho = ut.numero_elementos(formar_palavra) acertos = tamanho erros = 6 para(arquivo = 0; arquivo < tamanho; arquivo++) { formar_palavra[arquivo]= "_" } enquanto (acertos > 0 e erros >0) escreva("\nDigite Uma Letra","\nSuas tentativas restantes são:",erros) para (arquivo = 0; arquivo < tamanho; arquivo++) { escreva(formar_palavra[arquivo]) } escreva(" :") leia(letra) acertou = falso repetiu = falso para(arquivo = 0; arquivo < tamanho; arquivo++) { se(letra == formar_palavra[arquivo]) { se(formar_palavra[arquivo] == letra) { repetiu = verdadeiro } acertou = verdadeiro formar_palavra[arquivo] = letra acertos-- } } se(repetiu == verdadeiro) { escreva("\nVocê ja digitou essa letra\n\n") } senao se(acertou == verdadeiro) { escreva("\nVocê acertou continue !!!\n\n") } senao { erros-- escreva("\nVocê errou tente novamente\n\n") } se(acertos == 0) { escreva("\nParabéns você acertou a palavra '-' ") para(arquivo = 0; arquivo < tamanho; arquivo++) { escreva(formar_palavra[arquivo]) } } se(erros == 0) { escreva("\nQue pena não foi dessa vez tente a sorte novamente\n\n") } arq.fechar_arquivo(arquivo) } } Oh! Aqui: Você colocou para ficar repetindo essa linha...

@flordeserto, poste o que já conseguiu fazer e em qual parte está com dúvidas.

@Alexsander Romandini, como já está entregue, vou tentar reanalisar ponto a ponto: 1# Sobre a leitura dos números A leitura dos números no seu código está repetitiva. Veja: Observe que está lentado os mesmo dados e dá mesma forma 4 vezes... Bastaria ler uma vez só. Exemplo: leia(menu) escreva ("Digite o 1º numero:") leia(num[1]) escreva ("Digite o 2º numero:") leia(num[2]) escolha menu caso ("1") num[3] <- num[1]+num[2] escreval(num[1], "+", num[2], "=", num[3]) caso ("2") num[3] <- num[1]-num[2] escreval(num[1], "-", num[2], "=", num[3]) 2# Utilização do vetor Me pareceu que ficou tudo certo! 3# Sobre a formatação das respostas Segue um exemplo da formatação atual: Adição: Subtração: Divisão: Multiplicação: Observe como os sinais das operações e o sinal de igual estão colados ao números da esquerda... bastaria alinhar. Exemplos: Ou insere os espaços onde precisaria inserir: caso ("1") num[3] <- num[1]+num[2] escreval(num[1], " +" , num[2], " =", num[3]) caso ("2") num[3] <- num[1]-num[2] escreval(num[1], " -" , num[2], " =", num[3]) Ou insere uma formação nos números e faz os ajustes: caso ("1") num[3] <- num[1]+num[2] escreval(num[1]:1, " + " , num[2]:1, " = ", num[3]:1) caso ("2") num[3] <- num[1]-num[2] escreval(num[1]:1, " - " , num[2]:1, " = ", num[3]:1) Observe que os números normalmente insere um espaço a esquerda... o que não faz muito sentido... daí, poderia remover esses espaços com o :1 e depois ir inserindo espaços onde deseja. Nesse caso, veja como o 5 ficou encostado a esquerda... e que os espaçamentos entre os "símbolos" são controlados por espaços no próprio texto. Fica mais fácil de organizar. Entretanto, quando for para números reais precisará decidir se vai deixar casas decimais fixas (algo como :1:3) ou se vai deixar livre, deixaria o resultado sem a formatação. Exemplos: Assim: escreval(num[1]:1, " / ", num[2]:1, " = ", num[3]:1:3) Ou assim: escreval(num[1]:1, " / ", num[2]:1, " =", num[3]) 4# Proteção contra divisão por 0 No teu código você está verificando novamente o valor do menu: Assim... errado, errado, não estaria, mas, como está dentro do "caso 3", essa verificação estaria redundante... daí, para o contexto, não seria necessário essa verificação. Poderia ficar assim: caso ("3") enquanto (num[2] = 0) faca escreval("Impossível dividir por Zero !") escreval("digite novamente o divisor " ) leia(num[2]) fimEnquanto 5# Menu com laço de repetição Me parece tudo ok também. Aí só verificaria se ficaria melhor limpar a tela a cada loop ou não. Sem limpar parece que ficou bom, mas se quiser treinar, tente ajustar para limpar a tela após exibir o resulto e voltar para o menu.

Não exatamente... apenas tente absorver que: uma função é exatamente* a mesma coisa que um procedimento... simplesmente o que muda é que uma função também retorna um valor nela mesma... esse valor é atribuído lá pela comando retorne... Para fazer uma analogia, inverta... um procedimento nada mais é que uma função que não retorna nada nele mesmo... no resto.. ambos são idênticos! Segue um exemplo de uso para o contexto: procedimento pesquisar_item() var i: inteiro cod: inteiro p: inteiro inicio escreval("Digite o Código do Item que deseja pesquisar (ex: 91): ") leia(cod) p <- buscaPosicaoItem(cod) se (p = -1) entao escreval("Código não encontrado") senao escreval("---------------------------------------") escreval("Código : ", cadprod.codigo[p]) escreval("Produto : ", cadprod.item[p]) escreval("Descrições : ", cadprod.descricao[p]) escreval("---------------------------------------") fimSe escreval ("Pressione ENTER para voltar ao menu") leia(opc) fimProcedimento Não testei o código acima, mas é algo por aí... a função serviria apenas para retornar a posição desejada... Abaixo demonstro como seria sem uso da função: procedimento pesquisar_item() var i: inteiro cod: inteiro p: inteiro inicio escreval("Digite o Código do Item que deseja pesquisar (ex: 91): ") leia(cod) p <- -1 para i de 1 ate codItem faca se (cod = cadprod.codigo[i]) entao p <- i fimse fimPara se (p = -1) entao escreval("Código não encontrado") senao escreval("---------------------------------------") escreval("Código : ",cadprod.codigo[p]) escreval("Produto : ",cadprod.item[p]) escreval("Descrições : ",cadprod.descricao[p]) escreval("---------------------------------------") fimSe escreval ("Pressione ENTER para voltar ao menu") leia(opc) fimProcedimento Entende? Esse código acima funcionaria da mesma forma... só que ao usar uma função, possibilitaria reutilizar essa mesma característica de encontrar a posição p, da qual foi idealizada para ter a posição do item encontrado (ou o "código" -1 para identificar que não encontrou). Tudo isso é uma abstração.. uma forma de idealizar mesmo... Daí, lá quando você quiser não implementar um código repetido, você poderia usar a função (ou esse trecho que o substituiu) para verificar o código.. se retornar um valor diferente de -1, é porque o código já existe, concorda? Daí você faz ler outro..

Sim. Eu comentei isso... veja lá na postagem 6#. A pesquisa seria meio que análoga ao listar, só que só "listaria" o que o código fosse igual... Para tentar ajudar, poderia ser algo como: procedimento pesquisar_item var i: inteiro cod: inteiro inicio escreval("Digite o Código do Item que deseja pesquisar (ex: 91): ") leia(cod) para i de 1 ate codItem faca se (cod = cadprod.codigo[i]) entao escreval("---------------------------------------") escreval("Código : ",cadprod.codigo[i]) escreval("Produto : ",cadprod.item[i]) escreval("Descrições : ",cadprod.descricao[i]) escreval("---------------------------------------") escreval ("Pressione ENTER para voltar ao menu") leia(opc) fimse fimPara fimProcedimento Daí você vai testando e refinando... Sobre: Você fala em relação a diferença de função e procedimento? A resposta seria: são praticamente a mesma coisa! Uma função nada mais seria que um procedimento que ao mesmo tempo retorna um valor nela mesma... Como assim? O leia() é um procedimento, pois ela "faz algo e não retorna nada nela mesma"... Não dá para fazer algo como x = leia(). Sacou? Já um raizQ() da vida é uma função, pois ela "faz algo e ao mesmo tempo retorna algo nela mesma". Exemplo: x = raizQ(9). Observe que a função meio que seria um procedimento e uma variável a mesmo tempo... só isso. Uma função é um procedimento que tem retorno nela mesma... Para exemplificar e já tentando ajudar também, poderia fazer algo como: funcao buscaPosicaoItem(cod: inteiro): inteiro var i: inteiro resultado: inteiro inicio resultado <- -1 para i de 1 ate codItem faca se (cod = cadprod.codigo[i]) entao resultado <- i fimse fimPara retorne resultado fimFuncao Aí, tanto para pesquisar, tanto para verificar se já existe, poderia utilizar essa função... aí usa o retorno.. Vai retornar -1 quando não encontrar ou vai retornar a posição de onde está o código informado.... dá mesma forma, poderia ir testando e refinando... Adendo: nesse exemplo eu coloquei para receber o código já no parâmetro... mais, caso prefira, pode colocar para ler o código dentro da função, da mesma forma que já fez antes... lembre-se: a única coisa que mudou aí seria o uso desse retorne, ou seja: você poderá pegar o valor retornar lá onde chamar essa função e usar como desejar. Tente entender a base do funcionamento, daí criando a sua própria lógica.

Isso aqui acho que não tem nada a ver... Depois é só mantar o código indentado e arrumar os "bigodes". programa { inclua biblioteca Matematica --> mat funcao inicio() { //c =(a+b)/2 //f(x) = y=x²-2x²-3x = -5 /*a = 3b = 4 c= (a+b)/2 Ya 3³-2 * 3² -3 * 3 -5 = yb yc se (ya* yc < 0) a = a b = c senao a = c b = b repetir 10 vezes */ real a = 0.0 real b = 0.0 real c = 0.0 real f = 0.0 real ya = 0.0 real yb = 0.0 real yc = 0.0 real op1 = 0.0 real op2 = 0.0 real op3 = 0.0 real op5 = 0.0 real op6 = 0.0 real op7 = 0.0 real op4 = 0.0 real op8 = 0.0 real op9 = 0.0 real i =0.0 a = 3.0 b = 4.0 //encontrasmos o c c = (a+b)/2 para(i=0.0; i<=10; i++) { //f = { //encontramos o resutado de ya op1 = mat.potencia(a , 3.0) op2 = 2 * mat.potencia(3.0, 2.0) op3 = 3.0*3.0 ya = op1 - op2 - op3 -5 //encontramos o resultado de yb op4 = mat.potencia(b , 3.0) op5 = 2 * mat.potencia(b, 2.0) op6 = 3*b yb = op4 - op5 - op6 -5 //encontramos o resultado de yc op7 = mat.potencia ( c, 3.0) op8 = 2 * mat.potencia ( c, 2.0) op9 = 3 * c yc = op7 - op8 - op9 -5 se (ya * yc < 0) { a = a b = c } senao { a = c } b = b } } }

@Alexsander Romandini, finalize o código... Poste o código completo e em qual parte está com dúvidas.

@arfneto, eu acho que entendi o que você quis dizer, mas já para mim, acho que eu não consegui transmitir o que eu queria.. Não tem nada a ver com "testar logo" ou de "qualquer jeito", pelo contrário... seria tentar seguir aquilo que supostamente foi pedido... por exemplo: se eu compro uma pizza numa pizzaria e peço ketchup para temperar (enunciado), meio que não caberia ao garçom (programador) me trazer um azeite virgem, argumentando que "não se coloca ketchup em pizza. Tome aqui seu azeite", entende? Talvez, após o garçom já ter uma experiência e base melhor, chegar para o cliente e argumentaria: "senhor, não seria melhor um azeite em vez de ketchup ?". Então, no contexto eu estaria focando no que supostamente foi pedido: "muito obrigado pela sugestão, mas eu quero ketchup". Veja: não estou dizendo que foi isso que o enunciado pediu, mas apenas que foi o que eu definir o que poderia ser feito. (Por meu entendimento dos requisitos - errado ou não -, e não por atalhos.) Tem lá: Eu não sei até que ponto pode está implícito a necessidade ou não de uma "refatoração seguindo os padrões mais aceitos ou adequados"... acho que simplesmente estamos abordando um mesmo problema com visões diferentes. Então, a minha ideia seria que... se o código está de determinada forma, poderia/deveria seguir um mesmo suposto padrão... do código... a ideia de ter problemas poderia ser justamente o foco do exercício... entender que dessa forma vão ocasionar problemas e seria esses problemas que ele espera lá em : Ou seja: "quais problemas deram ao implementar e testar dessa forma?". Talvez um ponto relacionado seria: "Ora! se o conceito de FIFO é pré-definido, para que iria sugerir a implementação um código para ter as respostas? Bastaria responder pelo conceitos FIFO e os outro princípios já citados de pilha... não precisaria de um código para supor o resultado final. Já "implementando" errado, teria um contato mais próximo dos problemas, podendo chegar a algo como: A minha visão seria para uma jornada de entendimento... Acho que se resumiria a esse ponto: Ou seja: eu estou levando em consideração que deveria ser feito aquilo que supostamente teria sido solicitado... só isso. No caminho vai assimilando mais coisas.. mas entendo também essa proposta de refatorar. ADENDO: [adicionado posteriormente] Achei uma resposta na internet... minha interpretação seria parecida: O que divergiria seria que p.primeiro e p.ultimo seriam inicializados com 0. Logo: 1- A variável p.ultimo iria receber -1, e não 0; 2- Daí inseriria na posição -1, 0 e 1; //sim! nos testes o C armazena os dados numa posição inválida 3- Iria exibir na tela apenas as posições 0 e 1. //já que não faria sentido iniciar a impressão do -1, já que não é atualizado o p.primeiro. Obs.: mesmo no código dele, deveria exibir do segundo em diante.. não faz sentido (para o contexto) atualizar o p.primeiro . Fonte: https://brainly.com.br/tarefa/43765231 Resumindo: não fez o menos sentido inicializar com 1, já que o vetor começa do 0.

Resumindo: Primeiro apenas traduz a palavra: "UNICESUMAR" daria: 21 14 9 3 5 19 21 13 1 18 Só que, como quer "cifrar", incrementa com um valor arbitrário, como por exemplo o 4: "UNICESUMAR" resultaria em: 25 18 13 7 9 23 25 17 5 22 Por fim.. a definição "desse valor arbitrário" sugeria de OUTRA lógica lá... (que pode ser tratado posteriormente... ou seja: não precisa tentar fazer tudo de uma vez... OU tenta encontrar o valor do código; OU tenta codificar utilizando um código qualquer. Depois junta uma coisa com a outra.) Adendo: vejam... se o valor do código der errado, é praticamente impossível que a criptografia seja correta... logo: cada "pequena parte" do programa, como sugestão, precisaria ser feito separadamente... Seria algo assim: cada coisa que está implementando, precisa ter uma boa certeza que está correta... daí, implementar varias coisas ao mesmo tempo tende a tonar mais complicado identificar onde e o que está errado... Por exemplo, vamos testar o valor do resto: Veja que no seu código deu 30, mas deveria dar 4, veja: Logo, ANTES de tentar traduzir, você precisaria focar apenas no cálculo desse resto... OU, como sugeri, apenas definir que o resto é 4 e focar apenas na criptografia. ADENDO: independente do código utilizado, ao criptografar e decifrar, o resultado daria certo, pois para esse caso o valor do código não importa, importa apenas que tanto para criptografar, tanto para decifrar, utilizem o mesmo valor!!!. Entretanto, o contexto do enunciado subentende que necessariamente o código lá deveria dar 4, pois faz parte da fluxo... (Mesmo que eventualmente não faça diferença.)

@devair1010, não sei se foi uma pergunta retórica... mas vou tentar complementar: O propósito do problema é codificar uma palavra. Daí, para tanto precisaria "traduzir cada letra da palavra para o seu código (valor da posição) no alfabeto acrescido de um valor arbitrário".

@Eric level, segue algumas dicas para reorganizar o código (e ajudar a focar mais na lógica): 1# Pré-defina os valores para o testes Exemplo: // escreval ("Digite os caracteres da mensagem original, utilize um "." Para finalizar: ") // para i de 1 ate 20 faca // leia (original[i]) // se (original[i] = ".") entao // original[i] <- "" // Interrompa // fimse // fimpara original[1] <- "U" original[2] <- "N" original[3] <- "I" original[4] <- "C" original[5] <- "E" original[6] <- "S" original[7] <- "U" original[8] <- "M" original[9] <- "A" original[10] <- "R" original[11] <- "" E faz a mesma coisa com o RA: RA <- 19510095 resto <- 4 escreval ("RA: ", RA:1, " - RESTO: ", resto:1) Pronto. Você terá o original e o resto de uma forma prática... não ficar perdendo tempo.. 2# Cada variável deveria ser apenas utilizada para o propósito dela Exemplo: Ali dentro do se você está sobrescrevendo o conteúdo da palavra original (que está no vetor original)... isso não seria interessante. Sugeriria ter outra variável para armazenar o valor decifrado... a "palavra" decifrada não é a mesma "palavra" que a original... ela é uma palavra nova, apenas, pelo contexto, elas devem ser iguais entre si... entende? Poderia utilizar algo assim: var original, cifrado, decifrado: vetor [1..20] de caractere São 3 coisas distintas... fazendo assim, por exemplo, daria para você comparar se o conteúdo do original está igual ou não ao valor do decifrado. (Afinal, esse é o objetivo do algoritmo.) 3# Codificação de letras para número e vice-versa A minha sugestão é procurar tentar dividir o problema maior em parte menores... ou seja: procurar identificar uma parte do todo. Vamos lá: Aqui você queria que, para a palavra for "GHI", o programa retorne o código "789"? Algo do tipo? Se sim, tente simplificar.. que tal em vez de 3 letras, você tente responder apenas para 1 letra? Você concorda que para traduzir 3, precisaria traduzir 1 no processo? Vamos exemplificar um contexto para apenas uma letra: Exemplos: Letra informada: A Resultado esperado: 1 Letra informada: H Resultado esperado: 8 Letra informada: T Resultado esperado: 20 Agora perceba... o que você (supostamente) quer seria um conjunto de letras ao mesmo tempo, correto? Então PRIMEIRO consiga resolver com uma letra só... cria uma lógica para ela... depois de conseguir, verá que pode surgir outros problemas... por exemplo: Palavra informada: AHT Resultado esperado: 1820 Ao tentar, verá que se você tentar "somar" 1 + 8 + 20 vai dar 29, e não 1820... e aí? Perceba que, como você já sabe traduzir a letra, agora só irá se preocupar em como "concatenar" números... então, agora imagine tentado fazer as duas coisas ao mesmo tempo (saber traduzir e saber concatenar)??? Sacou? São 2 problema distintos.. ambos necessitam de um esforço... (A medida que vai testando e aprendendo/relembrando vai conseguindo fazer mais coisas ao mesmo tempo, mas a ideia seria sempre procurar fazer coisas mais simples antes de tentar ir direto por mais complexo.) Pelo o contexto do programa, você não precisará desses códigos concatenados, ou seja: o resultado não presaria ficar numa variável só, mas apenas ter cada código separado, que poderia ser armazenado num vetor... pronto! Seria algo do tipo: Palavra informada: AHT Resultado esperado: 1 //na posição 1 do vetor 8 //na posição 2 do vetor 20 //na posição 3 do vetor Minha sugestão... faça isso: "Leia uma letra do usuário e retorne a posição dessa letra no alfabeto." Só depois, tente fazer a tradução de um vetor de caracteres completos... Por fim, verás que para cifrar a palavra, você simplesmente precisaria incrementar o valor de resto para cada código encontrado... só isso. Para decifrar, o oposto: decrementa o valor de resto.

@Eric level, por favor, poste o enunciado completo da questão.

Você sabe me dizer se como vai ficar o display no código, eu tentei achar uma explicação nas minhas aula e não consegui achar algum exemplo. Se souber de algum exemplo ficarei grata @brunacamily, como vai ficar iria depender do que foi "exigido" num enunciado... se lá tiver dizendo que você vai simplesmente escrever "Bora Bahêa", você vai lá e escreve isso... então, o que constaria lá seria: Suponho que ele quer que exiba todos os dados da pilha... isso fazendo um sentido técnico ou não... Você vai lá e "exibe a pilha". Aí, como vai exibir, como não está especificado no enunciado, vai da sua criatividade e bom senso. Lá na minha postagem anterior fiz um exemplo indicando a posição e o valor que está nela. Segue outro exemplo: 7 5 3 Esse primeiro elemento de baixo podendo ser exibido ou não... mais lá em baixo comento. Perceba que essa tentativa acima seria simplesmente uma forma de mostrar os dados com eles empilhados... um em cima do outro... como seria numa pilha imaginária... na ordem que foi inserido.. daí, para sair assim precisaria ir lá no código e ajustar de forma que saia assim (seu papel)... Que basicamente seria ir imprimindo na tela o vetor em ordem inversa e pulando uma linha para cada elemento. Ficando um em cima do outro. Absorva que o cerne do conceito de pilha está lá no FIFO... "imaginar" um em cima do outro seria simplesmente uma forma natural de pensar... que faz sentido biológico no dia-dia.. mas que não seria obrigado e ficar um em cima do outro... lembre-se: o cerne está no conceito de FIFO, não importa como estão alinhados ou organizados visualmente... mas seria mais sugestivo seguir uma representação natural, né? Entende? Em relação ao exercício, teria que entender qual seria a proposta dele... particularmente entendo que, se ele quer de determinada forma, faz dessa forma... nada impende de ao mesmo tempo você entender que algumas pontos poderiam eventualmente ser feitos de outras formas mais corretas depois. Minha sugestão: simplesmente implemente cada uma das funções... faça algo! Desse funcionando! E poste o código completo aqui.. Depois, caso necessário, faz outra versão com "melhores práticas" ou ajudamos a "arrumar". Exemplo de base: #include<stdio.h> #define tam 10 struct pilha { int dados[tam]; int primeiro; int ultimo; }; pilha p; void pop(){ p.dados[p.ultimo-1] = 0; p.ultimo--; } void push(int x){ } void display() { } int main(void) { pop(); push(3); push(5); push(7); display(); } Exemplo de resultado: Se fosse imprimir do p.ultmo até o p.primeiro. Não sai o 3, pois estaria numa posição que não existe no vetor. Acredito que esse seria o comportamento esperado para o exercício. Se fosse imprimir do p.último até o a posição -1... apenas para demonstrar que tá lá... Essa exibição seria só para demonstrar mesmo que de algum modo o dado é salvo, mesmo numa posição que não deveria existir. Coisas do C (ou da versão que coloquei para compilar aqui). Por fim... depois, reajustaria todo o código para que ele fique da forma mais correta... que iria "corrigir" também os problemas do código atual (que você eventualmente implementaria antes). Vide: 1 - iria "remover" um elemento que sequer foi empilhado; ("Ficaria meio que com um saldo negativo".); 2 - iria inserir os elementos nas posições -1, 0 e 1; 3 - iria exibir os 2 últimos elementos, mas em ordem invertida entre si. Ou seja: posteriormente seguiria as orientações do @arfneto, que corrigiria os problemas que o suposto código do enunciado tem. - passar a receber os dados externos às funções por parâmetro, em vez de usar variável global; - implementar e usar as funções para prevenir ações inválidas como remover do vazio e inserir num cheio; etc RESUMINDO: OU o enunciado quer que você siga um mesmo fluxo que já está lá e informe o que aconteceria; OU o enunciado quer que você refatore todo o código e crie uma pilha seguindo os principais conceitos fundamentais do C e pilhas em geral. A minha sugestão é que você faça as duas coisas!

@Eric level, poste o enunciado completo da questão e tente demonstrar mais ou menos o que está tentando fazer... Adendo: Para facilitar a tua vida, você não precisa ficar digitando toda a hora o "original". Inseria logo no código... Exemplo: // escreval ("Digite os caracteres da mensagem original, utilize um "." Para finalizar: ") // para i de 1 ate 20 faca // leia (original[i]) // se (original[i] = ".") entao // original[i] <- "" // Interrompa // fimse // fimpara original[1] <- "V" original[2] <- "I" original[3] <- "S" original[4] <- "U" original[5] <- "A" original[6] <- "L" original[7] <- "G" original[8] <- "" Depois que tiver funcionando bem você faz testes com mais palavras.