MAC113 - Introdução à Computação

Aula 03: Comando de repetição e seleção

• Os assuntos de hoje:
  1. operadores logicos
  2. programas que tem tanto comando de repetição como comando de seleção

• Operadores lógicos:
  1. Os operadores lógicos combinam 2 condições para formar 1 condição mais complexo.
  2. !: não
  3. && e
  4. || ou

• Em R assim como várias linguagens de programação não existe expressão a < x < b. Você deve usar a < x && x < b.

• Tabela verdade:

  	  A | !A      A | B | A&&B       A | B | A||B
  	 ===|====    ===|===|=====      ===|===|=====
            V |  F      V | V |  V         V | V |  V
  	 ---|----    ---|---|-----      ---|---|-----
  	  F |  V      V | F |  F         V | F |  V
       	             ---|---|-----      ---|---|-----
  	              F | V |  F         F | V |  V
  	             ---|---|----       ---|---|-----
  		      F | F |  F         F | F |  F
          

• Se você vai formar 1 condição composta por 3 condições, deve usar sempre ( e ) para ficar claro sentido da sua condição. (A&&B)||C é diferente de A&&(B||C).

• Observações:
  • Até aqui vimos os comandos de repetição e os comandos de seleção separadamente.
  • Daqui em diante vamos ver programas mais complexos e reais em que aparecem estes 2 tipos de comando.
  • No comando de repetição, após while(cond) tinha 1 sequência de comandos (eventualmente pode ser só 1 comando) entre { e }.
  • No formato geral de comando de seleção, para não sobrecarregar o visual, coloquei sempre 1 comando entre { e }.
  • Na verdade vale a mesma observação acima, ou seja, para dentro de cada par de { e } pode caber tanto 1 só comando como 1 sequência de comandos.
  • Mas que tipo de comandos?
  • Qualquer 1 dos 5 comandos: atribuição, leitura, escrita, repetição e seleção.
  • Logo você pode escrever 1 programa que tem 1 comando de repetição dentro do comando de seleção e também 1 comando de seleção dentro de 1 comando de repetição.

• Problema 1:
  1. fazer 1 programa que lê n e em seguida 1 sequência de n números e determinar o maior elemento da sequência.
  2. Obs: PPra não cair no caso tribial, vamos supor que n > 1 sempre.
  3. Observação: Vamos considerar o 1o.elemento da sequência como o máximo, e sempre que lê 1 elemento maior que ele o valo de máximo é trocado.
  4. Exemplo: n=5 e sequência=12, 9,35, 20, 66
     1. passo 1: 12 é max.
     2. passo 2: comparo max com 9 => max continua sendo 12.
     3. passo 3: comparo max com 35 => max vai ser 35.
     4. passo 4: comparo max com 20 => max continua sendo 35
     5. passo final: comparo max com 66 => max vai ser 66.
  5. Programa:

                n <- as.numeric(readline("digite n:  "))
                num <- as.numeric(readline("digite o primeiro:  "))
                max <- num
                for(i in(2:n)){
     	     num <- as.numeric(readline("digite o numero:  "))
     	     if(num > max){
                    max <- num
                  }
     	   }
     	   print(paste0("O maior=  ", max))  
             

• Indentação:
  • Compare as 2 versões abaixos:

  •            #Versão 1  
               n <- as.numeric(readline("digite n:  "))
               num <- as.numeric(readline("digite o primeiro:  "))
               max <- num
               for(i in(2:n)){
    	     num <- as.numeric(readline("digite o numero:  "))
    	     if(num > max){
                   max <- num
                 }
    	   }
    	   print(paste0("O maior=  ", max))  
    		 

  •            #Versão 2  
               n <- as.numeric(readline("digite n:  "))
               num <- as.numeric(readline("digite o primeiro:  "))
               max <- num
               for(i in(2:n)){
    	   num <- as.numeric(readline("digite o numero:  "))
    	   if(num > max){
               max <- num
               }
    	   }
    	   print(paste0("O maior=  ", max))  
    		 

  • Obviamente a versão 1 é melhor pois deslocamento a 2 casas sempre que abre chave (indentação) facilita visualmente a estrutura logica do programa (quem está dentro de quem).

• Problema 2:
  • Fazer 1 programa que lê n, e em seguida 1 sequência de n notas de mac113 e calcula a média das notas aprovadas (maoir ou igual a 5) e a média das notas não aprovadas (estritamente menor a 5).
  • Programa:

               n <- as.numeric(readline("digite n:  "))
               somaAp <- 0
               somaNap <- 0
               nAp <- 0
    	   nNap <- 0		     
               for(i in(1:n)){
    	     nota <- as.numeric(readline("digite a nota:  "))
    	     if(nota >= 5){
                   somaAp <- somaAp + nota
                   nAp <- nAp + 1
    	     }else{
                    somaNap <- somaNap + nota
                    nNap <- nNap + 1
    	     }
                 mediaAp <- somaAp / nAp
                 mediaNap <- somaNap / nNap
    	     print(paste0("A media dos aprovados=   ", mediaAp))  
                 print(paste0("A media dos nao aprovados=   ", mediaNap))
    	

• Exercícios para casa:
  • Na verdade, o programa acima tem pequeno erro.
  • Questão1: O que está errado?
  • Questão2: Re-escrever o programa com a devida correção.