Considere os conectivos lógicos vistos na lógica proposicional para negação ( ¬ ), conjunção ( \wedge ) e disjunção ( \vee ). Mostre, com exemplos, expressões booleanas usadas no contexto de uso de commandos (atribuição, decisão, etc.) em linguagens de programação, ressaltando a representação sintática dos conectivos lógicos em expressões de cada uma das 3 linguagens de programação: C, Java (ou Harskel) e Python. Apresente \mathbf{2} exemplos, em cada linguagem, para cada caso, descrevendo instruções que contenham tais expressões booleanas, mostrando as avaliações delas, em termos de valores lógicos verdadeiro (1) ou falso (0).

Passo 1

O enunciado pede que eu mostre, com exemplos, expressões booleanas que usam os conectivos lógicos negação, conjunção e disjunção — isto é, \lnot, \land e \lor — no contexto de comandos de linguagens de programação (atribuição, decisão, etc.). Precisa também ressaltar a representação sintática desses conectivos em três linguagens: C, Java (ou Haskell) e Python. Para cada caso (negação, conjunção e disjunção) devo apresentar \mathbf{2} exemplos em cada linguagem (logo, 2 exemplos × 3 linguagens × 3 conectivos = 18 exemplos no total), descrevendo instruções que contenham tais expressões booleanas e mostrando a avaliação delas em termos de valores lógicos verdadeiro ( 1) ou falso ( 0).
Informações relevantes fornecidas ou assumidas:
  • Conectivos lógicos a tratar: negação \lnot, conjunção \land, disjunção \lor.
  • Linguagens: C, Java (uso Java nos exemplos), Python.
  • Para cada conectivo em cada linguagem: apresentar 2 exemplos com instruções (atribuição/if/etc.) e mostrar a avaliação (resultado booleano) em termos de 1 (verdadeiro) ou 0 (falso).
  • Mostrar sintaxe do conectivo em cada linguagem (por exemplo: !, &&, || em C/Java; not, and, or em Python).

Passo 2

Mini-aula rápida e prática sobre o que os conectivos significam (para solidificar a intuição antes de ver código):
  • Negação ( \lnot): inverte o valor lógico. Se uma proposição P vale 1 então \lnot P vale 0; se P vale 0 então \lnot P vale 1.
    Verdadeiro/Falso: \lnot 1 = 0, \lnot 0 = 1.
  • Conjunção ( \land): é o “E”. A expressão P \land Q é verdadeira apenas quando P e Q são ambos verdadeiros. Tabela:
\begin{array}{c c | c} P & Q & P \land Q\\hline 0 & 0 & 0\\\\ 0 & 1 & 0\\\\ 1 & 0 & 0\\\\ 1 & 1 & 1 \end{array}
  • Disjunção ( \lor): é o “OU” inclusivo. A expressão P \lor Q é verdadeira se pelo menos uma entre P e Q for verdadeira. Tabela:
\begin{array}{c c | c} P & Q & P \lor Q\\hline 0 & 0 & 0\\\\ 0 & 1 & 1\\\\ 1 & 0 & 1\\\\ 1 & 1 & 1 \end{array}
Dica prática: em programação, muitas vezes construímos P e Q como comparações (ex.: x > 0, y == 10) e depois combinamos com os conectivos.

Passo 3

Sintaxe dos conectivos nas linguagens pedidas (resumo rápido):
  • Negação \lnot:
    • C/Java: uso de ! para negar uma expressão booleana (ex.: !cond).
    • Python: uso de not (ex.: not cond).
  • Conjunção \land:
    • C/Java: uso de && (ex.: cond1 && cond2).
    • Python: uso de and (ex.: cond1 and cond2).
  • Disjunção \lor:
    • C/Java: uso de || (ex.: cond1 || cond2).
    • Python: uso de or (ex.: cond1 or cond2).
Observação rápida: em C, valores numéricos também podem ser usados como condição (zero = falso, não-zero = verdadeiro); em Java e Python é mais comum usar diretamente valores booleanos ou expressões de comparação (em Java, if requer boolean explícito).

Passo 4

Negação ( \lnot) — explicação curta e exemplos
  • Semântica: \lnot P é verdadeiro quando P é falso, e vice-versa.
  • Vou dar \mathbf{2} exemplos em cada linguagem. Para cada exemplo descrevo as variáveis iniciais, a instrução, e a avaliação passo a passo até chegar em 1 ou 0.
C — exemplos de negação:
  1. Exemplo C-neg1:
  • Variáveis iniciais: int a = 0; (em lógica: a = 0 significa falso).
  • Instrução: if (!a) { /* ramo */ }
  • Avaliação: em C, a é falso porque a=0. Então !a é verdadeiro. Em símbolos: \lnot 0 = 1.
  • Resultado final da expressão !a: 1.
  1. Exemplo C-neg2:
  • Variáveis iniciais: int b = 5; (qualquer não-zero é verdadeiro).
  • Instrução: if (!b) { /* ramo */ } else { /* outro ramo */ }
  • Avaliação: b é verdadeirosince b\neq 0. Então !b é falso. Em símbolos: \lnot 1 = 0 (aqui interpretamos b\neq0 como 1 na lógica).
  • Resultado final da expressão !b: 0.
Java — exemplos de negação:
  1. Exemplo Java-neg1:
  • Variáveis iniciais: boolean flag = false; (logo \text{flag}=0).
  • Instrução: if (!flag) System.out.println("vai entrar");
  • Avaliação: !\text{flag} = !\text{false} = \text{true}. Em termos numéricos: \lnot 0 = 1.
  • Resultado: expressão !flag = 1.
  1. Exemplo Java-neg2:
  • Variáveis iniciais: boolean cond = (x > 0); e suponha x = 3 (logo \text{cond}=1).
  • Instrução: if (!cond) ...
  • Avaliação: !\text{cond} = !\text{true} = \text{false}. Em termos numéricos: \lnot 1 = 0.
  • Resultado: expressão !cond = 0.
Python — exemplos de negação:
  1. Exemplo Py-neg1:
  • Variáveis iniciais: x = 0 (em condições, 0 é falso).
  • Instrução: if not x: print("entra")
  • Avaliação: not x = not 0 = True. Em números: \lnot 0 = 1.
  • Resultado: not x = 1.
  1. Exemplo Py-neg2:
  • Variáveis iniciais: s = "hello" (string não-vazia é verdadeira).
  • Instrução: if not s: ... else: ...
  • Avaliação: s é truthy (verdadeiro), logo not s é False. Em números: \lnot 1 = 0.
  • Resultado: not s = 0.

Passo 5

Conjunção ( \land) — explicação curta e exemplos
  • Semântica: P \land Q é 1 somente se ambos P e Q são 1. Caso contrário é 0.
  • Mostrar \mathbf{2} exemplos por linguagem.
C — exemplos de conjunção:
  1. Exemplo C-and1:
  • Variáveis: int x = 4, y = 2;
  • Expressões: x > 0 e y > 0. Em símbolos: P\equiv (x>0), Q\equiv (y>0). Aqui P=1, Q=1.
  • Instrução: if (x > 0 && y > 0) ...
  • Avaliação: P \land Q = 1 \land 1 = 1.
  • Resultado da expressão x > 0 && y > 0: 1.
  1. Exemplo C-and2:
  • Variáveis: int a = 3, b = -1;
  • Expressões: P\equiv (a < 5) é 1 (pois 3<5), Q\equiv (b > 0) é 0 (pois -1>0 é falso).
  • Instrução: if (a < 5 && b > 0) ...
  • Avaliação: 1 \land 0 = 0.
  • Resultado: expressão a < 5 && b > 0 = 0.
Java — exemplos de conjunção:
  1. Exemplo Java-and1:
  • Variáveis: int a = 10, b = 2;
  • Testes: a % b == 0 (verifica divisibilidade): P = 1 porque 10 é divisível por 2. a > 0 é 1.
  • Instrução: if (a % b == 0 && a > 0) ...
  • Avaliação: 1 \land 1 = 1.
  • Resultado: expressão = 1.
  1. Exemplo Java-and2:
  • Variáveis: boolean loggedIn = true; int attempts = 5;
  • Testes: P\equiv \text{loggedIn} = 1, Q\equiv (\text{attempts} < 3) é 0 (pois 5<3 é falso).
  • Instrução: if (loggedIn && attempts < 3) ...
  • Avaliação: 1 \land 0 = 0.
  • Resultado: expressão = 0.
Python — exemplos de conjunção:
  1. Exemplo Py-and1:
  • Variáveis: a = 7; b = 3
  • Testes: a > b é True ( 1), b >= 1 é True ( 1).
  • Instrução: if a > b and b >= 1: ...
  • Avaliação: 1 \land 1 = 1.
  • Resultado: a > b and b >= 1 = 1.
  1. Exemplo Py-and2:
  • Variáveis: x = 0; y = 10
  • Testes: x != 0 é False ( 0), y > 0 é True ( 1).
  • Instrução: if x != 0 and y > 0: ...
  • Avaliação: 0 \land 1 = 0.
  • Resultado: x != 0 and y > 0 = 0.

Passo 6

Disjunção ( \lor) — explicação curta e exemplos
  • Semântica: P \lor Q é 1 se pelo menos um entre P ou Q é 1; é 0 somente quando ambos são 0.
  • Novamente, \mathbf{2} exemplos por linguagem.
C — exemplos de disjunção:
  1. Exemplo C-or1:
  • Variáveis: int hour = 8; int weekend = 0;
  • Testes: P\equiv (\text{hour} < 9) é 1 ( 8<9), Q\equiv (\text{weekend} == 1) é 0.
  • Instrução: if (hour < 9 || weekend == 1) ...
  • Avaliação: 1 \lor 0 = 1.
  • Resultado: expressão = 1.
  1. Exemplo C-or2:
  • Variáveis: int a = 0, b = 0;
  • Testes: P\equiv (a != 0) é 0, Q\equiv (b > 0) é 0.
  • Instrução: if (a != 0 || b > 0) ...
  • Avaliação: 0 \lor 0 = 0.
  • Resultado: expressão = 0.
Java — exemplos de disjunção:
  1. Exemplo Java-or1:
  • Variáveis: boolean hasKey = false; boolean admin = true;
  • Testes: P = 0, Q = 1.
  • Instrução: if (hasKey || admin) ...
  • Avaliação: 0 \lor 1 = 1.
  • Resultado: expressão = 1.
  1. Exemplo Java-or2:
  • Variáveis: int x = -5;
  • Testes: P\equiv (x > 0) é 0, Q\equiv (x == 0) é 0.
  • Instrução: if (x > 0 || x == 0) ...
  • Avaliação: 0 \lor 0 = 0.
  • Resultado: expressão = 0.
Python — exemplos de disjunção:
  1. Exemplo Py-or1:
  • Variáveis: name = "" ; default_name = "guest"
  • Testes: name é string vazia (falsy → 0), default_name é truthy ( 1).
  • Instrução: user = name or default_name
  • Avaliação: name or default_name avalia para default_name porque name é falso; em booleano: 0 \lor 1 = 1.
  • Resultado booleano da expressão lógica subjacente = 1 (o valor verdadeiro corresponde a default_name como valor resultante).
  1. Exemplo Py-or2:
  • Variáveis: a = 0; b = False
  • Testes: a é falsy ( 0), b é False ( 0).
  • Instrução: if a or b: ...
  • Avaliação: 0 \lor 0 = 0.
  • Resultado: expressão = 0.

Passo 7

Observações pedagógicas finais (como aplicar isso na prova):
  • Passo-a-passo para avaliar uma expressão composta:
    1. Calcule o valor lógico de cada comparação/variável simples (ex.: x > 0 1 ou 0).
    2. Aplique a prioridade dos operadores (em geral, !/not tem maior precedência, depois &&/and, depois ||/or; parênteses forçam avaliação).
    3. Use as tabelas de verdade acima para combinar subresultados até o resultado final.
  • Em provas, escreva explicitamente os valores intermédios ( P=0 ou 1, Q=0 ou 1), e então mostre a aplicação das regras (ex.: P \land Q = 1 \land 0 = 0). Isso deixa claro o raciocínio e evita erros.
  • Lembre-se da diferença sintática entre linguagens: !, &&, || em C/Java; not, and, or em Python.

Resposta

C-neg1: !a com a = 0 avalia para 1.
C-neg2: !b com b = 5 avalia para 0.
Java-neg1: !flag com flag = false avalia para 1.
Java-neg2: !cond com cond = (x>0) e x=3 avalia para 0.
Py-neg1: not x com x = 0 avalia para 1.
Py-neg2: not s com s = "hello" avalia para 0.
C-and1: x > 0 && y > 0 com x=4,y=2 avalia para 1.
C-and2: a < 5 && b > 0 com a=3,b=-1 avalia para 0.
Java-and1: a % b == 0 && a > 0 com a=10,b=2 avalia para 1.
Java-and2: loggedIn && attempts < 3 com loggedIn=true,attempts=5 avalia para 0.
Py-and1: a > b and b >= 1 com a=7,b=3 avalia para 1.
Py-and2: x != 0 and y > 0 com x=0,y=10 avalia para 0.
C-or1: hour < 9 || weekend == 1 com hour=8,weekend=0 avalia para 1.
C-or2: a != 0 || b > 0 com a=0,b=0 avalia para 0.
Java-or1: hasKey || admin com hasKey=false,admin=true avalia para 1.
Java-or2: x > 0 || x == 0 com x=-5 avalia para 0.
Py-or1: name or default_name com name="" , default_name="guest" tem booleano equivalente 1.
Py-or2: a or b com a=0,b=False avalia para 0.

Exercícios relacionados