Simon Viegas

Dicas: Nomei alguns end; para deixar o código mais organizado. Facilita muito, sobretudo o código começa a ficar muito grande; SEMPRE DEIXE SEU CÓDIGO COMPILÁVEL, ou seja, vá fazendo o código por etapas e não acumule erros. Segue um exemplo de fluxo... program MiniMercado; var // Dados do produto produto1, produto2, produto3, produto4 : string; BEGIN writeln('Teste maroto'); END. Sempre que pressionar Ctrl+F9, o código deve compilar sem erros. Lembre-se sempre ir salvando também. A depender, crie cópias de arquivos separados quando fizer mudanças muitos grandes... "Vou iniciar a implementação do menu"... program MiniMercado; var // Dados do produto produto1, produto2, produto3, produto4 : string; cod1, cod2, cod3, cod4 : integer; valor1, valor2, valor3, valor4 : real; qtdEstoque1, qtdEstoque2, qtdEstoque3, qtdEstoque4 : integer; op : integer; BEGIN repeat ClrScr; TextColor(White); writeln('================================================================================'); writeln('=============================== MINI MERCADO ==================================='); writeln('================================================================================'); writeln('================================================================================'); writeln(); TextColor(LightGreen); writeln('Menu:'); writeln('1-Cadastrar Produto '); writeln('2-Iniciar Venda '); writeln('3-Encerrar Compra '); writeln('4-Controle de Estoque'); // Adicionada uma opção a mais para controle dos cadastros feitos. writeln('5-Sair '); writeln; writeln('Escolha uma das opções acima: '); readln(op); writeln(); ClrScr(); until (op = 5); END. O código continua compilável/executável. "Em vez de if/else, vou implementar com case ("switch")... program MiniMercado; var // Dados do produto produto1, produto2, produto3, produto4 : string; cod1, cod2, cod3, cod4 : integer; valor1, valor2, valor3, valor4 : real; qtdEstoque1, qtdEstoque2, qtdEstoque3, qtdEstoque4 : integer; op : integer; BEGIN repeat ClrScr; TextColor(White); writeln('================================================================================'); writeln('=============================== MINI MERCADO ==================================='); writeln('================================================================================'); writeln('================================================================================'); writeln(); TextColor(LightGreen); writeln('Menu:'); writeln('1-Cadastrar Produto '); writeln('2-Iniciar Venda '); writeln('3-Encerrar Compra '); writeln('4-Controle de Estoque'); // Adicionada uma opção a mais para controle dos cadastros feitos. writeln('5-Sair '); writeln; writeln('Escolha uma das opções acima: '); readln(op); writeln(); ClrScr(); case op of 1 :begin end; //op 1 2 :begin end; //op 2 3 :begin end; //op 3 else begin end; //else op end; //case op until (op = 5); END. Vai implementando e testando... A medida que os erros vão aparecendo, já vai corrigindo/melhorando.. Mas sempre deixe "executável". Por aí vai... program MiniMercado; var // Dados do produto produto1, produto2, produto3, produto4 : string; cod1, cod2, cod3, cod4 : integer; valor1, valor2, valor3, valor4 : real; qtdEstoque1, qtdEstoque2, qtdEstoque3, qtdEstoque4 : integer; totalVenda : real; op : integer; BEGIN totalVenda := 1234.56; //REMOVER - Apenas para testes repeat ClrScr; TextColor(White); writeln('================================================================================'); writeln('=============================== MINI MERCADO ==================================='); writeln('================================================================================'); write ('=============================================================='); TextColor(Yellow); writeln(' Total: R$ ', totalVenda:7:2); TextColor(White); {Sempre lembrar de voltar para a cor padrão da tela quando o trecho mudou a cor} writeln(); TextColor(LightGreen); writeln('Menu:'); writeln('1-Cadastrar Produto '); writeln('2-Iniciar Venda '); writeln('3-Encerrar Compra '); writeln('4-Controle de Estoque'); // Adicionada uma opção a mais para controle dos cadastros feitos. writeln('5-Sair '); writeln(); writeln('Escolha uma das opções acima: '); write ('=> '); TextColor(Yellow); readln(op); TextColor(White); writeln(); ClrScr(); writeln('================================================================================'); writeln('=============================== MINI MERCADO ==================================='); writeln('================================================================================'); write ('=============================================================='); TextColor(Yellow); writeln(' Total: R$ ', totalVenda:7:2); TextColor(White); writeln(); case op of 1 :begin produto1 := 'Ovo'; cod1 := 1427; valor1 := 24.00; qtdEstoque1 := 3; produto2 := 'Água'; cod2 := 6295; valor2 := 0.75; qtdEstoque2 := 2; produto3 := 'Arroz'; cod3 := 3790; valor3 := 9.00; qtdEstoque3 := 1; produto4 := 'Feijão'; cod4 := 1427; valor4 := 24.00; qtdEstoque4 := 5; writeln(' *** MODO DESENVOLVEDOR ATIVADO *** '); writeln('Produtos cadastrados automaticamente com sucesso'); writeln('Para a versão de PRODUÇÃO será disponibilizado o cadastro manual'); ReadKey(); end; //op 1 2 :begin writeln(' EM CONSTRUÇÃO '); ReadKey(); end; //op 2 5 :begin writeln(); writeln('Até Logo! Nos veremos em breve!'); ReadKey(); end; //op 5 else begin; writeln(); writeln('Opção Inválida! Escolha uma das opções citadas'); ReadKey(); end; //else op end; //case op until (op = 5); END.

@Jão386, massa! Eu gostava muito do Turbo Pascal, mas é 16bits... @DanielFRD, nessa fase de implementação, é possível evitar essa parte do cadastro de dados já deixando os dados cadastrados no próprio código. Pois imagine: cada vez que você for testar, terá que cadastrar tudo novamente... Não é nada produtivo e também chato pra daná. Exemplo: produto1 := 'Ovo'; cod1 := 1427; valor1 := 24.00; qtde1 := 3; produto2 := 'Água'; cod2 := 6295; valor2 := 0.75; qtde2 := 2; produto3 := 'Arroz'; cod3 := 3790; valor3 := 9.00; qtde3 := 1; produto4 := 'Feijão'; cod4 := 1427; valor4 := 24.00; qtde4 := 5; writeln(' *** MODO DESENVOLVEDOR ATIVADO ***'); writeln('Produtos cadastrados automaticamente com sucesso'); writeln('Para a versão de PRODUÇÃO será disponibilizado o cadastro manual'); ReadKey(); { //Primeiro Cadastro writeln('================================================================================'); writeln('=============================== MINI MERCADO ==================================='); writeln('================================================================================'); writeln('======================================================= Total: ',totaldavenda:2:2); writeln; writeln('cadastre seus produtos:'); writeln; . . . } Lá mais para frente, volta para implementar esse cadastro manual. Obs.: as "{ }" funcionam como um "bloco comentário", ou seja, nessa fase de implementação, deixa o código do cadastro desabilitado. Se preferir remove tudo para deixar o código mais limpo. É possível também utilizar "(**)" para comentários.

@DanielFRD, você está usando qual IDE ou programa para compilar? Como não tem "uses CRT" ou "uses WinCRT", seria o PascalZim? @Jão386, sugere usar qual IDE?

Faz sentido, mas isso o próprio @scorpionmyth2 já havia tentado e deu erro: Ou seja, o "compilador" entende que apenas a primeira expressão pertence ao se e que "não faz sentido" ter um se para encapsular um "e" (conjunção). Daqui em diante é uma explicação mais prolixa*... vamos lá: Estaria implementando algo assim: se (distancia1 > distancia2) e No caso, precisa ter um par (), com a instrução completa dentro deles, após o se e antes da próxima instrução que estará justamente sendo "protegida" pelo se. Ex.: um escreva(). Ou, como no exemplo, um bloco de instruções (que é iniciado por um "{"). Logo, funcionaria com algo assim: se (distancia1 > distancia2) escreva("A maior distancia é: ", distancia1) Mas como existem duas condições em uma única expressão lógica, a tal conjunção estaria servindo para vincular elas... Podendo ficar assim: se (distancia1 > distancia2 e distancia1 > distancia3) Aqui que tem a celeuma que citei na minha postagem anterior... Vejam: Acontece que o código acima fica meio poluído, pois poderia ser interpretado como algo assim: se (distancia1 > (distancia2 e distancia1) > distancia3) Deu para entender? Fica confuso. Tá! Abaixo a mesmíssima lógica, só que em VisualG (que também é em Portugol, mas com outra sintaxe): algoritmo "Maior distância" var distancia1, distancia2, distancia3 : inteiro inicio escrevaL("Digite o valor da primeira distancia:") leia(distancia1) escrevaL("Digite o valor da segunda distancia:") leia(distancia2) escrevaL("Digite o valor da terceira distancia:") leia(distancia3) se (distancia1 > distancia2 e distancia1 > distancia3) então escrevaL("A maior distancia é: ", distancia1) senao se (distancia2 > distancia1 e distancia2 > distancia3) então escrevaL("A maior distancia é: ", distancia2) senao se (distancia3 > distancia1 e distancia3 > distancia2) então escrevaL("A maior distancia é: ", distancia3) fimSe fimSe fimSe fimAlgoritmo Veja o que eventualmente ocorre: Deu erro em algum trecho da linha citada (VisualG nunca foi especialista em mensagens de erro). Para corrigir..... só "separar as sentenças". Veja: se ((distancia1 > distancia2) e (distancia1 > distancia3)) então escrevaL("A maior distancia é: ", distancia1) senao se ((distancia2 > distancia1) e (distancia2 > distancia3)) então escrevaL("A maior distancia é: ", distancia2) senao se ((distancia3 > distancia1) e (distancia3 > distancia2)) então escrevaL("A maior distancia é: ", distancia3) fimSe fimSe fimSe Resumindo: Mesmo que tivesse rodado sem essa separação, o código ficará mais claro com a separação clara. Esse mesmo problema do primeiro código poderá ocorrer outras linguagem mais modernas. Já evita fadiga.

Para uma melhor organização, inserir outro conjunto de parênteses para separar as sentenças. De: Para: se ((distancia1 > distancia2) e (distancia1 > distancia3)) { escreva("A maior distancia é: ", distancia1) }

@Victor Nanque, poste o texto do código e comentários sobre ele. Desta forma fica mais fácil para os visitantes copiarem e testarem.

@alinessilva, poste o que conseguiu fazer. Está com dúvida na lógica ou na implementação dela?

Para exemplificar, como existe uma verificação dupla para uma mesma coisa, poderia utilizar uma função para deixar mais organizado. Exemplo: funcao opcaoTexto (op:inteiro) : caractere var retorno : caractere inicio escolha op caso 1 retorno <- "PEDRA" caso 2 retorno <- "PAPEL" caso 3 retorno <- "TESOURA" fimEscolha retorne retorno fimFuncao Aí só usar: respJ <- opcaoTexto(opcaoJ) respC <- opcaoTexto(opcaoC)

Conseguiu como?

Achei a Unit no Github... aqui no Fórum acho que foi pro limbo (espero que não ): https://github.com/SimonViegas/unit-utilidades-pascal/blob/master/CRT_PLUS.pas

@devair1010, um detalhe: o método seria um procedimento, pois a alteração é feita diretamente na string de origem. Não tem retorno para isso. Seria algo como: string_1 <- "String " string_2 <- "Concatenada." strcat(string_1, string_2) escreval("Concatenação De String's No vsualG:" ) escreval(string_1) //"String Concatenada." escreval("") De qualquer forma, acho que o uso desse método por aqui não tem muita relação, pois, pelo que vi, lá no C teria relação com o fato dele tratar uma string como "vetor de ponteiros de letras"... É uma paradigma bem diferente.

Acho essa ideia de criar uma "biblioteca com funções extras" bem interessante. Começamos a fazer uma por aqui no Fórum para o Pascal, mas acho que sumiu!!! (não achei ). Era algo como "Unit de utilidades"... uma versão mais rica do CRT ou WinCRT... em fim.. Pelo que vi, existem diferentes sobrecargas (recurso esse não disponível para VisualG) para o método replace no C++, mas meio que o mecanismo seria um pouco diferente da sua proposta. Se puder citar qual versão se refere, agradeceria. Sugeria tentar seguir os mesmos padrões dos eventuais métodos originais... Achei um mais simples no ttps://www.educba.com/c-plus-plus-replace/ e vou usar como referência... Uma tradução pelo Google Translator: Exemplo de chamada do método: Como o VisualG não é OO, ficaria algo como: string1 <- replace(string1, start, length, string2); Ou seja: basicamente essa versão de função (pois tem várias) teria 4 parâmetros. Como o VisualG utiliza Portugol, seria coerente traduzir para português. Algo como: substitue(caractere1, inicio, tamanho, caractere2); A descrição de cada parâmetro seria algo como: Um exemplo de implementação que pensei: funcao substitue(c1:caractere; posI, tam:inteiro; c2:caractere) : caractere var i : inteiro temp : caractere inicio temp <- copia(c1, 1, posI-1) temp <- temp + c2 temp <- temp + copia(caractere1, posI+tam, compr(c1)) retorne temp fimFuncao Testando: algoritmo "Implementando uma versão do replace do C++ no VisualG" var caractere1, caractere2 : caractere funcao substitue(c1:caractere; posI, tam:inteiro; c2:caractere) : caractere var i : inteiro temp : caractere inicio temp <- copia(c1, 1, posI-1) temp <- temp + c2 temp <- temp + copia(caractere1, posI+tam, compr(c1)) retorne temp fimFuncao inicio caractere1 <- "Vamos aprender a linguagem C++ no FCdH"; caractere2 <- "VisualG"; escrevaL("Antes : ", caractere1) //Vamos aprender a linguagem C++ no FCdH caractere1 <- substitue(caractere1, 28, 3, caractere2) escrevaL("Depois: ", caractere1) //Vamos aprender a linguagem VisualG no FCdH fimAlgoritmo Ou seja: a partir da linha 28, substitua os próximos 3 caracteres pela cadeia de caracteres informada. Saiu 3 letras ("C++") e entrou "VisualG" no lugar. Esse seria um conceito de "substituir" (replace). ADENDO: Caso queria, por exemplo, substituir o separador das casas decimais de "," para ".", poderia utilizar algo assim: inicio caractere1 <- "R$ 148324,06" escrevaL("Antes : ", caractere1) //R$ 148324,06 caractere1 <- substitue(caractere1, pos(",", caractere1), 1, ".") escrevaL("Depois: ", caractere1) //R$ 148324.06 fimAlgoritmo Ou implementar uma função específica para isso.. mas acho que replace em si funciona de forma diferente, ou seja, teria um outro nome. (Não tenho experiência em programação C++.) Ai, se o objetivo for "substituir todas as ocorrências", algo como "todos as vírgulas por pontos", bastaria criar uma lógica fazendo um loop. Analogamente, a função teria outro nome diferente de "substitue" (replace).

Vamos tentar destrinchar cada ponto: Isto está ocorrendo por 2 erros centrais: você está atribuindo um valor do tipo caractere para uma variável de tipo numérica (inteiro), mas o VisualG não está dando erro; (Deveria dar!!!!!!) você está comparando um valor do tipo inteiro (da variável tipo_bem:inteiro) com um valor do tipo caractere (valor que está entre aspas duplas no se) e também o VisualG não está dando erro. (Deveria dar!!!!!!) Isso muito estranho, mas está ocorrendo! São falhas da versão do aplicativo! Provavelmente em todas... (Não testei, só imagino.) Existem algumas formas de testar para entender melhor o problema... uma delas é ir pressionando F8 e analisando linha a linha. Outra forma mais rápida é colocando um break point (F5), numa linha estratégia, como logo após o se onde está contando mais 1 para computador. Veja: É esse comando aqui: Basta pressionar F5 na linha desejada. A linha fica vermelha: Quando o VisualG executa uma linha que tem break point, o programa "para"... ficando pausando até que coloque para rodar novamente (pressionar F8 ou F9). Repare agora que interessante: A variável tipo_bem está com o valor 0 nela... Ao enviar o "c" para a variável, o VisualG, por algum motivo místico, está enviando o número 0 e armazenando na variável. Mas como sugerido mais acima, o programa deveria TRAVAR... pois são "variáveis de tipos incompatíveis". Veja um exemplo análogo do que deveria ocorrer: Inteiro não sabe receber caractere!!! Logo, deveria dar esse erro e citar a respectiva linha. Beleza... tem um 0 lá na variável... Ai vem o outro problema: como o break point está (propositalmente) dentro do se, significa que o VisualG está dizendo que 0 = "C" Concorda? Logo: basicamente o VisualG está dizendo que um inteiro qualquer é igual a um caractere qualquer! ... Em outras palavras: tá apresentando problemas! PARA RESOLVER: Só trocar de: Para: tipo_bem: caractere Só isso. Abaixo tem outros detalhes que podemos discutir: Entendo que seria o contrário. Como são condições mutualmente excludentes entre si, faz mais sentido utilizar o se/senão... pois quando uma condição é verdadeira, não precisará verificar as outras seguintes... Concordo. O escolha seria justamente uma "versão mais específica e organizada" de um conjunto de se/senão. (O que corrobora que deveria ser mesmo um conjunto de se/senão, em vez de um conjunto de se isolados.) Em relação às comparações de caracteres, não seria um bug, mas sim uma característica... ou seja: ocorre que VisualG não é Case Sensitive. A maioria das linguagens principais do dia-a-dia são, então é bom ir se acostumando mesmo... Mas aqui não precisa. Outro exemplo de característica "exótica" do VisualG (e também presente no seu pai Pascal/Delphi) é que não é preciso inicializar variáveis globais. Elas são automaticamente zeradas: Ou seja: esses 3 comandos acima seriam desnecessários. Podem apagar sem medo!... maaaaas, não custa nada deixá-los. Apenas levanto a observação de entender como funciona a "linguagem de programação"* que está utilizando. Por fim, sugeriria dar nomenclaturas de variáveis mais sugestivas, exemplo: var qtd_computador, qtd_scanner, qtd_impressora: inteiro tipo_bem: caractere continuar: caractere Uma forma de alterar todas é pressionando Ctrl+U e substituir as ocorrências necessárias. Exemplo: Vai pressionando "s" ou "n". Abaixo segue um exemplo de código mais limpo para VisualG: algoritmo "FCdH" var qtd_computador, qtd_scanner, qtd_impressora: inteiro tipo_bem: caractere continuar: caractere inicio repita limpaTela() escrevaL("-----------------------------------") escrevaL("---LEVANTAMENTO DE BENS MATERIAIS--") escrevaL("-----------------------------------") escrevaL("BENS PATRIMONIAIS: ") escrevaL(".............[C] COMPUTADOR ") escrevaL(".............[I] IMPRSSORA ") escrevaL(".............[S] SCANNER ") escrevaL("Selhecione o tipo do bens para realizar o levantamento: ") escreva ("=> ") leia(tipo_bem) escolha tipo_bem caso "C" qtd_computador <- qtd_computador+1 caso "I" qtd_impressora <- qtd_impressora+1 caso "S" qtd_scanner <- qtd_scanner+1 outroCaso escrevaL("") escrevaL("Código de item inválido") fimEscolha escrevaL("") escreva("Deseja continuar o levantamento [S] ou [N] ? ") leia(continuar) ate (continuar = "n") escrevaL("") escrevaL("---------------------------------------------------") escrevaL("Resultado do levantamento:") escrevaL("Total de Computadores: ", qtd_computador:1) escrevaL("Total de Impressoras : ", qtd_impressora:1) escrevaL("Total de Scanners : ", qtd_scanner:1) fimAlgoritmo Já esse abaixo seria implementando a questão da "inicialização das variáveis" e "case sensitive": algoritmo "FCdH" var qtd_computador, qtd_scanner, qtd_impressora: inteiro tipo_bem: caractere continuar: caractere inicio //em algumas linguagens seria necessário iniciar as variáveis "contadoras" //pois podem vir com um "lixo de memória" qtdComputador <- 0 qtdScanner <- 0 qtdImpressora <- 0 repita limpaTela() escrevaL("-----------------------------------") escrevaL("---LEVANTAMENTO DE BENS MATERIAIS--") escrevaL("-----------------------------------") escrevaL("BENS PATRIMONIAIS: ") escrevaL(".............[C] COMPUTADOR ") escrevaL(".............[I] IMPRSSORA ") escrevaL(".............[S] SCANNER ") escrevaL("Selhecione o tipo do bens para realizar o levantamento: ") escreva ("=> ") leia(tipo_bem) //utilizando a sugestão do @kgin. Comparar com o"maiúsculo do caractere" escolha maiusc(tipo_bem) caso "C" qtd_computador <- qtd_computador+1 caso "I" qtd_impressora <- qtd_impressora+1 caso "S" qtd_scanner <- qtd_scanner+1 outroCaso escrevaL("") escrevaL("Código de item inválido") fimEscolha escrevaL("") escreva("Deseja continuar o levantamento [S] ou [N] ? ") leia(continuar) //idem acima ate (maiusc(continuar) = "N") escrevaL("") escrevaL("---------------------------------------------------") escrevaL("Resultado do levantamento:") escrevaL("Total de Computadores: ", qtd_computador:1) escrevaL("Total de Impressoras : ", qtd_impressora:1) escrevaL("Total de Scanners : ", qtd_scanner:1) fimAlgoritmo EXTRA: Ainda sobre a questão do Case Sensitive, caso fosse utilizar variáveis ou constantes na comparação, poderia também tornar maiúscula (ou minúscula se fosse o caso) antes de comparar. Algo assim: Defino os código de cada item: algoritmo "FCdH" const COD_COMPUTADOR = "c" COD_SCANNER = "s" COD_IMPRESSORA = "i" var qtd_computador, qtd_scanner, qtd_impressora: inteiro tipo_bem: caractere continuar: caractere Aí ao comparar, faria: escolha maiusc(tipo_bem) caso maiusc(COD_COMPUTADOR) qtd_computador <- qtd_computador+1 caso maiusc(COD_SCANNER) qtd_impressora <- qtd_impressora+1 caso maiusc(COD_IMPRESSORA) qtd_scanner <- qtd_scanner+1 outroCaso escrevaL("") escrevaL("Código de item inválido") fimEscolha Saca? Assim você tentar garantir que estará comparando "letras com tamanhos iguais". PS: sim! Se você identificou que o código da impressora e scanner estão invertidos entre si, parabéns!

@NaieleF, justamente. Provavelmente o exercício que postou seria voltado para outra "linguagem de programação", como a utilizada no Portugol Studio, que é um Portugol também, mas que é diferente da utilizada no VisualG. Seria dessa lista de exercícios abaixo? Exercícios-de-Algoritmos-1-100.pdf Fonte: https://www.cursoemvideo.com/wp-content/uploads/2020/10/Exercícios-de-Algoritmos-1-100.pdf Se sim, lá cita o Portugol Studio mesmo... Logo, caso queira utilizar o VisualG, utilizaria o repita, que é essencialmente a mesma coisa de um faca-enquanto (a diferença entre um e outro eu cito na minha postagem anterior). Poderia ficar com algo como: algoritmo "Exercicio.61" //PASSO 06 – REPETIÇÃO COM FAÇA ENQUANTO //61) Crie um programa que mostre na tela a seguinte contagem, usando a //estrutura “faça enquanto” 0 3 6 9 12 15 18 21 24 27 30 Acabou! var C: inteiro inicio C <- 0 repita escreva (C) C <- C + 3 ate (C > 30) escrevaL(" Acabou!") fimAlgoritmo Resultado: Veja que se trata apenas da questão da escolha de uma sintaxe ("conjunto de regras que definem como escrever um código de programação de forma que o computador o compreenda"), ou seja, o VisualG seria "uma versão em português da linguagem de programação Pascal", onde no Pascal usam-se "while-do" e "repeat-until", ai no VisualG foi traduzido para "enquanto-faca" e "repita-ate" respectivamente. ADENDO: Estrutura correta para o VisualG: repita escreva (C) C <- C + 3 ate (C > 30) Possível estrutura caso o VisualG seguisse um mesmo padrão do Portugol Studio: faca escreva (C) C <- C + 3 enquanto (C <= 30) Veja que a condição do enquanto é a negação da condição do até... o que antes era "<=", passou a ser ">"... e vice-versa. Poderia fazer assim, oh!: algoritmo "Exercicio.61" //PASSO 06 – REPETIÇÃO COM FAÇA ENQUANTO //61) Crie um programa que mostre na tela a seguinte contagem, usando a //estrutura “faça enquanto” //0 3 6 9 12 15 18 21 24 27 30 Acabou! var C: inteiro inicio C <- 0 repita escreva (C) C <- C + 3 ate (não (C <= 30)) escrevaL(" Acabou!") fimAlgoritmo ADENDO 2: Uma outra característica curiosa do VisualG é que ela insere automaticamente um espaço em branco antes de imprimir valores do tipo inteiro, veja: Ou seja: o VisualG inseriu um espaço à esquerda, e você inseriu um espaço manualmente à direita, ficando assim com um espaço à esquerda lá no início, e com 2 espaços entre cada um dos números. (Está visualmente bagunçado... quando tiver contato com um tal de CSS você vai entender bem!!! kkkkkkkkk) No meu código eu retirei o " ". Veja a diferença: Uma forma de remover esses "espaços automáticos" seria utilizando uma formação com ":x", onde "x" seria o valor da quantidade de caracteres que quer reservar na impressão, exemplo: repita escreva (C:1, " ") C <- C + 3 ate (C > 30)) Resultado: Nessa formatação, não tem espaço extra... Daí precisa novamente inserir o " ", caso contrário os números ficariam colados. Agora ficou colado à esquerda e com apenas um espaço entre cada número.

@NaieleF, se for para VisualG, uma resposta curta seria: repita <instruções a serem executadas repetidamente ATÉ a expressão booleana retornar VERDADEIRO> ate (<expressão booleana>) De qualquer sorte, a questão inicial seria justamente essa: qual a linguagem* de programação que esse exercício está relacionado? Aí é só dar um google. Exemplo: "laços de repetição portugol studio" ou "laços de repetição visualg" ou "laços de repetição javascript" etc. Dá uma revisada em cada um dos laços de repetição da linguagem. Os básicos são 3... e analisa exemplos de cada um... Em Portugol Studio algo como: faca { <instruções a serem executadas repetidamente ENQUANTO a expressão booleana retornar VERDADEIRO> } enquanto (<expressão booleana>) Se prestar a atenção verás que o repita é o correspondente do faca-enquanto (do-while) de outras* linguagens (como a contida no próprio Portugol Studio). É praticamente a mesma coisa, entretanto muda que a condição usada no ate será a negação do que seria usado no enquanto. (Quando estudar e testar uma e outra entenderá bem isso.)

Sendo pragmático: não estaria correto, pois você o juiz precisa julgar de acordo com as condições do jogo (estão citadas lá no topo do código). Faltou o outro ponto: Só uns detalhes... @devair1010, sobre: Pelo verificado, só vai resultar em Papel ou Tesoura... Bastaria colocar um outro se: respM := "Pedra" se resp2 = 2 então respM := "PapeL" senao se resp2 = 3 então respM := "Tesoura" fimse fimse Sobre: Apesar de não acusar erro, o comando aleatório aceita 1 ou 2 parâmetros, pois ele funciona gerando "...dados numéricos aleatórios estabelecendo uma faixa de valores mínimos e máximos" [1]. No caso estaria só sorteando apenas na faixa dos inteiros entre 1 e 2 (inclusos, ou seja, só eles mesmos). Para o contexto, poderia utilizar: Aleatorio 1,3 Leia (resp2) // a escolha do computador Aleatorio off Uma forma alternativa de verificar o vencedor seria pelo valor da subtração dos valores das opções escolhidas. Utilizo no exemplo do código abaixo: // 31) [DESAFIO] Crie um jogo de JoKenPo (Pedra-Papel-Tesoura) // Jokenpo é uma brincadeira japonesa, onde dois jogadores escolhem // um dentre três possíveis itens: Pedra, Papel ou Tesoura. // O objetivo é fazer um juiz de Jokenpo que dada a jogada // dos dois jogadores informa o resultado da partida. algoritmo "Exercicio.31_JoKenPo" var opcaoJ, opcaoC, resultado : inteiro respJ, respC, sair : caractere Inicio repita limpaTela() escrevaL(" JO-KEN-PÔ ") escrevaL("~~~~~~~~~~~~~~~~~~~~~~~~") escrevaL("Pedra ganha da tesoura! ") escrevaL("Tesoura ganha do papel! ") escrevaL("Papel ganha da pedra! ") escrevaL("Sinais iguais>>EMPATE!!!") escrevaL("~~~~~~~~~~~~~~~~~~~~~~~~") escrevaL(" MENU ") escrevaL("[1] PEDRA") escrevaL("[2] PAPEL") escrevaL("[3] TESOURA") escrevaL("PEDRA, PAPEL OU TESOURA!") leia(opcaoJ) aleatorio 1,3 leia(opcaoC) aleatorio OFF escolha opcaoJ caso 1 respJ <- "PEDRA" caso 2 respJ <- "PAPEL" caso 3 respJ <- "TESOURA" fimEscolha escolha opcaoC caso 1 respC <- "PEDRA" caso 2 respC <- "PAPEL" caso 3 respC <- "TESOURA" fimEscolha escreval("Jogador escolheu ", respJ, " e o Computador escolheu ", respC) resultado <- opcaoJ-opcaoC se (resultado = 0) então escreval("Deu empate!!!") senao se ((resultado = 1) OU (resultado = -2)) então escreval("Jogador ganhou!") escreval(respJ, " ganha de ", respC) senao se ((resultado = -1) OU (resultado = 2)) então escreval("Computador ganhou essa!") escreval(respC, " ganha de ", respJ) fimSe fimSe fimSe escreva("Jogar novamente S/N ") leia(sair) ate (sair = "N") fimAlgoritmo

@NaieleF, dá também uma ajustada nos textos das respostas finais. A informação que é "moeda em Real" está duplicada. Ou "Você ganhou R$ 2.50", ou "Você ganhou 2.50 reais". Ou "Você ganhou R$ 0.10", ou "Você ganhou 10 centavos". (Obs.: dizer 0.10 centavos seria errado.)

@devair1010, que massa essa busca!!! Um detalhe: Como está armazenando o índice, creio que utilizaria a variável indice, em vez do x. se j >= z então // qtd de letras iguais, minimo uma y := y + 1 deposito [y] := nomes[indice] dep_posic[y] := indice // x indica a posicAo no vetor interrompa fimse

@NaieleF, você só postou um código, mas não deu qualquer outra informações sobre o que se trataria. Em relação ao jogo, você está só tratando do empate, faltaria tratar dos casos possíveis... A variável respJ não está sendo utilizada... Talvez ela de fato não seja necessária... Poderia postar o enunciado completo da questão e em qual parte está com dúvidas?

Só complementando: O que é um FIFO? É: “First in, first out”, traduzindo: "Primeiro a Entrar, Primeiro a Sair”¹)... por uma análise óbvia, uma fila só pode ser ordenada se a ordem for exatamente igual a original . Se mudou a ordem, deixou de ser FIFO... O mesmo ocorre para FILO ("First In Last Out"), no caso de pilhas. Se "pode mexer na ordem", então seria uma "lista". 1 = lá ele

Está recebendo o parâmetro, mas não está usando na ordenação... Poderia ficar com algo assim: Para L de 1 ate tam_vet Faca Para A de 1 ate tam_vet - L Faca Daí o retorno também não seria necessário, pois está retornando o próprio valor original que foi recebido. Se não me engano isso seria uma Tautologia. Portanto, usaria um procedimento (que não tem retorno na próprio método), em detrimento de usar uma função (que é basicamente um procedimento que tem o tal retorno). PS: em linguagens mais modernas/comuns, não existe diferenciação entre procedimento e função, tudo é função... daí, as funções podem ou não retornar algo... quando não precisa retornar, comumente é definido com o "retorno void" (que significa vazio), ou seja, se o VisualG tivesse esse conceito, um procedimento seria algo assim: funcao xpto () : vazio inicio fimFuncao Alguns pontos: Por que especificamente "L" e "A"? Tem alguma correlação com algo? Convencionalmente utilizam-se "i" e "j" como variáveis auxiliares para as iterações do para. i, j, aux : inteiro Como sugerível acima, as variáveis e comando também são comumentes iniciadas em minúsculo. Dá uma pesquisada sobre camelCase... (Obs.: isso não é obrigatório, estaria relacionado mais a uma tentativa de seguir um suposto padrão geral. Exemplo de código sem sub-rotina: algoritmo "EXE4SUBROTINAS" //Para demonstrar o uso de sub-rotina com passagem de parâmetro, considere a //leitura de 10 valores em um vetor e os coloque em ordem crescente. A //ordenação deve ser executada por uma sub-rotina apropriada para este fim. var vet : vetor [1..10] de inteiro i, j, aux : inteiro inicio para i de 1 ate 10 faca escreva ("Digite um numero: ") leia(vet[i]:3) fimPara escreva ("Vetor original :") para i <- 1 ate 10 Faca escreva (vet[i]) fimPara escrevaL("") para i de 1 ate 9 Faca para j de 1 ate 10-i faca se (vet[j] > vet[j+1]) então aux <- vet[j] vet[j] <- vet[j+1] vet[j+1] <- aux fimSe fimPara fimPara escreva ("Vetor ordenado :") para i <- 1 ate 10 faca escreva (vet[i]:3) fimPara fimAlgoritmo Para facilita os testes, pode deixar essa opção marcada: Ai o próprio VisualG preenche com valores aleatório. Resultado ao pressionar F9: Como já citado, por uma limitação técnica (o criador/desenvolvedor) simplesmente não implementou o recurso que possibilite passar vetores por parâmetro em procedimentos ou funções. É isso! O Pascal, "pai do VisualG", permite! Quem sabe vem numa próxima versão? Daí... meio que o enunciado fica vago... Pois o vetor, necessariamente, terá que ser "passado" via variável global... e o tamanho do vetor também já é conhecido e fixo... já que está no próprio enunciado: O código poderia ficar com algo assim: O esqueleto do procedimento: procedimento bubbleSort () inicio fimProcedimento https://pt.wikipedia.org/wiki/Bubble_sort Aí só joga o conteúdo dentro: para i de 1 ate 9 Faca para j de 1 ate 10-i faca se (vet[j] > vet[j+1]) então aux <- vet[j] vet[j] <- vet[j+1] vet[j+1] <- aux fimSe fimPara fimPara ADENDO IMPORTANTE: Como boa prática, é interessante que "tudo que método use, ou venha por parâmetro, ou seja declarado dentro do método", ou seja, o vetor e o tamanho do vetor deveriam* vir por parâmetro (o primeiro o VisualG não permite, o segundo já foi proposto que é fixo), e as variáveis utilizadas no laços de repetições, declaradas dentro do método (criação de variáveis locais, que se separam das variáveis locais). Veja: procedimento bubbleSort () var i, j, aux : inteiro inicio para i de 1 ate 9 Faca para j de 1 ate 10-i faca se (vet[j] > vet[j+1]) então aux <- vet[j] vet[j] <- vet[j+1] vet[j+1] <- aux fimSe fimPara fimPara fimProcedimento Daí só invocar o método onde precisa: ... escreva (vet[i]:3) fimPara escrevaL("") bubbleSort() escreva ("Vetor ordenado :") para i <- 1 ate 10 faca ... Olha como é interessante, uma sub-rotina seria basicamente um bloco de comandos em que se deu um nome... aí só invocar! Na prática, o VisualG vai "pular" para o trecho de código e ir executando linha a linha da mesma forma que se tivesse no corpo principal do código e depois volta para próxima linha depois de onde foi invocado. Como se fosse um "subprograma". O programa principal fica aguardando a sub-rotina terminar. Código completo: Aí, como parâmetros são necessário, poderia seguir a sugestão do @devair1010, ficaria algo assim: procedimento bubbleSort (tam : inteiro) var i, j, aux : inteiro inicio para i de 1 ate tam-1 Faca para j de 1 ate tam-i faca se (vet[j] > vet[j+1]) então aux <- vet[j] vet[j] <- vet[j+1] vet[j+1] <- aux fimSe fimPara fimPara fimProcedimento Chama o método passando o parâmetro necessário. ... escrevaL("") bubbleSort(10) escreva ("Vetor ordenado :") ... Ou, ainda aprimorar o Bubble Sort(), criando um método específico para efetuar as trocas de posições: algoritmo "EXE4SUBROTINAS" //Para demonstrar o uso de sub-rotina com passagem de parâmetro, considere a //leitura de 10 valores em um vetor e os coloque em ordem crescente. A //ordenação deve ser executada por uma sub-rotina apropriada para este fim. procedimento troca(var a, b : inteiro) var aux : inteiro inicio aux <- a a <- b b <- aux fimProcedimento procedimento bubbleSort () var i, j : inteiro inicio para i de 1 ate 10-1 Faca para j de 1 ate 10-i faca se (vet[j] > vet[j+1]) então troca(vet[j], vet[j+1]) fimSe fimPara fimPara fimProcedimento var vet : vetor [1..10] de inteiro i, j, aux : inteiro inicio para i de 1 ate 10 faca escreva("Digite um numero: ") leia(vet[i]) fimPara escreva ("Vetor original :") para i <- 1 ate 10 Faca escreva (vet[i]:3) fimPara escrevaL("") bubbleSort() escreva ("Vetor ordenado :") para i <- 1 ate 10 Faca escreva (vet[i]:3) fimPara fimAlgoritmo Ou seja: o procedimento troca() já satisfaria a exigência do enunciado ("uso de sub-rotina com passagem de parâmetro"). Mas tanto faz também deixar o método de ordenação também recebendo o parâmetro com o tamanho do vetor. Ah! se o VisualG aceitasse vetores por parâmetro, a assinatura seria algo assim: procedimento bubbleSort (var vet:vetor) Ou: procedimento bubbleSort (var vet:vetor; tam:inteiro) Lembrando que isso NÃO FUNCIONA... pois ainda não foi implementando no VisualG. Já no Pascal, sim!... (não exatamente assim, mas funciona ) PS: esse var determina que seria uma passagem de parâmetro do referência, ou seja, a variável local do método aponta diretamente para própria variável da qual foi passado o parâmetro, assim, tudo que for alterado dentro do método, será refletido na variável original... Funciona como um "ponteiro de memória". Já sem o var, o VisualG apenas "copia" o valor original e joga na variável local. Ao sair, a variável original fica intacta. POSSÍVEL DÚVIDAS: Oxente, por que declarou duas vezes as variáveis i e j? E pior, por que o VisualG não acusou que a variável foi "declarada mais de uma vez". Vide exemplo: Resposta: as variáveis i e j foram declaradas "novamente" pois eventualmente o escopo do método precisa dessas variáveis, e como foi exposto no "ADENDO IMPORTANTE" mais acima, o objetivo é "isolar" o método do programa principal, ou seja, mesmo que seja modificado o laço de repetição no programa principal, o método não será comprometido, pois "tudo dentro do método ou veio de fora ou foi criado dentro do método"... Por fim, foi utilizado também as mesmas letras, pois o VisualG permite. Poderia ser letras diferentes. Só se atente que são variáveis distintas! Tem a mesma nomenclatura, mas são de escopos diferentes. Veja: Cada par de variável não tem nada a ver com o outro. Se não declarasse as variáveis locais, a sub-rotina iria utilizar a variáveis globais... A magia vem aí... ao implementar uma método, você não precisa se preocupar se já existe uma variável com a mesma nomenclatura fora, nem muito menos vai se preocupar se está alterando um valor que não deveria... Por isso a importância do "isolamento". Isso vai ficar mais claro e medida que for implementando programas maiores... imagine a trabalheira que dá ficar "cuidado de cada variável".

@Luigi Milleo, além da imagem do erro, numas próximas ocasiões, poste também o código fonte (o texto). Assim facilita os teste e ajudar indexar a postagem.

@jooao2607, o que pode ocorrer é que uma estrutura de repetição (como o For, While, Do While, For Each etc) possa ser mais prática ou adequada que a outra para um caso, mas meio que não existe uma regra específica obrigue utilizar uma coisa ou outra. Vai do contexto. Cada estrutura pode funcionar melhor ou pior que a outra. Ou pode também existir "padrões de implementações", ou seja, uma forma de fazer que seria mais comum no dia a dia dos programadores em geral... Teria algum exemplo para contextualizar melhor a tua dúvida?

Só um detalhe... Para garantir o melhor funcionamento, utilizar ">=". Por que se der alguma zica e passar do 10, praticamente* vai entrar num loop infinito . * o tipo numérico inteiro tem um limite (pra lá de uns 2 bilhões positivos, pelo menos num x64), daí pularia para negativo (mais uns pra lá de 2 bi), até voltar para o positivo novamente podendo ou não repetir a zica. PS: outra forma seria começar do 1 e ajustar o limite: algoritmo "Conte Ate 10 (inclusive)" var contador : inteiro inicio contador <- 1 repita escreval(contador) contador <- contador + 1 ate (contador > 10) fimAlgoritmo Como é uma contagem, o para seria ainda mais harmonioso: algoritmo "Conte Ate 10 (inclusive)" var contador : inteiro inicio para contador de 1 ate 10 faca escreval(contador) fimPara fimAlgoritmo Obviamente, se o tópico de estudo for o repita, tem que ser com o repita.

Só analisando alguns pontos... Um detalhezinho para o primeiro código: Oras! Essa "troca" já existia no código: Seria só chamar a função: reiniciarVelha() trocarJogador() ...no novo código o problema da substituição já foi resolvida, que seria "salvando o jogador que vai começar". Para o novo código, temos um probleminha de conceito. Se a função chama-se "mostrar", nela não* deveria mexer em nada nos dados.... Só remover o se. Errado* Correto: procedimento mostrarVelha () var linha, coluna : inteiro inicio para linha <- 1 ate 3 faca para coluna <- 1 ate 3 faca escreva (tabela[linha,coluna]:3) fimPara escreval() fimPara fimProcedimento Veja que no código "errado", para cada vez que mostrar a velha, estará reescrevendo a tabela redundantemente. (Onde já tem o número, vai ter o mesmo número novamente...) A mesma regra vale para o reiniciarVelha(). Já existe uma função com o papel de mostrar, correto?... Deixa então o ela executar. Só remover o se lá dentro do para. procedimento reiniciarVelha () var contador : inteiro inicio contador <- 1 para linha <- 1 ate 3 faca para coluna <- 1 ate 3 faca tabela[linha,coluna] <- numpcarac(contador) contador <- contador+1 fimpara fimpara se c = "x" então simbolo <- "o" c <- simbolo senao se c = "o" então simbolo <- "x" c <- simbolo fimse fimse fimProcedimento Cada um no seu quadrado . **Como esperado, daí vai precisar chamar as duas funções para o código funcionar corretamente** Por falar em papeis... poderia retirar esse "troca da vez" de dentro do reiniciarVelha(), pois seria também uma função separada. Poderia criar algo como "definirQuemJoga()", onde na primeira vez seta para o "x", e depois seguiria com essa lógica de alternar o jogador. No código, chamaria logo após o comando enquanto, antes do repita. (Não testei, mas acho que lá mesmo.)