Simon Viegas

8 de maio

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.

5 de maio

@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.

5 de maio

@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?

17 de abril

Em 12/04/2025 às 17:23, bolever disse:

Acho que so precisar ser de 2 em 2

se (distancia1 > distancia2) e (distancia1 > distancia3)

Faz sentido, mas isso o próprio @scorpionmyth2 já havia tentado e deu erro:

Em 03/04/2025 às 11:05, scorpionmyth2 disse:

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.

10 de abril

Para uma melhor organização, inserir outro conjunto de parênteses para separar as sentenças.

De:

Em 03/04/2025 às 11:05, scorpionmyth2 disse:

se (distancia1 > distancia2 e distancia1 > distancia3)
{
escreva("A maior distancia é: ", distancia1)	
}

Para:

se ((distancia1 > distancia2) e (distancia1 > distancia3))
{
	escreva("A maior distancia é: ", distancia1)	
}

3 de fevereiro

@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.

23 de janeiro

@alinessilva, poste o que conseguiu fazer.

Está com dúvida na lógica ou na implementação dela?

23 de janeiro

Em 18/07/2024 às 12:33, Simon Viegas disse:

      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

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)

3 de dezembro de 2024

Em 28/11/2024 às 11:28, Nathan Underground disse:

Bom dia, pessoal. Consegui transformar o arquivo .bat em .exe, e o antivírus aqui da empresa não bloqueou nem relatou nenhuma instabilidade. Agradeço a atenção de todos.

Conseguiu como?

3 de novembro de 2024

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

3 de novembro de 2024

@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.

3 de novembro de 2024

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:

Citação

Ela ajuda a substituir uma parte da string que começará com uma certa posição que atuará como um início e se estenderá até um certo número de caracteres. Esta string será substituída pela string especificada. A string a ser substituída com as posições inicial e final deve ser dada à função replace() como parâmetros que nos ajudam a substituir a string.

Exemplo de chamada do método:

Citação

string1.replace(start,length,string2);

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:

Citação

caractere1: Cadeia de caracteres do qual se deseja substituir algo.

inicio: Especifica a posição da qual a substituição se inicia.

comprimento: Define o número de caracteres que serão substituídos na cadeia de caracteres original.

caractere2: Cadeia de caracteres que deseja substituir na cadeia original.

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).

25 de outubro de 2024

Vamos tentar destrinchar cada ponto:

Em 18/10/2024 às 19:43, ryan_santos disse:

se eu colocar s de scanner vai contabilizar 1 para computador

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:

Em 18/10/2024 às 19:43, ryan_santos disse:
tipo_bem: inteiro

Para:

tipo_bem: caractere

Só isso.

Abaixo tem outros detalhes que podemos discutir:

Em 18/10/2024 às 20:32, kgin disse:

Já no caso do estrutura Se ... Então o ideal seria usar sem o comando SeNão, dessa maneira.

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...

Em 18/10/2024 às 20:32, kgin disse:

Mas o ideal mesmo seria usar o Escolha ... Caso.

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 18/10/2024 às 21:19, kgin disse:

Esqueci de avisar que é bom você passar os caracteres para maiúsculo (ou minúsculo) antes de fazer uma comparação, e comparar os caracteres em uma caixa só (alta ou baixa, mas nunca as duas ao mesmo tempo).

O visualG tem um bug com isso, então é melhor evitar. Para passa para maiúsculo utilize a função maiusc(), e as outras funções você pode checar aqui no manual visualG

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:

Em 18/10/2024 às 20:32, kgin disse:

Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   computador <- 0
   impressora <- 0
   scanner <- 0

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!

12 de setembro de 2024

Em 10/09/2024 às 10:27, NaieleF disse:

pois no VisualG não existe essa estrutura

@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?

Exercícios-de-Algoritmos-1-100.pdf

Fonte: https://www.cursoemvideo.com/wp-content/uploads/2020/10/Exercí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 de setembro de 2024

Em 05/09/2024 às 12:01, NaieleF disse:

Qual é a sintaxe dessa estrutura?

@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.)

18 de julho de 2024

Em 15/07/2024 às 17:05, NaieleF disse:

Gostaria de saber se a forma que fiz o código deste jogo JoKenPo está correto.

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:

Em 08/07/2024 às 11:09, Simon Viegas disse:

e em qual parte está com dúvidas?

Só uns detalhes...

@devair1010, sobre:

Em 15/07/2024 às 21:23, devair1010 disse:

      respM := "Pedra"
      
      se resp2 = 2 então
         respM := "PapeL"
      senao
         respM := "Tesoura"
      fimse

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:

Em 15/07/2024 às 21:23, devair1010 disse:

      Aleatorio 1,2,3
      Leia (resp2)             // a escolha do computador
      Aleatorio off

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

10 de julho de 2024

@NaieleF, dá também uma ajustada nos textos das respostas finais.

Em 06/07/2024 às 12:20, NaieleF disse:

   Se (Saldo<1.0) então
      Escreval ("Você ganhou R$ ",Saldo:1:2, " centavos")
   Senao
      Se (Saldo>1.0) então
         Escreval ("Você ganhou R$ ",Saldo:1:2, " reais")
      FimSe
   FimSe

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.)

8 de julho de 2024

@devair1010, que massa essa busca!!!

Um detalhe:

Em 05/07/2024 às 01:04, devair1010 disse:

                  se j >= z então // qtd de letras iguais, minimo uma
                     y := y + 1
                     deposito [y] := nomes[indice]
                     dep_posic[y] := x // x indica a posicAo no vetor
                     interrompa
                  fimse

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

8 de julho de 2024

@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...

Em 06/07/2024 às 12:12, NaieleF disse:

   Escreval ("Pedra ganha da tesoura!")
   Escreval ("Tesoura ganha do papel!")
   Escreval ("Papel ganha da pedra!"  )

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?

27 de maio de 2024

Só complementando:

Em 19/03/2021 às 11:41, Simon Viegas disse:

Você não poderia ordenar uma fila, afinal, ela é uma FIFO.

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

27 de maio de 2024

13 horas atrás, devair1010 disse:

funcao sub_rotina(tam_vet : inteiro):inteiro
Var
  A,L : inteiro
Inicio
   Para    L de 1 ate 9      Faca
      Para A de 1 ate 10 - L Faca
         Se Vet[A    ] >  Vet[A + 1] então
            Aux        := Vet[A    ]
            Vet[A    ] := Vet[A + 1]
            Vet[A + 1] := aux
         FimSe
      FimPara
   FimPara
   retorne tam_vet
Fimfuncao

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:

19 horas atrás, Gustavo Alves7 disse:
L, A, Aux: Inteiro

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:

19 horas atrás, Gustavo Alves7 disse:

Para demonstrar o uso de sub-rotina com passagem de parâmetro [...]

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:

19 horas atrás, Gustavo Alves7 disse:

considere a leitura de 10 valores em um vetor

19 horas atrás, Gustavo Alves7 disse:

A ordenação deve ser executada por uma sub-rotina apropriada para este fim

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:

Spoiler

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 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

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

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".

27 de maio de 2024

@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.

9 de maio de 2024

13 horas atrás, jooao2607 disse:

boa noite, estou com essa duvida aqui se existe alguma regra ou algo do tipo onde eu não possa usar o <FOR>, ou pode usar em qualquer circunstancia

@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?

4 de maio de 2024

Em 03/05/2024 às 17:25, Ansi C disse:

   repita
      contador <- contador + 1
      Escreval(contador)
   Ate (contador = 10)

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.

4 de maio de 2024

Só analisando alguns pontos...

Um detalhezinho para o primeiro código:

Em 14/04/2024 às 01:41, Eli Almeida disse:

      reiniciarVelha()
        
      se simbolo = "x" então
         simbolo <- "o"
      senao
         se simbolo = "o" então
            simbolo <- "x"
         fimse
      fimse

Oras! Essa "troca" já existia no código:

Em 14/04/2024 às 01:41, Eli Almeida disse:

procedimento trocarJogador ()
inicio
   se simbolo = "x" então
      simbolo <- "o"
   senao
      simbolo <- "x"
   fimSe
fimProcedimento

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*

Em 15/04/2024 às 01:36, Eli Almeida disse:

procedimento mostrarVelha ()
var
   linha, coluna, contador : inteiro
inicio
   contador <- 1
     
   para linha <- 1 ate 3 faca
      para coluna <- 1 ate 3 faca
         se (tabela[linha,coluna] <> "x") e (tabela[linha,coluna]<> "o") então
            tabela[linha,coluna] <- numpcarac(contador)
         fimse
     
         escreva(tabela[linha,coluna]:3)
         contador <- contador+1
      fimPara
     
      escreval()
   fimPara
fimProcedimento

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().

Em 15/04/2024 às 01:36, Eli Almeida disse:

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)
         escreva(tabela[linha,coluna]:3)
         contador <- contador+1
      fimpara
     
      escreval()
   fimpara
      
   se c = "x" então
      simbolo <- "o"
      c <- simbolo
   senao
      se c = "o" então
         simbolo <- "x"
         c <- simbolo
      fimse
   fimse
fimProcedimento

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.)

Entrar

Artigos

Selos

Livros

Cursos

Análises

Fórum

posts postados por Simon Viegas

Sobre o Clube do Hardware

Direitos autorais

Mais