Exercice Java Corrigé pour Débutant | Partie 9

import java.util.*;

public class Main {
    public static void main(String[] args) {
        int[] tab = {10, 10, 10, 15, 50, 60, 20};
        System.out.println("Tab: "+Arrays.toString(tab));

        // Initialiser un compteur pour compter les occurrences 
        // de la valeur 10
        int c1 = 0; 
        // Initialiser un compteur pour compter les occurrences 
        // de la valeur 20
        int c2 = 0;

        for(int i = 0; i < tab.length; i++) {
            if(tab[i] == 10)
                // Incrémenter c1 lorsque l'élément est égal à 10
                c1++; 

            if(tab[i] == 20)
                // Incrémenter c1 lorsque l'élément est égal à 20
                c2++;
        }

        // Vérifier si le nombre de valeur 10 est supérieur au 
        // nombre de valeur 20
        System.out.printf(String.valueOf(c1 > c2)); 
    }
}

Sortie:

Tab: [10, 10, 10, 15, 50, 60, 20]
true

import java.util.*;

public class Main {
    public static void main(String[] args) {
        int[] tab = {10, 15, 25, 33, 45, 30, 55};
        int result = 1; 
        System.out.println("Tab: "+Arrays.toString(tab));

        // Parcourir le tableau
        for(int i = 0; i < tab.length; i++) {
            if(tab[i] == 10 || tab[i] == 30) {
                // Si l'élément est égal à 10 ou 30, le résultat est 
                // fixé à 0
                result = 0;
            }
        }

        if (result == 1)
            // Si le résultat est 1, afficher false
            System.out.printf(String.valueOf(false));
        else
            // Si le résultat est différent de 1, afficher true
            System.out.printf(String.valueOf(true)); 
    }
}

Sortie:

Tab: [10, 15, 25, 33, 45, 30, 55]
true

import java.util.*;
public class Main {
    public static void main(String[] args) {
        int[] tab = {10, 30, 10, 40, 50, 10};
        // Initialiser la variable count pour suivre le nombre 
        // d'occurrences de 10
        int count = 0; 
        // Initialiser une variable de résultat pour suivre 
        // l'évolution de la situation
        int result = 0; 

        // Vérifier si le tableau a au moins un élément et si le 
        // premier élément est 10
        if (tab.length >= 1 && tab[0] == 10) {
            // Incrémenter le compteur si le premier élément est 10
            count++;
        }

        // Parcourir le tableau en commençant par le deuxième élément 
        // (c'est-à-dire index 1)
        for (int i = 1; i < tab.length; i++) {
            // Vérifier si l'élément précédent et l'élément actuel 
            // sont tous les deux 10
            if (tab[i - 1] == 10 && tab[i] == 10) {
                // Afficher false si 10 éléments consécutifs sont 
                // trouvés
                System.out.printf(String.valueOf(false)); 
                result = 1; // Set the result to 1
            }

            // Vérifier si l'élément courant est 10 et incrémenter 
            // le compteur
            if (tab[i] == 10) {
                count++;
            }
        }

        // Si le résultat est toujours 0, cela signifie que le motif 
        // spécifique n'a pas été trouvé.
        if (result == 0) {
            // Afficher true si le nombre est égal à 3
            System.out.printf(String.valueOf(count == 3));
        }
    }
}

Sortie:

true

import java.util.*;

public class Main {
    public static void main(String[] args) {
        int[] tab = {50, 1, 2, 3, 8, 45};

        System.out.println("Tab: " + Arrays.toString(tab));

        // Initialiser une variable de résultat à 1
        int result = 1;

        // Parcourir le tableau pour vérifier la présence 
        // d'entiers consécutifs
        for (int i = 0; i <= tab.length - 3; i++) {
            // Vérifier si le nombre actuel, le suivant et celui 
            // d'après sont consécutifs
            if (tab[i] + 1 == tab[i + 1] && tab[i + 1] + 1 == tab[i + 2]) {
                // S'ils sont consécutifs, le résultat est fixé à 0
                result = 0;
            }
        }

        // Vérifier le résultat et afficher soit true, soit false
        if (result == 1) {
            System.out.printf(String.valueOf(false));
        } else {
            System.out.printf(String.valueOf(true));
        }
    }
}

Sortie:

Tab: [50, 1, 2, 3, 8, 45]
true

import java.util.Scanner;

public class Main {
    public static void main(String[] arg) {
        int test = 0;
        Scanner sc = new Scanner(System.in);

        System.out.print("Entrer un nombre entier positif: ");
        
        int n = sc.nextInt();

        if (n < 1) {
            // Si n est inférieur à 1, on affiche 'false' et on met 
            // 'test' à 1
            System.out.print(Boolean.toString(false));
            test = 1;
        }

        if ((n & (n - 1)) != 0) {
            // Si n n'est pas une puissance de 2, on affiche 'false' 
            // et on met 'test' à 1
            System.out.print(Boolean.toString(false));
            test = 1;
        }

        if (test == 0) {
            // Si 'test' est 0, vérifier si n a des bits impairs et 
            // afficher le résultat.
            System.out.print(Boolean.toString((n & 0x55555555) != 0)); 
        }
    }	
}

Sortie:

Entrer un nombre entier positif: 16
true

import java.util.Scanner;

public class Main {
    public static void main(String[] arg) {
        int x, y;
        Scanner sc = new Scanner(System.in); 

        System.out.print("Saisir le premier nombre: ");
        x = sc.nextInt();

        System.out.print("Saisir le deuxième nombre: ");
        y = sc.nextInt();

        while (y != 0) {
            // Calculer la retenue par l'opération AND bit à bit 
            // entre x et y
            int retenu = x & y;
            // Calculer la somme sans tenir compte de la retenue par 
            // l'opération XOR bit à bit.
            x = x ^ y; 
            // Calculer la retenue pour la prochaine itération en la 
            // décalant d'une position vers la gauche.
            y = retenu << 1; 
        }

        // Afficher la somme des deux nombres
        System.out.print("Somme: " + x); 
    }
}

Sortie:

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

import java.util.*;

public class Main {
    public static void main(String[] arg) {
        // tab1 a 'm' éléments mais est assez grand pour contenir 
        // 'm+n' éléments
        // Déclaration et instanciation de tab1
        int tab1[] = new int[8];
        
        // Initialiser les quatre premiers éléments de tab1
        tab1[0] = 1;
        tab1[1] = 2;
        tab1[2] = 3;
        tab1[3] = 4;
        
        // tab2 a 'n' éléments
        // Initialiser tab2
        int[] tab2 = {3, 6, 7, 8};
        
        System.out.println("\nTab1: " + Arrays.toString(tab1));
        System.out.println("\nTab2: " + Arrays.toString(tab2));
        
        // Définissez les variables m et n
        int m = 4, n = 4;
        
        // Initialiser les pointeurs pour tab1 (i) et tab2 (j) et 
        // l'index pour la fusion (index)
        int i = m - 1, j = n - 1, index = m + n - 1;
        
        // Fusionner les deux tableaux dans tab1
        while (i >= 0 && j >= 0) {
            if (tab1[i] > tab2[j]) {
                tab1[index--] = tab1[i--];
            } else {
                tab1[index--] = tab2[j--];
            }
        }
        
        // Traiter les éléments restants dans tab1 (s'il y en a)
        while (i >= 0) {
            tab1[index--] = tab1[i--];
        }
        
        // Traiter les éléments restants dans tab2 (s'il y en a)
        while (j >= 0) {
            tab1[index--] = tab2[j--];
        }

        System.out.println("\nTableau fusionné: " + Arrays.toString(tab1));
    }
}

Sortie:

Tab1: [1, 2, 3, 4, 0, 0, 0, 0]

Tab2: [3, 6, 7, 8]

Tableau fusionné: [1, 2, 3, 3, 4, 6, 7, 8]

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        System.out.print("Saisir un nombre entier positif: ");
        int n = sc.nextInt();
        
        System.out.printf("%d est-il un nombre palindrome ?\n", n);
        
        // Vérifier si le nombre est un palindrome et afficher 
        // le résultat.
        System.out.println(checkPalindrome(n));
    }

    // Fonction permettant d'inverser les chiffres d'un nombre
    public static int reverseNbr(int n) {
        int reverse = 0;
        while (n != 0) {
            reverse *= 10;
            reverse += n % 10;
            n /= 10;
        }
        return reverse;
    }

    // Fonction permettant de vérifier si un nombre est un palindrome
    public static boolean checkPalindrome(int n) {
        return (n == reverseNbr(n));
    }
}

Sortie:

Saisir un nombre entier positif: 121
121 est-il un nombre palindrome ?
true

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Saisir un nombre entier positif: ");
        int nbr = sc.nextInt(); 

        System.out.printf("La racine carrée de %d est: ", nbr);

        // Appeler la méthode sqrt pour calculer la racine carrée et 
        // afficher le résultat.
        System.out.println(sqrt(nbr)); 
    }

    // Méthode pour calculer la racine carrée d'un nombre
    private static int sqrt(int n) {
        if (n == 0 || n == 1) {
            return n;
        }
        int a = 0;
        int b = n;

        // Effectuer une recherche binaire pour trouver la racine 
        // carrée
        while (a <= b) {
            int mid = (a + b) >> 1;
            if (n / mid < mid) {
                b = mid - 1;
            } else {
                if (n / (mid + 1) <= mid) {
                    return mid;
                }
                a = mid + 1;
            }
        }
        return a;
    }
}

Sortie:

Saisir un nombre entier positif: 16
La racine carrée de 16 est: 4