3.4 Fluxograma em texto (com validação de entrada)

                        ╭────────────────╮
                        │     INÍCIO     │
                        ╰────────┬───────╯
                                 │
            ┌────────────────────▼────────────────────┐
     ┌─────►│  EXIBIR "Informe a idade do cliente"    /
     │     /   LER idade                              │
     │      └────────────────────┬────────────────────┘
     │                           │
     │                ╱──────────▼──────────╲
     │               ╱  idade >= 0  E         ╲
     │      NÃO     ╱   idade <= 120 ?         ╲     SIM
     │  ┌──────────⟨                            ⟩──────────┐
     │  │           ╲                          ╱           │
     │  │            ╲────────────────────────╱            │
     │  ▼                                                  │
     │ ┌──────────────────────────┐                        │
     └─/  EXIBIR "Idade inválida" │                        │
       └──────────────────────────┘                        │
                                                           │
            ┌──────────────────────────────────────────────┘
            │
            ▼
            ┌────────────────────────────────────────┐
     ┌─────►│  EXIBIR "É estudante? (S/N)"           /
     │     /   LER estudante                         │
     │      │   estudante ← MAIÚSCULA(estudante)     │
     │      └────────────────────┬───────────────────┘
     │                           │
     │                ╱──────────▼──────────╲
     │      NÃO      ╱  estudante == "S"  OU  ╲     SIM
     │  ┌───────────⟨   estudante == "N" ?    ⟩──────────┐
     │  │            ╲                       ╱           │
     │  │             ╲─────────────────────╱            │
     │  ▼                                                │
     │ ┌────────────────────────────┐                    │
     └─/  EXIBIR "Digite S ou N"    │                    │
       └────────────────────────────┘                    │
                                                         │
            ┌────────────────────────────────────────────┘
            │
            ▼
   ┌────────────────────────────────────────────┐
   │  temDireito = (idade < 18) OU              │   processo
   │               (estudante == "S")            │   (avaliação lógica)
   └────────────────────┬───────────────────────┘
                        │
             ╱──────────▼──────────╲
            ╱   temDireito é         ╲
   SIM     ╱     VERDADEIRO ?         ╲     NÃO
  ┌───────⟨                            ⟩───────┐
  │        ╲                          ╱        │
  │         ╲────────────────────────╱         │
  ▼                                            ▼
┌───────────────────────────┐   ┌──────────────────────────────────┐
│ EXIBIR                    /   │ EXIBIR                           /
│ "Cliente TEM direito      │   │ "Cliente NÃO tem direito à       │
/  à meia-entrada."         │   /  meia-entrada. Pagará inteira."  │
└─────────────┬─────────────┘   └────────────────┬─────────────────┘
              │                                  │
              └────────────────┬─────────────────┘
                               │
                       ╭───────▼────────╮
                       │      FIM       │
                       ╰────────────────╯

4. Pseudocódigo — versão direta

Algoritmo "CINEMA_VERIFICACAO_MEIA_ENTRADA"

Var
   idade      : inteiro
   estudante  : texto
   temDireito : logico

Inicio
   Escreval("========================================")
   Escreval("       BILHETERIA - MEIA-ENTRADA        ")
   Escreval("========================================")

   // ============================================================
   // FASE 1 - ENTRADA DA IDADE (com validacao)
   // ============================================================
   Repita
      Escreva("Idade do cliente: ")
      Leia(idade)

      Se (idade < 0) OU (idade > 120) Entao
         Escreval(">> Idade invalida. Informe um valor entre 0 e 120.")
      FimSe
   Ate (idade >= 0) E (idade <= 120)

   // ============================================================
   // FASE 1b - ENTRADA DA CONDICAO DE ESTUDANTE (com validacao)
   // MAIUSC padroniza a resposta: "s" e "S" sao equivalentes.
   // ============================================================
   Repita
      Escreva("O cliente e estudante? (S/N): ")
      Leia(estudante)
      estudante <- MAIUSC(estudante)

      Se (estudante != "S") E (estudante != "N") Entao
         Escreval(">> Resposta invalida. Digite S ou N.")
      FimSe
   Ate (estudante == "S") OU (estudante == "N")

   // ============================================================
   // FASE 2 - AVALIACAO DA REGRA
   // O operador OU exige que apenas UMA das condicoes seja
   // verdadeira para conceder o desconto.
   // ============================================================
   temDireito = (idade < 18) OU (estudante = "S")

   // ============================================================
   // FASE 3 - SAIDA
   // ============================================================
   Escreval("")
   Escreval("----------------------------------------")
   Escreval("Idade informada .....: ", idade, " anos")
   Escreval("E estudante .........: ", estudante)
   Escreval("----------------------------------------")

   Se (temDireito) Entao
      Escreval("Cliente TEM direito a meia-entrada.")
   Senao
      Escreval("Cliente NAO tem direito a meia-entrada.")
      Escreval("Pagara ingresso inteiro.")
   FimSe

   Escreval("========================================")

Fimalgoritmo

4.1 Variante sem a variável lógica

O mesmo resultado, testando a expressão diretamente no Se:

   Se (idade < 18) OU (estudante == "S") Entao
      Escreval("Cliente TEM direito a meia-entrada.")
   Senao
      Escreval("Cliente NAO tem direito a meia-entrada.")
   FimSe

Mais curto, mas a versão com temDireito é preferível: dá nome ao resultado da regra, permitindo reaproveitá-lo depois (para calcular preço, imprimir o ingresso, registrar estatística) sem reescrever a expressão lógica — e sem risco de as duas cópias divergirem no futuro.

5. Pseudocódigo — versão modularizada

Algoritmo "CINEMA_VERIFICACAO_MEIA_ENTRADA_MODULAR"

Var
   idade      : inteiro
   estudante  : texto
   temDireito : logico


// ============================================================
// MODULO 1 - VALIDACAO DA IDADE
// ============================================================
Funcao IdadeValida(i : inteiro) : logico
Inicio
   Retorne (i >= 0) E (i <= 120)
FimFuncao


// ============================================================
// MODULO 2 - LEITURA DA IDADE
// ============================================================
Funcao LerIdade() : inteiro
Var
   i : inteiro
Inicio
   Repita
      Escreva("Idade do cliente: ")
      Leia(i)

      Se (NAO IdadeValida(i)) Entao
         Escreval(">> Idade invalida. Informe um valor entre 0 e 120.")
      FimSe
   Ate IdadeValida(i)

   Retorne i
FimFuncao


// ============================================================
// MODULO 3 - LEITURA DA CONDICAO DE ESTUDANTE
// ============================================================
Funcao LerEstudante() : texto
Var
   r : texto
Inicio
   Repita
      Escreva("O cliente e estudante? (S/N): ")
      Leia(r)
      r <- MAIUSC(r)

      Se (r != "S") E (r != "N") Entao
         Escreval(">> Resposta invalida. Digite S ou N.")
      FimSe
   Ate (r == "S") OU (r == "N")

   Retorne r
FimFuncao


// ============================================================
// MODULO 4 - REGRA DE NEGOCIO
// Unico ponto do sistema que conhece as condicoes de desconto.
// Funcao pura: mesma entrada, mesma saida, sem efeito colateral.
// ============================================================
Funcao TemDireitoMeiaEntrada(i : inteiro ; e : caractere) : logico
Inicio
   Retorne (i < 18) OU (e == "S")
FimFuncao


// ============================================================
// MODULO 5 - SAIDA
// ============================================================
Procedimento ExibirResultado(i : inteiro ; e : caractere ; direito : logico)
Inicio
   Escreval("")
   Escreval("----------------------------------------")
   Escreval("Idade informada .....: ", i, " anos")
   Escreval("E estudante .........: ", e)
   Escreval("----------------------------------------")

   Se (direito) Entao
      Escreval("Cliente TEM direito a meia-entrada.")
   Senao
      Escreval("Cliente NAO tem direito a meia-entrada.")
      Escreval("Pagara ingresso inteiro.")
   FimSe

   Escreval("========================================")
FimProcedimento


// ============================================================
// PROGRAMA PRINCIPAL
// ============================================================
Inicio
   Escreval("========================================")
   Escreval("       BILHETERIA - MEIA-ENTRADA        ")
   Escreval("========================================")

   idade      = LerIdade()
   estudante  = LerEstudante()
   temDireito = TemDireitoMeiaEntrada(idade, estudante)

   ExibirResultado(idade, estudante, temDireito)

Fimalgoritmo

5.1 Catálogo de módulos

5.2 Hierarquia de chamadas

PROGRAMA PRINCIPAL
│
├── LerIdade()
│   └── IdadeValida(i)
│
├── LerEstudante()
│
├── TemDireitoMeiaEntrada(idade, estudante)
│
└── ExibirResultado(idade, estudante, temDireito)

6. Teste de mesa

Os casos 5, 6 e 7 são a fronteira crítica: com 17 anos há direito mesmo sem ser estudante; com 18 anos, o direito depende exclusivamente de ser estudante.

6.1 Cobertura da tabela-verdade

As quatro combinações possíveis do operador OU estão exercitadas — o teste de mesa é exaustivo em relação à regra.

7. Decisões de projeto

• OU, não E. É o núcleo do exercício. As condições são alternativas, não cumulativas: basta uma para conceder o desconto. Trocar por E reduziria o benefício apenas a menores de 18 que também fossem estudantes — três dos quatro casos da tabela-verdade seriam classificados errado.

• idade < 18, não idade <= 18. "Menos de 18 anos" exclui quem já completou 18. Alguém com exatamente 18 anos só tem direito se for estudante — o caso 6 do teste de mesa comprova, e o caso 7 mostra a diferença.

• A regra em uma função de nome próprio. TemDireitoMeiaEntrada é o único ponto do sistema que conhece as condições. Se a lei mudar a idade-limite para 16, ou incluir uma terceira hipótese, altera-se uma linha — e o resto do algoritmo continua válido. É também o módulo que se testa isoladamente contra a tabela-verdade.

• Resposta padronizada com MAIUSC. Sem isso, um cliente que digitasse s minúsculo seria classificado como não estudante — um erro silencioso, que não gera mensagem de falha e passa despercebido na bilheteria.

• Validação separada da regra. LerIdade e LerEstudante garantem que a regra receba apenas dados coerentes. TemDireitoMeiaEntrada não precisa se defender de idade negativa ou de resposta inválida, o que a mantém com uma única linha e uma única responsabilidade.

• Repita ... Ate para as entradas. O laço pós-testado é o adequado para leitura validada, porque a entrada precisa acontecer pelo menos uma vez antes que haja o que validar.

• Uma decisão, duas saídas, um fim. O Se/Senao final é exaustivo e mutuamente exclusivo: todo cliente recebe exatamente uma mensagem, e ambos os caminhos convergem para o mesmo terminal FIM.

• Escopo respeitado. O algoritmo apenas informa se há ou não direito, como o enunciado determina. Não calcula preço, não aplica percentual, não pede comprovante — essas seriam extensões posteriores, encaixadas depois de TemDireitoMeiaEntrada sem alterar a regra.