Genie logiciel bts 2024
Thème :
Junior
2 vues ·4/4 leçons

Voici la correction complète et détaillée de l’Épreuve 2 : Programmation (Session 2024). Comme pour les autres, j’ai structuré chaque réponse avec l’Explication Technique et la Méthodologie pour vous aider à comprendre la logique derrière le code.

CORRIGÉ : ÉPREUVE 2 - PROGRAMMATION (SESSION 2024)

PARTIE 1 : PROGRAMMATION STRUCTURÉE (Langage C)

EXERCICE I (2.5 pts)

1. Structure d’un programme en langage C : Un programme C suit généralement cet ordre :

  1. Directives de préprocesseur (#include <stdio.h>)
  2. Déclarations de fonctions globales (prototypes)
  3. Fonction principale main()
  4. Corps de la fonction (déclarations de variables et instructions)
  5. Retour de la fonction (return 0;)

2. Nature des instructions : int i; et char x; sont des instructions de déclaration de variables.

3. Explication :

  • int i; : Réserve un espace en mémoire pour stocker un nombre entier et nomme cet espace i.
  • char x; : Réserve un espace en mémoire pour stocker un caractère (ASCII) et nomme cet espace x.

4. Instructions de lecture et d’écriture :

  • Lecture : scanf()
  • Écriture : printf()

💡 Méthodologie : En C, tout commence par l’inclusion de bibliothèques. Retenez bien que pour chaque type de donnée, il existe un spécificateur de format (%d pour int, %c pour char, %f pour float).

EXERCICE II (2.5 pts)

1. Programme avec la boucle while :

#include <stdio.h>

void main() {
    int i = 0, n, som = 0; // Initialisation de i à 0
    
    while (i < 4) { // Condition de la boucle
        printf("donner un entier : ");
        scanf("%d", &n);
        som += n;
        i++; // Incrémentation cruciale pour éviter une boucle infinie
    }
    
    printf("somme : %d\n", som);
}

2. Explication du programme : Ce programme est un accumulateur. Il demande à l’utilisateur de saisir 4 nombres entiers un par un, calcule la somme de ces nombres au fur et à mesure, puis affiche le résultat total à la fin.

🛠️ Technique de résolution : La conversion d’une boucle for en while demande toujours trois étapes :

  1. L’initialisation (avant la boucle).
  2. La condition (dans la parenthèse du while).
  3. L’incrémentation (à l’intérieur du corps de la boucle).

PARTIE 2 : PROGRAMMATION ORIENTÉE OBJET (C++)

1. Déclaration de la classe (Fichier Point.h)

class Point {
private:
    float x, y; // Attributs privés

public:
    // Constructeur
    Point(float x0, float y0);
    
    // Méthodes
    void deplacer(float dx, float dy);
    void affiche();
};

2. Définition de la classe (Fichier Point.cpp)

#include "Point.h"
#include <iostream>
using namespace std;

// Définition du constructeur
Point::Point(float x0, float y0) {
    x = x0;
    y = y0;
}

// Définition de la méthode deplacer
void Point::deplacer(float dx, float dy) {
    x += dx;
    y += dy;
}

// Définition de la méthode affiche
void Point::affiche() {
    cout << "Coordonnées : (" << x << ", " << y << ")" << endl;
}

3. Programme d’essai (Fichier main.cpp)

#include "Point.h"

int main() {
    // Déclaration et initialisation
    Point p(10.5, 20.0);
    
    // Affichage initial
    p.affiche();
    
    // Déplacement
    p.deplacer(5.0, -2.5);
    
    // Nouvel affichage
    p.affiche();
    
    return 0;
}

💡 Rappel de cours (Encapsulation) : On met les attributs (x, y) en private pour empêcher une modification directe et accidentelle depuis l’extérieur. On passe obligatoirement par des méthodes public (le constructeur et les fonctions membres) pour manipuler l’objet.

PARTIE 3 : PROGRAMMATION WEB (HTML / PHP)

EXERCICE I (HTML) a) Structure : <!DOCTYPE html><html><head><title></title></head><body></body></html>
b) Script :

<!DOCTYPE html>
<html>
<head>
    <title>salutation</title>
</head>
<body>
    <b>Bonjour Monsieur</b>
</body>
</html>

EXERCICE II (Variables PHP) Les noms valides sont : mavar, $_mavar, $_élément1.

  • $mavar5 est valide (mais souvent les règles strictes déconseillent les chiffres juste après le nom, toutefois en PHP pur c’est accepté).
  • $_5var est INVALIDE (un nom de variable ne peut pas commencer par un chiffre après le $).
  • $hotel4* est INVALIDE (le caractère * est interdit).

EXERCICE III (PHP Conditionnel)

if ($sexe == "féminin" && $age >= 21 && $age <= 40) {
    echo "Bienvenue à vous !";
}

PARTIE 4 : PROGRAMMATION POUR TERMINAUX MOBILES (ANDROID)

1. Entête de la méthode (Java) : L’attribut android:onClick="recherche" appelle une méthode qui doit impérativement recevoir un objet View en paramètre.

public void recherche(View v) {
    // Code du comportement ici
}

2. Élément EditText : Il permet à l’utilisateur de saisir du texte au clavier.

3. Attribut de couleur : android:textColor

4. Instruction findViewById : Elle permet de faire le lien entre l’élément graphique défini dans le fichier XML et l’objet que l’on va manipuler dans le code Java (on “récupère” la référence de l’objet).

5. Identifiant XML : @+id/bRecherche

6. Type de l’élément : Button (Bouton)

🚀 Méthodologie Android : Retenez toujours le cycle :

  1. Définir l’interface en XML (avec un ID).
  2. Lier l’interface au code Java/Kotlin via findViewById.
  3. Programmer l’action (ex: onClick).

CORRIGÉ : ÉPREUVE 3 - RÉSEAUX ET ADMINISTRATION SYSTÈME (SESSION 2024)

PARTIE A : RÉSEAU INFORMATIQUE ET TÉLÉINFORMATIQUE (7 pts)

Section 1 : Base du réseau et protocole

1) Calculs de débit et transit :

  • Nombre de bits en transit sur le bus :

    • Méthodologie : Le nombre de bits en transit est le produit du temps de propagation et du débit du réseau.
    • Calcul du temps de propagation ($T_{prop}$) : $\text{Distance} / \text{Vitesse} = 800\text{m} / 200\text{m}/\mu\text{s} = 4 \mu\text{s}$.
    • Débit ($D$) : $10\text{ Mb/s} = 10\text{ bits}/\mu\text{s}$.
    • Résultat : $4 \mu\text{s} \times 10\text{ bits}/\mu\text{s} = \mathbf{40 \text{ bits}}$.

  • Débit efficace du réseau :

    • Méthodologie : Le débit efficace est le débit réel de données utiles. On soustrait l’en-tête (overhead) de la trame totale.
    • Données utiles par trame : $256 \text{ bits (total)} - 48 \text{ bits (service)} = 208 \text{ bits}$.
    • Ratio d’efficacité : $208 / 256 = 0,8125$.
    • Résultat : $10\text{ Mb/s} \times 0,8125 = \mathbf{8,125 \text{ Mb/s}}$.

2) Longueur minimale de la trame (CSMA/CD) :

  • Méthodologie : Pour que la détection de collision fonctionne, la trame doit être assez longue pour que l’émetteur soit encore en train de transmettre quand l’écho de la collision revient. La formule est $L \ge 2 \times T_{prop} \times \text{Capacité}$.
  • Calcul de $T_{prop}$ : $D / V = 2,5\text{ km} / 100,000\text{ km/s} = 0,000025\text{ s}$ (soit $25 \mu\text{s}$).
  • Calcul de $L$ : $2 \times 25 \mu\text{s} \times 10\text{ Mb/s} = 50 \mu\text{s} \times 10,000,000\text{ bits/s} = \mathbf{500 \text{ bits}}$.

Section 2 : Services réseau

a) Définitions :

  • Transpac : Réseau de commutation de paquets (historiquement X.25) permettant d’acheminer des données via des nœuds intermédiaires.
  • Client/Serveur : Architecture où des clients demandent des ressources et un serveur centralisé les fournit.

b) Éléments de connexion Internet : Un modem/routeur, un abonnement chez un Fournisseur d’Accès Internet (FAI), une carte réseau (NIC), et des protocoles (TCP/IP).

c) Équipements d’interconnexion et couches OSI :

  • Hub / Répéteur : Couche 1 (Physique).
  • Switch (Commutateur) : Couche 2 (Liaison de données).
  • Routeur : Couche 3 (Réseau).

PARTIE B : ADMINISTRATION RÉSEAUX ET SÉCURITÉ (3 pts)

  1. Rôle de l’administrateur : Garantir la disponibilité, la sécurité, la performance et l’intégrité du réseau et des ressources informatiques.
  2. Les 3 modèles d’administration :
    • Gestion des fautes/performances (ex: protocole SNMP).
    • Gestion de la configuration (gestion des équipements).
    • Gestion de la sécurité (contrôle des accès).
  3. Commande ping : Sert à tester la connectivité IP entre deux machines via l’envoi de messages ICMP.

PARTIE C : ADMINISTRATION SYSTÈME (4 pts)

  1. Windows pour virtualisation : Windows Server (avec rôle Hyper-V). Pourquoi ? Pour sa capacité à gérer des ressources massives et son intégration avec l’Active Directory.
  2. Schéma de licence : Serveur gestionnaire de clés (KMS). Pourquoi ? Pour permettre l’activation automatique et centralisée des 275 postes sans intervention manuelle.
  3. Virtualisation :
    • Avantages : Consolidation du matériel, économie d’énergie, isolation des services.
    • Limites : Complexité de gestion, dépendance totale à l’hôte physique.
  4. Installation Complète vs Minimale : La complète inclut l’interface graphique et tous les outils ; la minimale (Core) n’inclut que le strict nécessaire pour réduire la consommation de RAM et la surface d’attaque.
  5. SWAP : Espace d’échange sur le disque dur utilisé par le système pour étendre la mémoire vive (RAM) quand celle-ci est saturée.
  6. Corbeille Windows : Zone de stockage temporaire permettant de restaurer des fichiers supprimés par erreur.
  7. Commandes Linux : ps (liste les processus), kill (arrête un processus), jobs (liste les tâches en cours), top (moniteur de ressources en temps réel).

PARTIE D : ÉTUDE DE CAS (PAGING) (6 pts)

Données : Page = 256 mots. Table des pages (P1) :

  • Page 0 $\rightarrow$ Cadre 011 (3), Présence: Oui
  • Page 1 $\rightarrow$ Cadre 001 (1), Présence: Non
  • Page 2 $\rightarrow$ Cadre 000 (0), Présence: Oui
  • Page 3 $\rightarrow$ Cadre 010 (2), Présence: Non
  • Page 4 $\rightarrow$ Cadre 100 (4), Présence: Non
  • Page 5 $\rightarrow$ Cadre 111 (7), Présence: Non
  • Page 6 $\rightarrow$ Cadre 101 (5), Présence: Oui
  • Page 7 $\rightarrow$ Cadre 110 (6), Présence: Non

1) Taille de l’espace d’adressage :

  • 8 pages $\times$ 256 mots = 2048 mots.

2) Mémoire vive (RAM) disponible :

  • Il y a 8 cadres différents listés (0 à 7).
  • $8 \text{ cadres} \times 256 \text{ mots} = \mathbf{2048 \text{ mots}}$.

3) Calcul des adresses réelles :

  • Méthode : $\text{Adresse réelle} = (\text{Cadre} \times 256) + \text{Déplacement}$ (ou $R = \text{Cadre} \ll 8 + \text{déplacement}$).
  • 240 : Page 0 (car $240 < 256$). Cadre 3. $\rightarrow (3 \times 256) + 240 = \mathbf{1008}$.
  • 546 : Page 2 ($546 // 256 = 2$). Cadre 0. $\rightarrow (0 \times 256) + (546 \pmod{256}) = \mathbf{34}$.
  • 1578 : Page 6 ($1578 // 256 = 6$). Cadre 5. $\rightarrow (5 \times 256) + (1578 \pmod{256}) = 1280 + 54 = \mathbf{1334}$.
  • 2072 : Page 8 ($2072 // 256 = 8$). ERREUR (La page 8 n’existe pas dans l’espace d’adressage de 8 pages).

4) Adresse virtuelle 770 :

  • $770 // 256 = 3$. La page 3 est consultée.
  • Dans la table, la présence de la page 3 est “non”.
  • Résultat : Il y a un Défaut de page (Page Fault).

5) Conversion Adresse Virtuelle $\rightarrow$ Physique :

  • Virtuelle : 0000 0000 0000 0111
  • Numéro de page (4 bits poids fort) : 0000 (Page 0).
  • Déplacement (12 bits) : 0000 0000 0111 (7).
  • Cadre de la Page 0 (selon table) : 011.
  • Adresse Physique (Binaire) : 011 0000 0000 0111.

6) Cycle de vie d’un processus : Nouveau (New) $\rightarrow$ Prêt (Ready) $\rightarrow$ Élu/En exécution (Running) $\rightarrow$ En attente (Waiting/Blocked) $\rightarrow$ Terminé (Terminated).

Leçon précédente

ÉPREUVE 1 : ALGORITHMIQUE ET STRUCTURE DE DONNÉES (2024)

Prêt à passer à la suite ?

Vous avez terminé cette leçon sur CORRIGÉ : ÉPREUVE 2 - PROGRAMMATION (SESSION 2024). Continuez votre apprentissage avec la prochaine leçon ou explorez d'autres formations.

Explorer toutes les formations