Gráficos de Tempo de Resposta

Questão 1

Nesta aba, apresentamos o gráfico de linhas comparando os diferentes cenários de infraestrutura de névoa além do gráfico de barra (Fog).

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

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)

# Gráfico de Linhas (R Tradicional)
plot(clock, MRT_1F, type = "b", pch = 4, col = "black",
     xlab = "Time between Things requests (seconds)",
     ylab = "Response Time (sec.)",
     ylim = c(0, 530), xaxt = "n", yaxt = "n")

lines(clock, MRT_3F, type = "b", pch = 8, col = "yellow")
lines(clock, MRT_5F, type = "b", pch = 5, col = "red")
lines(clock, MRT_10F, type = "b", pch = 2, col = "blue")
lines(clock, MRT_15F, type = "b", pch = 9, col = "purple")
lines(clock, MRT_sem_F, type = "b", pch = 3, col = "green")

# Eixos customizados
axis(1, at = seq(0, 3, by = 0.5), labels = sprintf("%.1f", seq(0, 3, by = 0.5)))
axis(2, at = seq(0, 500, by = 100), labels = seq(0, 500, by = 100))

# Legenda
legend("topright", 
       legend = c("1 Fog", "3 Fogs", "5 Fogs", "10 Fogs", "15 Fogs", "w/o Fog"),
       col = c("black", "yellow", "red", "blue", "purple", "green"),
       pch = c(4, 8, 5, 2, 9, 3), bg = "white")

# Configuração da disposição dos gráficos (3 linhas x 2 colunas)
matriz_layout <- matrix(c(1, 2, 3, 4, 5, 0), nrow = 3, ncol = 2, byrow = TRUE)
layout(matriz_layout)

cores <- c("#E6E6E6", "#666666")

# Função para automatizar cada quadrante do layout
plotar_par_barras <- function(dados_fog, nome_fog, x_label = "Time between Things requests") {
  dados_combinados <- rbind(MRT_sem_F, dados_fog)
  
  barplot(dados_combinados, beside = TRUE, log = "y",
          names.arg = sprintf("%.1f", clock),
          xlab = x_label, ylab = "Response time (s)",
          col = cores, ylim = c(0.1, 1000), yaxt = "n")
  
  axis(2, at = c(0.1, 0.2, 0.5, 1.0, 5.0, 50.0, 500.0), 
       labels = c("0.1", "0.2", "0.5", "1.0", "5.0", "50.0", "500.0"))
  
  legend("topright", legend = c("w/o Fog", nome_fog), fill = cores, bg = "white", cex = 0.8)
}

# Gerando os 5 subgráficos
plotar_par_barras(MRT_1F, "1 Fog")
plotar_par_barras(MRT_3F, "3 Fogs")
plotar_par_barras(MRT_5F, "5 Fogs")
plotar_par_barras(MRT_10F, "10 Fogs", x_label = "Time between Thin requests")
plotar_par_barras(MRT_15F, "15 Fogs")

Questão 2

Nesta aba, apresentamos a análise da relação entre o preço da refeição (Meal Price) e sua respectiva classificação de qualidade (Quality Rating) através de um gráfico de barras empilhadas.

# 1. Criar a matriz com os dados da tabela (porcentagens por coluna)
# Cada coluna representa uma faixa de preço ($10-19, $20-29, $30-39, $40-49)
dados_restaurante <- matrix(c(
  53.8, 43.6,  2.6,  # $10–19
  33.9, 54.2, 11.9,  # $20–29
   2.6, 60.5, 36.8,  # $30–39
   0.0, 21.4, 78.6   # $40–49
), nrow = 3, byrow = FALSE)

# 2. Definir os nomes das linhas (Qualidade) e colunas (Preço)
rownames(dados_restaurante) <- c("Good", "Very Good", "Excellent")
colnames(dados_restaurante) <- c("$10–19", "$20–29", "$30–39", "$40–49")

# 3. Definir uma paleta de cores agradável para a qualidade (do mais claro ao mais escuro)
cores_qualidade <- c("#FDD49E", "#FDBB84", "#EF6548")

# Ajustar as margens para acomodar a legenda perfeitamente
par(mar = c(5, 5, 4, 9))

# 4. Gerar o gráfico de barras empilhadas (beside = FALSE faz ficar empilhado)
barplot(dados_restaurante, 
        beside = FALSE, 
        col = cores_qualidade,
        xlab = "Meal Price", 
        ylab = "Percentage (%)",
        main = "Meal Quality Rating by Price Category",
        ylim = c(0, 100),
        las = 1) # Deixa os números do eixo Y na horizontal

# 5. Adicionar a legenda posicionada fora das barras (à direita)
legend("topright", 
       inset = c(-0.25, 0), # Move a legenda para fora do gráfico
       legend = rownames(dados_restaurante), 
       fill = cores_qualidade, 
       title = "Quality Rating",
       xpd = TRUE,          # Permite que a legenda seja desenhada fora da área do gráfico
       bty = "n")           # Remove a borda da legenda

Questão 3

Nesta aba, realizamos a filtragem das temperaturas do mês de maio a partir do dataset airquality, convertemos os valores de Fahrenheit para Celsius e geramos o histograma com a curva de densidade sobreposta.

# 1. Carregar os dados originais e filtrar apenas para o mês de maio (Month == 5)
dados_maio <- subset(airquality, Month == 5)

# 2. Converter a coluna de temperatura (Temp) de Fahrenheit para Celsius
# Fórmula: °C = (°F - 32) / 1.8
temp_f <- dados_maio$Temp
temp_c <- (temp_f - 32) / 1.8

# 3. Gerar o Histograma configurado para Densidade (prob = TRUE)
hist(temp_c, 
     prob = TRUE, 
     col = "#9ecae1",          # Cor azul claro suave para as barras
     border = "white",         # Bordas brancas para destacar os blocos
     main = "Histogram of Temperatures in May", 
     xlab = "Temperature (°C)", 
     ylab = "Density",
     las = 1,
     ylim = c(0, 0.12))        # Ajusta o limite vertical para a curva não cortar no topo

# 4. Calcular e adicionar a linha da curva de densidade
curva_densidade <- density(temp_c)
lines(curva_densidade, 
      col = "#084594",         # Cor azul escuro para a linha contrastar
      lwd = 3)                 # Espessura da linha ampliada para melhor leitura

Questão 4

Nesta aba, importamos os dados de vendas globais, calculamos a participação percentual de cada país no total vendido e apresentamos os resultados em um gráfico de pizza personalizado.

# 1. Importar o dataset a partir da URL fornecida
sales <- read.table("https://training-course-material.com/images/8/8f/Sales.txt",header=TRUE)

# 2. Agrupar e somar as vendas (SALES) por país (COUNTRY)
vendas_por_pais <- aggregate(SALES ~ COUNTRY, data = sales, FUN = sum)

# 3. Calcular as porcentagens de cada país em relação ao total
porcentagens <- (vendas_por_pais$SALES / sum(vendas_por_pais$SALES)) * 100
porcentagens_formatadas <- round(porcentagens, 1) # Arredonda para 1 casa decimal

# 4. Criar os rótulos que vão aparecer nas fatias (apenas os números com o símbolo %)
rotulos_fatias <- paste0(porcentagens_formatadas, "%")

# 5. Definir uma paleta de cores para os países
cores_paises <- c("#fc8d62", "#66fc8d", "#8da0cb", "#e78ac3", "#a6d854")

# Ajustar as margens para a legenda não cortar
par(mar = c(4, 4, 4, 8))

# 6. Gerar o gráfico de pizza (labels recebe apenas a porcentagem)
pie(vendas_por_pais$SALES, 
    labels = rotulos_fatias, 
    col = cores_paises, 
    main = "Percentage of Total Sales by Country",
    cex = 1.1) # Aumenta um pouquinho o tamanho do texto das fatias

# 7. Adicionar a legenda mapeando as cores aos nomes dos países
legend("topright", 
       inset = c(-0.2, 0), # Joga a legenda ligeiramente para fora do círculo
       legend = vendas_por_pais$COUNTRY, 
       fill = cores_paises, 
       title = "Countries",
       xpd = TRUE,         # Permite desenhar fora da área padrão do gráfico
       bty = "o", 
       bg = "white")

Questão 5

Nesta aba, analisamos a quantidade de insetos encontrados após a aplicação de 6 tipos diferentes de inseticidas (sprays), utilizando um gráfico boxplot sem a presença de outliers.

# 1. Gerar o boxplot utilizando a fórmula: contagem em função do tipo de spray
boxplot(count ~ spray, 
        data = InsectSprays, 
        outline = FALSE,            # Remove completamente os pontos de outliers do gráfico
        col = "yellow",             # Define o preenchimento das caixas como amarelo
        main = "Insect Counts by Insecticide Spray Type", 
        xlab = "Insecticide Spray Type (A to F)", 
        ylab = "Insect Count (per experimental unit)",
        las = 1)                    # Deixa os valores do eixo Y na orientação horizontal

Questão 6

Nesta aba, analisamos o uso de memória ao longo do tempo para quatro cenários de monitoramento distintos. O tempo foi convertido para uma escala contínua em horas desde o início da coleta, e a memória utilizada foi padronizada para Megabytes (MB).

# 1. Função para limpar e converter a coluna usedMemory para Megabytes (MB)
converter_para_mb <- function(coluna_memoria) {
  # Remove espaços em branco nas pontas
  coluna_limpa <- trimws(as.character(coluna_memoria))
  
  # Dica 2: Regex para extrair apenas a parte numérica (mantendo pontos decimais)
  valores_numericos <- as.numeric(gsub("[^0-9.]", "", coluna_limpa))
  
  # Regex para extrair apenas as letras (unidade de medida) em maiúsculo
  unidades <- toupper(gsub("[0-9. ]", "", coluna_limpa))
  
  # Define o fator de conversão padrão como 1 (caso já esteja em MB)
  fatores <- rep(1, length(coluna_limpa))
  
  # Aplica as regras de conversão solicitadas no enunciado
  fatores[grepl("GB|G", unidades)] <- 1024
  fatores[grepl("TB|T", unidades)] <- 1000000
  fatores[grepl("KB|K", unidades)] <- 1 / 1024  # Caso exista KB por precaução
  
  return(valores_numericos * fatores)
}

# 2. Função principal para ler o arquivo, tratar e gerar o gráfico individual
processar_e_plotar <- function(nome_arquivo, titulo_grafico) {
  # Proteção: Verifica se o arquivo realmente existe na pasta
  if (!file.exists(nome_arquivo)) {
    plot.new()
    text(0.5, 0.5, paste("Arquivo não encontrado:\n", nome_arquivo), cex = 1.2, col = "red")
    return(NULL)
  }
  
  # Lendo o arquivo CSV
  dados <- read.csv(nome_arquivo, header = TRUE, stringsAsFactors = FALSE)
  
  # Dica 1: Convertendo para data/hora e calculando o tempo contínuo em horas
  dados$currentTime <- as.POSIXct(dados$currentTime)
  tempo_continuo <- difftime(dados$currentTime, dados$currentTime[1], units = "hours")
  dados$tempo_horas <- as.numeric(tempo_continuo)
  
  # Convertendo a memória usando a nossa função auxiliar
  dados$usedMemory_MB <- converter_para_mb(dados$usedMemory)
  
  # Gerando o gráfico de linha contínua (type = "l")
  plot(dados$tempo_horas, dados$usedMemory_MB, 
       type = "l", 
       col = "darkblue", 
       lwd = 2,
       main = titulo_grafico,
       xlab = "Time elapsed (hours)", 
       ylab = "Used Memory (MB)",
       las = 1)
  
  # Adiciona uma grade sutil de fundo para ajudar na leitura visual
  grid(nx = NULL, ny = NULL, col = "lightgray", lty = "dotted")
}

# 3. Configuração da disposição dos gráficos (2 linhas x 2 colunas)
matriz_layout <- matrix(1:4, nrow = 2, ncol = 2, byrow = TRUE)
layout(matriz_layout)

# 4. Executando para os quatro arquivos do seu diretório
processar_e_plotar("monitoringCloudData_0.1.csv", "Monitoring - Scenario 0.1")
processar_e_plotar("monitoringCloudData_0.5.csv", "Monitoring - Scenario 0.5")
processar_e_plotar("monitoringCloudData_1.csv", "Monitoring - Scenario 1.0")
processar_e_plotar("monitoringCloudData_NONE.csv", "Monitoring - Scenario NONE")

Questão 7

Nesta aba, filtramos o conjunto de dados da Netflix para considerar apenas produções com um único país de origem. Utilizando a biblioteca Plotly, apresentamos um gráfico de pizza interativo com os 10 países que possuem maior volume de conteúdo na plataforma.

# 1. Carregar a biblioteca Plotly
library(plotly)

# 2. Ler o dataset da Netflix (ajuste o nome exato do arquivo caso seja diferente)
# Supondo que o arquivo seja um CSV padrão chamado "netflix_titles.csv"
# Se o seu arquivo tiver outro nome (ex: "netflix.csv"), altere abaixo:
netflix_data <- read.csv("netflix_titles.csv", header = TRUE, stringsAsFactors = FALSE)

# 3. Filtrar linhas onde o país não está vazio
dados_filtrados <- subset(netflix_data, country != "" & !is.na(country))

# 4. Filtrar para manter apenas conteúdos com UM país de origem 
# (ou seja, linhas que NÃO possuem vírgula na coluna 'country')
dados_filtrados <- subset(dados_filtrados, !grepl(",", country))

# 5. Contar a quantidade de conteúdos por país e pegar os 10 maiores
contagem_paises <- as.data.frame(table(dados_filtrados$country))
colnames(contagem_paises) <- c("Pais", "Quantidade")

# Ordenar de forma decrescente e selecionar os 10 primeiros
top_10_paises <- contagem_paises[order(-contagem_paises$Quantidade), ][1:10, ]

# 6. Gerar o gráfico de pizza interativo com o Plotly
plot_ly(top_10_paises, 
        labels = ~Pais, 
        values = ~Quantidade, 
        type = 'pie',
        textposition = 'inside',
        textinfo = 'label+percent', # Mostra o nome do país e a % dentro da fatia
        insidetextfont = list(color = '#FFFFFF'),
        hoverinfo = 'text',
        text = ~paste("País:", Pais, "<br>Total de Títulos:", Quantidade),
        marker = list(colors = plot_ly(colors = "Set3", alpha = 0.8),
                      line = list(color = '#FFFFFF', width = 1))) %>%
  layout(title = list(text = "Top 10 Countries with Most Single-Origin Content on Netflix", 
                      y = 0.95),
         xaxis = list(showgrid = FALSE, zeroline = FALSE, showticklabels = FALSE),
         yaxis = list(showgrid = FALSE, zeroline = FALSE, showticklabels = FALSE),
         showlegend = TRUE)

Questão 8

Nesta aba, apresentamos a tabela interativa gerada com o Plotly detalhando o total de conteúdos para o Top 10 países selecionados na análise anterior.

# Como os dados já foram carregados e o 'top_10_paises' já foi calculado na aba anterior,
# podemos usá-lo diretamente aqui!

# Gerando a tabela interativa com o Plotly
plot_ly(
  type = 'table',
  header = list(
    values = c("<b>País</b>", "<b>Total de conteúdos</b>"),
    align = "center",                        # Centraliza o texto do cabeçalho
    line = list(width = 1, color = '#505050'),
    fill = list(color = '#666666'),          # Fundo cinza para o cabeçalho
    font = list(family = "Arial", size = 14, color = "white") # Letras brancas
  ),
  cells = list(
    values = rbind(as.character(top_10_paises$Pais), top_10_paises$Quantidade),
    align = "center",                        # Centraliza o texto das células (@centralizados)
    line = list(color = '#D3D3D3', width = 1),
    fill = list(color = c('#F9F9F9', '#FFFFFF')), # Efeito zebrado sutil nas linhas
    font = list(family = "Arial", size = 12, color = "black")
  )) %>%
  layout(title = list(text = "Summary Table: Top 10 Countries Content Volume", y = 0.95))

Questão 9

Nesta aba, agrupamos o volume de produções da Netflix por década de lançamento (coluna release_year), separando o crescimento histórico entre filmes (Movies) e séries (TV Series) em um gráfico de linhas interativo do Plotly.

# Como o dataset 'netflix_data' foi carregado nas abas anteriores, podemos reutilizá-lo aqui

# 1. Criar a coluna de década a partir do ano de lançamento (release_year)
# O cálculo floor(ano / 10) * 10 garante que anos de XXX0 a XXX9 fiquem na mesma década
netflix_data$decada <- floor(netflix_data$release_year / 10) * 10

# 2. Agrupar e contar a quantidade de conteúdos por Tipo e por Década
contagem_historica <- as.data.frame(table(netflix_data$decada, netflix_data$type))
colnames(contagem_historica) <- c("Decada", "Tipo", "Quantidade")

# Converter a coluna de Década para valor numérico para o gráfico alinhar corretamente o eixo X
contagem_historica$Decada <- as.numeric(as.character(contagem_historica$Decada))

# 3. Separar os dados em dataframes específicos para Filmes e Séries
dados_filmes <- subset(contagem_historica, Tipo == "Movie")
dados_series <- subset(contagem_historica, Tipo == "TV Show")

# 4. Criar o gráfico de linhas interativo com o Plotly
plot_ly() %>%
  # Linha Azul para Séries (TV Series)
  add_trace(data = dados_series,
            x = ~Decada, 
            y = ~Quantidade, 
            type = 'scatter', 
            mode = 'lines+markers',
            name = 'TV Series',
            line = list(color = '#1f77b4', width = 2), # Azul institucional
            marker = list(color = '#1f77b4', size = 6)) %>%
  # Linha Amarela/Laranja para Filmes (Movies)
  add_trace(data = dados_filmes,
            x = ~Decada, 
            y = ~Quantidade, 
            type = 'scatter', 
            mode = 'lines+markers',
            name = 'Movies',
            line = list(color = '#ff7f0e', width = 2), # Amarelo/Laranja idêntico ao modelo
            marker = list(color = '#ff7f0e', size = 6)) %>%
  # Configurações de layout, eixos e títulos
  layout(title = list(text = "Evolution of Netflix Content by Decade", y = 0.95),
         xaxis = list(title = "Década",
                      tickvals = seq(min(contagem_historica$Decada), max(contagem_historica$Decada), by = 20),
                      showgrid = TRUE,
                      gridcolor = '#EBF0F1'),
         yaxis = list(title = "Qnd. Conteúdo",
                      showgrid = TRUE,
                      gridcolor = '#EBF0F1'),
         plot_bgcolor = '#FFFFFF', # Fundo branco idêntico à imagem de referência
         legend = list(orientation = "v", x = 0.85, y = 0.95))

Questão 10

Nesta aba, analisamos o volume de filmes lançados ano a ano entre 2000 e 2010 para três gêneros específicos (“Dramas”, “Action & Adventure” e “Comedies”), utilizando o primeiro gênero descrito na coluna listed_in e gerando um gráfico de barras agrupadas interativo com o Plotly.

# Como o dataset 'netflix_data' já foi carregado nas abas anteriores, podemos reutilizá-lo aqui

# 1. Filtrar o dataset para manter apenas os registros que são Filmes (type == "Movie")
filmes_data <- subset(netflix_data, type == "Movie")

# 2. Extrair apenas o PRIMEIRO gênero da coluna 'listed_in'
# O comando gsub(",.*", "", ...) remove tudo o que estiver da primeira vírgula em diante
filmes_data$primeiro_genero <- trimws(gsub(",.*", "", filmes_data$listed_in))

# 3. Filtrar pelo intervalo de anos solicitado (entre 2000 e 2010)
filmes_filtrados <- subset(filmes_data, release_year >= 2000 & release_year <= 2010)

# 4. Filtrar para manter apenas os três gêneros pedidos pelo enunciado
generos_alvo <- c("Dramas", "Action & Adventure", "Comedies")
filmes_filtrados <- subset(filmes_filtrados, primeiro_genero %in% generos_alvo)

# 5. Criar a tabela de contingência/frequência por Ano (eixo X) e Gênero (as barras)
tabela_contagem <- as.data.frame(table(filmes_filtrados$release_year, filmes_filtrados$primeiro_genero))
colnames(tabela_contagem) <- c("Ano", "Genero", "Quantidade")

# Converter a coluna Ano para fator ou caractere para o Plotly plotar como categorias discretas no eixo X
tabela_contagem$Ano <- as.character(tabela_contagem$Ano)

# 6. Separar os dados de cada gênero para alimentar os traces do Plotly
dados_dramas   <- subset(tabela_contagem, Genero == "Dramas")
dados_action   <- subset(tabela_contagem, Genero == "Action & Adventure")
dados_comedies <- subset(tabela_contagem, Genero == "Comedies")

# 7. Gerar o gráfico de barras lado a lado (Agrupado)
plot_ly() %>%
  # Barras para Dramas
  add_trace(data = dados_dramas,
            x = ~Ano, 
            y = ~Quantidade, 
            type = 'bar', 
            name = 'Dramas',
            marker = list(color = '#1f77b4')) %>% # Azul
  # Barras para Action & Adventure
  add_trace(data = dados_action,
            x = ~Ano, 
            y = ~Quantidade, 
            type = 'bar', 
            name = 'Action & Adventure',
            marker = list(color = '#ff7f0e')) %>% # Laranja/Amarelo
  # Barras para Comedies
  add_trace(data = dados_comedies,
            x = ~Ano, 
            y = ~Quantidade, 
            type = 'bar', 
            name = 'Comedies',
            marker = list(color = '#2ca02c')) %>% # Verde
  # Configurar o Layout para barras lado a lado usando barmode = 'group'
  layout(title = list(text = "Movies Released by Genre (2000 - 2010)", y = 0.95),
         xaxis = list(title = "Ano de Lançamento"),
         yaxis = list(title = "Quantidade de Filmes"),
         barmode = 'group', # CRUCIAL: Faz as barras ficarem lado a lado em vez de empilhadas
         plot_bgcolor = '#FFFFFF',
         legend = list(title = list(text = "<b>Gênero</b>")))