Ir ao conteúdo

Simon Viegas

Membro VIP
  • Posts

    3.936
  • Cadastrado em

  1. @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.
  2. @alinessilva, poste o que conseguiu fazer. Está com dúvida na lógica ou na implementação dela?
  3. 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)
  4. 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
  5. @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.
  6. 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).
  7. 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!
  8. @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.
  9. @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.)
  10. 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
  11. @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.)
  12. @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
  13. @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?
  14. 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

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...