Ce document résume les résultats des tests informatiques effectués le 2 mars, couvrant divers problèmes de programmation et leurs solutions.
Ce problème consistait à inverser l'ordre des éléments d'un tableau. La solution implémente une simple inversion de la boucle d'itération pour lire et afficher les éléments dans l'ordre inverse.
Solution :
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
int taille;
std::cin >> taille;
std::vector<int> elements(taille);
for (int i = 0; i < taille; ++i) {
std::cin >> elements[i];
}
for (int i = taille - 1; i >= 0; --i) {
std::cout << elements[i] << " ";
}
std::cout << std::endl;
return 0;
}
L'objectif était de déterminer la valeur maximale et minimale dans un ensemble de nombres. Bien qu'une apprcohe par tournoi soit possible, la solution a utilisé la fonction de tri standard pour identifier rapidement ces valeurs.
Solution :
#include <iostream>
#include <vector>
#include <algorithm>
// Comparateur pour le tri décroissant
bool comparerDecroissant(int a, int b) {
return a > b;
}
// Comparateur pour le tri croissant
bool comparerCroissant(int a, int b) {
return a < b;
}
int main() {
int nombreElements;
std::cin >> nombreElements;
std::vector<int> valeurs(nombreElements);
for (int i = 0; i < nombreElements; ++i) {
std::cin >> valeurs[i];
}
// Trouver le maximum
std::sort(valeurs.begin(), valeurs.end(), comparerDecroissant);
std::cout << "Maximum: " << valeurs[0] << std::endl;
// Trouver le minimum
std::sort(valeurs.begin(), valeurs.end(), comparerCroissant);
std::cout << "Minimum: " << valeurs[0] << std::endl;
return 0;
}
Ce problème impliquait l'identification de nombres qui sont strictement supérieurs à leurs voisins immédiats. La solution consiste à parcourir le tableau avec une boucle et à utiliser des conditions if pour vérifier cette propriété.
Solution :
#include <iostream>
#include <vector>
int main() {
int taille;
std::cin >> taille;
std::vector<int> nombres(taille);
for (int i = 0; i < taille; ++i) {
std::cin >> nombres[i];
}
// Vérifier les éléments internes (excluant les bornes)
for (int i = 1; i < taille - 1; ++i) {
if (nombres[i] > nombres[i - 1] && nombres[i] > nombres[i + 1]) {
std::cout << nombres[i] << std::endl;
}
}
return 0;
}
Ce problème concerne la manipulation d'une matrice carrée 5x5. La solution utilise un tableau auxiliaire pour stocker temporairement une ligne lors de l'échange de deux lignes spécifiées par l'utilisateur.
Solution :
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
const int DIMENSION = 5;
std::vector<std::vector<int> > matrice(DIMENSION, std::vector<int>(DIMENSION));
// Lecture de la matrice
for (int i = 0; i < DIMENSION; ++i) {
for (int j = 0; j < DIMENSION; ++j) {
std::cin >> matrice[i][j];
}
}
int ligne1, ligne2;
std::cin >> ligne1 >> ligne2;
// Ajustement des indices pour être basés sur 0
--ligne1;
--ligne2;
// Échange des lignes
std::swap(matrice[ligne1], matrice[ligne2]);
// Affichage de la matrice modifiée
for (int i = 0; i < DIMENSION; ++i) {
for (int j = 0; j < DIMENSION; ++j) {
std::cout << matrice[i][j] << " ";
}
std::cout << std::endl;
}
return 0;
}
Ce problème demandait de séparer une liste de nombres en deux groupes : les nombres pairs et les nombres impairs. La solution utilise une boucle pour parcourir les nombres et les placer dans des tableaux distincts en fonction de leur parité.
Solution :
#include <iostream>
#include <vector>
int main() {
int taille;
std::cin >> taille;
std::vector<int> nombres(taille);
for (int i = 0; i < taille; ++i) {
std::cin >> nombres[i];
}
std::vector<int> impairs;
std::vector<int> pairs;
for (int nombre : nombres) {
if (nombre % 2 != 0) {
impairs.push_back(nombre);
} else {
pairs.push_back(nombre);
}
}
// Affichage des nombres impairs
for (int impair : impairs) {
std::cout << impair << " ";
}
std::cout << std::endl;
// Affichage des nombres pairs
for (int pair : pairs) {
std::cout << pair << " ";
}
std::cout << std::endl;
return 0;
}
Ce problème visait à transformer toutes les lettres minuscules d'une chaîne de caractères en leurs équivalents majuscules. La solution exploite la représentation ASCII des caractères, où la différence entre une minuscule et sa majuscule correspondante est de 32.
Solution :
#include <iostream>
#include <string>
#include <cctype> // Pour std::toupper, une alternative plus sûre
int main() {
std::string chaine;
std::getline(std::cin, chaine);
for (char &c : chaine) {
// Utilisation de std::toupper pour une conversion plus robuste
c = std::toupper(static_cast<unsigned char>(c));
// Alternative utilisant la différence ASCII (moins portable/robuste)
// if (c >= 'a' && c <= 'z') {
// c = c - ('a' - 'A'); // ou c = c - 32;
// }
}
std::cout << chaine << std::endl;
return 0;
}
Ce problème consistait à trouver le nombre qui apparaît le plus fréquemment dans un ensemble de nombres. La solution utilise une approche similaire au tri par dénombremetn (bucket sort) pour compter les occurrences de chaque nombre et identifier le plus fréquent.
Solution :
#include <iostream>
#include <vector>
#include <map> // Alternative plus flexible pour les fréquences
int main() {
int nombreElements;
std::cin >> nombreElements;
// Utilisation d'une map pour stocker les fréquences (plus flexible que le tableau fixe)
std::map<int, int> frequences;
int nombrePlusFrequent = 0;
int frequenceMax = 0;
for (int i = 0; i < nombreElements; ++i) {
int valeur;
std::cin >> valeur;
frequences[valeur]++; // Incrémente la fréquence pour cette valeur
if (frequences[valeur] > frequenceMax) {
frequenceMax = frequences[valeur];
nombrePlusFrequent = valeur;
}
// Gérer le cas où plusieurs nombres ont la même fréquence maximale
// (ici, on garde le premier rencontré qui atteint cette fréquence)
}
std::cout << "Le nombre le plus frequent est: " << nombrePlusFrequent << std::endl;
return 0;
}