Exercice Java Corrigé pour Débutant | Partie 3

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);		

		System.out.print("Entrez un nombre entre 0 et 1000: ");
		int n = sc.nextInt();


		// Trouve le dernier chiffre du nombre
		int a = n % 10;
		// Supprime le dernier chiffre en divisant le nombre par 10  
		n /= 10;
		int b = n % 10;
		n /= 10;			
		int c = n % 10;
		n /= 10;
		// Additionnez les chiffres du nombre
		int somme = a + b + c;

		// Afficher le résultat
		System.out.println("La somme des chiffres est " + somme);
	}
}

Sortie:

public class Main {
	public static void main(String[] args) {
	   int n1=0,n2=1,n3,i,nbr=10;
	   //Afficher 0 et 1  
	   System.out.print(n1+" "+n2);   
		
	   // La boucle commence à 2 car 0 et 1 sont déjà affichés 
	   for(i=2; i<nbr; ++i)   
	   {    
	      n3=n1+n2;    
	      System.out.print(" "+n3);    
	      n1=n2;    
	      n2=n3;    
	   }
	}
}

Sortie:

0 1 1 2 3 5 8 13 21 34

Voir aussi : L’algorithme de Fibonacci en Java

public class Main {  
  public static void main(String[] args) {
	Integer n = 15;
	String res = "";
	if (n % 3 == 0) {
	   res += "Fizz";
	}
	if (n % 5 == 0) {
	   res += "Buzz";
	}
	if (res.equals("")) {
	   res = n.toString();
	}
	System.out.print(res);
  }
}

Sortie:

FizzBuzz

import java.util.Scanner;

public class Main {
    public static void main(String args[]) {
        // Déclarez des variables pour stocker les nombres décimaux, 
        // le quotient et un tableau pour les chiffres binaires.
        int dec_nbr, quot, i = 1, j;
        int bin_nbr[] = new int[100];
        
        // Créer un objet Scanner pour lire les données de 
        // l'utilisateur
        Scanner scan = new Scanner(System.in);

        // Inviter l'utilisateur à saisir un nombre décimal
        System.out.print("Saisir un nombre décimal: ");
        dec_nbr = scan.nextInt();

        // Initialiser le quotient avec le nombre décimal
        quot = dec_nbr;

        // Convertir les nombres décimaux en nombres binaires et 
        // stocker les chiffres binaires
        while (quot != 0) {
            bin_nbr[i++] = quot % 2;
            quot = quot / 2;
        }

        // Afficher la représentation binaire du nombre décimal
        System.out.print("Le nombre binaire est: ");
        for (j = i - 1; j > 0; j--) {
            System.out.print(bin_nbr[j]);
        }
        System.out.print("\n");
    }
}

Sortie:

Saisir un nombre décimal: 5
Le nombre binaire est: 101

Explication:

Dans l’exercice ci-dessus :

• Le code prend d’abord un nombre entier ou décimal (‘dec_nbr’) comme entrée de l’utilisateur à l’aide de la classe « Scanner ».
• Il initialise un tableau « bin_nbr » pour stocker les chiffres binaires du nombre converti et d’autres variables nécessaires.
• Ensuite, il entre dans une boucle pour effectuer la conversion décimal-binaire :
• À chaque itération, il calcule le reste de « dec_nbr » lorsqu’il est divisé par 2 (ce qui donne le chiffre binaire le moins significatif) et le stocke dans le tableau « bin_nbr ».
• Il met ensuite à jour « dec_nbr » en le divisant par 2 (ce qui le décale effectivement vers la droite).
• La boucle continue jusqu’à ce que ‘dec_nbr’ devienne zéro, convertissant ainsi l’ensemble du nombre décimal en binaire.
• Après la boucle, la représentation binaire du nombre décimal est affichée en parcourant le tableau ‘bin_nbr’ dans l’ordre inverse (du chiffre le plus significatif au chiffre le moins significatif).

import java.util.Scanner;

public class Main {
    public static void main(String args[]) {
        // Déclarer des variables pour stocker le nombre décimal 
        // et le reste
        int dec_nbr, reste;
        
        // Initialiser une chaîne vide pour le nombre hexadécimal
        String hex_nbr = "";
        
        // Définir les chiffres du nombre hexadécimal
        char hex[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
        
        // Créer un objet Scanner pour lire les données de 
        // l'utilisateur
        Scanner in = new Scanner(System.in);

        // Inviter l'utilisateur à saisir un nombre décimal
        System.out.print("Saisir un nombre décimal: ");
        dec_nbr = in.nextInt();

        // Convertir le nombre décimal en hexadécimal
        while (dec_nbr > 0) {
            reste = dec_nbr % 16;
            hex_nbr = hex[reste] + hex_nbr;
            dec_nbr = dec_nbr / 16;
        }
        
        // Afficher la représentation hexadécimale du nombre décimal
        System.out.print("Le nombre hexadécimal est: "+ hex_nbr);
    }
}

Sortie:

Saisir un nombre décimal: 15
Le nombre hexadécimal est: F

Explication:

Dans l’exercice ci-dessus :

• Il prend un nombre décimal (‘dec_nbr’) comme entrée de l’utilisateur en utilisant la classe « Scanner ».
• Il initialise une chaîne vide « hex_nbr » pour stocker la représentation hexadécimale et définit un tableau « hex » contenant les chiffres hexadécimaux (0-9 et A-F).
• Il entre dans une boucle pour effectuer la conversion décimal-hexadécimal :
• À chaque itération, il calcule le reste de « dec_nbr » lorsqu’il est divisé par 16 (ce qui donne le chiffre hexadécimal) et l’ajoute à la chaîne « hex_nbr ».
• Il met ensuite à jour « dec_nbr » en le divisant par 16.
• La boucle continue jusqu’à ce que ‘dec_nbr’ devienne zéro, convertissant ainsi l’ensemble du nombre décimal en hexadécimal.
• Après la boucle, la représentation hexadécimale du nombre décimal stocké dans la chaîne ‘hex_nbr’ est affichée.

import java.util.Scanner;

public class Main {
    public static void main(String args[]) {
        // Déclarez des variables pour stocker le nombre décimal, 
        // le quotient et un tableau pour les chiffres octaux.
        int dec_nbr, quot, i = 1, j;
        int oct_nbr[] = new int[100];
        
        // Créer un objet Scanner pour lire les données de 
        // l'utilisateur
        Scanner scan = new Scanner(System.in);

        // Inviter l'utilisateur à saisir un nombre décimal
        System.out.print("Saisir un nombre décimal: ");
        dec_nbr = scan.nextInt();

        // Initialiser le quotient avec le nombre décimal
        quot = dec_nbr;

        // Convertir le nombre décimal en octal et stocker les 
        // chiffres octaux
        while (quot != 0) {
            oct_nbr[i++] = quot % 8;
            quot = quot / 8;
        }

        // Afficher la représentation octale du nombre décimal
        System.out.print("Le nombre octal est: ");
        for (j = i - 1; j > 0; j--) {
            System.out.print(oct_nbr[j]);
        }
        
        System.out.print("\n");
    }
}

Sortie:

Saisir un nombre décimal: 10
Le nombre octal est: 12

Explication:

Dans l’exercice ci-dessus :

• Il prend un nombre décimal (‘dec_nbr’) comme entrée de l’utilisateur en utilisant la classe « Scanner ».
• Il initialise un tableau ‘oct_nbr’ pour stocker les chiffres octaux du nombre converti et d’autres variables nécessaires.
• Il entre dans une boucle pour effectuer la conversion décimal-octal :
  • À chaque itération, il calcule le reste de « dec_nbr » lorsqu’il est divisé par 8 et le stocke dans le tableau « oct_nbr ».
  • Il met ensuite à jour ‘dec_nbr’ en le divisant par 8 (ce qui le décale effectivement vers la droite).
  • La boucle continue jusqu’à ce que ‘dec_nbr’ devienne zéro, convertissant ainsi l’ensemble du nombre décimal en octal.
• Après la boucle, la représentation octale du nombre décimal est affichée en parcourant le tableau ‘oct_nbr’ dans l’ordre inverse.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créer un objet Scanner pour lire les données de 
        // l'utilisateur
        Scanner sc = new Scanner(System.in);
        
        // Déclarer des variables pour stocker des chiffres binaires 
        // et décimaux, le reste et un multiplicateur.
        long bin_nbr, dec_nbr = 0, j = 1, reste;
        
        // Inviter l'utilisateur à saisir un nombre binaire
        System.out.print("Saisir un nombre binaire: ");
        bin_nbr = sc.nextLong();

        // Convertir le nombre binaire en nombre décimal
        while (bin_nbr != 0) {
            reste = bin_nbr % 10;
            dec_nbr = dec_nbr + reste * j;
            j = j * 2;
            bin_nbr = bin_nbr / 10;
        }
        
        // Afficher la représentation décimale du nombre binaire
        System.out.println("Nombre décimal: " + dec_nbr);
    }
}

Sortie:

Saisir un nombre binaire: 101
Nombre décimal: 5

Explication:

Dans l’exercice ci-dessus :

• Il prend un nombre binaire comme entrée de l’utilisateur en utilisant la classe « Scanner » et le stocke dans la variable « bin_nbr ».
• Il initialise une variable « dec_nbr » pour stocker l’équivalent décimal et une autre variable « j » comme multiplicateur, à partir de 1.
• Il entre dans une boucle pour effectuer la conversion binaire-décimale :
  • À chaque itération, il calcule le reste lorsque le « bin_nbr » est divisé par 10 (ce qui donne le chiffre binaire le moins significatif).
  • Il ajoute ensuite ce reste multiplié par la valeur actuelle de « j » au « dec_nbr ».
  • Il multiplie « j » par 2 pour préparer le chiffre binaire suivant.
  • Il met à jour « bin_nbr » en supprimant le chiffre le moins significatif (le plus à droite) et en le divisant par 10.
  • La boucle continue jusqu’à ce que ‘bin_nbr’ devienne zéro, convertissant ainsi l’ensemble du nombre binaire en décimal.
• Après la boucle, la représentation décimale du nombre binaire stocké dans la variable ‘dec_nbr’ est affichée.

 import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Déclarez un tableau pour stocker les chiffres 
        // hexadécimaux, les variables de calcul et les 
        // entrées binaires.
        int[] hex = new int[1000];
        int i = 1, j = 0, reste, dec = 0, bin;

        // Créer un objet Scanner pour lire les données de 
        // l'utilisateur
        Scanner in = new Scanner(System.in);

        // Inviter l'utilisateur à saisir un nombre binaire
        System.out.print("Saisir un nombre binaire: ");
        bin = in.nextInt();

        // Convertir le nombre binaire en nombre décimal
        while (bin > 0) {
            reste = bin % 2;
            dec = dec + reste * i;
            i = i * 2;
            bin = bin / 10;
        }
        i = 0;

        // Convertir le nombre décimal en hexadécimal
        while (dec != 0) {
            hex[i] = dec % 16;
            dec = dec / 16;
            i++;
        }

        // Afficher la valeur hexadécimale
        System.out.print("La valeur hexadécimale: ");
        for (j = i - 1; j >= 0; j--) {
            if (hex[j] > 9) {
                System.out.print((char)(hex[j] + 55));
            } else {
                System.out.print(hex[j]);
            }
        }
        System.out.print("\n");
    }
}

Sortie:

Saisir un nombre binaire: 1101
La valeur hexadécimale: D

Explication:

Dans l’exercice ci-dessus :

• Initialise un tableau « hex » pour stocker les chiffres hexadécimaux du nombre converti, ainsi que d’autres variables nécessaires.
• Il prend un nombre binaire comme entrée de l’utilisateur en utilisant la classe « Scanner » et le stocke dans la variable « bin ».
• Il entre dans une boucle pour convertir le nombre binaire en décimal :
  • À chaque itération, il calcule le reste lorsque la variable « bin » est divisée par 2 (ce qui donne le chiffre binaire le moins significatif).
  • Il ajoute ce reste multiplié par ‘i’ à la variable ‘dec’ pour accumuler la valeur décimale.
  • Il multiplie « i » par 2 pour préparer le chiffre binaire suivant.
  • Il met à jour « bin » en supprimant le chiffre le moins significatif (le plus à droite) en le divisant par 10.
  • La boucle se poursuit jusqu’à ce que « bin » devienne zéro, convertissant ainsi l’ensemble du nombre binaire en valeur décimale.
• Après la conversion en décimal, il entre dans une autre boucle pour convertir le nombre décimal en hexadécimal :
  • À chaque itération, il calcule le reste lorsque « dec » est divisé par 16 (ce qui donne le chiffre hexadécimal le moins significatif).
  • Il stocke ce reste dans un tableau « hex ».
  • Il met à jour « dec » en le divisant par 16 pour passer au chiffre hexadécimal suivant.
• Enfin, il affiche la représentation hexadécimale du nombre binaire d’origine en parcourant le tableau « hex » dans l’ordre inverse. Il gère également les chiffres hexadécimaux supérieurs à 9 en les convertissant en lettres correspondantes de A à F.

 import java.util.*;

public class Main {
    public static void main(String[] args) {
        // Déclarez des variables pour stocker les nombres binaires 
        // et décimaux, le reste, le quotient et un tableau pour 
        // les chiffres octaux.
        int bin_nbr, bin_orig, reste, dec_nbr = 0, quot, i = 1, j;
        int oct_nbr[] = new int[100];

        // Créer un objet Scanner pour lire les données de 
        // l'utilisateur
        Scanner scan = new Scanner(System.in);

        // Inviter l'utilisateur à saisir un nombre binaire
        System.out.print("Saisir un nombre binaire: ");
        bin_nbr = scan.nextInt();
        bin_orig = bin_nbr;

        // Convertir le nombre binaire en nombre décimal
        while (bin_nbr > 0) {
            reste = bin_nbr % 10;
            dec_nbr = dec_nbr + reste * i;
            i = i * 2;
            bin_nbr = bin_nbr / 10;
        }

        i = 1;
        quot = dec_nbr;

        // Convertir le nombre décimal en octal
        while (quot > 0) {
            oct_nbr[i++] = quot % 8;
            quot = quot / 8;
        }

        // Afficher la valeur octale équivalente du nombre binaire 
        // d'origine
        System.out.print("Valeur octale équivalente de " + bin_orig + " est :");
        for (j = i - 1; j > 0; j--) {
            System.out.print(oct_nbr[j]);
        }
        System.out.print("\n");
    }
}

Sortie:

Saisir un nombre binaire: 1101
Valeur octale équivalente de 1101 est :15

Explication:

Dans l’exercice ci-dessus :

• Tout d’abord, initialiser un tableau ‘oct_nbr’ pour stocker les chiffres octaux du nombre converti et d’autres variables nécessaires.
• Il prend un nombre binaire comme entrée de l’utilisateur en utilisant la classe « Scanner » et le stocke dans la variable « bin_nbr ».
• Il entre ensuite dans une boucle pour convertir le nombre binaire en décimal :
  • À chaque itération, il calcule le reste lorsque « bin_nbr » est divisé par 10 (ce qui donne le chiffre binaire le moins significatif).
  • Il ajoute ce reste multiplié par i à la variable ‘dec_nbr’ pour accumuler la valeur décimale.
  • Il multiplie « i » par 2 pour préparer le chiffre binaire suivant.
  • Elle met à jour ‘bin_nbr’ en supprimant le chiffre le moins significatif (le plus à droite) et en le divisant par 10.
  • La boucle continue jusqu’à ce que ‘bin_nbr’ devienne zéro, convertissant ainsi l’ensemble du nombre binaire en décimal.
• Après la conversion en décimal, il entre dans une autre boucle pour convertir le nombre décimal en octal :
  • À chaque itération, il calcule le reste lorsque ‘dec_nbr’ est divisé par 8 (ce qui donne le chiffre octal le moins significatif).
  • Il stocke ce reste dans le tableau ‘oct_nbr’.
  • Il met à jour ‘dec_nbr’ en le divisant par 8 pour passer au chiffre octal suivant.
• Enfin, il affiche la représentation octale du nombre binaire d’origine en parcourant le tableau ‘oct_nbr’ dans l’ordre inverse.