VisualG Valores impressos no algoritmo

Mr.Waffles · 14 de junho de 2020

Boa tarde, estou com dúvida que valor vai ser impresso? No primeiro fica x <- 10 - I + 1 = 8 e no segundo x <- x[11 - I] = 10, está correto?

Simon Viegas · 14 de junho de 2020

Os exercícios estão iguais?

adicionado 29 minutos depois

5 horas atrás, Mr.Waffles disse:

Boa tarde, estou com dúvida que valor vai ser impresso?

Você está perguntando se você está com dúvidas? Como é que vamos saber?

Brincadeiras à parte... segue:

5 horas atrás, Mr.Waffles disse:

No primeiro fica x <- 10 - I + 1 = 8 e no segundo x <- x[11 - I] = 10, está correto?

Então, X é um vetor... e ocorre iterações para preenchê-lo. Basta seguir o fluxo:

5 horas atrás, Mr.Waffles disse:

Na primeira iteração:

X[1] <- 10 - 1 + 1 ∴ X[1] <- 10 // X[] na posição 1 vai ter 10

Na segunda iteração:

X[2] <- 10 - 2 + 1 ∴ X[2] <- 9

Na terceira iteração:

X[3] <- 10 - 3 + 1 ∴ X[1] <- 8

etc.

Fazer o mesmo com o segundo e o terceiro para.

Mr.Waffles · 16 de junho de 2020

Em 14/06/2020 às 19:42, Simon Viegas disse:

Os exercícios estão iguais?

Sim, tem como editar esse tópico?

No primeiro for vai ficar: 10 9 8 7 6 5 4 3 2 1 e o segundo for vai ficar: posição do índice 1 que é 10, então fica X[11 - 10]? O terceiro for vai ser a impressão do valor que está no índice do vetor?

Simon Viegas · 16 de junho de 2020

Sobre:

13 minutos atrás, Mr.Waffles disse:

Sim, tem como editar esse tópico?

Sobre:

15 minutos atrás, Mr.Waffles disse:

e o segundo for vai ficar: posição do índice 1 que é 10, então fica X[11 - 10]?

OK.

14 minutos atrás, Mr.Waffles disse:

e o segundo for vai ficar: posição do índice 1 que é 10, então fica X[11 - 10]? O terceiro for vai ser a impressão do valor que está no índice do vetor?

Nops!

Em 14/06/2020 às 14:39, Mr.Waffles disse:

Na primeira iteração:

X[1] <- X[11-1] ∴ X[1] = ?

Na segunda iteração:

X[2] <- X[11-2] ∴ X[2] = ?

Na terceira iteração:

X[3] <- X[11-3] ∴ X[4] = ?

...

Mr.Waffles · 16 de junho de 2020

Não está aparecendo.

Consegui achar a resposta, só que não estou entendendo o motivo que o índice 6 x[6] fica de trás para frente. Tem algo errado?

Simon Viegas · 16 de junho de 2020

2 horas atrás, Mr.Waffles disse:

Não está aparecendo.

Eu já editei.

2 horas atrás, Mr.Waffles disse:

Consegui achar a resposta, só que não estou entendendo o motivo que o índice 6 x[6] fica de trás para frente. Tem algo errado?

Não, você não poderia utilizar o VisualG para encontrar a resposta.... Não faz sentido!!!

Esqueça o VisualG e qualquer coisa que apareceu lá!

Você precisa fazer manualmente... execute, mentalmente, o programa linha a linha... e informe qual é a resposta. A única coisa "nova" que precisa ter em mente é que todas variáveis globais são zeradas automaticamente, ou seja: como são números, todas as variáveis começam com zero.

Começa assim:

x = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

i = 0

Lá no para, i vai passar a ficar com 1, como 1 é menor ou igual a 10 vai entrar no loop. Após: x[1] <- 10 - 1 + 1, logo, x[1] = 10. O i passa para 2, 2 é menor ou igual a 10... x[2] <- 10 - 2 + 1, logo, x[2] = 9...por aí vai...

Até o momento está assim:

x [10, 9, 0, 0, 0, 0, 0, 0, 0, 0]

i = 2;

Siga todo o fluxo do programa e informe o que vai ser impresso na tela. É isso que o enunciado quer...

No aguardo.

Mr.Waffles · 16 de junho de 2020

3 horas atrás, Simon Viegas disse:

x [10, 9, 0, 0, 0, 0, 0, 0, 0, 0]

i = 2;

No primeiro para, o índice 1 fica com o valor 10 no vetor.

x <- 10 - I + 1

x [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

i=1, 2, 3, 4, 5, 6, 7, 8, 9, 10

No segundo para, o índice 1 fica com o valor 1 no vetor e por aí vai.

X[1] <- X[11 - 10] = 1, X[2] <- X[11 - 9] = 2, X[3] <- X[11 - 8] = 3, X[4] <- X[11 - 7] = 4, X[6] <- X[11 - 6] = 5...

Ficou: 1, 2 , 3 , 4 , 5, 6, 7, 8, 9, 10, minha lógica está certa?

Simon Viegas · 17 de junho de 2020

2 horas atrás, Mr.Waffles disse:

Ficou: 1, 2 , 3 , 4 , 5, 6, 7, 8, 9, 10, minha lógica está certa?

Nops! O seu raciocínio faz até sentido, mas é preciso ter atenção aos dados no momento de cada interação... Existe uma pegadinha aí no processo. Acho que não é tão fácil perceber assim de cara... Talvez seja realmente necessário executar linha a linha para ter uma base melhor.

Vou tentar explicar passo-a-passo a parte que você já soube fazer, mas tentando detalhar um pouco mais... assim, após, você aplicar a mesma lógica na segunda parte.

Vamos tentar abstrair alguns conceitos... vamos definir que o computador nada seja que um executador de instruções e que o "compilador/interpretador" de algoritmo vai mandando ordens para ele.

Exemplo:

Dentro do programa (ex.: VisualG.exe, se for como interpretador ou meuprograma.exe se estiver gerado o arquivo), o computador vai criar um sub-processo chamado ALG_04 (vai meio que entrar lá numa pilha* de sub-processos do seu programa) e vai mandar reservar um vetor com 10 posições que aceitam inteiros e outra variável que também aceita inteiros nesse sub-processo. A memória do computador vai apenas ser "formatada", ou seja: as regiões reservadas vão ficar preparadas para receber os dados de acordo com o tipo informado... logo, inteiros.

Vamos supor que que fica algo assim:

ALG_04 {
  x --> [?, ?, ?, ?, ?, ?, ?, ?, ?, ?]
  i --> ?
}

Essa variáveis do "sub-processo" principal é chamado de "variáveis globais". Se esse sub-processo criar um novo sub-processo (como uma função ou procedimento), este novo sub-processo vai enxergar essas variáveis... em fim...

Por que um monte "?" onde estaria os dados? apenas aceite que os dados que estão lá são restos de outras execuções ou algo que simplesmente nunca foi definido ainda, ou seja: quando um programa qualquer anterior parou se usar esse espaço de memória, não foi necessário "apagar tudo que está lá" (ia dar um trabalho desnecessário - compare o tempo de copiar um filme par o pendrive com o tempo que demora para apagar esse mesmo filme... o último é quase instantâneo, rs). Apenas foi descartado a reserva daquele espaço... daí outro programa poderá eventualmente requisitá-lo e utilizá-lo.

Daí, para facilitar a vida do programador, o VisualG, por exemplo, após reservar aqueles espaços de memória e formatá-lo para receber determinados tipos de dados, ele se dar o trabalho, também, de automaticamente inserir valores padrões, ou seja: vai inserir 0 onde é inteiro. Vai inserir "" onde é caractere. Vai inserir 0.0 quando o tipo é real... etc.

Fica algo assim:

ALG_04 {
  x --> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
  i --> 0
}

Entenda que isso é um "favor do VisualG" ou do programa similar... em algumas outras linguagens mais avançadas, isso pode não ocorrer (como no C e no Java)... daí vem o tão famoso "você precisa inicializar as variáveis primeiro".

Vamos lá:

AQUI VEM O PULO DO GATO

Se a primeira linha, após o "inicio", fosse para imprimir o valor que está na posição 4 do vetor x, vai aparecer o quê na tela? Adivinha?

Vai aparece 0, pois NAQUELE MOMENTO tem 0 na posição 4. O que importa é valor que está ali naquele momento.. o computador não faz ideia do que se trata o algoritmo... ele apenas sabe que existe um espaço na memória e que foi pedido para imprimir o que tem lá na tela.... se um "hacker" tiver acesso aquele ponto de memória e inserir 375 na posição 4, o computador vai imprimir 375!!! pois é isso que tinha lá naquele momento que foi solicitado.

No algoritmo do enunciado, logo ali no início do "corpo principal" (que seria entre o início e fimAlgoritmo), tem:

Esta "estrutura":

para <variável 1> de <varável 2> ate <variável 3> faca

...seria uma forma interna lá do "compilador/interpretador" de criar uma estrutura de repetição, certo? Daí, nesse processo, vai definir que o valor do conteúdo da "variável 2" vai ser inserido no conteúdo da "variável 1". Em outras palavras vai ficar, nesse momento, algo assim:

ALG_04 {
  x --> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
  i --> 1
}

Após, fazendo parte do fluxo lá interno do laço de repetição, vai fazer uma verificação se o valor atual de I (naquele momento) é menor ou igual ao conteúdo da variável 3, ou seja: se 1 é menor ou igual a 10. Como é, vai "entrar" no loop.

Dentro do loop, tem o comando <-, que de alguma forma funciona para "atribuir o VALOR que está no lado direito no CONTEÚDO da variável que está no lado esquerdo. Primeiro é feito o que está na direita (é lógico, pois como iria atribuir algo que não se sabe ainda?). Lá tem:

10 - I + 1

Qual o valor de I nesse momento? Vale 1. Logo, vai ficar 10 - 1 + 1, que é igual a 10. Daí, o comando lá de atribuição (<--) vai fazer o seu papel inserindo esse valor em x[I ]. Quanto vale I nesse momento??? Logo:

ALG_04 {
  x --> [10, 0, 0, 0, 0, 0, 0, 0, 0, 0]
  i --> 1
}

O processo continua...

ALG_04 {
  x --> [10, 9, 0, 0, 0, 0, 0, 0, 0, 0]
  i --> 2
}

...

ALG_04 {
  x --> [10, 9, 8, 0, 0, 0, 0, 0, 0, 0]
  i --> 3
}

Deu para entender legal?

Após o fim do para/faca as variáveis estão assim:

ALG_04 {
  x --> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
  i --> 10
}

Obs.: perceba algo interessante: apesar que ao final de cada loop lá no para/faca está incrementado o I em 1, no VisualG pelo menos, o valor de I ficará com 10, ou seja: o valor final (da "variável 3"). Não sei porque é assim, faria mais sentido sair com 11. Em fim... cada """linguagem""" com as suas definições...

Agora, é só seguir o mesmo fluxo para a outra parte:

Quanto vale I no primeiro momento ali dentro do para/faca? Lembra que tinha 10?, mas foi atribuído o valor 1 na primeira linha na "assinatura" do para/faca... Logo, fica:

X[1] <-- X[10]

Qual o valor que tem lá na posição 10 de x nesse momento? Tem 1! se ligue no "nesse momento". Logo, ficando assim:

ALG_04 {
  x --> [1, 9, 8, 7, 6, 5, 4, 3, 2, 1]
  i --> 1
}

O valor que está na posição 10 foi inserido na posição 1.

Agora siga o mesmo fluxo até que o valor de I não seja menor ou igual a 10 e observe como vai ficar o vetor final.

@Mr.Waffles, a ideia é fazer a ficha cair e treinar as abstrações... usar o VisualG para "executar o algoritmo" foi até uma técnica "esperta", mas deve-se entender como uma "burlagem do processo", e não o processo em si. Percebe a diferença? Ele poderia servir para ajudar a entender, mas não para ser o método para chegar ao resultado.

Imagine que essa fosse uma questão de concurso? Iria achar o VisuaG onde?

E outra: o enunciado dar uma grande colher de chá... a resposta "1, 2 , 3 , 4 , 5, 6, 7, 8, 9, 10" não tem como opção de resposta... . Se tivesse, muitos apressadinhos iriam errar feio!!! kkkkkkk. Já foi uma dica boa que precisaria ter mais atenção!

Vá na fé... mantenha de alguma forma os valores das variáveis e vá atualizando linha a linha... e se atente o valor que vai está a cada momento...