Capítulo 14 Exercícios de Revisão

1 Um pesquisador está a analisar os resultados de uma pesquisa que avalia a satisfação de clientes com três diferentes serviços (A, B e C). Abaixo estão os dados recolhidos, em que cada linha representa um cliente e cada coluna indica a pontuação (de 1 a 10) atribuída a cada serviço:

satisfacao <- data.frame(
  servico_A = c(8, 5, 9, 6, 7, 4, 10, 6, 3, 7),
  servico_B = c(7, 6, 8, 5, 8, 5, 9, 7, 4, 6),
  servico_C = c(9, 4, 10, 6, 6, 3, 10, 5, 5, 8)
)

  1. Escreva uma função chamada calcula_media() que receba o data frame satisfacao e devolva um vetor com a média de satisfação de cada cliente (média das 3 colunas).

  2. Adicione ao data frame uma nova coluna chamada media, contendo os valores calculados pela função.

  3. Com base na coluna media, use um loop for com estrutura if-else para classificar cada cliente como:

  • “Satisfeito” se a média for maior ou igual a 7
  • “Insatisfeito” caso contrário

Adicione uma nova coluna chamada classificacao ao data frame com essa informação.

2. Uma empresa registou o número de tarefas concluídas por 15 funcionários ao longo de 5 dias úteis. A meta da empresa é que cada funcionário realize pelo menos 20 tarefas por dia. Pretende-se agora verificar quem atingiu a meta em pelo menos 3 dos 5 dias.

Os dados estão organizados no seguinte data.frame, chamado tarefa_funcionarios, onde cada linha representa um funcionário e cada coluna um dia da semana:

tarefa_funcionarios <- data.frame(
  dia1 = c(22, 18, 19, 25, 30, 15, 21, 24, 20, 19, 28, 26, 12, 20, 18),
  dia2 = c(18, 21, 23, 20, 27, 18, 20, 25, 16, 21, 22, 29, 17, 19, 20),
  dia3 = c(25, 17, 15, 18, 26, 16, 19, 30, 21, 18, 24, 20, 14, 23, 22),
  dia4 = c(20, 19, 22, 26, 28, 20, 23, 22, 17, 25, 19, 18, 19, 21, 24),
  dia5 = c(19, 22, 18, 27, 29, 14, 24, 28, 20, 23, 25, 27, 16, 17, 18)
)

  1. Escreva uma função chamada verifica_meta() que receba o data.frame e devolva um vetor lógico indicando, para cada funcionário, se ele atingiu a meta em pelo menos 3 dias.

  2. Com base no vetor lógico obtido, use um for com if-else para criar um vetor chamado classificacao com os valores:

  • “Atingiu Meta” se o funcionário atingiu a meta em 3 ou mais dias
  • “Não Atingiu Meta” caso contrário
  1. Adicione o vetor classificacao como uma nova coluna do data.frame tarefa_funcionarios.

3. Um estatístico está a estudar o comportamento da média amostral em diferentes populações. Para isso, simulou 6 amostras de tamanho 15 (valores entre 0 e 100), e pretende calcular a média de cada uma. A simulação deve interromper-se assim que for encontrada uma média superior a 75.

Os dados encontram-se na seguinte matriz chamada amostras:

amostras <- matrix(
  c(
    52, 68, 75, 48, 60, 55, 72, 81, 64, 70, 45, 69, 74, 60, 71,
    49, 50, 63, 41, 59, 55, 67, 62, 58, 66, 61, 54, 65, 60, 57,
    80, 82, 85, 79, 90, 88, 92, 85, 87, 84, 86, 81, 89, 83, 91,
    30, 42, 51, 39, 35, 48, 46, 52, 41, 37, 45, 43, 38, 44, 36,
    69, 74, 70, 66, 68, 72, 71, 73, 65, 67, 75, 64, 63, 62, 76,
    55, 58, 61, 56, 60, 63, 57, 62, 64, 59, 65, 66, 68, 67, 69
  ),
  nrow = 6,
  byrow = TRUE
)

  1. Crie uma função chamada calcula_media_amostra() que receba a matriz amostras e devolva a média de uma linha específica (dada por um índice).

  2. Escreva um ciclo while que percorra as linhas da matriz, calculando a média de cada amostra uma a uma. Se a média for superior a 75, o programa deve imprimir a mensagem: “Média Excedeu Limite” e parar a execução. Caso contrário, o programa deve continuar até processar todas as amostras.

4. Crie uma lista chamada listas_transformadas com comprimento 7, onde o elemento de índice \(i\) deve conter a seguinte sequência:

\[x = \left\{ \left( j^2 + i \right) \,\middle|\, j = 1, 2, \dots, i \right\}\] Ou seja, para cada \(i = 1, \dots, 7\), gera-se uma sequência com \(i\) elementos, em que cada elemento da sequência é calculado como:

\[x_j = j^2 + i\]

Exemplo: Para \(i = 3\), o vetor seria: \[\left[ 1^2 + 3,\, 2^2 + 3,\, 3^2 + 3 \right] = [4, 7, 12]\]

  1. Crie a lista listas_transformadas conforme descrito, utilizando um loop for.

  2. Verifique o comprimento do último vetor da lista.

  3. Escreva uma função chamada soma_elementos() que receba uma lista como entrada e devolva um vetor com a soma de cada vetor contido na lista.

  4. Use a função soma_elementos() para calcular a soma dos elementos de cada vetor da lista listas_transformadas.

5. Crie dois vetores \(x\) e \(y\), ambos com comprimento 60, cujos valores devem ser inteiros aleatórios escolhidos com repetição entre 0 e 999 (inclusive).

  1. Gere os vetores \(x\) e \(y\) conforme descrito. Utilize sample() com replace = TRUE.

  2. Selecione os valores de \(y\) que são menores que 500 e cujos correspondentes em \(x\) (mesma posição) são múltiplos de 3.

  3. Crie um novo vetor chamado dif_absoluta, contendo o valor absoluto da diferença entre \(x\) e \(y\) (isto é, \(|x_i - y_i|\) para cada posição \(i\)).

  4. Calcule a média e o desvio padrão dos valores em dif_absoluta.

6. Seja \(x\) um vetor de números reais aleatórios com comprimento 80, gerado a partir de uma distribuição normal com média 5 e desvio padrão 2.

  1. Gere o vetor \(x\) com 80 observações da distribuição \(\mathcal{N}(5, 2)\), utilizando a função rnorm().

  2. Calcule a média amostral \(\bar{x}\) do vetor \(x\).

  3. Crie um novo vetor resultado, onde o i-ésimo elemento é definido por:

\[z_i = \sqrt{ \left| x_i^3 - \bar{x}^2 \right| }\]

  1. Calcule o valor máximo, mínimo e a média do vetor resultado.

7. Um climatologista está a estudar as temperaturas médias diárias em 12 cidades ao longo de uma semana (7 dias). O seu objetivo é calcular a temperatura média semanal de cada cidade e verificar se essa média está acima ou abaixo de uma temperatura de referência de 25ºC.

Os dados abaixo representam as temperaturas médias diárias (em ºC) registadas durante uma semana em cada cidade. Estes dados estão organizados num data.frame chamado temperaturas_cidades, onde:

  • Cada linha representa uma cidade
  • Cada coluna representa um dia da semana (segunda a domingo)
temperaturas_cidades <- data.frame(
  segunda  = c(28, 22, 25, 19, 30, 24, 21, 26, 27, 23, 31, 20),
  terca    = c(29, 24, 23, 20, 32, 25, 22, 27, 26, 24, 33, 21),
  quarta   = c(30, 25, 22, 18, 33, 26, 23, 28, 25, 22, 34, 22),
  quinta   = c(31, 23, 24, 17, 31, 27, 20, 29, 28, 21, 32, 23),
  sexta    = c(27, 21, 26, 16, 29, 28, 19, 30, 29, 25, 30, 24),
  sabado   = c(26, 22, 27, 15, 28, 26, 18, 28, 27, 26, 29, 25),
  domingo  = c(25, 23, 28, 14, 27, 25, 17, 27, 26, 27, 28, 26)
)

  1. Escreva uma função chamada calcula_media_temperaturas() que receba o data.frame temperaturas_cidades e devolva um vetor com a temperatura média semanal de cada cidade.

  2. Crie um vetor chamado classificacao, utilizando um ciclo while, que percorra as médias semanais e, com base numa comparação com o valor de referência de 25ºC, classifique cada cidade como:

  • “Acima de 25ºC” se a média for maior que 25
  • “Abaixo de 25ºC” caso contrário
  1. Adicione os vetores media_semanal e classificacao como novas colunas no data.frame temperaturas_cidades.

8. Os computadores podem sofrer alterações aleatórias em bits da memória (bit flips) devido à ação de partículas de alta energia, como os raios gama. Esse fenómeno é estudado em contextos críticos como aviação, medicina, criptografia e computação de alto desempenho.

Um engenheiro está a simular o impacto de radiação em blocos de memória RAM, com o objetivo de identificar quais blocos foram mais afetados por possíveis bit flips.

Considere a seguinte simulação:

set.seed(2025)

# Vetor que representa o estado original de 1000 bits (0 ou 1)
original <- sample(c(0,1), size = 1000, replace = TRUE)

# Vetor que representa o estado final após exposição à radiação (raios gama)
# Cada bit tem 3% de probabilidade de ser alterado (flipado)
flipado <- ifelse(runif(1000) < 0.03, 1 - original, original)

# Divisão dos bits em blocos de memória (100 bits por bloco)
blocos <- rep(1:10, each = 100)

  1. Crie um vetor erros que contenha o número de bits alterados (bit flips), comparando original com flipado.

  2. Crie um fator chamado bloco_memoria com os valores de 1 a 10, indicando o bloco de cada bit, como já feito na variável blocos.

  3. Calcule o número de bit flips em cada bloco de memória.