MAC2166 - Introdução à Computação (1º Semestre de 2023)

(x < 3) or (y == 0)

Podemos aplicar a dupla negação sem alterar seu resultado:

not not ((x < 3) or (y == 0))

Podemos agora trocar o operador or pelo operador and, aplicando a "Leis de De Morgan":

not (not (x < 3) and not (y == 0))

Finalmente, podemos então simplificar a expressão, trocando os operadores relacionais negados por operadores relacionais complementares:

not (x >= 3 and y != 0)

Curiosidades:

Em linguagem C, os valores booleanos False e True são definidos como os valores numéricos 0 e 1, respectivamente. Isso significa que o mesmo efeito do operador lógico and pode ser obtido em C através de um simples produto, isto é, A && B pode ser obtido como A * B. Porém, observe que a multiplicação possui maior nível de precedência, o que pode gerar alterações na ordem de execução no caso de expressões mais complexas, consequentemente levando a um resultado diferente do esperado. Já no caso do operador lógico or temos que A || B pode ter o seu efeito reproduzido pela expressão A+B-A*B.

No Python 3, o tipo bool de dados booleanos é uma subclasse dos inteiros. Logo, no Python 3, os valores booleanos False e True se comportam como os valores 0 e 1, respectivamente, em quase todos os contextos, a exceção é que, quando convertidos em uma string, as strings "False" ou "True" são retornadas, respectivamente. Experimente digitar no prompt (>>>) do Python shell os comandos abaixo:

Problema 1:

Solução 1: Sem o uso de operadores lógicos

    # Primeira data.
    d1 = int(input("Dia: "))
    m1 = int(input("Mês: "))
    a1 = int(input("Ano: "))
    # Segunda data.
    d2 = int(input("Dia: "))
    m2 = int(input("Mês: "))
    a2 = int(input("Ano: "))

    if a1 > a2:
        print("Data1 é maior!")
    elif a1 == a2:
        if m1 > m2:
            print("Data1 é maior!")
        elif m1 == m2:
            if d1 > d2:
                print("Data1 é maior!")
            elif d1 == d2:
                print("Datas são iguais!")
            else:
                print("Data2 é maior!")
        else:
            print("Data2 é maior!")
    else:
        print("Data2 é maior!")
      

Solução 2: Solução mais compacta com o uso de operadores lógicos

      # Primeira data.
      d1 = int(input("Dia: "))
      m1 = int(input("Mês: "))
      a1 = int(input("Ano: "))
      # Segunda data.
      d2 = int(input("Dia: "))
      m2 = int(input("Mês: "))
      a2 = int(input("Ano: "))

      if a1>a2 or (a1==a2 and m1>m2) or (a1==a2 and m1==m2 and d1>d2):
           print("Data1 é maior!")
      elif a1==a2 and m1==m2 and d1==d2:
           print("Datas são iguais!")
      else:
           print("Data2 é maior!")
      

Solução 3:
Segundo a propriedade distributiva da álgebra booleana temos:

    expr1 and (expr2 or expr3) = (expr1 and expr2) or (expr1 and expr3)
    

      # Primeira data.
      d1 = int(input("Dia: "))
      m1 = int(input("Mês: "))
      a1 = int(input("Ano: "))
      # Segunda data.
      d2 = int(input("Dia: "))
      m2 = int(input("Mês: "))
      a2 = int(input("Ano: "))

      if a1>a2 or (a1==a2 and (m1>m2 or (m1==m2 and d1>d2))):
           print("Data1 é maior!")
      elif a1==a2 and m1==m2 and d1==d2:
           print("Datas são iguais!")
      else:
           print("Data2 é maior!")
      

Problema 2:

Solução 1:

Uma solução usando operadores lógicos:

      n = int(input("Digite n: "))
      rec = 0
      i = 1
      while i <= n:
          nota = float(input("Digite uma nota: "))
          if 3.0 <= nota and nota < 5.0:
              rec = rec + 1
          i = i + 1

      print(rec,"alunos ficaram de recuperação")
      

Observe que graficamente o operador lógico "and" possui o efeito de intersecção dos conjuntos.

Solução 2:

Uma segunda solução sem usar operadores lógicos:

      n = int(input("Digite n: "))
      rec = 0
      i = 1
      while i <= n:
          nota = float(input("Digite uma nota: "))
          if nota >= 3.0:
              if nota < 5.0:
                  rec = rec + 1
          i = i + 1

      print(rec,"alunos ficaram de recuperação")
      

Solução 3:

O Python ainda permite uma terceira solução, na qual o intervalo numérico é especificado de modo mais similar a nossa linguagem, usando operadores de comparação de forma encadeada:

      n = int(input("Digite n: "))
      rec = 0
      i = 1
      while i <= n:
          nota = float(input("Digite uma nota: "))
          if 3.0 <= nota < 5.0:
              rec = rec + 1
          i = i + 1

      print(rec,"alunos ficaram de recuperação")
      

     #include <stdio.h>

     int main(){
       float nota;
       int rec;
       nota = 8.0;
       rec = 3.0 <= nota < 5.0;
       if(rec)
         printf("Ficou de recuperação!\n");

       return 0;
     }
    

Problema 3:

    0    2    3   4    6    8

  # dados de entrada
  print("Cálculo dos n primeiros múltiplos de i ou de j")
  n = int(input("Digite n: "))
  i = int(input("Digite i: "))
  j = int(input("Digite j: "))

  cont = 0 #conta quantos múltiplos foram impressos.
  cm = 0 #candidato a múltiplo.
  while cont < n:
      if cm%i == 0 or cm%j == 0:
          print(cm)
          cont += 1
      cm += 1
  

  # dados de entrada
  print("Cálculo dos n primeiros múltiplos de i ou de j")
  n = int(input("Digite n: "))
  i = int(input("Digite i: "))
  j = int(input("Digite j: "))

  multi = 0 # múltiplos de i
  multj = 0 # múltiplos de j
  cont = 0 # conta quantos múltiplo foram impressos

  while cont < n:
      if multi < multj:
          print(multi)
          multi += i
      elif multj < multi:
          print(multj)
          multj += j
      else: # multi == multj
          print(multj)
          multi += i
          multj += j
      cont += 1