library(tidyverse)

library(nycflights13)

data(flights)

data(airports)

data(airlines)

#Exercice 1

#1. Sélectionner la dixième ligne du tableau des aéroports (airports).

#airports %>% slice(1:10)

airports %>% slice(10)

#2. Sélectionner les 5 premières lignes de la table airlines.

airports %>% slice(1:5)

#3. Sélectionner l’aéroport avec l’altitude la plus basse.

airports %>% arrange(alt) %>% slice(1)

#Exercice2

str(flights)

#Sélectionnez les vols du mois de juillet (variable month).

flights %>% filter(month == 7) %>% select(flight)

#Sélectionnez les vols des compagnies Delta, United et American (codes DL, UA et AA de la variable
carrier).

flights %>% filter(carrier %in% c("DL", "UA", "AA")) %>% select (flight)

#Exercice 3

#Triez la table flights par retard au départ décroissant.

flights %>% arrange(desc(dep_delay))

#Exercice 4
#Sélectionnez les colonnes name, lat et lon de la table airports

# Sélectionner toutes les colonnes sauf "tz" et "tzone"

airports %>% select(-tz, -tzone)

#Sélectionnez toutes les colonnes de la table flights dont les noms se terminent par “delay”.

flights %>% select(ends_with("delay"))

#Dans la table airports, renommez la colonne alt en altitude et la colonne tzone en fuseau_horaire.

airports %>%

rename(altitude = alt, fuseau_horaire = tzone)

#Exercice 5

#Créer une nouvelle variable alt_m contenant l'altitude en mètres (en divisant par 3.2808), puis
sélectionner les colonnes alt et alt_m.

airports %>%

mutate(alt_m = alt / 3.2808) %>%

select(alt, alt_m)

#Exercice 6

#Réécrire l'exercice précédent en utilisant des pipes :

airports %>%

mutate(alt_m = alt / 3.2808) %>%

select(alt, alt_m)

#(Le code est déjà en utilisant le pipe.)

#Exercice 7

#Sélectionner les vols à destination de San Francisco (SFO) et trier les résultats selon le retard au
départ (dep_delay) décroissant.

flights %>%

filter(dest == "SFO") %>%

arrange(desc(dep_delay))

#Exercice 8

#Sélectionner les vols des mois de septembre et octobre, conserver les colonnes dest et dep_delay,
créer une nouvelle variable retard_h en heures, et conserver les 5 lignes avec les plus grands retards.

flights %>%

filter(month %in% c(9, 10)) %>%

select(dest, dep_delay) %>%

mutate(retard_h = dep_delay / 60) %>%

arrange(desc(retard_h)) %>%

head(5)

#Exercice 9

#Afficher le nombre de vols par mois en utilisant group_by et summarise :

flights %>%

group_by(month) %>%

summarise(n = n())

#Exercice 10
#Trier la table résultat de l'exercice 9 selon le nombre de vols croissant :

flights %>%

group_by(month) %>%

summarise(n = n()) %>%

arrange(n)

#Exercice 11

#Calculer la distance moyenne des vols selon l’aéroport de départ (origin) :

flights %>%

group_by(origin) %>%

summarise(distance_moyenne = mean(distance, [Link] = TRUE))

#Exercice 12

#Calculer le nombre de vols à destination de Los Angeles (LAX) pour chaque mois de l’année :

flights %>%

filter(dest == "LAX") %>%

group_by(month) %>%

summarise(n = n())

#Exercice 13

#Calculer le nombre de vols selon le mois et la destination :

flights %>%

group_by(month, dest) %>%

 summarise(n = n())

#Exercice 14

#Ne conserver, pour chaque mois, que la destination avec le nombre maximal de vols :

flights %>%

group_by(month, dest) %>%

summarise(n = n()) %>%

top_n(1, n) n

#Exercice 15

#Calculer le nombre de vols selon le mois, ajouter une colonne comportant le pourcentage de vols
annuels réalisés par mois :

flights %>%

group_by(month) %>%

summarise(n = n()) %>%

mutate(pourcentage_vols = (n / sum(n)) * 100)

#Exercice 16

#Calculer, pour chaque aéroport de départ et de destination, la durée moyenne des vols (air_time),
et ne conserver que la destination avec la durée moyenne la plus longue pour chaque aéroport de
départ :

flights %>%

group_by(origin, dest) %>%

summarise(air_time_moyenne = mean(air_time, [Link] = TRUE)) %>%

group_by(origin) %>%

top_n(1, air_time_moyenne)
#Exercice 17

#Faire la jointure de la table airlines sur la table flights à l’aide de left_join :

flights %>%

left_join(airlines, by = "carrier")

#Exercice 18

#Calculer le retard moyen au départ pour chaque compagnie, et trier selon ce retard décroissant :

flights %>%

left_join(airlines, by = "carrier") %>%

group_by(carrier) %>%

summarise(retard_moyen = mean(dep_delay, [Link] = TRUE)) %>%

arrange(desc(retard_moyen))

#Exercice 19

#Faire la jointure de la table airports sur la table flights en utilisant comme clé le code de l’aéroport
de destination (dest) :

flights %>%

left_join(airports, by = c("dest" = "faa"))

#Exercice 20

#Afficher, pour chaque mois, le nom de l’aéroport de destination ayant eu le plus petit nombre de
vols :

flights %>%
 group_by(month, dest) %>%

summarise(n = n()) %>%

group_by(month) %>%

top_n(-1, n)

#Exercice 21

#Créer une table indiquant, pour chaque vol, uniquement le nom de l’aéroport de départ et celui de
l’aéroport d’arrivée :

flights %>%

select(origin, dest)

#Exercice 22

#Calculer le nombre de vols selon l’aéroport de destination, puis faire la jointure avec la table
airports en utilisant left_join :

flights %>%

group_by(dest) %>%

summarise(n = n()) %>%

left_join(airports, by = c("dest" = "faa")) %>%

rename(flights_dest = dest)
colnames(delay_columns)
tp1

# 1. Créer les vecteurs pour chaque variable

Individus <- c("Erika", "Celia", "Eric", "Eve", "Paul", "Jean", "Aden", "Louis", "Jules", "Léo")

Sexe <- c("F", "F", "G", "F", "G", "G", "G", "G", "G", "G")

ZEP <- c("O", "O", "O", "O", "N", "O", "N", "O", "O", "O")

Poids <- c(16, 14, 13.5, 15.5, 16.5, 16, 17, 14.8, 17, 16.7)

An <- c(3, 3, 3, 4, 3, 4, 3, 3, 4, 3)

Mois <- c(5, 10, 5, 0, 8, 0, 11, 9, 1, 3)

Taille <- c(100.0, 97.0, 95.5, 101.0, 100.0, 98.5, 103.0, 98.0, 101.5, 100.0)

# 2. Calculer la moyenne des variables quantitatives

moyenne_poids <- mean(Poids)

moyenne_taille <- mean(Taille)

# 3. Calculer l'IMC (Indice de Masse Corporelle) : IMC = Poids (kg) / Taille (m)^2

IMC <- Poids / (Taille / 100)^2

# 4. Regrouper les variables dans un dataframe

enfants_df <- [Link](Individus, Sexe, ZEP, Poids, An, Mois, Taille, IMC)

# 5. Tracer le nuage de points du Poids en fonction de la Taille

plot(enfants_df$Taille, enfants_df$Poids,

main = "Nuage de points : Poids en fonction de la Taille",

xlab = "Taille (cm)",

ylab = "Poids (kg)",

pch = 19, col = "blue")

===============================================

# 1. Importer le fichier [Link]

library(readxl)

pn_data <- read_excel("[Link]")

# 2. Ordonner le fichier selon les poids de naissance (BWT) croissants

pn_data_ordered <- pn_data[order(pn_data$BWT), ]

#2. Ordonner le fichier selon les poids de naissance (BWT) decroissants

pn_data_ordered <- pn_data[order(pn_data$BWT, decreasing = TRUE), ]

# 3. Extraire les individus ayant des mères noires ou blanches et qui fument

filtered_data <- subset(pn_data_ordered, (RACE == 1 | RACE == 2) & SMOKE == 1)

==================================================================================
# 1. Rentrer les valeurs dans les variables ccont et exam

ccont <- c(11, 13, 15.5, 12, 8, 9, 13, 16)

exam <- c(8.5, 7, 16, 9, 7, 13, 14, 17)

# 2. Créer un tableau « Note » à 8 lignes et 3 colonnes

Note <- [Link](

Controle_continu = ccont,

Examen = exam,

Moyenne = (ccont * 0.4) + (exam * 0.6)

# 3. Ordonner le tableau selon les moyennes croissantes

Note_ordered <- Note[order(Note$Moyenne), ]

# 4. Déterminer le nombre d’étudiants ayant validé la matière

nombre_valides <- sum(Note_ordered$Moyenne > 10)

# 5. Extraire la moyenne la plus élevée et la moyenne la plus basse

moyenne_max <- max(Note_ordered$Moyenne)

moyenne_min <- min(Note_ordered$Moyenne)

# 6. Déterminer le nombre d’étudiants dont la moyenne est supérieure à 15

nombre_sup_15 <- sum(Note_ordered$Moyenne > 15)

# 7. Exporter le tableau « Note » sur votre ordinateur sous le nom « Validation »

[Link](Note_ordered, "[Link]", [Link] = FALSE)

========================================================================================

# 1. Créer le vecteur z et le stocker dans un objet x

x <- c(1, 2, 3, 4, 5)

mode_x <- mode(x)

length_x <- length(x)

# 3. Extraire le premier élément, puis le dernier

first_element <- x[1]

last_element <- x[length(x)]

# 4. Extraire les trois premiers éléments et les stocker dans un vecteur s

s <- x[1:3]

# 5. Extraire les éléments en position 1, 3, 5 et les stocker dans un vecteur b

b <- x[c(1, 3, 5)]

# 6. Additionner le nombre 10 au vecteur x, puis multiplier le résultat par 2

x_plus_10 <- x + 10

result <- x_plus_10 * 2

# 7. Effectuer l'addition de a et b (a n'est pas défini, supposons que a est un vecteur)

# Supposons que a est un vecteur de même longueur que b

a <- c(10, 20, 30)

addition_a_b <- a + b

# 8. Effectuer l'addition suivante : x + a (a doit être de même longueur que x)

# Supposons que a est un vecteur de même longueur que x

a <- c(10, 20, 30, 40, 50)

addition_x_a <- x + a

# 9. Multiplier le vecteur x par un scalaire c (supposons c = 2)

c <- 2

x_multiplied_by_c <- x * c

# 10. Effectuer la multiplication de a et b (a et b doivent être de même longueur)

multiplication_a_b <- a * b

# 11. Effectuer la multiplication suivante : x * a (a doit être de même longueur que x)

multiplication_x_a <- x * a

# 12. Récupérer les positions des multiples de 2 et les stocker dans un vecteur nad

nad <- which(x %% 2 == 0)

(traja3 les positions)

# 13. Afficher les éléments de x qui sont multiples de 3 et multiples de 2

multiples_3_and_2 <- x[x %% 3 == 0 & x %% 2 == 0]

# 14. Afficher les éléments de x qui sont multiples de 3 ou multiples de 2

multiples_3_or_2 <- x[x %% 3 == 0 | x %% 2 == 0]

# 15. Calculer la somme des éléments de x

sum_x <- sum(x)

# 16. Remplacer le premier élément de x par un 6

x[1] <- 6

# 17. Remplacer le premier élément de x par la valeur M (supposons M = 10)

M <- 10

x[1] <- M

sum_x_after_replacement <- sum(x)

=====================================================================================================
======================

tp2

# 1. Importer le fichier

data_baby <- [Link]("data_baby.csv") # Remplacez par le chemin correct

# 2. Décrire le jeu de données

names(data_baby)

dim(data_baby)

summary()

str()

# 3. Justifier graphiquement l’existence de données aberrantes dans la variable âge

boxplot(data_baby$age, main = "Boxplot de l'âge des mères", ylab = "Âge")

# Utilisation de la méthode Isolation Forest pour détecter les anomalies

library(isotree)

iso <- [Link](data_baby$age)

anomalies <- predict(iso, data_baby$age)

data_baby$anomaly <- anomalies > 0.5 # Seuil pour détecter les anomalies

# 4. Identifier les points aberrants et remplacer par NA

data_baby$age[data_baby$anomaly] <- NA

# 5. Vérifier si toutes les variables ont bien été filtrées

colSums([Link](data_baby))

# 6. Tracer le poids de la mère en fonction du nombre de grossesses antérieures

boxplot(data_baby$weight ~ data_baby$parity,
 main = "Poids de la mère en fonction du nombre de grossesses",

xlab = "Nombre de grossesses", ylab = "Poids de la mère")

=================================================================================================

# 1. Construire le dataframe DB

DB <- [Link](

Gender = c("M", "F", "M", "M", "F", "M", NA, "M"),

Manpower = c(25.00, NA, 33.00, NA, 25.00, 29.00, 26.00, 32.00),

Sales = c(343.00, 280.00, 332.00, 272.00, NA, 326.00, 259.00, 297.00)

# 2. Calculer la moyenne de la variable Manpower pour chaque genre

mean_manpower <- aggregate(Manpower ~ Gender, DB, mean, [Link] = TRUE)

# 3. Imputer les valeurs manquantes de Manpower en utilisant la méthode « similar case imputation »

DB$Manpower[[Link](DB$Manpower) & DB$Gender == "M"] <- mean_manpower$Manpower[mean_manpower$Gender ==

"M"]

DB$Manpower[[Link](DB$Manpower) & DB$Gender == "F"] <- mean_manpower$Manpower[mean_manpower$Gender ==

"F"]

=====================================================================================================
===

# 1. Importer le fichier

library(readxl)

gazela_data <- read_excel("[Link]") # Remplacez par le chemin correct

# 2. Décrire le jeu de données

dim(gazela_data)

summary(gazela_data)

# 3. Justifier l’existence de données manquantes

colSums([Link](gazela_data))

# 4. Calculer le taux de données manquantes et proposer un scénario de gestion

taux_manquantes <- colSums([Link](gazela_data)) / nrow(gazela_data) * 100

# 5. Imputer les données manquantes pour la variable NO2

# Méthode de type « Generalized imputation » (par exemple, la moyenne)

gazela_data$NO2[[Link](gazela_data$NO2)] <- mean(gazela_data$NO2, [Link] = TRUE)

# 6. Imputer les données manquantes pour la variable SO2 avec l'algorithme KNN

library(VIM)

gazela_data <- kNN(gazela_data, variable = "SO2")

# 7. Utiliser Random Forest pour l’imputation

library(missForest)

gazela_data_imputed <- missForest(gazela_data)

# 8. Utiliser MICE pour l’imputation des NA

library(mice)

gazela_data_mice <- mice(gazela_data, method = "pmm")

gazela_data_complete <- complete(gazela_data_mice)

================================================================================================

tp2 (ranim)
#1. Importer le fichier.

baby1 <- read_table("C:/Users/hkace/OneDrive - Private Higher School of Technologies & Engineering (TEKUP)/Bureau/4
eme annee ing data science/R/R/[Link]")

#2. Décrire le jeu de données : contenu du tableau de données : nom des variables,dimension.

summary(baby1)

View(baby1)

str(baby1)

#ou bien

colnames((baby1))

dim(baby1)

#3. Justifier graphiquement l’existence de données aberrantes dans le fichier, en utilisant la variable âge. Utiliser
maintenant la méthode isolation forest.

#Isolation Forest (iForest) est une méthode d'apprentissage automatique non supervisée utilisée pour détecter les
valeurs aberrantes (outliers).

valeurs_manquantes=sum([Link](baby1)) #permet de compter le nombre total de valeurs manquantes (NA) dans le

dataframe baby.

valeurs_manquantes

par(mfrow=c(1,1))

boxplot(baby1$age)
#methode par isolation forest

# Entra?nement d'Isolation Forest

library(isotree)

iso_forest <- [Link](baby1, ntrees = 100)

iso_forest

# Pr?diction des scores d'anomalie

scores <- predict(iso_forest, baby1, type = "score")

baby1$score <- scores

# D?finir un seuil d'anomalie (ex: 80e percentile)

threshold <- quantile(scores, 0.90) #On utilise le 90e percentile (0.90), ce qui signifie que les 10% des observations avec les
scores les plus élevés seront considérées comme des anomalies.

baby1$prediction <- ifelse(baby1$score > threshold, "Anomalie", "Normal")

baby1$prediction

table(baby1$prediction)

#4. Identifier les points aberrants (on s’intéresse à la variable âge) et remplacer la valeur aberrante par NA. r

Q1 <- quantile(baby1$age, 0.25, [Link] = TRUE) # Premier quartile (25%)

Q3 <- quantile(baby1$age, 0.75, [Link] = TRUE) # Troisième quartile (75%)

IQR <- Q3 - Q1 # Intervalle interquartile

# Définition des limites des valeurs normales

lower_bound <- Q1 - 1.5 * IQR

upper_bound <- Q3 + 1.5 * IQR

# Remplacement des valeurs aberrantes par NA

baby1$age[baby1$age < lower_bound | baby1$age > upper_bound] <- NA

# Vérifier les valeurs après remplacement

summary(baby1$age)

View(baby1)

#exercice2
#1

gender<-c("M","F","M","M","F","M",NA,"M")

Manpower<-c(25.00,NA,33.00,NA,25.00,29.00,26.00,32.00)

Sales<-c(343.00,280.00,332.00,272.00,NA,326.00,259.00,297.00)

data<-[Link](gender,Manpower,Sales)

data

#2

aggregate(Manpower ~ gender, data = data, FUN = mean, [Link] = TRUE)

# Calculer la moyenne de Manpower pour chaque genre avec aggregate

# Filtrer les données pour les individus de genre masculin

male_data <- data[data$gender == 'M', ]

# Calculer la moyenne de 'Manpower' pour les individus de genre masculin

mean_male <- mean(male_data$Manpower, [Link] = TRUE)

mean_male

# Filtrer les données pour les individus de genre féminin

female_data <- data[data$gender == 'F', ]

# Calculer la moyenne de 'Manpower' pour les individus de genre féminin

mean_female <- mean(female_data$Manpower, [Link] = TRUE)

mean_female

# Filtrer les données pour les individus de genre masculin

male_data <- data[data$gender == 'M', ]

# Calculer la moyenne de 'Manpower' pour les individus de genre masculin

#3 imputer

# L'imputation est une technique utilisée en analyse de données pour remplacer les valeurs manquantes (NA) par des
estimations raisonnables afin d'éviter la perte d'information et améliorer la qualité des analyses.

# 1.1 Remplacement par une valeur fixe

#df$colonne[[Link](df$colonne)] <- 0 # Remplacement par 0

#df$colonne[[Link](df$colonne)] <- mean(df$colonne, [Link] = TRUE) # Par la moyenne

#df$colonne[[Link](df$colonne)] <- median(df$colonne, [Link] = TRUE) # Par la médiane

#1.2 Suppression des valeurs manquantes

#df_sans_na <- [Link](df) # Supprime toutes les lignes avec au moins un NA

#1.3 Imputation avec mice (Multivariate Imputation by Chained Equations)

#Imputation avancée prenant en compte plusieurs variables.

#estimation intelligent selon les valeurs lo5ren

#library(mice)

#df_impute <- mice(df, method = "pmm", m = 5) # Predictive Mean Matching

#df_complet <- complete(df_impute, 1) # Sélection du premier jeu de données imput

#1.4 Imputation avec missForest (Random Forest)

#Prédiction des valeurs manquantes avec un modèle de Random Forest(machine leaning)

#library(missForest)

#df_impute <- missForest(df)

#df_complet <- df_impute$ximp

#1.5 Imputation par KNN (K-Nearest Neighbors)

#Remplace les NA en utilisant les valeurs des k plus proches voisins.

#library(DMwR)

#df_impute <- knnImputation(df, k = 5)

#1.3 Imputation avec mice (Multivariate Imputation by Chained Equations)

# Pour chaque colonne avec des valeurs manquantes, mice utilise les autres colonnes pour faire une estimation
intelligente.

[Link]("mice")

library(mice)

# Imputation avec Predictive Mean Matching (pmm)

data_impute <- mice(data, method = "pmm", m = 5)

data_impute

#1.4 Imputation avec missForest (Random Forest)

#Prédiction des valeurs manquantes avec un modèle de Random Forest.

library(missForest)

# Convertir gender en facteur si ce n'est pas déjà fait

data$gender <- factor(data$gender)

# Imputer les données avec missForest

data_impute2 <- missForest(data)

data_impute2

# Extraire la colonne 'gender' de la version imputée

data_complet <- data_impute$ximp$gender

data_complet

#1.5 Imputation par KNN (K-Nearest Neighbors)

#Remplace les NA en utilisant les valeurs des k plus proches voisins.

[Link]("VIM")

library(VIM)

data

# Imputation par KNN avec k=5

data_impute <- KNN(data,"gender", k = 5)

#exercice3

#1. Importer le fichier

library(readr)

gazelle <- read_delim("C:/Users/hkace/OneDrive - Private Higher School of Technologies & Engineering (TEKUP)/Bureau/4
eme annee ing data science/R/R/[Link]",

delim = ";", escape_double = FALSE, trim_ws = TRUE)

View(gazelle)

#2. Décrire le jeu de données : dimension, descriptif des variables et résumé statistique

summary(gazelle)

str(gazelle)

#3. Justifier l’existence de données manquantes dans le fichier

sum([Link](gazelle))

colSums([Link](gazelle))

#4. Calculer le taux de données manquantes. Proposer alors un scénario de gestion.

sum([Link](gazelle))/prod((dim(gazelle)))

dim(gazelle)

prod((dim(gazelle)))

12*16965

#Supprimer les lignes ou colonnes avec trop de NA

#Si le taux de NA est faible (< 5%), on peut supprimer les lignes concernées :

#df_clean <- [Link](df) # Supprime toutes les lignes avec des NA

#Imputation des valeurs manquantes Si les NA sont significatifs, on peut remplacer les valeurs manquantes par des
estimations

#5. Dans un premier lieu, on essayera d’imputer les données manquantes pour la variable NO2

colSums([Link](gazelle)) / nrow(gazelle) * 100

#sitaux<=0.05 on peux le supprimer avec omit na

#mputation avec la m?diane pour NO2

gazelle$NO2[[Link](gazelle$NO2)] <- median(gazelle$NO2, [Link] = TRUE)

colSums([Link](gazelle))

# 4. Imputation avec KNN pour SO2

library(VIM)

df_knn <- kNN(gazelle, variable = "SO2", k = 5)

df_knn

colSums([Link](gazelle)) / nrow(gazelle) * 100

# Imputer les données avec missForest

#Prédiction des valeurs manquantes avec un modèle de Random Forest.

library(missForest)

# Convertir gender en facteur si ce n'est pas déjà fait

#gazelle$SO2_imp <- factor(gazelle$SO2_imp)

#gazelle$TEMPS <- [Link](gazelle)

# 5. Imputation avec Random Forest

df_rf<- missForest(gazelle[, -1]) # On enl?ve la colonne date car elle n'est pas imputable

gazelle[, -1] <- df_rf$ximp # Remplacement des valeurs imput?es

#7

[Link]("mice") # Installer MICE si ce n'est pas déjà fait

library(mice) # Charger la librairie

colSums([Link](gazelle)) # Affiche le nombre de NA par colonne

# Appliquer MICE avec 5 imputations

imputation <- mice(gazelle, method = "pmm", m = 5)

# Voir un résumé des valeurs imputées

summary(imputation)

df_impute <- complete(imputation) # Convertir les données imputées en dataset final

=====================================================================================================
===========

test:

Voici comment accomplir chaque étape en R :

1. Importer le dataset

Si ton fichier est un Excel, utilise :

library(readxl)

df <- read_excel("chemin/vers/ton_fichier.xlsx")

Si c'est un CSV :

df <- [Link]("chemin/vers/ton_fichier.csv", header = TRUE, sep = ",")

2. Décrire le jeu de données

Dimensions du dataset :

dim(df) # Nombre de lignes et colonnes

Description des variables :

str(df) # Type des variables

summary(df) # Statistiques descriptives

3. Justifier l’existence de données manquantes

Méthode 1 : Vérifier les valeurs NA

sum([Link](df)) # Nombre total de NA

colSums([Link](df)) # Nombre de NA par colonne

Méthode 2 : Visualiser les valeurs manquantes

library(VIM)

aggr(df, col=c("navyblue", "red"), numbers=TRUE, sortVars=TRUE, labels=names(df))

4. Détection et traitement des valeurs aberrantes

Méthode : Utilisation des Boxplots

boxplot(df$SO2, main="Boxplot de SO2", col="lightblue")

Détection avec IQR

Q1 <- quantile(df$SO2, 0.25, [Link]=TRUE)

Q3 <- quantile(df$SO2, 0.75, [Link]=TRUE)

IQR <- Q3 - Q1

seuil_bas <- Q1 - 1.5 * IQR

seuil_haut <- Q3 + 1.5 * IQR

valeurs_aberrantes <- df$SO2 < seuil_bas | df$SO2 > seuil_haut

df[valeurs_aberrantes, "SO2"] <- NA # Convertir en NA

5. Calcul du taux de données manquantes

taux_na <- sum([Link](df)) / prod(dim(df))

print(taux_na)

Scénario de traitement :

Suppression : Si trop de NA dans une colonne → df <- df[ , colSums([Link](df)) < seuil]

Imputation : Remplacer par la moyenne/médiane ou une méthode avancée.

6. Convertir une valeur aberrante en NA

Déjà fait en étape 4, on a remplacé les valeurs aberrantes par NA.

7. Imputation des NA

Pour SO2 : remplacer les NA par la moyenne

df$SO2[[Link](df$SO2)] <- mean(df$SO2, [Link] = TRUE)

Pour SR : Imputation avec KNN et Random Forest

library(VIM)

df_knn <- kNN(df, variable = "SR", k = 5)

library(missForest)

df_rf <- missForest(df)$ximp # Imputation avec Random Forest

8. Normalisation de SO2

Méthode Min-Max

df$SO2_minmax <- (df$SO2 - min(df$SO2)) / (max(df$SO2) - min(df$SO2))

Méthode Z-score (Standardisation)

df$SO2_zscore <- (df$SO2 - mean(df$SO2)) / sd(df$SO2)

9. Ajouter une variable qualitative POP1 avec des valeurs aléatoires

[Link](123)

df$POP1 <- sample(c("M1", "M2", "M3", "M4", NA), size = nrow(df), replace = TRUE, prob = c(0.225, 0.225, 0.225, 0.225,
0.1))

10. Imputation des NA de POP1

df$POP1[[Link](df$POP1)] <- [Link](names(sort(table(df$POP1), decreasing = TRUE))[1])

On remplace les NA par la modalité la plus fréquente.

Pour vérifier en détail chaque question et s'assurer que les réponses sont
correctes, nous allons examiner chaque point avec plus de précision. Voici
une vérification détaillée des réponses :

Section A

1. Charger et visualiser la base de données hdv2003 :

Copy

library(questionr)
db <- hdv2003
o Cette commande charge la base de données hdv2003 du
package questionr et la stocke dans la variable db.
2. Lister les noms des variables :
names(db)
o Cette commande affiche les noms de toutes les colonnes
(variables) dans le dataframe db.
3. Calculer la moyenne et la médiane de la variable [Link] :
mean(db$[Link], [Link] = TRUE)
median(db$[Link], [Link] = TRUE)
o [Link] = TRUE est utilisé pour
ignorer les valeurs manquantes
lors du calcul.
4. Changer les noms des variables bricol et occup :
names(db)[names(db) == "bricol"] <- "bricolage"
names(db)[names(db) == "occup"] <- "occupation"
o Cette commande renomme les
colonnes bricol en bricolage et occup en occupation.
5. Convertir [Link] en variable qualitative :
db$[Link] <- [Link](db$[Link])
o Cette commande convertit la variable
numérique [Link] en une variable qualitative (facteur).
6. Déterminer les modalités de la variable qualif :
levels(db$qualif)
o Cette commande affiche les niveaux (modalités) de la
variable qualif.
7. Changer la modalité « ouvrier specialise » en « ouvrier » :
levels(db$qualif)[levels(db$qualif) == "ouvrier specialise"] <- "ouvrier"
o Cette commande remplace la modalité "ouvrier specialise" par
"ouvrier".
8. Regrouper les modalités :
levels(db$qualif)[levels(db$qualif) %in% c("ouvrier specialise", "ouvrier qualifié")]
<- "ouvrier"
levels(db$qualif)[levels(db$qualif) %in% c("technicien", "profession
intermédiaire")] <- "intern"
o Cette commande regroupe les modalités spécifiées sous un
seul nom.
9. Imputer les valeurs manquantes de [Link] :
 # Méthode 1 : Remplacer par la moyenne
db$[Link][[Link](db$[Link])] <- mean(db$[Link], [Link] = TRUE)

# Méthode 2 : Remplacer par la médiane

db$[Link][[Link](db$[Link])] <- median(db$[Link], [Link] = TRUE)
o Ces commandes remplacent les valeurs manquantes par la
moyenne ou la médiane.

Section B

10. Créer la matrice A :

A <- matrix(c(-2, 2, -1, 0, 1, 5, -4, 3, 0), nrow=3, byrow=TRUE)
dim(A)
ncol(A)
nrow(A)
length(A)
A[, 3]
A[2, ]
A[2, 1]
A[2:3, 2:3]
o Ces commandes créent la matrice A et effectuent les
opérations demandées.

Section C

11. Reconstruire la colonne code_insec :

db$code_insec <- paste0(db$code_departement, db$code_commune)
o Cette commande concatène les
colonnes code_departement et code_commune pour
créer code_insec.
12. Remplacer la première valeur de pop_tot par NA :
db$pop_tot[1] <- NA
o Cette commande remplace la première valeur
de pop_tot par NA.
13. Remplacer la dernière valeur de pop_tot :
db$pop_tot[nrow(db)] <- 2513131313
o Cette commande remplace la dernière valeur
de pop_tot par 2513131313.
14. Afficher les valeurs manquantes et aberrantes :
[Link](db$pop_tot)
db$pop_tot[db$pop_tot > 1000000]
o Ces commandes identifient les valeurs manquantes et
aberrantes.
15. Faire un graphique pour justifier la valeur aberrante :
boxplot(db$pop_tot, main="Boxplot de pop_tot")
o Cette commande crée un boxplot pour visualiser les valeurs
aberrantes.
16. Remplacer la valeur manquante en ignorant la valeur
réelle 14204 :
# Méthode 1 : Remplacer par la moyenne
db$pop_tot[[Link](db$pop_tot)] <- mean(db$pop_tot, [Link] = TRUE)
 # Méthode 2 : Remplacer par la médiane
db$pop_tot[[Link](db$pop_tot)] <- median(db$pop_tot, [Link] = TRUE)
o Ces commandes remplacent les valeurs manquantes par la
moyenne ou la médiane.
17. Créer et afficher les tableaux et faire une jointure :
Tab1 <- [Link](Etudiant = c("salah", "ramzi", "ali", "sami", "khaled"),
Marque_du_PC = c("D", "Mac", "L", "A", "H"))
Tab2 <- [Link](Marque_du_PC = c("D", "Mac", "L", "A", "H"), Processor = c(2,
12, 4, 3, 1))
merge(Tab1, Tab2, by="Marque_du_PC")
o Ces commandes créent les tableaux et effectuent une jointure.

Section D

18. Vols avec un retard d’arrivée de deux heures ou plus :

library(nycflights13)
flights[flights$arr_delay >= 120, ]
o Cette commande filtre les vols avec un retard d'arrivée de
deux heures ou plus.
19. Vols pour Houston (IAH ou HOU) :
flights[flights$dest %in% c("IAH", "HOU"), ]
o Cette commande filtre les vols
à destination de Houston.
20. Vols assurés par United, American, ou Delta :
flights[flights$carrier %in% c("UA", "AA", "DL"), ]
o Cette commande filtre les vols assurés par les compagnies
spécifiées.
21. Vols en été (juillet, août, septembre) :
flights[flights$month %in% 7:9, ]
o Cette commande filtre les vols ayant eu lieu en été.
22. Vols arrivés en retard de plus de 2 heures :
flights[flights$arr_delay > 120, ]
o Cette commande filtre les vols arrivés avec plus de deux
heures de retard.
Pour corriger cet examen de programmation R avec tous les détails, nous
allons passer en revue chaque question et fournir des réponses
appropriées. Voici les corrections pour chaque section :

QS. Contrôle du comportement des bouts de code dans un

document Markdown

Les options qui peuvent être utilisées pour contrôler le comportement des
bouts de code dans un document Markdown sont :
 1. "echo" : Affiche le code dans le document.

2. "message" : Affiche les messages générés par le code.

3. "eval" : Exécute le code.

4. "warning" : Affiche les avertissements générés par le code.

Exercice 1 : Utilisation du jeu de données 'diamonds'

1. Importer les librairies nécessaires :

library(ggplot2)
library(dplyr)
2. Sélectionnez les 5 premières lignes du jeu de données :
head(diamonds, 5)
3. Sélectionnez le diamant avec la plus grande table :
diamonds %>% arrange(desc(table)) %>% head(1)
4. Sélectionnez les colonnes 'carat', 'cut', 'color' et 'price' :
diamonds %>% select(carat, cut, color, price)
5. Sélectionnez les diamants avec un poids strictement
supérieur à 2 et une coupe de qualité « ideal »
diamonds %>% filter(carat > 2 & cut == "Ideal")
6. Créer un nouvel attribut « price_per_carat » :
diamonds <- diamonds %>% mutate(price_per_carat = price / carat)
7. Sélectionnez les colonnes 'carat', 'cut', 'color', 'price' et
'depth', ensuite calculez la nouvelle colonne prix par
profondeur 'price_per_depth' :
diamonds %>% filter(cut == "Premium") %>% select(carat, cut, color, price,
depth) %>% mutate(price_per_depth = price / depth) %>% head(3)
8. Faire un nuage de points croisant le prix et le poids 'carat' :
ggplot(diamonds, aes(x = carat, y = price, color = cut)) + geom_point()
9. Faire un box plot représentant la répartition des prix selon la
qualité de la coupe 'cut' :
ggplot(diamonds, aes(x = cut, y = price)) + geom_boxplot()

Questionnaire

Q1. Affirmations correctes sur 'markdown' :

1. 'markdown' permet d’embarquer du code R et le résultat de
l’exécution dans un document. (Correct)

2. Un document 'markdown' peut inclure des bouts de code

d’autres langages de programmation comme « Python
». (Correct)

Q2. Affirmations incorrectes sur 'flexdashboard' :

2. Il faut utiliser le package 'shiny' pour faire fonctionner
'flexdashboard'. (Incorrect)
 3. Un tableau de bord 'flexdashboard' est contraint en utilisant
un script R. (Incorrect)

Q3. Affirmations correctes sur 'shinydashboard' :

1. Le package 'shinydashboard' offre des fonctions qui
permettent de créer des dashboards avec un « sidebar
layout ». (Correct)

2. Le package 'shinydashboard' doit être utilisé avec le

package 'shiny'. (Correct)

Q4. Formats qui ne peuvent pas être générés par 'markdown' :

4. Excel (Incorrect)

5. Word (Incorrect)

Exercice 2 : Script R avec 'Shiny'

library(shiny)

ui <- fluidPage(
titlePanel("Histogramme du jeu de données MTCARS"),
sidebarLayout(
sidebarPanel(
selectInput("variable", "Choisis une variable:", choices = names(mtcars)),
sliderInput("bins", "Nombre de bars:", min = 1, max = 50, value = 10)
),
mainPanel(
plotOutput("histPlot")
)
)
)

server <- function(input, output) {

output$histPlot <- renderPlot({
data <- mtcars[[input$variable]]
hist(data, breaks = input$bins, col = 'darkblue', border = 'white',
main = paste('Histogramme de la variable', input$variable))
})
}

shinyApp(ui = ui, server = server)

Exercice 3 : Tableau de bord avec 'flexdashboard'

library(flexdashboard)
library(DT)
library(dplyr)
library(ggplot2)

# Exemple de données
data <- [Link](
year = c(2011, 2021, 2022, 2032, 2040, 2052),
month = c(1, 1, 1, 1, 1, 1),
day = c(50, 50, 50, 50, 50, 50),
 school_day_time = c(525, 500, 500, 500, 500, 500)
)

# Tableau de bord
flex_dashboard(
title = "Tableau de bord",
sidebar = sidebar(
selectInput("year", "Année:", choices = unique(data$year))
),
body = body(
fluidRow(
box(plotOutput("histPlot")),
box(dataTableOutput("table"))
)
)
)

server <- function(input, output) {

output$histPlot <- renderPlot({
filtered_data <- data %>% filter(year == input$year)
ggplot(filtered_data, aes(x = month, y = school_day_time)) + geom_bar(stat =
"identity")
})

output$table <- renderDataTable({

data %>% filter(year == input$year))
})
}

shinyApp(ui = ui, server = server)