VisualG numero divisel por 4

Marigimenez · 16 de fevereiro de 2022

Oi gente, preciso de uma ajudinha. O enunciado da questão diz assim:

Desenvolva um algoritmo que mostre uma contagem regressiva de 30 até 1, marcando os números que forem divisíveis por 4, exatamente como mostrado abaixo:

30 29 [28] 27 26 25 [24] 23 22 21 [20] 19 18 17 [16] ...

Eu fiquei bastante confusa e não consegui desenvolver, vou mostrar o que eu fiz. Se alguém puder me ajudar eu agradeço muito.

algoritmo "semnome"
// Função :
// Autor :
// Data : 16/02/2022
// Seção de Declarações
var
   contador : real

inicio
      contador <- 30
      Enquanto (contador >=0) faca
      escrevaL (contador)
      contador <- contador -1
      Se (contador % 4 = 0) entao
      EscrevaL ("É divisível")
      FimSe
      FimEnquanto
// Seção de Comandos
fimalgoritmo

Midori · 16 de fevereiro de 2022

O enunciado diz para mostrar só os números, mas antes você deve verificar se ele é divisível por 4. Isso você já fez porém no lugar da mensagem "É divisível", coloque o número entre colchetes. Depois faça um senão (else) para mostrar o número sem colchetes. E deixe o decremento do contador para um fim do loop depois de mostrar os números.

Blumer Celta · 16 de fevereiro de 2022

em pascal ficaria assim:

program div4;

{$apptype console}

uses
  sysutils;

var contador: integer; //talvez não funcione o comando mod com variaveis reais por isso usei integer
begin //bloco principal do programa
      contador:= 30; //contador recebe 30 como valor inicial
      while contador >0 do //enquanto o contador for maior que zero então faça
        begin //inicio do bloco de comandos
          if (contador mod 4) = 0 then writeln(contador); //se contador dividido por 4 for 0 então escreva o valor atual de contador
          contador:= contador - 1; //diminui 1 do valor do contador.
        end; //fim do bloco de comandos

end. //fim do bloco principal do programa

Sem os comentarios ficaria assim

program div4;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var contador: integer; 
begin 
      contador:= 30;
      while contador >0 do
        begin 
          if (contador mod 4) = 0 then writeln(contador); 
          contador:= contador - 1; 
        end; 

end.

SAIDA:

Não conheço muito da linguagem/sistema que você está utilizando, mas poderia funcionar mais ou menos assim:

algoritmo "semnome"
// Função :
// Autor :
// Data : 16/02/2022
// Seção de Declarações
var
   contador : real

inicio
      contador <- 30
      Enquanto (contador >=0) faca
      Se (contador % 4 = 0) entao
      EscrevaL (contador)
      FimSe
      contador <- contador -1
      FimEnquanto

// Seção de Comandos
fimalgoritmo

Marigimenez · 16 de fevereiro de 2022

Gente, ainda não consegui, se alguém que esteja acostumado com visualg puder ajudar, meu muito obrigada a quem tentou ajudar.

Midori · 16 de fevereiro de 2022

@Marigimenez Essa é mais uma questão de organizar e editar o código para fazer como pedido no enunciado do que especificamente da linguagem de programação em si.

Você está no caminho certo, mas está mostrando o que não é pedido. Esta linha por exemplo,

EscrevaL("É divisível")

O enunciado não pede para mostrar isso. É só para mostrar os números. No lugar dessa mensagem escreva o número (contador).

E depois mova para o fim do *loop (loop é o Enquanto e termina em FimEnquanto) a linha do decremento que é esta,

contador <- contador -1

Feito isso poste o seu código com as modificações caso ainda não tenha conseguido resolver.

*Loop também é conhecido como laço ou ciclo.

Blumer Celta · 16 de fevereiro de 2022

O compilador (programa visualG) apresenta algum erro? ou o resultado não é o esperado?

      Enquanto (contador >=0) faca
      escrevaL (contador)

Esta parte por exemplo, você manda o programa escrever valor contido dentro da variável (contador) sempre que o valor (dela mesma) for maior ou igual a zero... ou seja ele vai repetir varias vezes o valor da variável contador. (mesmo quando não for divisível por 4)

contador <- contador -1

esta linha a meu ver está em posição errada, ela deve ser escrita depois da verificação MOD (deve ser o % na linguagem do visualG).

Pois se "tirar 1" da variável contador, antes da verificação você sempre estará comparando um número a menos.

Ou seja: verifica primeiro e decrementa a varável depois.

Você chegou a testar o último exemplo que postei?

Tente digitar, pois se só copiar e colar as vezes os compiladores dão erro pois pode copiar alguma formatação ou caracteres invisíveis das paginas HTML e com isso as vezes dá erro e nem sabemos do que é.

o programa que você usa é este: https://visualg3.com.br/ ?

=========================

ATUALIZANDO, Testei no visualG

veja aqui funcionou (só tirei o >=0 e coloquei >0) para que ele não faça o teste com o número zero)

segue código atualizado e funcionando:

algoritmo "semnome"
// Função :
// Autor :
// Data : 16/02/2022
// Seção de Declarações
var
   contador : real

inicio
      contador <- 30
      Enquanto (contador >0) faca
      Se (contador % 4 = 0) entao
      EscrevaL (contador)
      FimSe
      contador <- contador -1
      FimEnquanto

// Seção de Comandos
fimalgoritmo

tela de saída:

Acrescentando que o enunciado parece um pouco falho, pois manda mostrar os números divisíveis por 4 e mostra a sequência desejada), mas deveriam frisar que esta sequência vem de divisões exatas (ou seja divisões sem resto)

Midori · 16 de fevereiro de 2022

40 minutos atrás, Blumer Celta disse:

Acrescentando que o enunciado parece um pouco falho, pois manda mostrar os números divisíveis por 4 e mostra a sequência desejada), mas deveriam frisar que esta sequência vem de divisões exatas (ou seja divisões sem resto)

O enunciado frisou que os divisíveis são os números marcados. Então o código deve mostrar a sequência de todos os números entre 30 e 1 (inclusive os não divisíveis) e marcar com os colchetes.

Blumer Celta · 16 de fevereiro de 2022

Realmente.

neste caso isso deve se aplicar melhor (precisando de um pouco de ajustes apenas:

algoritmo "semnome"
// Função :
// Autor :
// Data : 16/02/2022
// Seção de Declarações
var
   contador : real

inicio
      contador <- 30
      Enquanto (contador >0) faca
      Se (contador % 4 = 0) entao
      Escreva ("[")
      Escreva (contador)
      Escreva (" ]")
      Senao
      Escreva (contador)
      Fimse
      contador <- contador -1
      FimEnquanto

// Seção de Comandos
fimalgoritmo

devair1010 · 17 de fevereiro de 2022

@Blumer Celta testei seu código e ele funciona bem , porém ele não está mostrando o resuLtado igual está especificado lá no enunciado , pois ele escreve os números , e Quando coloca os colchetes marcando os divisíveis por Quatro ele coloca um esPaço entre o abre colchete e o número , e não era para ter esse espaÇo , então se usar caracteres pode escrever do modo certo , pois como números o visualG pula mesmo um espaço , e outra coisa que observei , foi que você não fez a indentação do código , que poderia ser assim :

algoritmo "divisivel por quatro"
// Data : 17/02/2022
var
  contador : inteiro
inicio
  contador <- 30
  Enquanto contador > 0 faca
    Se contador % 4 = 0 entao
      Escreva (" [",numpcarac(contador),"]")
    Senao
      Escreva (contador)
    Fimse
    contador <- contador -1
  FimEnquanto
  Escreval(" ...")
fimalgoritmo

Midori · 17 de fevereiro de 2022

No lugar do Enquanto também pode usar Para, assim a atribuição e o contador podem ser especificados no próprio comando,

algoritmo "semnome"
var
  contador : inteiro
inicio
  para contador de 30 ate 1 passo -1 faca
    se contador % 4 = 0 entao
      escreva(" [",numpcarac(contador),"]")
    senao
      escreva(contador)
    fimse
  fimpara
fimalgoritmo

Simon Viegas · 17 de fevereiro de 2022

18 horas atrás, Marigimenez disse:

Desenvolva um algoritmo que mostre uma contagem regressiva de 30 até 1, marcando os números que forem divisíveis por 4, exatamente como mostrado abaixo:

30 29 [28] 27 26 25 [24] 23 22 21 [20] 19 18 17 [16] ...

Existem 2 pontos centrais:

- Interpretação de texto X fazer o que está sendo pedido;

- Exercício e uso da abstração.

Para o primeiro, veja:

Citação

exatamente como mostrado abaixo:

30 29 [28] 27 26 25 [24] 23 22 21 [20] 19 18 17 [16] ...

Percebe? Ele que assim, e tem que ser feito assim... não tem algo a ver com informar se é divisível ou não. Ele quer apenas "destacar os divisíveis".

Então, o que o exercício quer? Seria algo como: "Ele quer exibir uma lista decrescente, só que destacando os múltiplos de 4". Correto?

Poderia começar com o mais simples: Exibir a lista sem destacar:

Utilizando o para, como sugerido pelo @Midori:

algoritmo "De 30 a 1, destacando os múltiplos de 4"
var
   contador : inteiro
inicio
   para contador de 30 ate 1 passo -1 faca
      escreva(contador)
   fimPara
fimAlgoritmo

Utilizando enquanto:

algoritmo "De 30 a 1, destacando os múltiplos de 4"
var
   contador : inteiro
inicio
   contador <- 30
   
   enquanto (contador >= 1) faca
      escreva(contador)
      contador <- contador-1
   fimEnquanto
fimAlgoritmo

Observação: TUDO que faz com enquanto, dá para fazer com para ou repita. Apenas um vai ser "mais prático" que o outro, ok? Quando usar um ou outro? Vai do contexto. Por exemplo, se está estudando enquanto, tem que usar enquanto. (muito gente não consegue entender isso, mesmo no nível superior).. isso tem a ver com lógica! Mas, se não um exercício para um laço em específico, no caso acima, se quer simplificar, o para seria o melhor caminho.

Hum! Um exemplo com repita:

   repita
      escreva(contador)
      contador <- contador-1
   ate (contador < 1)

Vê? Se for colocar no que seria do "melhor para o pior" para esse exercício: para (pois já controla o contador nele mesmo) > repita (pois vai exibir primeiro, para depois verificar) > enquanto (esse verifica primeiro, mas sabemos que sempre vai exibir na primeiro, logo perda de tempo)

Tá, "já consegui listar os número", agora seria só "destacar os múltiplos de 4"... algo que já foi demonstrado em postagem anteriores.

Adendo:
Sobre:

1 hora atrás, devair1010 disse:

pois como números o VisualG pula mesmo um espaço

Isso, alguns tipos de dados o desenvolvedor do VisualG resolveu inserir um espaço antes da exibição. No Pascal (pai do VisualG) não é assim. Acho ruim isso.

Forma de contornar:

   enquanto contador > 0 faca
      se contador % 4 = 0 entao
         escreva (" [", contador:1, "]")
      senao
         escreva (contador)
      fimSe
      contador <- contador-1
   fimEnquanto

Esse número após o ":" diz para o VisualG a quantidade de casas reservadas, como sempre tem uma casa, vai ficar colado à esquerda (retira o espaço). Tem gente que usa ":0". Eu não gosto.

Marigimenez · 17 de fevereiro de 2022

Gente, muito obrigada, consegui! E de quebra aprendi muito com cada um de vocês. Valeeeu!

Blumer Celta · 17 de fevereiro de 2022

6 horas atrás, devair1010 disse:
@Blumer Celta testei seu código e ele funciona bem , porém ele não está mostrando o resuLtado igual está especificado lá no enunciado , pois ele escreve os números , e Quando coloca os colchetes marcando os divisíveis por Quatro ele coloca um esPaço entre o abre colchete e o número , e não era para ter esse espaÇo , então se usar caracteres pode escrever do modo certo , pois como números o visualG pula mesmo um espaço , e outra coisa que observei , foi que você não fez a indentação do código , que poderia ser assim :
algoritmo "divisivel por quatro"
// Data : 17/02/2022
var
  contador : inteiro
inicio
  contador <- 30
  Enquanto contador > 0 faca
    Se contador % 4 = 0 entao
      Escreva (" [",numpcarac(contador),"]")
    Senao
      Escreva (contador)
    Fimse
    contador <- contador -1
  FimEnquanto
  Escreval(" ...")
fimalgoritmo

Exatamente, fiz este último na pressa, pois estava na hora de fechar a empresa onde trabalho e estava fazendo no PC aqui. (não entendo muito desta linguagem/sistema do VisuAlg3... por isso falei que precisava de pequenos ajustes, valeu a dica.

6 horas atrás, devair1010 disse:
Escreval(" ...")

Por isso falei que o enunciado era um pouco falho (deveria indicar que com divisível ele pretende divisões exatas, senão poderia causar confusão com os divisíveis com vírgulas), estes três pontinhos ele dá a entender que "prossegue até o fim da contagem, mas que não escreverá a contagem inteira para não ficar gigante o enunciado", mas claro, se for pra fazer exatamente igual, daria pra colocar esta linha mesmo.

6 horas atrás, devair1010 disse:
Escreva (" [",numpcarac(contador),"]")

Perfeito, sabia que faltava isso, mas como não conheço a linguagem não sabia o comando para concatenar.

4 horas atrás, Simon Viegas disse:

Acho ruim isso.

Exatamente isso é terrível.

Eu acredito que deveriam iniciar o ensino diretamente no pascal por ser mais simples e poucas palavras em inglês, rapidinho aprende. Vi pessoas que iniciaram no portugol e depois tiveram certa dificuldade para migrar para linguagens diferentes por não encontrar certas facilidades do portugol.

Simon Viegas · 17 de fevereiro de 2022

2 horas atrás, Blumer Celta disse:

Por isso falei que o enunciado era um pouco falho (deveria indicar que com divisível ele pretende divisões exatas, senão poderia causar confusão com os divisíveis com vírgulas)

Então, só é divisível quando a divisão é exata... Essa justamente a ideia.

2 horas atrás, Blumer Celta disse:

estes três pontinhos ele dá a entender que "prossegue até o fim da contagem, mas que não escreverá a contagem inteira para não ficar gigante o enunciado", mas claro, se for pra fazer exatamente igual, daria pra colocar esta linha mesmo.

Exato, não é necessário imprimir os "...". Isso foi usado apenas para resumir o enunciado. Entra nos pontos que cheguei a comentar: abstração e contexto. Estaria bem claro que ele quer a lista completa... o "exatamente como mostrado abaixo" seria apenas uma pequena falha... um pequeno detalhe.. Outra coisa: esses "..." podem ter sido inseridos por outra pessoa, como o autor do post, ou o professor, que poderia ter usado apenas para não deixar o resultado todo pronto... sei lá.

Ah! Ainda em relação ao "análise do contexto", eu falei sobre isso:

7 horas atrás, Simon Viegas disse:

Vai do contexto. Por exemplo, se está estudando enquanto, tem que usar enquanto.

Ou seja: se teve uma aula hoje sobre enquanto, aí o exercício está na lista do assunto, porque raios vai querer fazer com para? Está implícito que necessariamente tem que fazer com enquanto. Agora, se já estudou os 3 laços de repetições que citei e não está preso ao tema, aí o programador poderia escolher.

Então, da mesma forma eu não poderia fazer isso!!!

Veja aí: a resposta está certa!!!! Concorda? Eu exibi a lista como ele pediu... mas é (deveria estar) óbvio que está querendo que crie uma lógica que gere a sequência... No caso da solução encontrada. envolvendo "laços de repetições" (enquanto, para ou repita) e "estrutura de seleção" (se / senao). Daria para fazer só com se/senao, verificando cada número, mas ficaria tosco :D.

2 horas atrás, Blumer Celta disse:

Eu acredito que deveriam iniciar o ensino diretamente no pascal por ser mais simples e poucas palavras em inglês, rapidinho aprende. Vi pessoas que iniciaram no portugol e depois tiveram certa dificuldade para migrar para linguagens diferentes por não encontrar certas facilidades do portugol.

O VisualG seria justamente o Pascal em Português. Basicamente meio que uma tradução dos comandos... A estrutura é bem parecida.. além da implementação de outras facilidades.. Mas infelizmente nem tudo funciona muito bem ainda. Um projeto semelhante seria o Portugol Studio. No site deles dá uma resumida no porque seria interessante usar em Português. (Meio que focar na lógica para os resultados... ficando mais atrativo)

Site:

http://lite.acad.univali.br/portugol/

Vídeo: