Este artigo foi feito para documentar as soluções para as questões do Exercício 12 da disciplinas de CPAD.2025. Como demandado, cada questão está em uma aba separada usando tabset.

Análise de Dados

Questão 1

Use os dados abaixo para gerar os gráficos. Para o segundo gráfico (barras), use a escala logarítmica (log = “y”) e as seguintes cores: “#E6E6E6”, “#666666”. Além disso, os gráficos podem ser organizados com a função layout().

MRT_1F <-c(517.1468515630205, 85.13094142168089, 30.333207896694553, 12.694776264558937, 3.3041601673945418, 1.1823111717498882, 1.1892293502386786)

MRT_3F <-c(156.68929936163462, 11.540837783562276, 0.4512835621696538, 0.4509797929766453, 0.4502068233039181, 0.4496185276300172, 0.4543157082191288)

MRT_5F <-c(83.90319666471157, 0.3068151086494968, 0.30522314133037304, 0.3072588968084928, 0.30655265997285697, 0.3055812715727718, 0.3053297166713006)

MRT_10F <-c(29.55430642951759, 0.19832832665772515, 0.1971923924717474, 0.19796648905716516, 0.19615594370806338, 0.2034569237883263, 0.19617420889447737)

MRT_15F <-c(11.317736530583566, 0.167364215666193, 0.16172168266811013, 0.16701085329580515, 0.1598052657153692, 0.1645934043532696, 0.16216563797118075)

MRT_sem_F <-c(11.93430909937736, 0.6095414637034009, 0.6060645101029295, 0.612167181646899, 0.6146761002685637, 0.6096747087200697, 0.6125810476877268)

clock <- c(0.1, 0.5, 1, 1.5, 2, 2.5, 3)


### Plot gráfico de linhas

layout(matrix(1:2, nrow = 1), widths = c(2, 1)) 

plot(clock, MRT_1F, type = "o", col = "black", pch = 4, lty = 1, lwd = 2,
     ylim = c(0, max(MRT_1F)), xlab = "Time between Things requests (seconds)", 
     ylab = "Response Time (sec.)", main = "")

lines(clock, MRT_3F, type = "o", col = "yellow", pch = 11, lty = 1, lwd = 2)
lines(clock, MRT_5F, type = "o", col = "red", pch = 1, lty = 1, lwd = 2)
lines(clock, MRT_10F, type = "o", col = "blue", pch = 2, lty = 1, lwd = 2)
lines(clock, MRT_15F, type = "o", col = "magenta", pch = 5, lty = 1, lwd = 2)
lines(clock, MRT_sem_F, type = "o", col = "green", pch = 4, lty = 1, lwd = 2)

legend("topright", legend = c("1 Fog", "3 Fogs", "5 Fogs", "10 Fogs", "15 Fogs", "w/o Fog"),
       col = c("black", "yellow", "red", "blue", "magenta", "green"),
       pch = c(4, 11, 1, 2, 5, 4), lty = 1, lwd = 2, cex = 0.8)

# Cores e layout
cores <- c("#E6E6E6", "#666666")
layout(matrix(c(1,2,3,4,5,6), nrow = 2, byrow = TRUE))

#Função para plots
plot_comparativo <- function(fog, label) {
  dados <- rbind(MRT_sem_F, fog)
  ymax <- max(dados)
  barplot(dados,
          beside = TRUE,
          log = "y",
          col = cores,
          names.arg = clock,
          ylim = c(0.1, ymax), 
          xlab = "Time between Things requests",
          ylab = "Response time (s)",
          main = NULL)
  legend("topright", legend = c("w/o Fog", label),
         fill = cores, border = "black", bty = "n")
}

# Plots
plot_comparativo(MRT_1F, "1 Fog")
plot_comparativo(MRT_3F, "3 Fogs")
plot_comparativo(MRT_5F, "5 Fogs")
plot_comparativo(MRT_10F, "10 Fogs")
plot_comparativo(MRT_15F, "15 Fogs")

Questão 2

Para a tabela que classifica a qualidade de refeição de acordo com categorias de preços crie um gráfico de barras empilhadas. Também adicione título, nomes de eixos e legenda.

#dados e nomes das linhas e colunas
dados_refeicao <- matrix(c(
  53.8, 33.9, 2.6, 0.0,43.6, 54.2, 60.5, 21.4,2.6, 11.9, 36.8, 78.6), 
  nrow = 3, byrow = TRUE)

#rotulos
rownames(dados_refeicao) <- c("Good", "Very Good", "Excellent")
colnames(dados_refeicao) <- c("$10-19", "$20-29", "$30-39", "$40-49")

label_cores <- c("red", "yellow", "green")
par(mar = c(5, 4, 4, 10))

#plotagem
barplot(dados_refeicao,
        col = label_cores,
        main = "Qualidade das Refeições / Faixa de Preço",
        xlab = "Faixa de Preço",
        ylab = "Porcentagem",
        ylim = c(0, 100),  
        legend.text = FALSE,  
        beside = FALSE)

#Descrição
legend("topright", 
       title = "Classificação da Qualidade",
       legend = c("Excellent", "Very Good", "Good"), 
       fill = c("red", "yellow", "green"),  
       xpd = TRUE,  
       inset = c(-0.46, 0))

Questão 3

Faça o histograma das temperaturas do mês de maio do dataset airquality. No entanto, primeiro converta as temperaturas para graus Celsius através da expressão °C = (°F − 32) / 1.8. Após isso, gere o histograma. Também adicione título, nomes de eixos, cor e curva de densidade.

#Carregando, filtragem e converção
data(airquality)
dados_maio <- airquality[airquality$Month == 5, ]
temperaturas_celsius <- (dados_maio$Temp - 32) / 1.8

#geração do histograma
hist(temperaturas_celsius, 
     col = "skyblue",  
     border = "white",  
     main = "Histograma das Temperaturas em Maio",  
     xlab = "Temperatura em graus celsius",  
     ylab = "Frequência",  
     prob = TRUE)  


lines(density(temperaturas_celsius), 
      col = "red", 
      lwd = 2)  


legend("topright", 
       legend = c("Densidade"),
       col = c("red"),
       lwd = 2,
       bty = "n")

Questão 4

Crie um gráfico de pizza com a porcentagem da tabela total de vendas por país. Use o dataset abaixo. Inclua a porcentagem de cada fatia, as cores das fatias e o nome do gráfico. Adicionalmente, use o comando legend() para incluir a legenda do gráfico.

#importa dados
dados <- read.table("https://training-course-material.com/images/8/8f/Sales.txt",header=TRUE)

vendas_pais <- aggregate(dados$SALES, by=list(Country=dados$COUNTRY), FUN=sum)
colnames(vendas_pais) <- c("Pais", "Total_Vendas")

#cria nova coluna porcentagem
vendas_pais$Porcentagem <- round(vendas_pais$Total_Vendas / sum(vendas_pais$Total_Vendas) * 100, 1)



cores <- c("red", "blue", "green", "yellow", "pink", "black")


par(mar = c(1, 1, 4, 10), xpd = TRUE)
#plota gráfico
pie(vendas_pais$Total_Vendas, 
    labels = paste0(vendas_pais$Pais, " (", vendas_pais$Porcentagem, "%)"), 
    col = cores,
    main = "Porcentagem de Vendas p/ País")


legend("right", 
       legend = paste0(vendas_pais$Pais, " (", vendas_pais$Porcentagem, "%)"),
       fill = cores,
       title = "Países",
       inset = c(-0.3, 0),
       cex = 0.8)

Questão 5

Utilize os dados de contagens de insetos em unidades experimentais agrícolas tratados com inseticidas diferentes disponíveis no R em InsectSprays e construa um boxplot sem a presença dos outliers para os 6 tipos de inseticidas. Coloque título e nomes de eixos adequados. Além disso, as caixas devem ser preenchidas com a cor “yellow”.

#obtem dados
data(InsectSprays)
par(mar = c(5, 4, 4, 2))

#plota Boxplot
boxplot(count ~ spray, 
        data = InsectSprays,
        main = "Número de Insetos por Tipo de Inseticida",
        xlab = "Tipo de Inseticida",
        ylab = "Número de Insetos",
        col = "yellow",
        outline = FALSE)

Questão 6

Gere os gráficos abaixo a partir dos seguintes dados: monitoringCloudData_0.1.csv, monitoringCloudData_0.5.csv, monitoringCloudData_1.csv e monitoringCloudData_NONE.csv. Esses dados consistem de informações de monitoramento dos recursos de uma máquina virtual. Basicamente, é necessário gerar gráficos de linha do tempo de coleta dos recursos (currentTime) em relação a memória usada (usedMemory). Porém, é necessário ajustar a coluna “currentTime” para que o tempo fique contínuo e a coluna “usedMemory” para que todas as informações fiquem megabytes. Por fim, use a função layout() para organizar os gráficos. Dica 1: use a função difftime() para calcular a diferença do tempo em horas. Dica 2: use os conceitos vistos na aula de string/regex para converter os dados na coluna “usedMemory” para apenas megabytes. Além disso, considere que um terabyte equivale a 1000000 megabytes e 1 gigabyte equivale a 1024 megabytes.

#funcao de processamento csv
process_data <- function(file_path) {
  # le csv
  dado <- read.csv(file_path, stringsAsFactors = FALSE)
  
  # converte tempo em horas
  dado$currentTime <- as.POSIXct(dado$currentTime)
  dado$time_hours <- as.numeric(difftime(dado$currentTime, min(dado$currentTime), units = "hours"))

  valor_num <- as.numeric(gsub("[^0-9.]", "", dado$usedMemory))
  
  # cria variavel multiplicador conforme unidade
  multiplicador <- ifelse(grepl("TB", dado$usedMemory, ignore.case = TRUE), 1e6,
                ifelse(grepl("GB", dado$usedMemory, ignore.case = TRUE), 1024, 1))
  
  # Converte memória para MB
  dado$usedMemory_mb <- valor_num * multiplicador
  
  dado
}

#importando dados e aplicando conversao
dado_none <- process_data("monitoringCloudData_NONE.csv")
dado_01 <- process_data("monitoringCloudData_0.1.csv")
dado_05 <- process_data("monitoringCloudData_0.5.csv")
dado_10 <- process_data("monitoringCloudData_1.csv")


layout(matrix(c(1, 2, 3, 4), nrow = 2, byrow = TRUE))


par(mar = c(4, 4, 2, 1))


plot(dado_none$time_hours, dado_none$usedMemory_mb, 
     type = "l", 
     main = "Memory Analysis (None Workload)",
     xlab = "Time (hour)",
     ylab = "Used Memory (MB)",
     col = "black")


plot(dado_01$time_hours, dado_01$usedMemory_mb, 
     type = "l", 
     main = "Memory Analysis (Workload of 0.1)",
     xlab = "Time (hour)",
     ylab = "Used Memory (MB)",
     col = "black")


plot(dado_05$time_hours, dado_05$usedMemory_mb, 
     type = "l", 
     main = "Memory Analysis (Workload of 0.5)",
     xlab = "Time (hour)",
     ylab = "Used Memory (MB)",
     col = "black")


plot(dado_10$time_hours, dado_10$usedMemory_mb, 
     type = "l", 
     main = "Memory Analysis (Workload of 1.0)",
     xlab = "Time (hour)",
     ylab = "Used Memory (MB)",
     col = "black")

Questão 7

Filtrando os conteúdos com apenas UM país de origem (coluna “country”), utilize o Plotly para obter um gráfico de pizza dos 10 países com mais conteúdo na plataforma.

#Importa dataset
netflix_dado <- read_csv("netflix_titles.csv", show_col_types = FALSE)


unico_pais <- function(country_str) {
  return(!grepl(",", country_str))
}


pais <- netflix_dado[!is.na(netflix_dado$country) & 
                                      sapply(netflix_dado$country, unico_pais), ]


pais$country_clean <- sapply(pais$country, function(x) gsub("^\\s+|\\s+$", "", x))


tabela_pais <- table(pais$country_clean)
pais_df <- data.frame(
  country = names(tabela_pais),
  count = as.numeric(tabela_pais)
)


pais_df <- pais_df[order(-pais_df$count), ]


top_10 <- head(pais_df, 10)


total_cont <- sum(top_10$count)
top_10$percentage <- round(top_10$count / total_cont * 100, 2)


#Plot
plot_ly(top_10, 
               labels = ~country, 
               values = ~count, 
               type = 'pie',
               textinfo = 'label+percent',
               insidetextorientation = 'radial',
               textposition = 'outside',
               texttemplate = '%{label}<br>%{percent}') %>%
      layout(
        title = '10 principais países com mais conteúdo na netflix',
        showlegend = TRUE,
        legend = list(orientation = "h", x = 0.5, y = -0.2, xanchor = "center"),
        margin = list(l = 50, r = 50, b = 100, t = 100, pad = 4),
        autosize = FALSE,
        width = 900,
        height = 600
      )
## Warning: Specifying width/height in layout() is now deprecated.
## Please specify in ggplotly() or plot_ly()

Questão 8

Considerando os 10 países descritos na questão anterior, utilize o Plotly para obter uma tabela com as colunas “País” e “Total de conteúdos”. Para tal tabela, é necessário que o cabeçalho esteja com o fundo da célula cinza e a letra em branco, e que todos os textos das células estejam centralizados.

plot_ly(
  type = 'table',
  header = list(values = c("País", "Soma de conteúdos"),
    align = 'center',
    fill = list(color = 'gray'),
    font = list(color = 'white', size = 14)
  ),
  cells = list(
    values = list(top_10$country, top_10$count),
    align = 'center')
)

Questão 9

Utilizando o Plotly, obtenha um gráfico de linha com uantidade de conteúdo por década dpontos (como na imagem abaixo) contendo a qo Netflix, onde o eixo X representa as décadas e o eixo Y a quantidade de conteúdo disponível na plataforma (coluna “release_year”). Use uma linha azul para representar as séries e uma linha amarela representando os filmes. (Obs: considerar como década o período que compreende os anos de XXX0 à XXX9, por exemplo, 2000 à 2009)

#Reduz o dataset a partir do ano de lançamento
netflix_dado$decade <- floor(netflix_dado$release_year / 10) * 10

#Filtra por filmes e series
filmes <- aggregate(type ~ decade, data = netflix_dado[netflix_dado$type == "Movie", ], FUN = length)
series <- aggregate(type ~ decade, data = netflix_dado[netflix_dado$type == "TV Show", ], FUN = length)


names(filmes)[2] <- "count"
names(series)[2] <- "count"

#Plota o gráfico
plot_ly() %>%
  add_trace(
    x = series$decade, 
    y = series$count, 
    type = 'scatter', 
    mode = 'lines+markers',
    name = 'TV Series',
    line = list(color = 'blue')
  ) %>%
  add_trace(
    x = filmes$decade, 
    y = filmes$count, 
    type = 'scatter', 
    mode = 'lines+markers',
    name = 'Movies',
    line = list(color = 'yellow')
  ) %>%
  layout(
    title = "Numero de Conteúdo por Década na Netflix",
    xaxis = list(title = "Década", gridcolor = 'lightgray'),
    yaxis = list(title = "Soma dos Conteúdos", gridcolor = 'lightgray'),
    plot_bgcolor = 'white'
  )

Questão 10

Utilizando o Plotly, obtenha um gráfico que representa a quantidade de filmes lançados de um determinado gênero entre os anos de 2000 e 2010. Este gráfico deve ser de barras lado-a-lado (como na imagem abaixo), com cada barra representando a quantidade de filmes dos gêneros “Dramas”, “Action & Adventure” e “Comedies” lançados naquele determinado ano. (Obs: Para filmes com múltiplos gêneros, considerar apenas o primeiro descrito na coluna “listed_in”).

# Filtra apenas os filmes entre 2000 e 2010
filmes <- netflix_dado[netflix_dado$type == "Movie" & 
                 netflix_dado$release_year >= 2000 & 
                 netflix_dado$release_year <= 2010, ]

# Extrai apenas o primeiro genero
filmes$genero <- sapply(strsplit(as.character(filmes$listed_in), ","), function(x) trimws(x[1]))

# somente os gêneros solicitados
filmes_filtrados <- filmes[filmes$genero %in% c("Dramas", "Action & Adventure", "Comedies"), ]

# Conta o número de lançamento
contagem <- table(filmes_filtrados$release_year, filmes_filtrados$genero)
df_contagem <- as.data.frame(contagem)
names(df_contagem) <- c("Ano", "Genero", "Quantidade")

# Cria o gráfico de barras
plot_ly(df_contagem, 
               x = ~Ano, 
               y = ~Quantidade, 
               color = ~Genero, 
               type = 'bar',
               colors = c("Dramas" = "blue", 
                          "Action & Adventure" = "orange", 
                          "Comedies" = "green")) %>%
             layout(title = "",
             xaxis = list(title = "Ano de Lançamento", 
                          tickmode = "array",
                          tickvals = seq(2000, 2010, by = 2)),
             yaxis = list(title = "Qtd. de Lançamentos"),
             barmode = 'group',
             legend = list(title = ""))