Exercice Java "Débutant"

Il s'agit d'une édition pour débutants suivant l'édition de base.

Édition débutant

Créez un programme qui vous permet d'entrer deux valeurs entières, affiche le résultat de la division de la première valeur par la deuxième valeur, puis affiche le résultat de la multiplication du résultat par la deuxième valeur. Tous les calculs doivent être de type entier (s'ils ne sont pas divisibles, les chiffres après la virgule décimale sont automatiquement tronqués).

    public static void question21(int num1, int num2) {
        System.out.println("Q21");
        int num3 = num1 / num2;
        //Afficher le résultat de la division de la première valeur par la deuxième valeur
        System.out.println(num3);
        //Afficher le résultat de la multiplication du résultat par une seconde valeur
        System.out.println(num3 * num2);
    }

Créez un programme qui vous permet de saisir une valeur entière et affiche OK si la valeur est supérieure à 5 et inférieure à 20.

     *
     * @param num1
     */
    public static void question22(int num1) {
        System.out.println("Q22");
        //Si la valeur est supérieure à 5 et inférieure à 20
        if (num1 > 5 && num1 < 20) {
            //Si la valeur est supérieure à 5 et inférieure à 20
            System.out.println("La première valeur est OK");
        }
    }

Créez un programme qui vous permet d'entrer une valeur entière et affiche OK si la valeur est -10 ou moins, ou 10 ou plus.

     *
     * @param num1
     */
    public static void question23(int num1) {
        System.out.println("Q23");
        if (num1 <= -10 || num1 >= 10) {
            //valeur-10 ou moins, ou 10 ou plus
            System.out.println("La première valeur est OK");
        }
    }

Entrons une valeur numérique et créons un programme qui affiche OK si la valeur est -10 ou plus et inférieure à 0, ou 10 ou plus, et NG sinon.

     *
     * @param num1
     */
    public static void question24(int num1) {
        System.out.println("Q24");
        //valeur-Lorsque 10 ou plus et moins de 0
        if ((num1 >= -10 && num1 < 0) || (num1 >= 10)) {
            System.out.println("La première valeur est OK");
        } else {
            System.out.println("C'est NG");
        }
    }

Créez un programme qui vous invite à entrer une valeur entière et affiche la plage 1 si la valeur est inférieure à -10, la plage 2 si la valeur est -10 ou plus et inférieure à 0 et la plage 3 si la valeur est égale ou supérieure à 0.

    public static void question25(int num1) {
        System.out.println("Q25");
        //valeur-Si moins de 10
        if (num1 < -10) {
            System.out.println("range 1");
            //　-10 ou plus et moins de 0
        } else if (num1 < 0) {
            System.out.println("range 2");
            //0 ou plus
        } else {
            System.out.println("range 3");
        }
    }

Utilisez l'instruction swicth-case pour créer un programme qui vous invite à entrer une valeur entière et en affiche un si la valeur est 1, deux si elle est 2, trois si elle est 3 et d'autres dans le cas contraire.

     *
     * @param num1
     */
    public static void question26(int num1) {
        System.out.println("Q26");
        //Exemple d'entrée num1(1,2,3,0)
        switch (num1) {
            //Traitement lorsque la valeur de l'expression et la valeur num1 correspondent
            case 1:
                System.out.println("one");
                break;
            case 2:
                System.out.println("two");
                break;
            case 3:
                System.out.println("three");
                break;
            //Que faire lorsque la valeur d'une expression ne correspond à la valeur d'aucune observation
            default:
                System.out.println("others");
        }
    }

Créez un programme qui vous permet d'entrer une valeur entière et calcule et affiche la somme de 1 à cette valeur. Cependant, si une valeur inférieure ou égale à 0 est entrée, elle sera affichée comme 0.

     *
     * @param num1
     */

    public static void question27(int num1) {
        System.out.println("Q27");
        for (int i = 1; i < num1; i++) {
            System.out.println(i);
        }
        if (num1 == 0) {
            System.out.println(0);
        }
    }

Créez un programme qui vous permet d'entrer une valeur entière et affiche la puissance de cette valeur. Cependant, si une valeur inférieure ou égale à 0 est saisie, 1 s'affiche. (Méthode flottante)

     *
     * @param num1
     */
    public static void question28(int num1) {
        for (int i = 1; i <= 10; i++) {
            num1 = num1 * i;
        }
        System.out.println(num1);
    }

Créez à plusieurs reprises un programme qui vous invite à saisir des valeurs entières 5 fois et affiche la somme de ces valeurs.

     *
     * @param num1
     * @param num2
     * @param num3
     * @param num4
     * @param num5
     */

    public static void question29(int num1, int num2, int num3, int num4, int num5) {
        System.out.println("Q29");
        //Afficher les valeurs totales
        System.out.println(num1 + num2 + num3 + num4 + num5);
    }

Créez un programme qui vous permet d'entrer des valeurs entières et affiche * pour ce nombre. Si la valeur d'entrée est égale ou inférieure à 0, rien ne doit être écrit.

     *
     * @param num1
     */
    public static void question30(int num1) {
        System.out.println("Q30");
        for (int i = 0; i < num1; i++) {
            System.out.print("*");
        }
    }

Créez un programme qui vous permet d'entrer des valeurs entières et affiche ce nombre de * avec des espaces tous les cinq.

     *Si la valeur d'entrée est égale ou inférieure à 0, rien ne doit être écrit.
     *
     * @param num1
     */
    public static void question31(int num1) {
        System.out.println("Q31");
        for (int i = 1; i < num1; i++) {
            System.out.print("*");
            // *Être vierge tous les 5
            if (i % 5 == 0) {
                System.out.print("\t");
            }
        }
    }

Afficher de 1 à 20 dans l'ordre, mais s'il s'agit d'un multiple de 5, créez un programme qui affiche une barre au lieu d'un nombre.

    public static void question32() {
        System.out.println("Q32");
        for (int i = 1; i < 20; i++) {
            //Pour les multiples de 5
            if (i % 5 == 0) {
                System.out.println("bar");
            } else {
                //Lorsqu'il n'est pas multiple de 5
                System.out.println(i);
            }
        }
    }

Créez un programme qui vous permet d'entrer des valeurs entières et affiche des valeurs autres que les valeurs d'entrée de 1 à 9.

     *
     * @param num1
     */
    public static void question33(int num1) {
        System.out.println("Q33");
        for (int i = 1; i < 10; i++) {
            //Si i n'est pas la valeur que vous avez entrée
            if (!(i == num1)) {
                System.out.println(i);
            }
        }
    }

Entrons une valeur entière et créons un programme qui affiche la valeur d'entrée et autre que la valeur d'entrée +1 de 1 à 9. Si la valeur d'entrée est 9, seul 9 n'est pas affiché.

     *
     * @param num1
     */
    public static void question34(int num1) {
        System.out.println("Q34");
        //Valeur d'entrée et valeur d'entrée+Sinon 1
        for (int i = 1; i < 10; i++) {
            if ((!(i == num1)) && (!(i == (num1 + 1)))) {
                System.out.println(i);
            }
        }
    }

Déclarez un tableau de type entier de taille 10 initialisé avec {3, 7, 0, 8, 4, 1, 9, 6, 5, 2}, faites-lui entrer une valeur entière et le numéro d'élément est la valeur d'entrée. Créez un programme qui affiche les valeurs des éléments du tableau. Vérifier si la valeur d'entrée est en dehors de la plage des éléments du tableau peut être omis.

    public static void question35(int num1) {
        System.out.println("Q35");
        // {3, 7, 0, 8, 4, 1, 9, 6, 5, 2}Déclarez un tableau de type entier de taille 10 initialisé avec
        int[] array = {3, 7, 0, 8, 4, 1, 9, 6, 5, 2};
        System.out.println(array[num1]);
    }

Déclarez un tableau de type entier de taille 10 initialisé avec {3, 7, 0, 8, 4, 1, 9, 6, 5, 2}, faites entrer deux valeurs entières et le numéro d'élément est la valeur d'entrée. Créez un programme qui calcule et affiche le produit des valeurs de deux éléments du tableau. Vérifier si la valeur d'entrée est en dehors de la plage des éléments du tableau peut être omis.

     *
     * @param num1
     */
    public static void question36(int num1, int num2) {
        System.out.println("Q36");
        // {3, 7, 0, 8, 4, 1, 9, 6, 5, 2}Déclarez un tableau de type entier de taille 10 initialisé avec
        int[] array = {3, 7, 0, 8, 4, 1, 9, 6, 5, 2};
        System.out.println(array[num1] * array[num2]);
    }

Déclarez un tableau de type entier de taille 10 initialisé avec {3, 7, 0, 8, 4, 1, 9, 6, 5, 2}, saisissez la valeur entière et le numéro d'élément est le tableau de valeurs d'entrée. Créez un programme qui fait référence à la valeur d'un élément, puis fait référence à et affiche la valeur d'un élément de tableau dont le numéro d'élément est la valeur référencée. Vérifier si la valeur d'entrée est en dehors de la plage des éléments du tableau peut être omis.

    public static void question37(int num1) {
        System.out.println("Q37");
        // {3, 7, 0, 8, 4, 1, 9, 6, 5, 2}Déclarez un tableau de type entier de taille 10 initialisé avec
        int[] array = {3, 7, 0, 8, 4, 1, 9, 6, 5, 2};
        int num2;
        num2 = array[num1];
        System.out.println(array[num2]);
    }

Déclarez un tableau de type entier de taille 10 initialisé avec {3, 7, 0, 8, 4, 1, 9, 6, 5, 2}, définissez initialement le numéro d'élément à référencer à 0 et faites référence à ceci La valeur de l'élément de tableau du numéro d'élément est affichée, puis la valeur de l'élément de tableau est définie comme le numéro d'élément suivant auquel faire référence, la valeur de l'élément de tableau de ce numéro d'élément de référence suivant est affichée et la valeur de l'élément de tableau est définie ultérieurement. Créez un programme qui se répète 10 fois avec le numéro d'élément auquel se référer ensuite.

    public static void question38() {
        System.out.println("Q38");
        // {3, 7, 0, 8, 4, 1, 9, 6, 5, 2}Déclarez un tableau de type entier de taille 10 initialisé avec
        int[] array = new int[]{3, 7, 0, 8, 4, 1, 9, 6, 5, 2};
        //Afficher la valeur de l'élément du tableau avec le numéro d'élément référencé 0
        int index = 0;
        //Répéter 10 fois
        for (int i = 0; i < 10; i++) {
            //Attribuer la valeur d'index à l'index de numéro d'élément
            index = array[index];
            //Affiche la valeur de l'élément du tableau lorsque le numéro de l'élément est un
            System.out.println(index);
        }
    }

Déclarez un tableau de type entier de taille 10 initialisé avec {3, 7, 0, 8, 4, 1, 9, 6, 5, 2} et définissez initialement le numéro d'élément référencé sur 0. Affichez la valeur obtenue en soustrayant la valeur de l'élément de tableau du numéro d'élément suivant de la valeur de l'élément de tableau de ce numéro d'élément de référence, et augmentez le numéro d'élément de référence de 1. Créez un programme qui répète cette procédure 9 fois. )

    public static void question39() {
        System.out.println("Q39");
        // {3, 7, 0, 8, 4, 1, 9, 6, 5, 2}Déclarez un tableau de type entier de taille 10 initialisé avec
        int[] array = new int[]{3, 7, 0, 8, 4, 1, 9, 6, 5, 2};
        //Répéter 9 fois
        //Index du numéro d'élément actuel
        for( int index = 0; index < 9; index++){
            /**
             * index=Lorsque 0, currentValue=3,nextIndex=1,nextValue=7
             * index=Quand 1 currentValue=7,nextIndex=2,nextValue=0
             * index=Lorsque 2 currentValue=0,nextIndex=3,nextValue=8
             * */
            //Valeur d'élément de tableau du numéro d'élément à référencer currentValue
            int currentValue = array[index];
            //Numéro d'élément existant(index)Le numéro d'élément suivant de nextIndex
            int nextIndex = index + 1;
            //NextValue est la valeur de l'élément du tableau avec le numéro d'élément suivant
            int nextValue = array[nextIndex];
            //Valeur obtenue en soustrayant la valeur de l'élément de tableau du numéro d'élément suivant de la valeur de l'élément de tableau du numéro d'élément
            System.out.println(currentValue - nextValue);
        }
    }
}