Portugol Fluxograma em exercicios de Algoritmos

[Thais Monteiro]

Boa tarde pessoal.

 

Estou com dificuldades em um exercício de algoritmos da faculdade.

 

segue print do exercício abaixo: 

 

ps: Acho que esse fluxograma contém uma anomalia, porque não tem como q1 ser falso sem executar c, pelo menos foi o que entendi.
sendo assim esse fluxograma não seria estruturado. Me corrijam se eu estiver errada.

 

Poderiam me dar um help?

Agradecida!

[Simon Viegas]

@Thais Monteiro, vamos lá:

 

1 hora atrás, Thais Monteiro disse:

Acho que esse fluxograma contém uma anomalia, porque não tem como q1 ser falso sem executar c, pelo menos foi o que entendi.
sendo assim esse fluxograma não seria estruturado. Me corrijam se eu estiver errada.

 

O valores de resultado de uma "tabela verdade" podem ser montados das formas que quiserem, logo, qualquer possibilidade é válida. Observe que a tabela verdade é apenas uma representação de algo. No caso, cada combinação de valores estão resultando em determinadas ações.

 

O comportamento do fluxograma é análogo... as verificações feitas nele só podem ser feitas após o fluxograma está feito, ou seja: você está invertendo a lógica... o fluxograma será também apenas uma "representação" de algo, logo, o que estaria errado era este algo (não a sua representação). (Obs.: ou o fluxograma estará mal feito assim não representando a realidade, ou ele está certo e representando o algo que está errado. O fluxograma é inocente aí, rs).

 

Só para ficar mais claro, poderia dizer algo como: "o possível fluxo deste programa contém uma anomalia". Perceba que mesmo assim o fluxograma e a tabela verdade poderá ser feito! (representando algo que está errado) 

 

Mas como citado, não tem anomalias na tabela verdade, pois ela é totalmente livre para ter qualquer valores de resultado... e como só ela está pronto, devem-se supor que ela está correta!

 

 

Para demonstrar, segue uma lógica simples (e que é válida) para as linhas de código (em VisualG) :

         se (p = VERDADEIRO) E (q = VERDADEIRO) entao
            escreval("Executando a")
            escreval("Executando d")
         senao
            se (p = VERDADEIRO) E (q = FALSO) entao
               escreval("Executando a")
               escreval("Executando d")
            senao
               se (p = FALSO) E (q = VERDADEIRO) entao
                  escreval("Executando c")
               senao
                  se (p = FALSO) E (q = FALSO) entao
                     escreval("Executando b")
                     escreval("Executando d")
                  fimSe
               fimSe
            fimSe
         fimSe

 

Código teste:

algoritmo "FCdH"
var
   p, q :logico
   valoresLogicos : vetor [0..1] de logico
   i, j :inteiro
inicio
   valoresLogicos[0] <- FAlSO
   valoresLogicos[1] <- VERDADEIRO
   para i de 1 ate 0 passo -1 faca
      para j de 1 ate 0 passo -1 faca
         escreval("")
         p <- valoresLogicos[i]
         q <- valoresLogicos[j]
         escreval("p =", p, "  q =", q)
         se (p = VERDADEIRO) E (q = VERDADEIRO) entao
            escreval("Executando a")
            escreval("Executando d")
         senao
            se (p = VERDADEIRO) E (q = FALSO) entao
               escreval("Executando a")
               escreval("Executando d")
            senao
               se (p = FALSO) E (q = VERDADEIRO) entao
                  escreval("Executando c")
               senao
                  se (p = FALSO) E (q = FALSO) entao
                     escreval("Executando b")
                     escreval("Executando d")
                  fimSe
               fimSe
            fimSe
         fimSe
      fimPara
   fimPara
fimAlgoritmo

 

Resultado:

 

Veja: a base deste algoritmo, supostamente, serve como resposta!!! ele seria UMA solução para o problema!!! mas óbvio, claro, lógico, que não se esperam uma lógica tão simples... devem-se está buscando algo mais sofisticado, como pela questão do "d" ser executado em quase todos os casos ou que para "p = V", dá o mesmo resultado independente do valor de "q" . E por aí vai.

 

RESUMO:

Pelo que eu entendi do problema, é necessário analisar os valores da tabela verdade e imaginar um possível programa que, ao terem o valores de p e q, resultem nas ações correspondente aos listados na tabela. Daí, imagine que você imaginou esta lógica acima. A partir dela (que seria mental), crie o seu fluxograma, e após "implemente" o código correspondente a este fluxograma.

 

Após conseguir, tente imaginar outras lógicas (outras soluções) que satisfaçam esta tabela verdade... e seguir o mesmo fluxo acima.

 

No contexto: Tabela verdade (está pronta) --> Fluxograma (vai criar um a partir de uma lógica) --> Código (implementação do que está proposto no fluxograma).

No aguardo.

[Thais Monteiro]

ok

adicionado 4 minutos depois

@Simon Viegas Agradeço suas explicações, mas está complexo demais pra mim.
 

 

[Simon Viegas]

16 horas atrás, Thais Monteiro disse:

ok

adicionado 4 minutos depois

@Simon Viegas Agradeço suas explicações, mas está complexo demais pra mim.

 

O que define como complexo? o tamanho do texto? rs. Normal. Sou "verboso" mesmo. Mas é bom para treinar a interpretação de texto...
 

RESUMO DO PROBLEMA: 

Crie um fluxograma que ao inserir os valores de q1 e q2, o resultado seja o respectivo da tabela verdade.

 

OU

 

Crie um programa (linhas de códigos) que ao inserir os valores de q1 e q2, o resultado seja o respectivo o da tabela verdade.

 

 

Daí poste a resposta aqui.
 

 

 

***

 

Vou tentar explicar novamente os conceitos. O enunciado diz algo como:

 

Existe um determinado programa! Você NÃO tem acesso ao código fonte, e nem tem acesso ao fluxograma deste programa, mas alguém teve acesso ao funcionamento dele. A partir daí, concluíram-se que para determinados comportamentos de entrada, o programa resulta em determinadas ações!

 

Por exemplo:
Pela análise do programa foi identificado que existem dois valores de entrada que chamaremos de q1 (no meu código chamei de p) e q2 (no meu código chamei de q). Beleza? Daí viu que esses q1 e q2 tem apenas 2 estados: VERDADEIRO ou FALSO. Simplesmente ele fez a combinação de possibilidades e chegou a seguinte tabela verdade:

 

Esta tabela representa como o program se comporta!
 

Tipo: quando q1=V e q2=F, o programa vai executar as ações a e d. O que são estas ações? não importa (abstração). O que importa é que sempre algo é feito de acordo com os valores de q1 e q2.

 

Mais uma vez: ele não sabe como o programa funciona internamente (é transparente, está criptografado no programa), mas ele sabe que para determinadas entradas, terá determinados resultados.

 

A sua função é tentar deduzir qual foi a lógica utilizada neste programa. Você analisou e chegou a uma conclusão:

 

18 horas atrás, Thais Monteiro disse:

ps: Acho que esse fluxograma contém uma anomalia, porque não tem como q1 ser falso sem executar c, pelo menos foi o que entendi.

 

Daí um equívoco inicial é que ainda NÃO existe fluxograma, oras! pois ele é justamente o que você precisa criar. Sacou? Seria algo como:

 

Citação

ps: Acho que essa tabela verdade contém uma anomalia, porque não tem como q1 ser falso sem executar c, pelo menos foi o que entendi.

 

Obs.: mas como disse, não tem como uma tabela verdade ter anomalias, pois os valores lá das ações podem ser qualquer um!!!

 

ou

 

Citação

ps: Acho que o possível fluxo do programa, do qual gerou esta tabela verdade, contém uma anomalia, porque não tem como q1 ser falso sem executar c, pelo menos foi o que entendi.

Obs.: idem: o programa pode dar qualquer resultado, vai ser simplesmente o que o programador criou!
 

RESUMINDO:
Não dá para concluir que existem anomalias, pois não se sabe o que ele faz! Simplesmente sabem-se que ele é assim!

 

Entende? o objetivo do exercício é "tendo uma tabela verdade (que por natureza representa o resultado do fluxo do programa ao ter determinadas valores de entrada), deduzir um fluxograma (que por natureza representará o que você imaginou como sendo o fluxo do programa, ou seja: representará o fluxo do programa em forma de diagrama!) e, a partir deste fluxograma, criar uma código (que natureza deve seguir o fluxograma, que por consequência as execuções vão resultar os mesmo valores que a tabela verdade indica - pois esta tabela É a representação dos resultado reais, se der valores diferentes, a "engenharia reversa tá errada").

 

É tudo interligado. O fluxograma é uma representação dos possíveis fluxos, em forma de diagrama, do do código; assim como o código do programa é uma implementação do que estará representado no fluxograma; assim como a tabela verdade é uma representação dos resultados reais ao "executar" o fluxograma ou executar o programa...

 

No aguardo.

[Thais Monteiro]

@Simon Viegas Agradeço novamente suas longas explicações e desejo boa sorte com seus treinos de interpretação de texto.

Mas já consegui fazer o exercício. Pedi ajuda porque estou sou humilde e mostro que não sei, pois quero aprender, não preciso ficar mostrando o tempo inteiro que sei das coisas. E não me refiria a complexidade em relação ao tamanho do seu texto, até porque li tudo. Me referi a quantidade de abordagens muito específicas de coisas que nem aprendi ainda na faculdade... Você falou e falou e ainda não tinha ficado claro pra mim. Acho que tá sendo um "pouquinho" exibicionista e está muito preocupado em afirmar o tempo todo que sabe das coisas. 

Conforme o print 1 abaixo me baseei no exemplo que o professor nos falou em aula, me baseei nesse fluxograma e, se quer afirmei de que era uma anomalia, disse até pra me corrigirem se eu estiver errada.... Poderia ser como poderia não ser, tanto que vim aqui pedir ajuda... Até porque não existe um fluxograma pronto, o fluxograma seria criado com base a tabela de ações, e depois eu faria o pseudo-código. 

No print 2 é o meu exercício pronto.

Nem precisa responder.

[Simon Viegas]

@Thais Monteiro, sobre toda problemática que ocorreu, eu cheguei até a escrever uma resposta pontuando cada questão, mas acho melhor deixar queto. Você está 100% certa! Vou acabar piorando (vou continuar sendo impreciso e levar a outros mal-entendidos ). De qualquer sorte: desculpa por qualquer se disse algo errado e pela aparente presunção minha. Não foi/é minha intenção!

 

Sobre o problema, apesar de desnecessário, vai aí minha interpretação, ainda que também prolixa... caso se interesse. Ou de qualquer forma para possíveis outros visitantes. Antecipadamente peço desculpas por postar e por qualquer outras coisas. Segue:

 

Sobre o fluxograma:

17 horas atrás, Thais Monteiro disse:

 

O q2 é um estado, certo?. Acho que no neste fluxograma você utilizou um laço de repetição (pelo que consta no código também), e, se esse estado de q2 for fixo, acho que vai ficar num loop infinito quando q1 = F e q2 = V. Acho que poderia ocorrer de ficar executando o c várias vezes (vai depender da natureza de q2). Outra questão: acho, que mesmo que q2 mude de estado para F em algum momento, o resultado seria c, (c, c, c,...) b, d, o que eu acho que não corresponderia à tabela verdade.

 

 

Sobre o código:

 

Não sei qual é sintaxe, mas acho que ali no lugar do fim-se seria fim-senão ou, se for algo semelhante ao Portugol do VisualG, acho que não fecharia, pois lá o senao é atrelado ao seu se. Acho também que o b ficaria no mesmo alinhamento do enquanto (pois está dentro do senao e no mesmo nível do enquanto).

 

Acho que ficaria algo assim:

se q1 entao
  a
senao
  enquanto q2 faca
    c
  fim-enq q2
  b
fim-se q1
d

ou algo como:

se q1 entao
  a
senao
  enquanto q2 faca
    c
  fim-enq q2
  b
fim-senao q1
fim-se q1
d

 

Como sugerível, acho que o d estará SEMPRE sendo executado, independente dos valores de q1 e q2, e acho que não é isto que a tabela verdade indica. Logo, acho que o fluxograma está inconsistente com a tabela verdade, e por consequência, as linhas de códigos também.

 

Fiz uns ajustes no meu código de acordo com o que você explicou sobre o que o professor ensinou e o resultado deu certo. Segue uma tela:

 

 

OBSERVAÇÃO: cortei propositalmente o trecho de código com a minha interpretação... preferi não postar uma possível solução para o fluxograma (cheguei até fazer um pelo site https://app.creately.com/diagram, que achei no Google), tanto as linhas de código das quais acho que estariam mais adequadas, pois achei que seria mais adequado você analisar se estou no caminho correto e você mesma encontrar uma resposta se for o caso.

 

Caso queira analisar o que explanei e quiser postar um nova resposta para analisarmos, estamos a disposição.

 

No aguardo,

[Simon Viegas]

Como já tem um tempinho, segue o que eu entendi:

 

Uma forma natural de se pensar no fluxograma poderia ser assim:

 

 

Mas como já sugerido na imagem, esta ligação da instrução b para a instrução d não poderia ser feita, pois ocasionaria a tal da ANOMALIA citada pelo professor... deixando o algoritmo não estruturado.

 

Só complementando... mas por que isto aconteceria? então, uma forma de entender melhor poderia ser algo assim:

 

 

Estas "caixas pretas" estariam representando que, cada lado após a decisão da estrutura condicional ali em q1, é um "bloco de instruções completos". Observem que fica mais claro que o fluxo de um bloco estaria tentando entrar no meio do fluxo do outro bloco"... o que é pressuposto que NÃO é possível num paradigma estruturado. Quando for lá para o "código do programa", não vai conseguir implementar esse algoritmo. Se conseguirem, me avisem! (eu acho que não dá)

 

Daí, uma forma poderia ser algo assim:

 

Fica faltando só as linhas de código.

 

adicionado 17 minutos depois

Sobre o fluxograma do código que postei:

 

Em 25/03/2020 às 19:09, Simon Viegas disse:

Para demonstrar, segue uma lógica simples (e que é válida) para as linhas de código (em VisualG) :

         se (p = VERDADEIRO) E (q = VERDADEIRO) entao
            escreval("Executando a")
            escreval("Executando d")
         senao
            se (p = VERDADEIRO) E (q = FALSO) entao
               escreval("Executando a")
               escreval("Executando d")
            senao
               se (p = FALSO) E (q = VERDADEIRO) entao
                  escreval("Executando c")
               senao
                  se (p = FALSO) E (q = FALSO) entao
                     escreval("Executando b")
                     escreval("Executando d")
                  fimSe
               fimSe
            fimSe
         fimSe

 

 

O fluxograma poderia ser algo assim:

 

 

Ou seja: tanto este fluxograma, tanto o outro fluxograma (logo mais acima), estariam corretos para o exercício. Apenas que este último poderia ser considerado um pouco "mais pobre"... ou talvez não seja permitido utilizar a verificação do q2 duas vezes, por exemplo.

 

adicionado 38 minutos depois

ADENDO:
Esse fluxograma acima não estaria totalmente preciso com o "código simples", pois estaria omitido algumas reverificações, entretanto os resultados seriam iguais. Um código mais preciso ficaria algo assim:

         se (p = VERDADEIRO) entao
            se (q = VERDADEIRO) entao
               escreval("Executando a")
               escreval("Executando d")
            senao
               escreval("Executando a")
               escreval("Executando d")
            fimSe
         senao
            se (q = VERDADEIRO) entao
               escreval("Executando c")
            senao
               escreval("Executando b")
               escreval("Executando d")
            fimSe
         fimSe

 

Não sei dizer exatamente qual seria o "mais certo" (se é que estão certos).
 

Uma simplificação simples do código simplificado, poderia ser algo assim:

         se (p = VERDADEIRO) entao
            escreval("Executando a")
            escreval("Executando d")
         senao
            se (p = FALSO) E (q = VERDADEIRO) entao
               escreval("Executando c")
            senao
               se (p = FALSO) E (q = FALSO) entao
                  escreval("Executando b")
                  escreval("Executando d")
               fimSe
            fimSe
         fimSe

ou seguindo a mesma lógica de não reverificações:

         se (p = VERDADEIRO) entao
            escreval("Executando a")
            escreval("Executando d")
         senao
            se (q = VERDADEIRO) entao
               escreval("Executando c")
            senao
               escreval("Executando b")
               escreval("Executando d")
            fimSe
         fimSe

Creio que os fluxograma correspondente seria fácil de deduzir (bastaria remover a verificação do q2 quando q1 = V).

 

Att,