Exercice programme java algorithme if boucle - L'heure du bilan -

Rédigé par GC Team, Publié le 13 Août 2010, Mise à jour le Samedi, 17 Décembre 2022 18:47
Participez au vote ☆☆☆☆☆★★★★★
But:
 Votre tante fortunée revient ... mais cette fois avec des boucles !
Thème:
 algorithme, if, boucles
Fichiers:
 -


Votre tante fortunée vous envoie désormais un montant chaque mois. A la fin de l'année vous souhaitez faire un bilan de vos richesses. Ecrivez le programme Java Bilan.java vous affichant la somme mensuelle moyenne reçue, le montant minimal reçu sur l'année et le montant maximal reçu sur l'année. Le bilan se fera sur n montants de la façon suivante:

Donnez n: ..
Donnez le montant du mois 1 (Frs): ..
Donnez le montant du mois 2 (Frs): ..
Donnez le montant du mois 3 (Frs): ..
...

Il affichera (exemple pour n = 3, montant1 = 100, montant2 = 200 et montant3 = 400):

La somme mensuelle moyenne reçue est: 233 
Le montant mensuel minimal reçu est: 100 
Le montant mensuel maximal reçu est: 400




 

 Ici, il fallait noter qu'il n'est pas nécessaire de stocker les montants  de chaque  mois. On s'intéresse uniquement à faire un certain nombre de  calculs/tests sur  les montants introduits au fur et à mesure. Par exemple: à chaque fois  qu'un montant  est introduit, on l'ajoute au total des montants, stocké dans la  variable total,  et qui va nous servir au calcul de la moyenne. L'algorithme pour trouver  le minimum  (resp. maximum) est classique: à chaque fois qu'un nouveau montant est  introduit  on teste si ce montant est plus petit que le minimum déjà connu. Si oui,  le minimum  connu devient ce montant, sinon il garde sa valeur.

 Le minimum connu est ici initialisé  à la plus grande valeur possible pour une variable de type int, donnée en Java par Integer.MAX_VALUE. Si on l'initialisait arbitrairement avec une valeur trop petite (par  exemple 10),  l'algorithme nous retournerait la valeur d'initialisation au lieu du  véritable  minimum. On procède de manière analogue pour le maximum.  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

import java.util.Scanner;
class Bilan {

    private static Scanner scanner = new Scanner(in);

    public static void main(args[]) {
        // Lecture du nombre de mois
       System.out.print("Donnez le nombre de mois: ");
        int months = scanner.nextInt();

        int min = Integer.MAX_VALUE;
        int max = 0;

        int total = 0;

        // Lecture des montants, accumulation et valeurs extrêmes
        for (int i = 0; i < months; i++) {
           System.out.print(" Donnez le montant du mois " + (i + 1)  + " (Frs): ");
            int montant = scanner.nextInt();
            total = total + montant;

            if (montant > max) {
                max = montant;
            }

            if(montant < min) {
                min = montant;
            }           
        }
       System.out.println("La somme mensuelle moyenne reçue est: " + (total / months));
       System.out.println("Le montant mensuel minimal reçu est: "+ min);
       System.out.println("Le montant mensuel maximal reçu est: "+ max);
    }
}

Exercice JAVA sur les sariables statiques - Static

But:

Indiquez l'affichage d'un programme.

Thème:

static

Fichiers:

AfficherCouleur.java

Indiquez l'affichage du programme AfficherCouleur ci-dessous. La classe
FigureGeometrique se trouve juste après.

AfficherCouleur.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

class AfficherCouleur {
    public static void main(String[] args) {
        FigureGeometrique f1, f2, f3, f4;
        f1 = new FigureGeometrique("Rouge", "Noir");
        f2 = new FigureGeometrique("Bleu", "Blanc");
        f3 = new FigureGeometrique();
        f4 = new FigureGeometrique("Violet", "Orange");

        f2.changerCouleurContour("Noir");

        System.out.println(f3.couleurSurface);
        System.out.println(f3.couleurContour);

        System.out.println(f2.couleurContour);

        System.out.println(FigureGeometrique.nbFigures);
        System.out.println(f2.nbFigures);

        System.out.println(f1.nbFigContNoir);
        System.out.println(f4.nbFigSurfBlanc);
    }
}

class FigureGeometrique {
    String couleurContour = "Jaune";
    String couleurSurface = "Blanc";

    static int nbFigures = 0;
    static int nbFigContNoir = 0;
    static int nbFigSurfBlanc = 0;

    FigureGeometrique() {
    }

    FigureGeometrique(String coulSurf, String coulCont) {
        couleurSurface = coulSurf;
        couleurContour = coulCont;
        if (couleurContour.equals("Noir")) {
            nbFigContNoir++;
        }
        if (couleurSurface.equals("Blanc")) {
            nbFigSurfBlanc++;
        }
        nbFigures++;
    }

    void changerCouleurContour(String couleur) {
        couleurContour = couleur;
    }

    void changerCouleurSurface(String couleur) {
        couleurSurface = couleur;
    }
}

 encore une fois, faire bien attention à ce qui est statique est ce qui ne l'est pas. Pour ce genre d'exercices, aidez-vous toujours de petits schémas associés à vos objets et décrivant leur contenu, puis déroulez le programme pas à pas en mettant à jour le contenu des objets dans vos schémas.

L'affichage est:

Blanc
Jaune
Noir
3
3
1
0

Exercices programme JAVA - Terminologie et structure - programme à trous

Exercice 1 : terminologie

Soit le morceau de code Java suivant : (x * 3) + 1
– quel nom donne-t-on à ce morceau de code tout entier ?
– quels sont les opérateurs ?
– quels sont les opérandes de * ?
– quels sont les opérandes de + ?
– quel genre de chose est x dans ce morceau de code ? {sidebar id=2}
– quel(s) type(s) a ou peut éventuellement avoir x ?
– quel est le type de 3 et 1 ?
– quel est le type de (x * 3) + 1 ?
– quelle est la valeur de (x * 3) + 1 ?

Exercice 2 : structure d’un programme

Dans le programme suivant , dire quelles sont les les déclarations, les appels de méthode et les affectations:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
public class Td1 {
public static void main ( String [ ] arguments )
{
    Terminal.ecrireStringln( "exo1" ) ;
     int n =2 ;
     char c ;
     boolean b ;
      Terminal.ecrireDoubleln(3.0 + 2 ) ;  
           n =3+2;
           n=n+n ;
           i n t m;
          m=n +( 2  ( n + 2 ) ) ;
       Terminal.ecrireIntln(m) ;
       Terminal.ecrireIntln(n) ;
  }
}

Exercice 3 : programme à trous

Compléter les trous de ce programme en choisissant parmis les instructions encadrées suivantes de façcon à ce que l’exécution du programme produise l’effet suivant :
> java Exo3_3
Au marche je dois acheter 6 oeufs mais aussi 9 carottes , 4 choux et 6 navets.

Le programme à compléter :

1
2
3
4
5
6
7
8
9
 
public class Exo3_3 {
public static void main ( String [ ] arguments )
 {
     int x ;
     int a =4 ;
     char b = ’ a ’ ;
     . . .
   }
}

Les instructions parmi lesquelles il faut choisir (toutes ne sont pas à utiliser mais chacune ne peut s’utiliser qu’une seule fois) :{sidebar id=1}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
x= 6;
x=x+3;
a=x+3;
Terminal.ecrireInt(x) ;
Terminal.ecrireInt(a) ;
Terminal.ecrireInt(b) ;
Terminal.ecrireString("Au marche je dois acheter ");
Terminal.ecrireStringln(x + " oeufs ");
Terminal.ecrireStringln( " x oeufs mais aussi ");
Terminal.ecrireString("mais aussi " + x);
Terminal.ecrireString("mais aussi " + a);
Terminal.ecrireString("carottes , " +(x-2) +"choux");
Terminal.ecrireString("carottes , " + a +"choux");
Terminal.ecrireStringln(b + "choux");
Terminal.ecrireString("et");
Terminal.ecrireStringln(" navets.");

Exercice 4 : petits programmes

Question 1 : positif ou négatif
Ecrire un programme qui détermine si un nombre est positif ou négatif. Il considérera 0 comme positif.
Ce programme demandera un nombre à l’utilisateur puis affichera si le nombre est positif ou négatif au moyen d’un message approprié (chaîne de caractère).

Exercice POO de base stockage en mémoire

But:
 Indiquer l'affichage d'un programme donné
Thème:
 POO de base
Fichiers:
 Memoire.java

Indiquez l'affichage du programme Memoire.java. Abstenez-vous d'exécuter le programme avant de répondre à la question. Faites toujours très attention aux détails en répondant à ce genre de question.


Il s'agit de comprendre les différentes façons de stocker en mémoire une variable de type primitif et une variable de type objet. La classe A est déclarée dans le même fichier que la classe Memoire.

Memoire.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

class Memoire {
    public static void main (String args[]) {
        int i = 1;
        afficher(i);
        modifier(i);
        afficher(i);
        System.out.println("-----");
        A a1 = new A(1);
        a1.afficher();
        a1.modifier();
        a1.afficher();
        System.out.println("-----");
        A a2 = new A(2);
        a2.afficher();
        A a3 = new A(3);
        a3.afficher();
        System.out.println("-----");
        a3 = a2;
        a2.afficher();
        a3.afficher();
        System.out.println("-----");
        a2.modifier();
        a3.modifier();
        a2.afficher();
        a3.afficher();
        System.out.println("-----");
    }
    static void modifier (int i) {
        i++;
    }
    static void afficher (int i) {
        System.out.println(i);
    }
}

class A {
    private int i;
    A (int i) {
        this.i = i;
    }
    void modifier () {
        i++;
    }
    void afficher () {
        System.out.println(i);
    }
}

Affichage du programme:

1
1
-----
1
2
-----
2
3
-----
2
2
-----
4
4
-----

 Exercice JAVA modularisation du code de la multiplication matricielle

But:
 Modulariser le code de la multiplication matricielle
Thème:
 Modularisation


Le programme MulMat.java que vous avez développé  contient de nombreuses portions de code dupliquées: il est mal modularisé!
On souhaiterait améliorer ce programme au moyen de méthodes auxiliaires. Dans le programme MulMatMod.java, la méthode main a déjà été réécrite avec des appels à des méthodes auxiliaires utiles. Il vous est demandé de compléter le code de MulMatMod.java. Vous pouvez transférer les instructions nécessaires depuis le programme MulMat.java en les copiant-collant. Exécutez les deux programmes pour vérifier qu'ils ont le même comportement.
Code à compléter :

1
2
3
4
5
6
7
8
9
10
11
12
13

class MulMatMod {
    public static void main(String[] args) {
        double[][] mat1 = lireMatrice();
        double[][] mat2 = lireMatrice();
        if (mat1[0].length != mat2.length) {
          System.out.println("Multiplication de matrices impossible !");
        } else {
            double [][] prod = multiplierMatrice(mat1, mat2);
          System.out.println("Résultat :");
            afficherMatrice(prod);
        }
    }
}
Fichiers:


Pour faire cet exercice, il fallait créer les méthodes permettant de lire une matrice, mutliplier deux matrices et afficher une matrice. Le corps de ces méthodes contient les instructions nécessaires au traitement, copiées depuis la version non modularisée MulMat.java.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

import java.util.Scanner;

class MulMatMod {

    private static Scanner scanner = new Scanner(System.in);

    /**
     * Point d'entrée du programme. Demande à l'utilisateur
     * d'entrer deux matrices, les multiplie, et affiche
     * le résultat.
     */
    public static void main(String[] args) {
        double[][] mat1 = lireMatrice();
        double[][] mat2 = lireMatrice();
        if (mat1[0].length != mat2.length) {
          System.out.println("Multiplication de matrices impossible !");
        } else {
            double[][] prod = multiplierMatrice(mat1, mat2);
          System.out.println("Résultat :");
            afficherMatrice(prod);
        }
    }

    /**
     * Demande à l'utilisateur d'entrer un entier
     * strictement positif.
     * @param message Le message affiché à l'utilisateur.
     * @return Un entier strictement positif.
     */ 
    static int lireEntier(String message) {
        int n;
        do {
          System.out.print(message);
            n = scanner.nextInt();
        } while (n < 1);
        return n;
    }

    /**
     * Demande à l'utilisateur de remplir une matrice.
     * @return Un tableau de double contenant la matrice.
     */ 
    static double[][] lireMatrice() {
      System.out.println("Saisie d'une matrice :");

        int lignes = lireEntier("  Nombre de lignes : ");
        int colonnes = lireEntier("  Nombre de colonnes : ");

        double[][] mat = new double[lignes][colonnes];
        for (int row = 0; row < lignes; row++)
            for (int col = 0; col < colonnes; col++) {
              System.out.print("  mat[" + (row + 1) + "," + (col + 1) + "]=");
                mat[row][col] = scanner.nextDouble();
            }
        return mat;
    }

    /**
     * Multiplie deux matrices.
     * @param mat1 Le premier opérande
     * @param mat2 Le deuxième opérande
     * @return Un tableau de double contenant le produit
     */ 
    static double[][] multiplierMatrice(double[][] mat1, double[][] mat2) {
        double[][] prod = new double[mat1.length][mat2[0].length];
        for (int row = 0; row < mat1.length; row++) {
            for (int col = 0; col < mat2[0].length; col++) {
                prod[row][col] = 0.0;
                for (int i = 0; i < mat2.length; i++) {
                    prod[row][col] += mat1[row][i] * mat2[i][col];
                }
            }
        }
        return prod;
    }

    /**
     * Affiche une matrice à l'écran
     * @param prod La matrice à afficher
     */ 
    static void afficherMatrice(double[][] prod) {
        for (int row = 0; row < prod.length; row++) {
            for (int col = 0; col < prod[row].length; col++) {
              System.out.print(prod[row][col] + " ");
            }
            // Retour à la ligne
          System.out.println();
        }
    }
}

 Exercices Java : Les boucles - somme des carrés - sondage - traingle

Nous vous proposons ici des exercices qui concernent des points avancés des chapitres 6 et 7, notamment les tableaux à plusieurs dimensions.

Exercice 1 : somme des carrés

Ecrire une fonction qui calcule la somme des n premiers carrés 12 + 22 + . . . + n {sidebar id=8}
2. L’entier n est un paramètre de la fonction.

Exercice 2 : sondage

Un institut de sondage veut faire une enquête sur les intentions de vote à un référendum. Il y a trois intentions possibles :

– voter oui
– voter non
– voter blanc ou s’abstenir

L’institut veut distinguer les intentions de vote des hommes et des femmes.
Le résultat du sondage sera donné sous la forme d’un tableau du genre :

oui non abstention
homme 12 37 25
femme 9 47 13

Ce tableau signifie par exemple que 12 hommes ont l’intention de voter oui, 37 de voter non, etc.

La représentation en Java d’un tel tableau se fera de la façon suivante :

0             1          2

12 37 25
9 47 13

{sidebar id=1}

Il y a donc un encodage où l’indice 0 signifie une intention de vote oui, l’indice 1 pour le non, l’indice 2 pour l’abstention, ainsi que l’indice 0 pour les hommes et l’indice 1 pour les femmes.
Ecrivez un programme qui lit au clavier un tel tableau et qui comporte les fonctions suivantes :
– une fonction qui calcule le nombre de femmes prises en compte dans l’enquête.

– une fonction qui calcule le nombre total de personnes ayant une intention de vote donnée. Cette intention de vote, de même que le tableau, sera un paramètre de la fonction. Elle pourra être donné sous forme de l’indice encodant cette intention.

– une fonction qui prédit le résultat du vote. Ce résultat ne prend pas en compte les abstentionnistes. Seuls les votes exprimés sont pris en compte (en France).
– une fonction qui détermine si les hommes et les femmes sont équitablement représentés dans l’enquête.

Exercice 3 : triangle (bis)

On rappelle le programme qui dessine des triangles faits avec des étoiles (exercice 6.2).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
class Exo6_2{
public static void main ( String [ ] args ) {
int taille , nbEt , nbEsp ;
Terminal . ecrireString ( " Entrez la taille du triangle : " ) ;
taille = Terminal . lireInt ( ) ;
nbEsp = taille ?1;
nbEt = 1 ;
for ( int i =1 ; i <= taille ; i ++){
/ / les espaces
for ( intj =1 ; j <= nbEsp ; j ++){
Terminal .ecrireChar ( ’ ’ ) ;
}
/ / les etoiles
for ( int j =1 ; j <= nbEt ; j ++){
Terminal . ecrireChar ( ’ * ’ ) ;
}
Terminal . sautDeLigne ( ) ;
nbEsp = nbEsp ?1;
nbEt = nbEt +2 ;
}
}
}

Question 1

Adaptez ce programme pour qu’au lieu d’afficher les espaces et les étoiles à l’écran, il les mette dans
un tableau de caractères à deux dimensions. Le calcul du tableau sera fait dans une fonction qui prendra la
taille du triangle en paramètre.
Exemple de tableau avec une dimension 3 :

0 1  2   3    4
0 ’ ’ ’ ’ ’*’ ’ ’ ’ ’
1 ’ ’ ’*’ ’*’ ’*’ ’ ’
2 ’*’ ’*’ ’*’ ’*’ ’*’

Question 2

Ecrivez trois méthodes qui affichent un tableau contenant un triangle. La première doit afficher le triangle
avec la pointe en haut. La deuxième doit afficher la pointe à droite et la troisième, la pointe en bas.

pointe en haut

*                       
***                    
*****

pointe à droite

*
**
***
**
*

pointe en bas

*****
***
*

TD de Programmation par objets et Java #1 : Etude d'instructions

TD de Programmation par objets et Java #1

Etude d'instructions

J. Ferber

Quelles sont les erreurs et les effets des instructions suivantes:

1
2
3
4
5
6
7
8
9
10
11
12
13

int a, b, c, d;
String z, t;
boolean u,v;
a = 7;
c = b + c;
t = "zozo";
v = (t != "zaza");
u = (a == 7) || v;
z = t + a;
t = t + " est " + t;
a*2 = a + 5;
d == 5;
c = 3a;

Trace d'une exécution

Que fait le programme suivant:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import java.io.*;
public class trace
{
public static void main(String[] args) throws IOEception, NumberFormatException
{
int x, y;
x = 4;
y = 10;
x = x+y;
y = y-y;
x = x-y;
System.out.println("x= " + x);
System.out.println("y= " + y);
}
}