Question

alguém pode me ajudar em essa questão de python??

É muito comum em programação usarmos operadores lógicos. Python fornece 3 operadores lógicos:

not, and e or.

Esses três são suficientes para descrever qualquer expressão lógica, mas não são os únicos que existem.

Um outro operador lógico que existe é o condicional. Sejam pe q expressões lógicas, a operação condicional p q é definida de acordo com a tabela verdade acima.

Seu trabalho será implementar a operação lógica condicional, mas para 3 expressões.

Para isso, implemente uma função cond, que recebe os argumentos p, q e r (booleanos), e retorne o resultado de p → q → r.

Obs.: condicional é uma operação left- associative, ou seja, p → q → r é a mesma coisa que (p → q) → r.

Entrada:

A entrada consiste nos parâmetros da função cond que são os booleanos p, q e r.

Saída:

sua função deve retornar um booleano, que é o resultado de p → q → r.

Observações:

• No primeiro caso de teste, a primeira implicação diz que 1 ser menor do que 2 implica que é menor do que 3 (obviamente verdade), e isso implica que 1 é menor do que 5 ( também verdade).

• No segundo caso de teste, a primeira implicação diz que 1 ser menor do que 2 implica que 1 é menor do que 3 (obviamente verdade), e isso implica que 1 é maior que 5, o que é falso.

• Submeta somente o que foi solicitado,​

Answer 1

Antes, é preciso salientar que o texto pede para que o código se limite ao que é proposto no exercício e, portanto, os códigos que serão apresentados abaixo não irão contar com validação de dados ou tratamento de erros/exceções.

Assim, é necessário preencher corretamente os parâmetros da função com True ou False ou será retornado valores/respostas incorretos.

Vamos começar montando a tabela verdade para o condicional de 3 expressões. Note que não será objetivo dessa resolução a explicação do operador lógico em questão, portanto, caso ainda não esteja familiarizado com o assunto, sugiro que pause a leitura aqui e volte depois que tiver estudado a matéria.

$\begin{array}{|c|c|c|c|c|}\sf p&\sf q&\sf p\rightarrow q&\sf r&\sf p\rightarrow q\rightarrow r\\-&-&--&-&----\\F&F&V&F&F\\F&V&V&F&F\\V&F&F&F&V\\V&V&V&F&F\\&&&&\\F&F&V&V&V\\F&V&V&V&V\\V&F&F&V&V\\V&V&V&V&V\end{array}$

Nesse ponto, vamos apresentar algumas alternativas de implementação dessa tabela verdade em Python e, é importante que seja ressaltado, há outras tantas possibilidades de faze-la, incluindo com bibliotecas específicas.

1) A primeira alternativa que será reproduzir a tabela verdade inteira através de uma  estrutura condicional (if/elif).

$\sf de f ~cond(p,~q,~r):\\ ~~~~if~ p==False ~and ~q==False~ and~ r==False:\\ ~~~~~~~~ return~False\\~~~~ elif~ p==False~ and~ q==True ~and~ r==False:\\~~~~~~~~ return ~False\\ ~~~~ elif~ p==True~ and~ q==False ~and~ r==False:\\~~~~~~~~ return~ True\\ ~~~~elif~ p==True~ and ~q==True~ and ~r==False:\\~~~~~~~~ return~ False$

$\sf .\!~~~elif~ p==False~ and ~q==False ~and ~r==True:\\~~~~~~~~ return~ True\\~~~~ elif~ p==False~ and ~q==True ~and~ r==True:\\~~~~~~~~ return~ True\\~~~~ elif~ p==True ~and ~q==False~ and~ r==True:\\~~~~~~~~ return ~True\\~~~~ elif ~p==True ~and ~q==True ~and ~r==True:\\ ~~~~~~~~ return ~True$

(2) e (3) Como pudemos ver acima, transcrever a tabela, embora efetivo e legível, é uma opção trabalhosa.

Nessas 2ª e 3ª implementações vamos agora extrair da tabela a expressão booleana correspondente ao operador condicional de 3 entradas (p, q e r). A expressão booleana pode ser escrita como soma de produtos (SOP) utilizando-se as linhas que nos retornaram resultado Verdadeiro ou como produto de somas (POS) utilizando-se as linhas que nos retornaram resultado Falso.

$\sf \underline{SOP}:~~p\rightarrow q\rightarrow r~=~p\overline{q}\,\overline{r}~+~\overline{p}\,\overline{q}r~+~\overline{p}qr~+~p\overline{q}r~+~pqr\\\\\\\sf \underline{POS}:~~p\rightarrow q\rightarrow r~=~(p+q+r)\cdot(p+\overline{q}+r)\cdot(\overline{p}+\overline{q}+r)$

Vamos implementa-las:

SOP:

$\sf de f~ cond(p,~ q,~ r):\\ ~~~~ return~ (p~ and~ not~ q~ and~ not~ r )~ or~ (not~ p~ and ~ not~ q~ and~ r~ ) ~ or~ (not~ p~ and\\~~~~ q~ and~ r )~ or~ (p~ and~ not~ q~ and~ r )~ or~ (p~ and~ q~ and~ r )$

POS:

$\sf de f~cond(p,~q,~r):\\~~~~return~(p~ or~q~or~r)~and~(p~or~not~ q~or~r)~and~(not~ p~ or~not ~q~or~r)$

4) Estes dois códigos (2 e 3) já parecem boas opções em relação à primeira implementação, no entanto, se quisermos, podemos deixa-los ainda mais simples.

Utilizando algebra booleana ou um mapa de Karnaugh, as expressões de SOP e POS podem ser simplificadas.

Aqui vou deixar a implementação utilizando SOP simplificada pelo mapa de Karnaugh (anexado).

$\sf \underline{SOP~simplificado}:~~p\rightarrow q\rightarrow r~=~p\overline{q}+r$

$\sf de f~ cond(p,~q,~r):\\~~~~ return~ (p~ and~ not~ q)~ or~ r$

$\Huge{\begin{array}{c}\Delta \tt{\!\!\!\!\!\!\,\,o}\!\!\!\!\!\!\!\!\:\,\perp\end{array}}Qualquer~d\acute{u}vida,~deixe~ um~coment\acute{a}rio$