Exercice Java Corrigé pour Débutant | Partie 10

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Création d'un objet Scanner pour recueillir les données de 
        // l'utilisateur
        Scanner sc = new Scanner(System.in);
        
        // Inviter l'utilisateur à saisir le premier nombre
        System.out.print("Saisir le premier nombre: ");
        double n1 = sc.nextDouble();
        
        // Inviter l'utilisateur à saisir le deuxième nombre
        System.out.print("Saisir le deuxième nombre: ");
        double n2 = sc.nextDouble();
        
        // Vérifier si les deux nombres sont supérieurs à 0 et 
        // inférieurs à 1
        System.out.print(n1 > 0 && n1 < 1 && n2 > 0 && n2 < 1);
    }
} 

Sortie:

Saisir le premier nombre: .15
Saisir le deuxième nombre: .59
true

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // Initialiser un tableau d'entiers
        Integer tab[] = new Integer[]{1, 2, 65, 9, 12, 4, 99};
        
        int k = 3; // Initialiser la valeur de 'k' à 3
        
        System.out.println("Tableau original: ");
        System.out.println(Arrays.toString(tab));
        
        // Afficher les k plus petits éléments du tableau
        System.out.println(k + " plus petits éléments de ce tableau sont:");
        
        // Trier le tableau par ordre croissant
        Arrays.sort(tab);
        
        // Afficher les k plus petits éléments du tableau trié
        for (int i = 0; i < k; i++) {
            System.out.print(tab[i] + " ");
        }
    }
}

Sortie:

Tableau original: 
[1, 2, 65, 9, 12, 4, 99]
3 plus petits éléments de ce tableau sont:
1 2 4 

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // Initialiser un tableau d'entiers
        Integer tab[] = new Integer[]{1, 2, 65, 9, 12, 4, 99};
        
        int k = 2; // Initialiser la valeur de 'k' à 2
        
        System.out.println("Tableau original: ");
        System.out.println(Arrays.toString(tab));
        
        System.out.println(k +"ème plus petit élément du tableau: ");
        
        // Trier le tableau par ordre croissant
        Arrays.sort(tab);
        
        // Afficher le k'ème plus petit élément du tableau trié
        System.out.print(tab[k-1] + " ");
        
        System.out.println("\n"+ k +"ème plus grand élément du tableau:");
        
        // Trier le tableau par ordre décroissant pour trouver le 
        // k'ème plus grand élément
        Arrays.sort(tab, Collections.reverseOrder());
        
        // Afficher le k'ème plus grand élément du tableau trié
        System.out.print(tab[k-1] + " ");
    }
} 

Sortie:

Tableau original: 
[1, 2, 65, 9, 12, 4, 99]
2ème plus petit élément du tableau: 
2 
2ème plus grand élément du tableau:
65 

import java.util.*;
public class Main {
    public static void main(String[] args) {
        // Initialiser un tableau d'entiers
        Integer tab[] = new Integer[]{1, 2, 65, 9, 12, 4, 99};
        // Initialisation de la variable sum
        double sum = 0;
		
        System.out.println("Tableau original: ");
        System.out.println(Arrays.toString(tab));
		
        // Calculer la somme des éléments du tableau
        for(int i = 0; i < tab.length; i++) {
            sum = sum + tab[i];
        }
        // Calculer la moyenne des éléments du tableau
        double moy = (double) sum / tab.length;
		
        System.out.println("La moyenne de ce tableau est: "+ moy);
        System.out.println("Les nombres supérieurs à la moyenne sont: ");
        // Afficher les nombres supérieurs à la moyenne dans 
        // le tableau
        for(int i = 0; i < tab.length; i++) {
            if(tab[i] > moy) {
                System.out.println(tab[i]);
            }
        }
    }
}

Sortie:

Tableau original: 
[1, 2, 65, 9, 12, 4, 99]
La moyenne de ce tableau est: 27.428571428571427
Les nombres supérieurs à la moyenne sont: 
65
99

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Saisir le dividende: ");
        int dividend = sc.nextInt();
        
        System.out.print("Saisir le diviseur: ");
        int diviseur = sc.nextInt();

        if (diviseur == 0) {
            // Si le diviseur est zéro, sortir du prog
            System.exit(0); 
        }
        
        // Initialiser la variable result pour stocker le quotient
        float result = 0; 
        
        // Effectuer une division par soustraction
        while (dividend > diviseur) {
            // Soustraire le diviseur du dividende
            dividend -= diviseur; 
            result++; // Incrémenter le résultat (quotient)
        }
        
        // Calculer la partie décimale du quotient
        float dec = (float) dividend / (float) diviseur; 
        // Ajouter la partie décimale au résultat
        result += dec; 
		
        // Afficher le résultat de la division
        System.out.println("\nRésultat: " + result); 
    }
}

Sortie:

Saisir le dividende: 8
Saisir le diviseur: 4

Résultat: 2.0

import java.util.*;

public class Main {
    // Méthode pour séparer et trier un tableau
    public static int[] diviser_trier_tab(int[] tab) {
        // Vérifier si le tableau fourni est nul
        if (tab == null) {
            // Lancer une exception pour un tableau nul
            throw new IllegalArgumentException("Le tableau fourni est nul!"); 
        }
        
        // Drapeau d'initialisation indiquant l'état du tableau
        boolean flag = true; 
        while (flag) {
            // Initialement, le drapeau est mis à false
            flag = false; 
            
            // Parcourir le tableau pour effectuer un tri
            for (int j = 0; j < tab.length - 1; j++) {
                // Vérifier si l'élément courant est plus grand que 
                // l'élément suivant
                if (tab[j] > tab[j + 1]) { 
                    // Échanger les éléments s'ils sont dans le 
                    // mauvais ordre
                    swap(tab, j, j + 1); 
                    // Mettre le drapeau à true pour indiquer que la 
                    // permutation a eu lieu
                    flag = true; 
                }
            }
        }
        return tab; // Retourner le tableau trié
    }
    
    // Méthode pour permuter les éléments du tableau
    private static void swap(int[] tab, int left, int right) {
        // Stocker la valeur de l'index de droite dans une variable 
        // temporaire
        int temp = tab[right]; 
        // Attribuer la valeur de l'index de gauche à l'index de 
        // droite
        tab[right] = tab[left]; 
        // Attribuer la valeur stockée à l'index de gauche
        tab[left] = temp; 
    }
    
    public static void main(String[] args) {
        // Initialiser le tableau d'entrée
        int[] tab = {-1, 4, 2, -2, -4, 1, 3, -5, 6}; 
        System.out.println("\nTableau original:"+ Arrays.toString(tab));
        
        //Obtenir le résultat de la division et du tri
        int[] result = diviser_trier_tab(tab); 
        System.out.println("\nRésultat: " + Arrays.toString(result));
    }
} 

Sortie:

Tableau original: [-1, 4, 2, -2, -4, 1, 3, -5, 6]

Résultat: [-5, -4, -2, -1, 1, 2, 3, 4, 6]

import java.util.*;

public class Main {
  
  // Méthode pour déplacer tous les zéros du tableau vers la fin
  public static int[] dep_zero(int[] tab) {
    
    // Initialisation d'une variable booléenne pour suivre les 
    // opérations de permutation
    boolean swap = true; 
    
    // Boucle pour déplacer les zéros à la fin du tableau
    while (swap) {
      // Réinitialisation du drapeau de permutation à chaque 
      // itération
      swap = false; 
      
      // Parcourir les éléments du tableau
      for (int i = 0; i < tab.length - 1; i++) {
        // Permutation des éléments non nuls avec des zéros pour 
        // déplacer les zéros vers la fin
        if (tab[i] == 0 && tab[i + 1] != 0) {
          // Appel de la méthode permuter pour effectuer l'opération 
          // de permutation
          permuter(tab, i, i + 1); 
          // Mettre le drapeau de permutation à true après avoir 
          // effectué une permutation
          swap = true; 
        }
      }
    }
    // Retourner le tableau modifié
    return tab; 
  }
  
  // Méthode pour échanger des éléments dans le tableau
  private static void permuter(int[] tab, int a, int b) {
    // Stocker la valeur de tab[a] dans une variable temporaire
    int temp = tab[a];
    // Affectation de la valeur de tab[b] à tab[a]	
    tab[a] = tab[b]; 
    // Affectation de la valeur stockée dans la variable temporaire à 
    // tab[b]
    tab[b] = temp; 
  }
  
  // La méthode principale du programme
  public static void main(String[] args) {
    // Initialiser un tableau avec des entiers
    int[] tab = {0, 1, 2, 0, 3, 0, 4, 0}; 
    
    System.out.println("\nTableau original: "+ Arrays.toString(tab));
    
    // Appel de la méthode dep_zero pour déplacer les zéros à la fin 
    // du tableau
    int[] res = dep_zero(tab);
    
    System.out.println("\nRésultat: " + Arrays.toString(res));
  }
}

Sortie:

Tableau original: [0, 1, 2, 0, 3, 0, 4, 0]

Résultat: [1, 2, 3, 4, 0, 0, 0, 0]

import java.util.*;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    
    System.out.print("Saisir le premier nombre: ");
    int n1 = sc.nextInt();
    
    System.out.print("Saisir le deuxième nombre: ");
    int n2 = sc.nextInt();
    
    // Initialisation de la variable pour stocker le résultat de la 
    // multiplication
    int result = 0; 
    // Vérifier si le résultat est négatif
    boolean negative_nbr = (n1 < 0 && n2 >= 0) || (n2 < 0 && n1 >= 0);
    // Déterminer si le résultat est positif
    boolean positive_nbr = !negative_nbr; 
    
    // Conversion de n1 en valeur absolue pour simplifier la 
    // multiplication
    n1 = Math.abs(n1); 
    
    // Boucle pour effectuer une multiplication sans utiliser 
    // l'opérateur *
    for (int i = 0; i < n1; i++) {
      // Traiter l'addition ou la soustraction en fonction des signes 
      // des nombres
      if (negative_nbr && n2 > 0 || positive_nbr && n2 < 0)
        result -= n2; // Soustraire n2 du résultat
      else
        result += n2; // Ajouter n2 au résultat
    }
	
    // Afficher le résultat
    System.out.println("\nResult: "+ result);
  }
} 

Sortie:

Saisir le premier nombre: 2
Saisir le deuxième nombre: 4

Result: 8

import java.util.*;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    
    System.out.print("Saisir la première chaîne: ");
    String str1 = sc.nextLine();
    
    System.out.print("Saisir la deuxième chaîne: ");
    String str2 = sc.nextLine();
    
    // Initialisation de la variable pour stocker le résultat
    boolean res = false; 
    
    // Boucle pour parcourir les caractères de str2
    for (int i = 0; i < str2.length() - 1; i++) {
      // Vérifier si le caractère actuel de str2 correspond au 
      // premier caractère de str1
      if (str2.charAt(i) == str1.charAt(0)) {
        // Boucle pour comparer str1 avec une sous-chaîne de str2 à 
        // partir du caractère actuel
        for (int j = 0; j < str1.length(); j++) {
          // Vérifier si les caractères de str1 correspondent à la 
          // sous-chaîne correspondante de str2
          if ((i + j) < str2.length() && str1.charAt(j) == str2.charAt(i + j) && j == str1.length() - 1) {
            // Fixer le résultat à true si str1 est trouvé dans str2
            res = true; 
            // Sortie de la boucle une fois la correspondance trouvée
            break; 
          }
        }
      }
    }
    System.out.println("La deuxième chaîne contient la première? "+ res);
  }
} 

Sortie:

Saisir la première chaîne: hello
Saisir la deuxième chaîne: WayToLearnX, hello Alex.
La deuxième chaîne contient la première? true