ENPC - Programmation - Corrections 1

Avertissements

Cette page a pour but de donner des corrections des exercices proposés dans la feuille de la séance 1. Que vous ayez réussi à les faire ou non, regarder ces corrections peut vous donner des idées sur la manière de programmer, d'écrire les commentaires, d'organiser le code, etc.

Néanmoins, ces corrections proposent une façon de résoudre les problèmes posés. Ce n'est certainement pas la seule, et pas nécessairement la meilleure.

Par ailleurs, les exercices qui sont corrigés ici ont dû être effectués, rendus et accessoirement notés. Les corrections ne sont publiées sur le Web qu'ultérieurement. Autrement dit, si vous voyez un exercice corrigé dans une de ces pages, ce n'est plus la peine de me le rendre!

Autour du programme Bonjour.java

Ce que l'on voulait, dans un premier temps, c'est avoir l'affichage Bonjour ! si aucun argument n'est passé sur la ligne de commande, mais Bonjour Robert ! si la chaîne "Robert" a été passée sur la ligne de commande. Voilà donc une solution:

public class Bonjour {
  public static void main(String[] args) {
    /* on fait deux traitements différents selon
       le nombre d'éléments dans le tableau args. */
    if (args.length == 0) {
      // Premier cas: pas d'argument.
      System.out.println("Bonjour !");
    }
    else {
      // Sinon: au moins un argument.
      System.out.println("Bonjour " + args[0] + " !");
      /* Dans la ligne ci-dessus, l'opérateur '+' est
	 utilisé pour concaténer des String. */
    }
  }
}

Le programme ci-dessus ne prend en compte que le premier argument sur la ligne de commande, même s'il y en a plusieurs. Le programme ci-dessous "dit bonjour à tous les arguments".

public class Bonjour {
  public static void main(String[] args) {
    // Dans tous les cas, il faut dire "Bonjour"
    System.out.print("Bonjour ");
    /* Pour chaque argument (élément à l'indice i du tableau args)
       il faut l'afficher suivi d'une virgule. */
    for(int i = 0; i < args.length; i++) {
      System.out.print(args[i] + ", ");
    }
    // Dans tous les cas, on ajoute un point d'exclamation
    System.out.println("!");
  }
}
Voici deux exemples d'utilisation:
[home]$ java Bonjour
Bonjour ! 
[home]$ java Bonjour Pierre Paul Jacques
Bonjour Pierre, Paul, Jacques, ! 

Comme vous le constatez, ce n'est pas très joli d'avoir une virgule après le dernier argument. Pour avoir un résultat plus propre, il faut différencier le traitement des deux derniers arguments, s'ils existent:

public class Bonjour {
  public static void main(String[] args) {
    // Dans tous les cas, il faut dire "Bonjour"
    System.out.print("Bonjour ");
    
    /* On doit faire des traitements différents en fonction
       du nombre d'arguments. Cela peut être fait par une
       "instruction d'aiguillage", le "switch" (voir poly page 26).
       Il va "aiguiller" le code à exécuter vers le cas
       correspondant à la situation. */ 
    switch(args.length) {
    case 0:
      // Rien à faire
      break;
    case 1:
      // Juste afficher cet argument suivi d'un blanc
      System.out.print(args[0] + " ");
      break;
    default:
      /* S'il y en a au moins deux (n au total), il faut afficher
	 les n-2 premiers suivis de virgules et les deux derniers
	 séparés par le mot "et". */
      // Les n-2 premiers:
      int nbVirg = args.length - 2;
      for(int i = 0; i < nbVirg; i++)
	System.out.print(args[i] + ", ");
      // Les deux derniers:
      System.out.print(args[nbVirg] + " et " + args[nbVirg+1] + " ");
    }
    
    // Dans tous les cas, on ajoute un point d'exclamation
    System.out.println("!");
  }
}
ce qui donnerait alors:
[home]$ java Bonjour
Bonjour ! 
[home]$ java Bonjour Pierre Paul 
Bonjour Pierre et Paul ! 
[home]$ java Bonjour Pierre Paul Jacques 
Bonjour Pierre, Paul et Jacques !                                                              

Lecture d'un entier dans une String

Pour qu'un programme affiche autant de fois "Bonjour !" que spécifié par un nombre entier passé sur la ligne de commande, il faut simplement lire un entier dans la String passée en argument:

public class BonjourPlusieursFois {
  public static void main(String[] args) {
    // Précaution: si aucun argument n'est passé sur la ligne de commande
    if (args.length == 0) {
      // On affiche un message explicatif 
      System.out.println("Usage: java BonjourPlusieursFois ");
      // Et on sort du programme immédiatement
      System.exit(0);
    }

    /* À ce point du code, on est sûr qu'il y a au moins un argument
       car sinon, on serait sorti par System.exit(0). */
    int n = Integer.parseInt(args[0]);
    for(int i = 1; i<= n; i++) {
      System.out.println("Bonjour !");
    }
  }
}

Exercices de manipulation

  1. Le programme qui affiche un message disant si l'entier n, lu sur la ligne de commande, est un nombre premier ou non:
    /**
     * Programme qui affiche si un entier est premier ou non.
     */
    public class Premier {
      /**
       * Méthode principale de test. Elle accepte dans args les
       * arguments de la ligne de commande.
       * @param args le tableau des arguments de la ligne de
       * commande. args[0] doit contenir une String
       * représentant l'entier n à prendre en compte.
       */
      public static void main(String[] args) {
        // S'il n'y a pas d'argument, quitter immédiatement
        if (args.length < 1) {
    	    System.out.println("Usage: java Premier ");
    	    System.exit(0);
    	}
    	// Récupération de l'entier n
    	int n = Integer.parseInt(args[0]);
    	boolean prem = true;
    	int div = 2;
    	while (prem && (div < n)) {
    	    if (n % div == 0)
    		prem = false;
    	    else
    		div++;
    	}
    	if (prem)
    	    System.out.println(n + " est premier.");
    	else 
    	    System.out.println(n + " n'est pas premier. (" + 
    			       div + " * " + (n/div) + ")");
        }
    }
    
  2. Le programme qui affiche les valeurs des carrés des n premiers entiers, puis la somme cumulée de ces valeurs, où n est un entier passé sur la ligne de commande:
    /**
     * Programme qui affiche les carrés des n premiers entiers et leur
     * somme.
     */
    public class SommeCarres {
        /**
         * Méthode principale de test. Elle accepte dans args les
         * arguments de la ligne de commande.
         * @param args le tableau des arguments de la ligne de
         * commande. args[0] doit contenir une String
         * représentant l'entier n à prendre en compte.
         */
        public static void main(String[] args) {
    	// S'il n'y a pas d'argument, quitter immédiatement
    	if (args.length < 1) {
    	    System.out.println("Usage: java SommeCarres ");
    	    System.exit(0);
    	}
    	// Récupération de l'entier n
    	int n = Integer.parseInt(args[0]);
    	int somme = 0;
    	int carre;
    	for(int i = 1; i <= n; i++) {
    	    carre = i * i;
    	    System.out.println("Carré de " + i + " = " + carre);
    	    somme += carre;
    	}
    	System.out.println("Somme des carrés des " + n + 
    			   " premiers entiers = " + somme);
        }
    }
    
  3. Mise en commun dans un même programme qui n'affiche que la somme des carrés des nombres premiers inférieurs ou égaux à n. Utilise des méthodes.
    /**
     * Programme qui affiche les carrés des n premiers nombres entiers
     * premiers et leur somme.  
     */
    public class Exo {
      /**
       * Méthode renvoyant le carré de son argument.
       * @param i l'entier dont on doit calculer le carré.
       * @return le carré de i.
       */
      public static int carre(int i) {
        return i * i;
      }
      /**
       * Méthode testant si son argument est un nombre premier.
       * @param i l'entier dont on doit tester la parité.  
       * @return true si i est premier, false
       * sinon.
       */
      public static boolean estPremier(int i) {
        boolean prem = true;
        int div = 2;
        while (prem && (div < i)) {
          if (i % div == 0)
    	prem = false;
          else
    	div++;
        }
        return prem;
      }
      
      /**
       * Méthode principale de test. Elle accepte dans args les
       * arguments de la ligne de commande.
       * @param args le tableau des arguments de la ligne de
       * commande. args[0] est sensé contenir une
       * String représentant l'entier n à prendre en compte.
       */
      public static void main(String[] args) {
        // S'il n'y a pas d'argument, quitte immédiatement
        if (args.length < 1) {
          System.out.println("Usage: java Exo ");
          System.exit(0);
        }
        
        // Récupération de l'entier n
        int n = Integer.parseInt(args[0]);
        int somme = 0;
        for(int i = 1; i <= n; i++) {
          if (estPremier(i))
    	somme += carre(i);
        }
        System.out.println("Somme des carrés des nombres entiers premiers infériers à "
                           + n + " = " + somme);
      }
    }
    
    

    Etienne.Duris[at]univ-mlv.fr - © École Nationale des Ponts et Chaussées - Novembre 2001 - http://www-igm.univ-mlv.fr/~duris/ENPC