Première Année Cycle d'Ingénieur :
Filiére : Sciences des données, Big Dta et IA (Semestre 5)
Année Universitaire : 2023-2024
TP1 POO JAVA
Module : POO en JAVA
Professeur : Mohamed Saad AZIZI
Exercice 1 :
Écrire un programme qui affiche à l’écran le message Bonjour "tout le monde"
Solution :
public class BonjourMonde {
public static void main(String[] args) {
[Link]("Bonjour tout le
monde");
}
}
Exercice 2 :
Dans cet exercice nous désirons calculer et afficher la somme, la différence, le produit, le quotient, et le reste de la
division entière de deux nombres entiers ! .
Solution :
import [Link];
public class CalculsEntiers {
public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);
// Saisie du premier nombre
[Link]("Entrez le premier nombre entier : ");
int nombre1 = [Link]();
// Saisie du deuxième nombre
[Link]("Entrez le deuxième nombre entier : ");
int nombre2 = [Link]();
// Calculs
int somme = nombre1 + nombre2;
int difference = nombre1 - nombre2;
int produit = nombre1 * nombre2;
// Vérification pour éviter la division par zéro
if (nombre2 != 0) {
int quotient = nombre1 / nombre2;
int reste = nombre1 % nombre2;
// Affichage des résultats
[Link]("Somme : " + somme);
[Link]("Différence : " + difference);
[Link]("Produit : " + produit);
[Link]("Quotient : " + quotient);
[Link]("Reste : " + reste);
} else {
[Link]("La division par zéro n'est pas autorisée.");
}
// Fermeture du scanner
[Link]();
}
}
Exercice 3 :
Écrire un programme en java qui détermine la parité d’un entier positif.
Solution :
import [Link];
public class PariteEntier {
public static void main(String[] args) {
// Création d'un objet Scanner pour lire l'entrée utilisateur
Scanner scanner = new Scanner([Link]);
// Demander à l'utilisateur de saisir un nombre entier positif
[Link]("Veuillez saisir un nombre entier positif : ");
int entier = [Link]();
// Vérifier si l'entier est positif
if (entier >= 0) {
// Déterminer la parité
if (entier % 2 == 0) {
[Link]("Le nombre " + entier + " est pair.");
} else {
[Link]("Le nombre " + entier + " est impair.");
}
} else {
[Link]("Veuillez saisir un nombre entier positif.");
}
// Fermer le scanner pour eviter les fuites de ressources
[Link]();
}
}
Exercice 4 :
Écrire un programme qui permet de saisir deux entiers, de déterminer le maximum et de l’afficher.
Solution :
import [Link];
public class MaximumEntiers {
public static void main(String[] args) {
// Création d'un objet Scanner pour lire l'entrée utilisateur
Scanner scanner = new Scanner([Link]);
// Demander à l'utilisateur de saisir le premier entier
[Link]("Veuillez saisir le premier entier : ");
int entier1 = [Link]();
// Demander à l'utilisateur de saisir le deuxième entier
[Link]("Veuillez saisir le deuxième entier : ");
int entier2 = [Link]();
// Déterminer le maximum
int maximum = entier1 > entier2 ? entier1 : entier2;
// Afficher le maximum
[Link]("Le maximum entre " + entier1 + " et " + entier2 + " est : " + maximum);
// Fermer le scanner pour éviter les fuites de ressources
[Link]();
}
}
Exercice 5 :
Écrire un programme en java qui résout l’équation du premier degré
ax + b= 0. (a, b et x de type réel).
Solution :
import [Link];
public class EquationPremierDegre {
public static void main(String[] args) {
// Création d'un objet Scanner pour lire l'entrée utilisateur
Scanner scanner = new Scanner([Link]);
// Demander à l'utilisateur de saisir les valeurs de a et b
[Link]("Veuillez saisir la valeur de a : ");
double a = [Link]();
[Link]("Veuillez saisir la valeur de b : ");
double b = [Link]();
// Vérifier si l'équation est une équation du premier degré (a != 0)
if (a != 0) {
// Calculer la solution de l'équation (x)
double x = -b / a;
// Afficher la solution
[Link]("La solution de l'équation " + a + "x + " + b + " = 0 est x = " + x);
} else {
[Link]("L'équation n'est pas du premier degré (a doit être différent de 0).");
}
// Fermer le scanner pour éviter les fuites de ressources
[Link]();
}
}
Exercice 6 :
Écrire un programme en java pour résoudre l’équation du second degré :
ax2 + bx + c= 0. (a, b, c, x de type réel).
Solution :
import [Link];
public class EquationSecondDegre {
public static void main(String[] args) {
// Création d'un objet Scanner pour lire l'entrée utilisateur
Scanner scanner = new Scanner([Link]);
// Demander à l'utilisateur de saisir les valeurs de a, b et c
[Link]("Veuillez saisir la valeur de a : ");
double a = [Link]();
[Link]("Veuillez saisir la valeur de b : ");
double b = [Link]();
[Link]("Veuillez saisir la valeur de c : ");
double c = [Link]();
// Calculer le discriminant (b^2 - 4ac)
double discriminant = b * b - 4 * a * c;
// Vérifier la nature des solutions en fonction du discriminant
if (discriminant > 0) {
// Deux solutions réelles distinctes
double x1 = (-b + [Link](discriminant)) / (2 * a);
double x2 = (-b - [Link](discriminant)) / (2 * a);
[Link]("Les solutions de l'équation sont x1 = " + x1 + " et x2 = " + x2);
} else if (discriminant == 0) {
// Une solution réelle unique
double x = -b / (2 * a);
[Link]("L'équation a une solution unique : x = " + x);
} else {
// Pas de solution réelle
[Link]("L'équation n'a pas de solution réelle.");
}
// Fermer le scanner pour éviter les fuites de ressources
[Link]();
}
}
Exercice 7 :
Ecrire un programme en java qui détermine si un nombre entier est parfait ou non.
Solution :
import [Link];
public class NombreParfait {
public static void main(String[] args) {
// Création d'un objet Scanner pour lire l'entrée utilisateur
Scanner scanner = new Scanner([Link]);
// Demander à l'utilisateur de saisir un nombre entier positif
[Link]("Veuillez saisir un nombre entier positif : ");
int nombre = [Link]();
// Vérifier si le nombre est parfait
if (estNombreParfait(nombre)) {
[Link](nombre + " est un nombre parfait.");
} else {
[Link](nombre + " n'est pas un nombre parfait." );
}
// Fermer le scanner pour éviter les fuites de ressources
[Link]();
}
// Fonction pour vérifier si un nombre est parfait
public static boolean estNombreParfait(int n) {
if (n <= 0) {
return false; // Les nombres négatifs ne sont pas parfaits
}
int sommeDiviseurs = 0;
// Parcourir les diviseurs potentiels de 1 à n/2
for (int i = 1; i <= n / 2; i++) {
if (n % i == 0) {
sommeDiviseurs += i;
}
}
// Vérifier si la somme des diviseurs est égale au nombre original
return sommeDiviseurs == n;
}
}
Exercice 8 :
Écrire un programme en java qui permet de saisir deux entiers positifs a et b, de calculer et d’afficher leur PGCD.
Solution :
import [Link];
public class CalculPGCD {
public static void main(String[] args) {
// Création d'un objet Scanner pour la saisie utilisateur
Scanner scanner = new Scanner([Link]);
// Saisie des entiers positifs a et b
[Link]("Entrez le premier entier positif (a) : ");
int a = [Link]();
[Link]("Entrez le deuxième entier positif (b) : ");
int b = [Link]();
// Calcul du PGCD à l'aide de l'algorithme d'Euclide
int pgcd = calculerPGCD(a, b);
// Affichage du résultat
[Link]("Le PGCD de " + a + " et " + b + " est : " + pgcd);
// Fermeture du scanner
[Link]();
}
// Méthode pour calculer le PGCD avec l'algorithme d'Euclide
private static int calculerPGCD(int a, int b) {
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}
}
Exercice 9 :
Écrire un programme permettant de saisir et de valider si un entier lu (exemple 3245) est positif ou non. Ensuite on
affiche l’entier tel que lu en plus d’afficher cet entier lu à l’envers ici (5423).
Solution :
import [Link];
public class PositiveIntegerValidation {
public static void main(String[] args) {
// Création d'un objet Scanner pour la saisie utilisateur
Scanner scanner = new Scanner([Link]);
// Saisie d'un entier
[Link]("Entrez un entier : ");
int userInput = [Link]();
// Validation si l'entier est positif ou non
if (userInput >= 0) {
[Link]("L'entier saisi est positif.");
} else {
[Link]("L'entier saisi n'est pas positif.");
}
// Affichage de l'entier tel qu'il a été lu
[Link]("Entier lu : " + userInput);
// Affichage de l'entier à l'envers
int reversedNumber = reverseNumber(userInput);
[Link]("Entier lu à l'envers : " + reversedNumber);
// Fermeture du scanner
[Link]();
}
// Méthode pour inverser les chiffres d'un entier
private static int reverseNumber(int num) {
int reversedNum = 0;
while (num != 0) {
reversedNum = reversedNum * 10 + num % 10;
num /= 10;
}
return reversedNum;
}
}
Exercice 10 :
Écrire un programme permettant de saisir et de valider si un entier lu (exemple 3245) est positif ou non. Puis on calcule
et on affiche la somme de ces chiffres exemple si on a 854 comme donné d’entré on aura la somme des chiffres est =
17.
Solution :
import [Link];
public class PositiveIntegerSum {
public static void main(String[] args) {
// Creating a Scanner object for user input
Scanner scanner = new Scanner([Link]);
// Entering an integer
[Link]("Enter an integer: ");
int userInput = [Link]();
// Validating if the integer is positive or not
if (userInput >= 0) {
[Link]("The entered integer is positive.");
// Calculating and displaying the sum of digits
int digitSum = calculateDigitSum(userInput);
[Link]("The sum of digits is: " + digitSum);
} else {
[Link]("The entered integer is not positive.");
}
// Closing the scanner
[Link]();
}
// Method to calculate the sum of digits of an integer
private static int calculateDigitSum(int num) {
int sum = 0;
while (num != 0) {
sum += num % 10;
num /= 10;
}
return sum;
}
}
Exercice 11 :
Écrire un programme qui permet de saisir un entier entre 1 et 7 et de saisir le rang d’une journée de la semaine ( 1
:dimanche, 2 lundi….7 : samedi) et d’afficher le jour correspondant.
Solution :
import [Link];
public class WeekdaySelection {
public static void main(String[] args) {
// Création d'un objet Scanner pour la saisie utilisateur
Scanner scanner = new Scanner([Link]);
// Saisie du rang de la journée de la semaine
[Link]("Entrez un entier entre 1 et 7 : ");
int dayNumber = [Link]();
// Vérification si le nombre saisi est dans la plage valide
if (dayNumber >= 1 && dayNumber <= 7) {
// Appel de la méthode pour obtenir le jour correspondant
String dayName = getDayName(dayNumber);
// Affichage du jour correspondant
[Link]("Le jour correspondant au rang " + dayNumber + " est : " + dayName);
} else {
[Link]("Le nombre saisi n'est pas valide. Veuillez entrer un nombre entre 1 et 7.");
}
// Fermeture du scanner
[Link]();
}
// Méthode pour obtenir le nom du jour correspondant au rang
private static String getDayName(int dayNumber) {
switch (dayNumber) {
case 1: return "Dimanche";
case 2: return "Lundi";
case 3: return "Mardi";
case 4: return "Mercredi";
case 5: return "Jeudi";
case 6: return "Vendredi";
case 7: return "Samedi";
default: return "Jour non valide";
}
}
}
Exercice 12 :
Écrire un programme qui permet de saisir un entier entre 1 et 7 et de saisir le rang d’une journée de la semaine ( 1
:dimanche, 2 lundi….7 :samedi) et d’afficher un message du genre :
On travail très fort ! (Pour lundi à jeudi)
La fin de la semaine s approche (pour vendredi)
Youpi ! C’est la fin de la semaine (pour samedi, dimanche)
Message pertinent (pour un rang imprévu)
Solution :
import [Link];
public class WeekdayMessage {
public static void main(String[] args) {
// Creating a Scanner object for user input
Scanner scanner = new Scanner([Link]);
// Entering the day number
[Link]("Enter an integer between 1 and 7: ");
int dayNumber = [Link]();
// Checking if the entered number is in the valid range
if (dayNumber >= 1 && dayNumber <= 7) {
// Calling the method to get the corresponding message
String message = getDayMessage(dayNumber);
// Displaying the message
[Link](message);
} else {
[Link]("The entered number is not valid. Please enter a number between 1 and 7.");
}
// Closing the scanner
[Link]();
}
// Method to get the message corresponding to the day number
private static String getDayMessage(int dayNumber) {
switch (dayNumber) {
case 1:
case 2:
case 3:
case 4:
return "We work very hard!"; // Monday to Thursday
case 5:
return "The end of the week is approaching."; // Friday
case 6:
case 7:
return "Hooray! It's the weekend!"; // Saturday, Sunday
default:
return "Unexpected day number.";
}
}
}
Exercice 13 :
Écrire un programme en java qui calcule les sommes suivantes : S1 = 1 + 2 + 3 + …..n
S2 =1 + 1/2 + 1/3 + …+ 1/n
S3 = 10 + 15 + 20 + ….. +50
Solution :
import [Link];
public class CalculatingSums {
public static void main(String[] args) {
// Création d'un objet Scanner pour la saisie utilisateur
Scanner scanner = new Scanner([Link]);
// Saisie de la valeur de n pour S1 et S2
[Link]("Enter a positive integer (n) for S1 and S2: ");
int n = [Link]();
// Calcul et affichage de S1
int sumS1 = calculateSumS1(n);
[Link]("S1 = 1 + 2 + 3 + ... + " + n + " is: " + sumS1);
// Calcul et affichage de S2
double sumS2 = calculateSumS2(n);
[Link]("S2 = 1 + 1/2 + 1/3 + ... + 1/" + n + " is: " + sumS2);
// Calcul et affichage de S3
int sumS3 = calculateSumS3();
[Link]("S3 = 10 + 15 + 20 + ... + 50 is: " + sumS3);
// Fermeture du scanner
[Link]();
}
// Méthode pour calculer la somme S1
private static int calculateSumS1(int n) {
return (n * (n + 1)) / 2;
}
// Méthode pour calculer la somme S2
private static double calculateSumS2(int n) {
double sum = 0.0;
for (int i = 1; i <= n; i++) {
sum += 1.0 / i;
}
return sum;
}
// Méthode pour calculer la somme S3
private static int calculateSumS3() {
int sum = 0;
for (int i = 10; i <= 50; i += 5) {
sum += i;
}
return sum;
}
}
Exercice 14 :
Écrire un programme java qui calcule les sommes suivantes :
S1= 1 + 4 + 9 + …….+ n2, S2 =1 + 1/23 + 1/32 + …+ 1/n3
Estimation de PI/4 PI_Sur4= 1 –1/3 + 1/5 –1/7.…………1/9999
Solution :
import [Link];
public class CalculatingSumsAndPI {
public static void main(String[] args) {
// Création d'un objet Scanner pour la saisie utilisateur
Scanner scanner = new Scanner([Link]);
// Saisie de la valeur de n pour S1 et S2
[Link]("Enter a positive integer (n) for S1 and S2: ");
int n = [Link]();
// Calcul et affichage de S1
long sumS1 = calculateSumS1(n);
[Link]("S1 = 1 + 4 + 9 + ... + " + n + "^2 is: " + sumS1);
// Calcul et affichage de S2
double sumS2 = calculateSumS2(n);
[Link]("S2 = 1 + 1/2^3 + 1/3^2 + ... + 1/" + n + "^3 is: " + sumS2);
// Estimation de PI/4
double piOver4 = estimatePiOver4();
[Link]("Estimation of PI/4 is: " + piOver4);
// Fermeture du scanner
[Link]();
}
// Méthode pour calculer la somme S1
private static long calculateSumS1(int n) {
long sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i;
}
return sum;
}
// Méthode pour calculer la somme S2
private static double calculateSumS2(int n) {
double sum = 0.0;
for (int i = 1; i <= n; i++) {
sum += 1.0 / (i * i * i);
}
return sum;
// Méthode pour estimer PI/4
private static double estimatePiOver4() {
double result = 1.0;
boolean subtractTerm = false;
for (int i = 3; i <= 9999; i += 2) {
if (subtractTerm) {
result -= 1.0 / i;
} else {
result += 1.0 / i;
}
subtractTerm = !subtractTerm;
return result;
}
}