Exercícios

Questão 1

Primeiro guarde nas variáveis a, b e c o tamanho dos lados de um triangulo qualquer. Em seguida implemente um código no R que imprime na tela uma mensagem informando se o triângulo em questão é equilátero, isósceles ou escaleno. Teste o código implementado para diferentes valores de a, b e c.

a = 5; b = 4; c = 7
if(a+b>c & a+c>b & b+c>a){
  if(a!=b & b!=c & a!=c){
    print( "O triângulo é Escaleno ")

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

Questão 2

Para cada item a seguir implemente um código no R para encontrar o que se pede. Não use a função seq() ou outra parecida. Dica: Comece com um vetor nulo e use o(s) controle(s) de fluxo que achar adequado para preenchê-lo.

(a). Crie um array com os 100 primeiros múltiplos de 3.

a = NULL; i = 0
for( i in 1:100){
    a[i] =  i*3
} ; a
##   [1]   3   6   9  12  15  18  21  24  27  30  33  36  39  42  45  48  51  54
##  [19]  57  60  63  66  69  72  75  78  81  84  87  90  93  96  99 102 105 108
##  [37] 111 114 117 120 123 126 129 132 135 138 141 144 147 150 153 156 159 162
##  [55] 165 168 171 174 177 180 183 186 189 192 195 198 201 204 207 210 213 216
##  [73] 219 222 225 228 231 234 237 240 243 246 249 252 255 258 261 264 267 270
##  [91] 273 276 279 282 285 288 291 294 297 300

(b). Crie um array com todos os múltiplos de 3 menores que 100

b = NULL; i = 0
repeat{
  i = i + 1
  if(i*3>100)
    break
  b[i] = i*3
}; b
##  [1]  3  6  9 12 15 18 21 24 27 30 33 36 39 42 45 48 51 54 57 60 63 66 69 72 75
## [26] 78 81 84 87 90 93 96 99

(c). Crie um array com os 100 primeiros números ímpares

c = NULL; i = 1; n = 1 
repeat{
  if(i%%2!=0){
   c[n] = i 
   n = n + 1
 } 
  i = i + 1
  if(length(c)>=100)
    break
}; c
##   [1]   1   3   5   7   9  11  13  15  17  19  21  23  25  27  29  31  33  35
##  [19]  37  39  41  43  45  47  49  51  53  55  57  59  61  63  65  67  69  71
##  [37]  73  75  77  79  81  83  85  87  89  91  93  95  97  99 101 103 105 107
##  [55] 109 111 113 115 117 119 121 123 125 127 129 131 133 135 137 139 141 143
##  [73] 145 147 149 151 153 155 157 159 161 163 165 167 169 171 173 175 177 179
##  [91] 181 183 185 187 189 191 193 195 197 199

Questão 3

Repita cada item do Exercício 2 acima usando um controle de fluxo diferente daquele que você usou quando resolveu esse exercício.

(a). Crie um array com os 100 primeiros múltiplos de 3.

n = 1; a = NULL
while(n<100){
  a[n] = n*3
  n = n + 1
}; a
##  [1]   3   6   9  12  15  18  21  24  27  30  33  36  39  42  45  48  51  54  57
## [20]  60  63  66  69  72  75  78  81  84  87  90  93  96  99 102 105 108 111 114
## [39] 117 120 123 126 129 132 135 138 141 144 147 150 153 156 159 162 165 168 171
## [58] 174 177 180 183 186 189 192 195 198 201 204 207 210 213 216 219 222 225 228
## [77] 231 234 237 240 243 246 249 252 255 258 261 264 267 270 273 276 279 282 285
## [96] 288 291 294 297

(b). Crie um array com todos os múltiplos de 3 menores que 100.

controle = TRUE; n = 1; b = NULL
while (controle) {
  b[n] = n*3
  controle = (n*3)<99
  n = n + 1
}; b
##  [1]  3  6  9 12 15 18 21 24 27 30 33 36 39 42 45 48 51 54 57 60 63 66 69 72 75
## [26] 78 81 84 87 90 93 96 99

(c). Crie um array com os 100 primeiros números ímpares.

c = NULL
for(i in 1:100){
  c[i] = 2*i-1
}; c
##   [1]   1   3   5   7   9  11  13  15  17  19  21  23  25  27  29  31  33  35
##  [19]  37  39  41  43  45  47  49  51  53  55  57  59  61  63  65  67  69  71
##  [37]  73  75  77  79  81  83  85  87  89  91  93  95  97  99 101 103 105 107
##  [55] 109 111 113 115 117 119 121 123 125 127 129 131 133 135 137 139 141 143
##  [73] 145 147 149 151 153 155 157 159 161 163 165 167 169 171 173 175 177 179
##  [91] 181 183 185 187 189 191 193 195 197 199

Questão 4

Usando os controles de fluxo vistos em sala de aula, faça o que se pede. Dica: a partir do segundo item vai ser preciso usar dois controles de fluxo, um dentro do outro.

(a). Comece com uma matriz 10 × 10 nula. Usando um dos controles de fluxos vistos em aula, implemente um código que preencha todas as posições da primeira linha dessa matriz com o número 1.

i = 1; a = matrix(0, nrow = 10, ncol = 10)
repeat{
  a[1,i] = 1
  if(i>=10)
    break
  i = i + 1
}; a
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1    1    1    1    1    1    1    1    1     1
##  [2,]    0    0    0    0    0    0    0    0    0     0
##  [3,]    0    0    0    0    0    0    0    0    0     0
##  [4,]    0    0    0    0    0    0    0    0    0     0
##  [5,]    0    0    0    0    0    0    0    0    0     0
##  [6,]    0    0    0    0    0    0    0    0    0     0
##  [7,]    0    0    0    0    0    0    0    0    0     0
##  [8,]    0    0    0    0    0    0    0    0    0     0
##  [9,]    0    0    0    0    0    0    0    0    0     0
## [10,]    0    0    0    0    0    0    0    0    0     0

(b). Comece com uma matriz 10 × 10 nula. Usando um dos controles de fluxos vistos em aula, implemente um código que preencha cada uma de suas linhas com o número que indica a linha em questão. Por exemplo, a primeira linha deve ser preenchida toda com o número 1, a segunda com o número 2 e assim por diante, até a décima linha que deve ser preenchida com 10.

b = matrix(0, nrow = 10, ncol = 10); l = 1; c = 1
for (l in 1:10) {
  for(c in 1:10){
    b[l,c] = l
  }
}; b
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1    1    1    1    1    1    1    1    1     1
##  [2,]    2    2    2    2    2    2    2    2    2     2
##  [3,]    3    3    3    3    3    3    3    3    3     3
##  [4,]    4    4    4    4    4    4    4    4    4     4
##  [5,]    5    5    5    5    5    5    5    5    5     5
##  [6,]    6    6    6    6    6    6    6    6    6     6
##  [7,]    7    7    7    7    7    7    7    7    7     7
##  [8,]    8    8    8    8    8    8    8    8    8     8
##  [9,]    9    9    9    9    9    9    9    9    9     9
## [10,]   10   10   10   10   10   10   10   10   10    10

(c). Comece com uma matriz 100 × 100 nula. Usando um dos controles de fluxos vistos em aula, implemente um código que preenche cada coluna com o número que indica a coluna em questão (análogo ao item anterior).

c = matrix(0, nrow = 100, ncol = 100); l = 1; i = 1
for (l in 1:100) {
  for(i in 1:100){
    c[i,l] = l
  }
}; c[1:10,1:10]
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1    2    3    4    5    6    7    8    9    10
##  [2,]    1    2    3    4    5    6    7    8    9    10
##  [3,]    1    2    3    4    5    6    7    8    9    10
##  [4,]    1    2    3    4    5    6    7    8    9    10
##  [5,]    1    2    3    4    5    6    7    8    9    10
##  [6,]    1    2    3    4    5    6    7    8    9    10
##  [7,]    1    2    3    4    5    6    7    8    9    10
##  [8,]    1    2    3    4    5    6    7    8    9    10
##  [9,]    1    2    3    4    5    6    7    8    9    10
## [10,]    1    2    3    4    5    6    7    8    9    10

(d). Agora comece com uma matriz 100 × 100 nula. Usando um dos controles de fluxos vistos em aula, implemente um código que preenche as posições em linhas pares com o número 2 e as posições em linhas ímpares com o número 1.

d = matrix(0, nrow = 100, ncol = 100); l = 1; c = 1
for (l in 1:100) {
  for(c in 1:100){
    if(l%%2==0){d[l,c] = 2
    } else{ d[l,c] = 1 }
  }
}; d[1:10,1:10]
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1    1    1    1    1    1    1    1    1     1
##  [2,]    2    2    2    2    2    2    2    2    2     2
##  [3,]    1    1    1    1    1    1    1    1    1     1
##  [4,]    2    2    2    2    2    2    2    2    2     2
##  [5,]    1    1    1    1    1    1    1    1    1     1
##  [6,]    2    2    2    2    2    2    2    2    2     2
##  [7,]    1    1    1    1    1    1    1    1    1     1
##  [8,]    2    2    2    2    2    2    2    2    2     2
##  [9,]    1    1    1    1    1    1    1    1    1     1
## [10,]    2    2    2    2    2    2    2    2    2     2

Questão 5

Comece cada item a seguir com uma matriz 100 × 100 nula e não use a fução seq() ou outra parecida.

(a). Crie uma matriz diagonal 100 × 100 cujos elementos da diagonal principal são os números de 1 até 100 em ordem crescente.

a = matrix(0, nrow = 100, ncol = 100); l = 1
for (l in 1:100) {
  a[l,l] = l
  l = l + 1
}; a[1:10,1:10]
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1    0    0    0    0    0    0    0    0     0
##  [2,]    0    2    0    0    0    0    0    0    0     0
##  [3,]    0    0    3    0    0    0    0    0    0     0
##  [4,]    0    0    0    4    0    0    0    0    0     0
##  [5,]    0    0    0    0    5    0    0    0    0     0
##  [6,]    0    0    0    0    0    6    0    0    0     0
##  [7,]    0    0    0    0    0    0    7    0    0     0
##  [8,]    0    0    0    0    0    0    0    8    0     0
##  [9,]    0    0    0    0    0    0    0    0    9     0
## [10,]    0    0    0    0    0    0    0    0    0    10

(b). Crie uma matriz diagonal 100 × 100 cujos elementos da diagonal principal são os números de 1 até 100 em ordem decrescente.

b = matrix(0, nrow = 100, ncol = 100); l = 1; i = 1
for (l in 100:1) {
 b[i,i] = l
 i = i + 1
}; b[1:10,1:10]
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]  100    0    0    0    0    0    0    0    0     0
##  [2,]    0   99    0    0    0    0    0    0    0     0
##  [3,]    0    0   98    0    0    0    0    0    0     0
##  [4,]    0    0    0   97    0    0    0    0    0     0
##  [5,]    0    0    0    0   96    0    0    0    0     0
##  [6,]    0    0    0    0    0   95    0    0    0     0
##  [7,]    0    0    0    0    0    0   94    0    0     0
##  [8,]    0    0    0    0    0    0    0   93    0     0
##  [9,]    0    0    0    0    0    0    0    0   92     0
## [10,]    0    0    0    0    0    0    0    0    0    91

Questão 6

Usando os controles de fluxo vistos em aula crie as listas definidas em cada item a seguir. (a). L1 é uma lista com 10 posições tal que cada posição i guarda o número i.

l1 = list(); i = 1
for (i in 1:10) {
  l1[[i]] = i
}; l1
## [[1]]
## [1] 1
## 
## [[2]]
## [1] 2
## 
## [[3]]
## [1] 3
## 
## [[4]]
## [1] 4
## 
## [[5]]
## [1] 5
## 
## [[6]]
## [1] 6
## 
## [[7]]
## [1] 7
## 
## [[8]]
## [1] 8
## 
## [[9]]
## [1] 9
## 
## [[10]]
## [1] 10

(b). L2 é uma lista com 10 posições tal que cada posição i guarda um vetor de tamanho i com todas as posições iguais a 1.

l2 = list(); i = 1
for(i in 1:10){
  vetor = vector(length = i )
  vetor[] = i
  l2[[i]] = vetor 
  }; l2
## [[1]]
## [1] 1
## 
## [[2]]
## [1] 2 2
## 
## [[3]]
## [1] 3 3 3
## 
## [[4]]
## [1] 4 4 4 4
## 
## [[5]]
## [1] 5 5 5 5 5
## 
## [[6]]
## [1] 6 6 6 6 6 6
## 
## [[7]]
## [1] 7 7 7 7 7 7 7
## 
## [[8]]
## [1] 8 8 8 8 8 8 8 8
## 
## [[9]]
## [1] 9 9 9 9 9 9 9 9 9
## 
## [[10]]
##  [1] 10 10 10 10 10 10 10 10 10 10

(c). L3 é uma lista com 10 posições tal que cada posição i guarda um vetor com os 10 primeiros múltiplos de i.

l3 = list(); i = 1; l = 1
for (i in 1:10) {
  vetor = vector(length = 10)
  for (l in 1:10) {
    vetor[l] = i*l
  }
       l3[[i]] = vetor 
}; l3
## [[1]]
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## [[2]]
##  [1]  2  4  6  8 10 12 14 16 18 20
## 
## [[3]]
##  [1]  3  6  9 12 15 18 21 24 27 30
## 
## [[4]]
##  [1]  4  8 12 16 20 24 28 32 36 40
## 
## [[5]]
##  [1]  5 10 15 20 25 30 35 40 45 50
## 
## [[6]]
##  [1]  6 12 18 24 30 36 42 48 54 60
## 
## [[7]]
##  [1]  7 14 21 28 35 42 49 56 63 70
## 
## [[8]]
##  [1]  8 16 24 32 40 48 56 64 72 80
## 
## [[9]]
##  [1]  9 18 27 36 45 54 63 72 81 90
## 
## [[10]]
##  [1]  10  20  30  40  50  60  70  80  90 100

(d). L4 é uma lista com 10 posições tal que cada posição i guarda um vetor com os i primeiros múltiplos de 2.

l4 = list(); i = 1 ; l = 1
for(i in 1:10){
  vetor = vector(length = i)
  for (l in 1:i) {
    vetor[l] = l*2
  }
      l4[[i]] = vetor
}; l4
## [[1]]
## [1] 2
## 
## [[2]]
## [1] 2 4
## 
## [[3]]
## [1] 2 4 6
## 
## [[4]]
## [1] 2 4 6 8
## 
## [[5]]
## [1]  2  4  6  8 10
## 
## [[6]]
## [1]  2  4  6  8 10 12
## 
## [[7]]
## [1]  2  4  6  8 10 12 14
## 
## [[8]]
## [1]  2  4  6  8 10 12 14 16
## 
## [[9]]
## [1]  2  4  6  8 10 12 14 16 18
## 
## [[10]]
##  [1]  2  4  6  8 10 12 14 16 18 20

(e). L5 é uma lista com 10 posições tal que cada posição i guarda a matriz identidade de tamanho i×i.

l5 = list(); i = 1 ; l = 1
for (i in 1:10) {
  matriz = matrix(0, nrow = i, ncol = i)
  for (l in 1:i) {
    matriz[l,l] = 1 
  }
     l5[[i]] = matriz
}; l5
## [[1]]
##      [,1]
## [1,]    1
## 
## [[2]]
##      [,1] [,2]
## [1,]    1    0
## [2,]    0    1
## 
## [[3]]
##      [,1] [,2] [,3]
## [1,]    1    0    0
## [2,]    0    1    0
## [3,]    0    0    1
## 
## [[4]]
##      [,1] [,2] [,3] [,4]
## [1,]    1    0    0    0
## [2,]    0    1    0    0
## [3,]    0    0    1    0
## [4,]    0    0    0    1
## 
## [[5]]
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    0    0    0    0
## [2,]    0    1    0    0    0
## [3,]    0    0    1    0    0
## [4,]    0    0    0    1    0
## [5,]    0    0    0    0    1
## 
## [[6]]
##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]    1    0    0    0    0    0
## [2,]    0    1    0    0    0    0
## [3,]    0    0    1    0    0    0
## [4,]    0    0    0    1    0    0
## [5,]    0    0    0    0    1    0
## [6,]    0    0    0    0    0    1
## 
## [[7]]
##      [,1] [,2] [,3] [,4] [,5] [,6] [,7]
## [1,]    1    0    0    0    0    0    0
## [2,]    0    1    0    0    0    0    0
## [3,]    0    0    1    0    0    0    0
## [4,]    0    0    0    1    0    0    0
## [5,]    0    0    0    0    1    0    0
## [6,]    0    0    0    0    0    1    0
## [7,]    0    0    0    0    0    0    1
## 
## [[8]]
##      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
## [1,]    1    0    0    0    0    0    0    0
## [2,]    0    1    0    0    0    0    0    0
## [3,]    0    0    1    0    0    0    0    0
## [4,]    0    0    0    1    0    0    0    0
## [5,]    0    0    0    0    1    0    0    0
## [6,]    0    0    0    0    0    1    0    0
## [7,]    0    0    0    0    0    0    1    0
## [8,]    0    0    0    0    0    0    0    1
## 
## [[9]]
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]
##  [1,]    1    0    0    0    0    0    0    0    0
##  [2,]    0    1    0    0    0    0    0    0    0
##  [3,]    0    0    1    0    0    0    0    0    0
##  [4,]    0    0    0    1    0    0    0    0    0
##  [5,]    0    0    0    0    1    0    0    0    0
##  [6,]    0    0    0    0    0    1    0    0    0
##  [7,]    0    0    0    0    0    0    1    0    0
##  [8,]    0    0    0    0    0    0    0    1    0
##  [9,]    0    0    0    0    0    0    0    0    1
## 
## [[10]]
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1    0    0    0    0    0    0    0    0     0
##  [2,]    0    1    0    0    0    0    0    0    0     0
##  [3,]    0    0    1    0    0    0    0    0    0     0
##  [4,]    0    0    0    1    0    0    0    0    0     0
##  [5,]    0    0    0    0    1    0    0    0    0     0
##  [6,]    0    0    0    0    0    1    0    0    0     0
##  [7,]    0    0    0    0    0    0    1    0    0     0
##  [8,]    0    0    0    0    0    0    0    1    0     0
##  [9,]    0    0    0    0    0    0    0    0    1     0
## [10,]    0    0    0    0    0    0    0    0    0     1

Questão 7

Usando as listas L1 e L3 do Exercício 6, faça o que se pede.

(a). Encontre o valor da soma de todos os números guardados em L1.

i = 1; soma = 0
for ( i in 1:10 ) {
  soma = soma + l1[[i]]
}; soma
## [1] 55

(b). Encontre o array tal que cada posição i guarda a soma de todos elementos guardados na posição i da lista L3.

i = 1 ; vetor = vector(length = 10)
for(i in 1:10){
  vetor[i] = sum(l3[[i]])
}; vetor
##  [1]  55 110 165 220 275 330 385 440 495 550

Questão 8

Usando a lista L4 do Exercício 6, faça o que se pede.

(a). Crie um array soma tal que a sua posição i guarda a soma dos elementos alocados na posição i da lista L4.

i = 1 ; soma = vector(length = 10)
for(i in 1:10){
  soma[i] = sum(l4[[i]])
}; soma
##  [1]   2   6  12  20  30  42  56  72  90 110

(b). Crie um array v de "character" tal que a sua posição i guarda o objeto soma[i] concatenado com o texto "é um múltiplo de 5" se a o valor de soma[i] for um múltiplo de 5. Caso contrário, guarde na posição i de v o objeto soma[i] concatenado com "não é um múltiplo de 5". Para concatenar textos use a função paste().

i = 1 ; vetor = character(length = 10)
for(i in 1:10){
  soma = sum(l4[[i]])
  if(soma%%5==0){
  vetor[i] = paste(soma,"é um múltiplo de 5")
  } else{ vetor[i] = paste(soma,"NÃO é um múltiplo de 5")  }
}; vetor
##  [1] "2 NÃO é um múltiplo de 5"  "6 NÃO é um múltiplo de 5" 
##  [3] "12 NÃO é um múltiplo de 5" "20 é um múltiplo de 5"    
##  [5] "30 é um múltiplo de 5"     "42 NÃO é um múltiplo de 5"
##  [7] "56 NÃO é um múltiplo de 5" "72 NÃO é um múltiplo de 5"
##  [9] "90 é um múltiplo de 5"     "110 é um múltiplo de 5"

(c). A partir do array soma ou do array v criados nos itens anteriores, conte o número de arrays da lista L4 tais que a sua soma é um número múltiplos de 5. Não é para você visualizar soma ou v e contar, e sim para usar um controle de fluxo e uma variável que servirá de contador para realizar essa conta.

i = 0 ; qtd = 0
for(i in 1:10){
  soma = sum(l4[[i]])
  if(soma%%5==0){
    qtd = qtd + 1
  } 
}
paste("Tem", qtd, "arrays da lista L4 tais que a sua soma é um número múltiplos de 5")
## [1] "Tem 4 arrays da lista L4 tais que a sua soma é um número múltiplos de 5"

Questão 9

Uma progressão aritmética (p.a.) é uma sequência numérica em que cada termo, a partir do segundo, é igual à soma do termo anterior com uma constante \(r\). O número \(r\) é chamado de razão. O primeiro termo da sequência será chamado de \(x0\).

(a). Faça um código em R que cria um array y com os 100 primeiros termos da progressão aritmética cuja termo inicial é \(x0=2\) e a razão é \(r=3\).

Y = numeric(length = 100); Y[1] = 2; i = 2
repeat{
  Y[i] = Y[i - 1] + 3
  if(i==100)
    break
  i = i + 1
}; Y
##   [1]   2   5   8  11  14  17  20  23  26  29  32  35  38  41  44  47  50  53
##  [19]  56  59  62  65  68  71  74  77  80  83  86  89  92  95  98 101 104 107
##  [37] 110 113 116 119 122 125 128 131 134 137 140 143 146 149 152 155 158 161
##  [55] 164 167 170 173 176 179 182 185 188 191 194 197 200 203 206 209 212 215
##  [73] 218 221 224 227 230 233 236 239 242 245 248 251 254 257 260 263 266 269
##  [91] 272 275 278 281 284 287 290 293 296 299

(b). Faça um código que determine a soma dos 35 primeiros termos dessa sequência. Compare o valor encontrado com o valor fornecido pela fórmula da soma de uma p.a.. Você lembra dessa fórmula?

soma = 0
for (i in 1:35) {
  soma = soma + Y[i]
}
sn = 35 * (Y[1] + Y[35])/2 
soma==sn
## [1] TRUE

(c). Faça um código que conte um número de elementos em y múltiplos de 4 (lembre do comando %% visto na semana passada, que fornece o resto da divisão).

i = 1; qtd = 0
repeat{
  if(Y[i]%%4==0){
    qtd = qtd + 1 
  }
  if(i==100)
    break
  i = i + 1
}
paste("Tem", qtd, "elementos em Y múltiplos de 4")
## [1] "Tem 25 elementos em Y múltiplos de 4"

(d). Faça um código que conte um número de elementos em y múltiplos de 4 e múltiplos de 5 simultaneamente.

i = 1; qtd = 0
repeat{
  if(Y[i]%%4==0 & Y[i]%%5==0){
    qtd = qtd + 1 
  }
  if(i==100)
    break
  i = i + 1
}
paste("Tem", qtd, "elementos em Y múltiplos de 4 e múltiplos de 5 simultaneamente")
## [1] "Tem 5 elementos em Y múltiplos de 4 e múltiplos de 5 simultaneamente"

(e). Faça um código que conte um número de elementos em y múltiplos de 4 ou múltiplos de 5.

i = 1; qtd = 0
repeat{
  if(Y[i]%%4==0 | Y[i]%%5==0){
    qtd = qtd + 1 
  }
  if(i==100)
    break
  i = i + 1
}
paste("Tem", qtd, "elementos em Y múltiplos de 4 e múltiplos de 5 simultaneamente")
## [1] "Tem 40 elementos em Y múltiplos de 4 e múltiplos de 5 simultaneamente"

(f). Faça um código que cria um novo array x a partir y, como descrito a seguir. O array x guarda na posição i o mesmo elemento que y guarda em i, caso esse elemento seja um número par. Se o elemento da posição i do array y for um número ímpar, x recebe na posição i o valor 0.

X = vector(length = length(Y)); i = 1
repeat{
  if(Y[i]%%2==0){
    X[i] = Y[i]
  } else{X[i] = 0}
  if(i==100)
    break
  i = i + 1
}; X
##   [1]   2   0   8   0  14   0  20   0  26   0  32   0  38   0  44   0  50   0
##  [19]  56   0  62   0  68   0  74   0  80   0  86   0  92   0  98   0 104   0
##  [37] 110   0 116   0 122   0 128   0 134   0 140   0 146   0 152   0 158   0
##  [55] 164   0 170   0 176   0 182   0 188   0 194   0 200   0 206   0 212   0
##  [73] 218   0 224   0 230   0 236   0 242   0 248   0 254   0 260   0 266   0
##  [91] 272   0 278   0 284   0 290   0 296   0

Questão 10

A famosa sequência de Fibonacci é definida da seguinte maneira: os dois primeiros elementos são iguais a \([1, 1]\) e a partir do terceiro elemento cada termo da sequência é definido como a soma dos dois termos anteriores. Por exemplo, o terceiro termo é \(2 (= 1 + 1)\), o quarto termo é \(3 (= 1 + 2)\), o quinto termo é \(5 (= 2 + 3)\) e assim por diante.

(a). Faça um código em R que cria um array fib_12 com os 12 primeiros números da sequência de Fibonacci.

fib_12 = c(1,1); i = 1
for (i in 3:12) {
  fib_12[i] = fib_12[i-2] + fib_12[i-1]
}
fib_12
##  [1]   1   1   2   3   5   8  13  21  34  55  89 144

(b). Faça um código em R que cria um array fib_m_300 com todos os números da sequência de Fibonacci menores que 300.

fib_m_300 = c(1,1); i = 3; n = numeric()

repeat{
    n = fib_m_300[i-2] + fib_m_300[i-1]
    if(n>=300)
      break
    fib_m_300[i] = n
    i = i + 1
}; fib_m_300
##  [1]   1   1   2   3   5   8  13  21  34  55  89 144 233

(c). Faça um código em R que retorna o número de termos da sequência de Fibonacci menores que 1.000.000. Veja que nesse caso você não precisa (e nem deve!) guardar os termos da sequência, apenas precisa contar o número de elementos.

primeiro = 1;segundo = 1;n = 0; i = 3; termos = 2;  controle = TRUE; teste = 0

while(controle){
  n = primeiro + segundo
  
    if(n<1000000){
    termos = termos + 1
    primeiro = segundo
    segundo = n
    } else{controle = FALSE}
}
paste("A sequência de Fibonacci tem",termos,"menores que 1.000.000")
## [1] "A sequência de Fibonacci tem 30 menores que 1.000.000"