Exercícios

Questão 1

Para cada item a seguir implemente a função que se pede. Atenção: não use a função min já pronta no R

(a). Implemente uma função que recebe como argumento dois números reais e retorna o menor entre eles.

a_menor <- function(a,b){
  if(class(a)!="numeric" | class(b)!="numeric" )
    stop("Não são números reais")
  if(a<b)
    return(a)
  else
    return(b)
} 
a_menor(85, 84)
## [1] 84

(b). Implemente uma função que recebe como argumento três números reais e retorna o menor entre eles.

b_menor <- function(a,b,c){
  if(class(a)!="numeric" | class(b)!="numeric" | class(c)!="numeric")
    stop("Não são números reais")
  if(a<b & a<c)
    return(a)
  if(b<c & b<a)
    return(b)
  else
    return(c)
} 
b_menor(85, 84,98)
## [1] 84

(c). Implemente uma função que recebe como argumento um array de números e retorna o menor número dentro do array.

c_menor <- function(v){
  if(class(v)!="numeric")
    stop("Não é um vetor de números reais")
  
  n = length(v) 
  menor = v[1]
  
  for (i in 1:n){
    if(v[i]<menor){
      menor = v[i]
    }
  } 
    return(menor)
} 

vetor = c(100,80,30,55,47,94,19,5,30,48,5.5,50)
c_menor(vetor)
## [1] 5

Questão 2

Implemente uma função que recebe como argumento o tamanho de cada lado de um triângulo e retorna um objeto do tipo character com o texto informando se o triângulo é equilátero, isósceles ou escaleno. Antes de fazer o exercício pense:

  • Quantos argumentos a sua função vai receber?
  • Quais são os valores aceitáveis para esses argumentos?
  • Qual o tipo de objeto que a sua função deve retornar?
triangle = function(a,b,c){
  if( a<=0 | b<=0 | c<=0)
      stop("Não é um triângulo: Números negativos!")
  if(a+b>c & a+c>b & b+c>a){

  if(a!=b & b!=c & a!=c){
    return( "O triângulo é Escaleno ")
    
  } else if(a==b & b==c){
    return( "O triângulo é Equilátero ")
    
  } else{ print("O triângulo é  isósceles ") 
    }
  } else{print("Não é triângulo")}
  }

triangle(27,28,27)
## [1] "O triângulo é  isósceles "

Questão 3

Implemente uma função que recebe como argumento um array de números reais e retorna a quantidade de elementos positivos nesse array. Não se esqueça de inciar todas as variáveis locais usadas em sua função. Depois que a sua função estiver pronta invente vetores para o argumento de forma a verificar se a função está funcionando como o esperado. Por exemplo, use a função para contar o número de elementos positivos em v = c(1.0,3.2,-2.1,10.6,0.0,-1.7,-0.5).

positivo = function(vetor){
  if(class(v)!="numeric")
    stop("Não é um vetor de números reais")
  n = length(vetor)
  qtd = 0
  for (i in 1:n) {
    if(vetor[i]>=0){
      qtd = qtd + 1
    }
  }
  
  return(qtd)
}

v = c(1.0,3.2,-2.1,10.6,0.0,-1.7,-0.5)
positivo(v)
## [1] 4

Questão 4

Implemente uma função que recebe como argumento um array de numerics denominado v e um número real a. Essa função retorna o número de elementos em v menores que a.

menor_x = function(vetor, x){
  if(class(v)!="numeric")
    stop("Não é um vetor de números reais")
  
  n = length(vetor)
  qtd = 0
  for (i in 1:n) {
    if(vetor[i]<x){
      qtd = qtd + 1
    }
  }
  return(qtd)
}

v = c(1.0,3.2,-2.1,10.6,0.0,-1.7,-0.5)
menor_x(v,0)
## [1] 3

Questão 5

Para cada item a seguir faça o que se pede. Não se esqueça de fazer as verificações necessárias para garantir que o usuário passe os argumentos de forma correta.

(a). Implemente uma função que recebe como argumento as variáveis n e m e retorna um array que guarda os n primeiros múltiplos de m.

multiplos_a = function(n,m){
  if(class(n)!="numeric" | class(m)!="numeric")
    stop("Não é um vetor de números reais")
  i = 1
  vetor = numeric(0)
  repeat{
    vetor[i] = i*m
    if(i >= n)
      break
    i = i + 1
  }
  return(vetor)
}

multiplos_a(8,2)
## [1]  2  4  6  8 10 12 14 16

(b). Implemente uma função que recebe como argumento as variáveis m e k e retorna um array com os múltiplos de m menores que k.

multiplos_b = function(m,k){
  if(class(k)!="numeric" | class(m)!="numeric")
    stop("Não é um vetor de números reais")
  
  vetor = numeric(0); i = 1
  repeat{
    vetor[i] = i*m
    i = i + 1
    if(i*m >= k)
      break
  }
  return(vetor)
}

multiplos_b(2,15)
## [1]  2  4  6  8 10 12 14

(c). Implemente uma função que recebe como argumento as variáveis m e k e retorna a quantidade de múltiplos de m menores que k.

multiplos_c = function(m,k){
  if(class(k)!="numeric" | class(m)!="numeric")
    stop("Não é um vetor de números reais")
  
  qtd = 0
  while (qtd*m < k) {
    qtd = qtd + 1
  }
  return(qtd-1)
}

multiplos_c(10,40)
## [1] 3

(d). Classifique cada variável que aparece dentro das funções implementadas nesse exercício como “variável local” ou “argumento de entrada” da função. Todas as variáveis locais foram iniciadas dentro do corpo da função?

Resposta: Sim

Questão 6

Para cada item a seguir faça o que se pede. Não se esqueça de fazer as verificações necessárias para garantir que o usuário passe os argumentos de forma correta.

(a). Implemente uma função que recebe como entrada um número natural n e retorna uma matriz n × n tal que as posições em linhas pares recebem o número 2 e as posições em linhas ímpares o número 1.

matriz_a = function(n){
  if(n%%1 != 0)
    stop("Não é um número natural")
  matriz = matrix(0, nrow = n, ncol = n); i = 1
  
  for (i in 1:n) {
    if(i%%2 == 0){
      matriz[i,] = 2
    } else {matriz[i,] = 1}
  }
  return(matriz)
}

matriz_a(6)
##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]    1    1    1    1    1    1
## [2,]    2    2    2    2    2    2
## [3,]    1    1    1    1    1    1
## [4,]    2    2    2    2    2    2
## [5,]    1    1    1    1    1    1
## [6,]    2    2    2    2    2    2

(b). Implemente uma função que recebe como entrada um numero natural n e retorna uma matriz n × n tal que a coluna i dessa matriz guarda o valor i. Por exemplo, a primeira coluna deve ser preenchida com 1, a segunda com 2 e assim por diante, até a n-ésima coluna que deve ser preenchida com o número n.

matriz_b = function(n){
  if(n%%1 != 0)
    stop("Não é um número natural")
  matriz = matrix(0, nrow = n, ncol = n)
  
  for (i in 1:n) {
      matriz[i,] = i
  }
  return(matriz)
}

matriz_b(6)
##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]    1    1    1    1    1    1
## [2,]    2    2    2    2    2    2
## [3,]    3    3    3    3    3    3
## [4,]    4    4    4    4    4    4
## [5,]    5    5    5    5    5    5
## [6,]    6    6    6    6    6    6

(c). Implemente uma função que recebe como entrada um numero natural n e retorna uma matriz diagonal n × n tal que na diagonal principal aparecem os valores de 1 até n. Por exemplo, a posição (1,1) deve ser preenchido com 1, a posição (2,2) com 2 e assim por diante. As demais posições devem ser nulas, uma vez que a matriz de saída é diagonal.

matriz_c = function(n){
  if(n%%1 != 0)
    stop("Não é um número natural")
  matriz = matrix(0, nrow = n, ncol = n)
  
  for (i in 1:n) {
    matriz[i,i] = i
  }
  return(matriz)
}

matriz_c(6)
##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]    1    0    0    0    0    0
## [2,]    0    2    0    0    0    0
## [3,]    0    0    3    0    0    0
## [4,]    0    0    0    4    0    0
## [5,]    0    0    0    0    5    0
## [6,]    0    0    0    0    0    6

Questão 7

Para cada item a seguir faça o que se pede. Não se esqueça de fazer as verificações necessárias para garantir que o usuário passe os argumentos de forma correta.

(a). Implemente uma função que recebe como entrada um vetor de número reais v e retorna uma matriz diagonal com os elementos de v guardados na diagonal principal.

diagonal_a = function(v){
  if(class(v)!="numeric")
    stop("Não é um vetor de números reais")
  n = length(v)
  matriz = matrix(0, nrow = n, ncol = n)
  
  for (i in 1:n) {
    matriz[i,i] = v[i]
  }
  return(matriz)
}

v  = c(-9,4,78,40,13,1)
diagonal_a(v)
##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]   -9    0    0    0    0    0
## [2,]    0    4    0    0    0    0
## [3,]    0    0   78    0    0    0
## [4,]    0    0    0   40    0    0
## [5,]    0    0    0    0   13    0
## [6,]    0    0    0    0    0    1

(b). Implemente uma função que recebe como entrada um vetor de número reais v e retorna uma matriz quadrada cujas colunas são iguais ao vetor v.

colunas_b = function(v){
  if(class(v)!="numeric")
    stop("Não é um vetor de números reais")
  n = length(v)
  matriz = matrix(0, nrow = n, ncol = n)
  for (i in 1:n) {
    matriz[,i] = v
  }
  return(matriz)
}

v  = c(-9,4,78,40,13,1)
colunas_b(v)
##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]   -9   -9   -9   -9   -9   -9
## [2,]    4    4    4    4    4    4
## [3,]   78   78   78   78   78   78
## [4,]   40   40   40   40   40   40
## [5,]   13   13   13   13   13   13
## [6,]    1    1    1    1    1    1

(c). Implemente uma função que recebe como entrada um vetor de número reais v e retorna uma matriz quadrada cujas linhas são iguais ao vetor v.

linhas_c = function(v){
  if(class(v)!="numeric")
    stop("Não é um vetor de números reais")
  n = length(v)
  matriz = matrix(0, nrow = n, ncol = n)
  for (i in 1:n) {
    matriz[i,] = v
  }
  return(matriz)
}

v  = c(-9,4,78,40,13,1)
linhas_c(v)
##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]   -9    4   78   40   13    1
## [2,]   -9    4   78   40   13    1
## [3,]   -9    4   78   40   13    1
## [4,]   -9    4   78   40   13    1
## [5,]   -9    4   78   40   13    1
## [6,]   -9    4   78   40   13    1

Questão 8

Para cada item a seguir faça o que se pede. Não se esqueça de fazer as verificações necessárias para garantir que o usuário passe os argumentos de forma correta.

(a). Implemente uma função que recebe como argumento o valor inicial x0 e retorna os 10 primeiros termos de uma p.a. cuja razão é 3.

pa_a = function(x0){
  if(class(x0)!="numeric")
    stop("Não é um número real")
  
  vetor = numeric(length = 10); i = 1
  vetor[1] = x0
  while (i<10) {
    vetor[i+1] = vetor[i] + 3
    i = i + 1
  }
  return(vetor)
}

pa_a(2)
##  [1]  2  5  8 11 14 17 20 23 26 29

(b). Implemente uma função que recebe como argumento o valor inicial x0, a razão r e retorna um vetor com os 10 primeiros termos dessa p.a.

pa_b = function(x0,r){
  if(class(x0)!="numeric" | class(r)!="numeric")
    stop("Não é um número real")
  
  vetor = numeric(length = 10); i = 1
  vetor[1] = x0
  while (i<10) {
    vetor[i+1] = vetor[i] + r
    i = i + 1
  }
  return(vetor)
}

pa_b(2,5)
##  [1]  2  7 12 17 22 27 32 37 42 47

(c). Implemente uma função que recebe como argumentos o valor inicial x0, a razão r, um inteiro n e retorna um vetor com os n primeiros termos de uma p.a. Nomeie essa função de pa.

pa = function(x0,r,n){
  if(class(x0)!="numeric" | class(r)!="numeric" | class(n)!="numeric")
    stop("Não é um número real")
  
  vetor = numeric(length = n); i = 1
  vetor[1] = x0
  while (i<n) {
    vetor[i+1] = vetor[i] + r
    i = i + 1
  }
  return(vetor)
}

pa(2,5,3)
## [1]  2  7 12

(d). Implemente uma função que recebe como argumento o valor inicial x0, a razão r, um inteiro n e retorna a soma dos n primeiros termos de uma p.a. Nomeie essa função de soma_pa. Obs: Você deve chamar no corpo da função soma_pa a função pa implementasda no item anterior.

soma_pa = function(x0,r,n){
  soma = sum(pa(x0,r,n))
  return(soma)
}

soma_pa(2,5,3)
## [1] 21

(e). Classifique cada variável que aparece dentro das funções soma_pa e pa como “variável local” ou “argumento de entrada” da função. Todas as variáveis locais foram iniciadas dentro do corpo da função?

Resposta: Sim

Questão 9

Implemente uma função que:

(a). recebe como argumento a variável n e retorna um vetor com os n primeiros termos da sequência de Fibonacci.

fibonnaci_a = function(n){
  if(class(n)!="numeric")
    stop("Não é um número real")
  vetor = numeric(length = n)
  vetor[1] = 1
  vetor[2] = 1 
  for (i in 3:n) {
    vetor[i] = vetor[i-1] + vetor[i-2]
  }
  return(vetor)
}

fibonnaci_a(14)
##  [1]   1   1   2   3   5   8  13  21  34  55  89 144 233 377

(b). recebe como argumento a variável k e retorna um vetor com os todos os termos da sequência de Fibonacci menores que k.

fibonnaci_b = function(k){
  if(class(k)!="numeric")
    stop("Não é um número real")
  
  vetor = numeric(0); i = 3
  vetor[1] = 1;  vetor[2] = 1 
  
  repeat{
    prox = vetor[i-1] + vetor[i-2]
    if(prox>=k)
      break
    vetor[i] = prox
    i = i + 1
  }
  return(vetor)
}

fibonnaci_b(21)
## [1]  1  1  2  3  5  8 13

(c). recebe como argumento a variável k e retorna o número de termos da sequência de Fibonacci menores que k.

fibonnaci_c = function(k){
  if(class(k)!="numeric")
    stop("Não é um número real")
  
  vetor = fibonnaci_b(k)
  qtd = length(vetor)
  return(qtd)
}

fibonnaci_c(21)
## [1] 7

Questão 10

Suponha que a função f apresentada a seguir foi implementada no R com o intuito de gerar um array com os naturais de 1 até n, sendo n passado como argumento pelo usuário. Após f ter sido definida ela foi chamada a partir da sequência de comandos também apresentada abaixo.

(a). Sem usar o computador, qual o valor de v e qual o valor de vet ao final dessa sequência de comandos?

Resposta: Erro, pois não foi declarado a variável v dentro da função.

(b). A saída da função f, guardada no array vet, é como o esperado? Caso negativo, qual mudança você faria em f para que essa função passe a funcionar corretamente?

f <- function(n){
   for(i in 1:n){
       v[i] <- i
   }
   return(v)
}
v <- c(0,0,0,0,0)
vet <- f(3)

Resposta: Não pois ele considerou v como sendo a variavel criada localmente com tamanho 5 e solicitou n = 3.

f <- function(n){
  if(class(n)!="numeric")
    stop("Não é um número real")
  v = vector(length = n)
  
  for(i in 1:n){
    v[i] <- i
  }
  return(v)
}

v <- c(0,0,0,0,0)
vet <- f(5)

Questão 11

Uma progressão geométrica (p.g.) é uma sequência numérica em que cada termo, a partir do segundo, é igual ao produto do termo anterior por uma constante q. Esta constante q é chamada razão e o primeiro termo da sequência será chamado de x0.

(a). Implemente uma função cujas entradas são x0, q e n e a saída é um array com os n primeiros termos de uma p.g. cujo termo inicial x0 e a razão é q.

pg = function(x0,q,n){
  if(class(x0)!="numeric" | class(q)!="numeric" | class(n)!="numeric")
    stop("Não é um número real")
  
  vetor = numeric(0); vetor[1] = x0
  for (i in 2:n) {
    vetor[i] = vetor[i-1]*q
  }
  return(vetor)
}

pg(2,2,10)
##  [1]    2    4    8   16   32   64  128  256  512 1024

(b). Implemente uma função cujas entradas são x0, q e m e a saída é a soma dos m primeiros termos de uma p.g. com termo inicial x0 e razão q.

pg_soma = function(x0,q,m){
  if(class(x0)!="numeric" | class(q)!="numeric" | class(m)!="numeric")
    stop("Não é um número real")
  
  pg = pg(x0,q,m)
  soma = sum(pg)

  return(soma)
}

pg_soma(2,2,10)
## [1] 2046

(c). Usando as funções implementadas, encontre a soma dos 10 primeiros termos da p.g. de razão \(\frac{1}{2}\) e valor inicial \(\frac{1}{2}\).

pg_soma(1/2,1/2,10)
## [1] 0.9990234

(d). Usando as funções implementadas, encontre a soma dos 30 primeiros termos da p.g. de razão \(\frac{1}{2}\) e valor inicial \(\frac{1}{2}\).

pg_soma(1/2,1/2,30)
## [1] 1

(e). Você acredita que essa soma converge, ou seja, você acha que \(\frac{1}{2}+122+…12n=∑ni=112i−→−−n→∞a∈R\)?

Resposta: Converge para 1.

(f). É possível demonstrar se essa série convergência ou não pelo computador? OBS: Use o comando options(digits=22) se quiser usar o número máximos de casas decimais que o R aceita, que é 22.

options(digits=22)
pg_soma(1/2,1/2,50)
## [1] 0.99999999999999911

Questão 12 : Desafio

Questão Desafio.

(a). Implemente uma função que recebe como entrada um número natural positivo k e retorna um array com a fatoração de k em números primos. Isto é, o array de saída contém somente números primos tais que o produto deles é igual a k.

fatoracao = function(k){
  if(class(k)!="numeric" | k<0 )
    stop("Não é número real positivo")
  
  vetor = vector(mode = "numeric"); aux = 1; n = k
  
  for (i in 2:n) {
    repeat{
      if( (k/i)%%1 == 0 ){
        vetor[aux] = i
        aux = aux + 1
        k = k/i
      }
      if( (k/i)%%1 != 0 | prod(vetor)==n )
        break
    }
  }
  return(vetor)
}
fatoracao(85) ; fatoracao(67); fatoracao(30)
## [1]  5 17
## [1] 67
## [1] 2 3 5

(b). Implemente uma função que recebe como entrada um número k e retorna TRUE se k for primo e FALSE caso contrário.

primos = function(k){
  if(class(k)!="numeric" | k<=1)
    stop("Não é primo")
  f = "Falso"; v = "Verdadeiro"; qtd = 0
  
  for (i in 2:k){
    if(k%%i == 0){
      qtd = qtd + 1
    }
  }
   if(qtd == 1){
     return(v)
   } else{return(f)}
}

primos(67); primos(48); primos(19)
## [1] "Verdadeiro"
## [1] "Falso"
## [1] "Verdadeiro"

(c). Implemente uma função que recebe como entrada um número n e retorna um array com os n primeiros primos. Dica: dentro desta função chame a função implementada no item (b).

primos_c = function(n){
  if(class(n)!="numeric" )
    stop("Não é um número real")
  i = 2; aux = 0; v = NULL
  
  while(length(v)<n){
    if(primos(i)=="Verdadeiro"){
      p = i
      aux = aux + 1
    }
    v[aux] = p
    i = i + 1
  }
  return(v)
}

primos_c(6)
## [1]  2  3  5  7 11 13