2.6  Les sous-programmes

• Initiation
• Géométrie
• Arithmétique
• Passage de tableaux en paramètre
• Décomposition en facteurs premiers
• Pour le sport

2.6.1  Initiation

Exercice 1 Compte à rebours

Écrire un sous-programme prenant en paramètre un nombre n et affichant les valeurs n, n−1, …, 1, 0.

Corrigé

2.6.2  Géométrie

Exercice 2 Jolies figures

Écrire un programme demandant à l’utilisateur de saisir une valeur numérique positive n et affichant un carré, une croix et un losange, tous de coté n. Par exemple, si n = 10, l’exécution donne

Saisissez la taille des figures
10
* * * * * * * * * *
*                 *
*                 *
*                 *
*                 *
*                 *
*                 *
*                 *
*                 *
* * * * * * * * * *
                  *
                *   *
              *       *
            *           *
          *               *
        *                   *
      *                       *
    *                           *
  *                               *
*                                   *
  *                               *
    *                           *
      *                       *
        *                   *
          *               *
            *           *
              *       *
                *   *
                  *
*                                   *
  *                               *
    *                           *
      *                       *
        *                   *
          *               *
            *           *
              *       *
                *   *
                  *
                *   *
              *       *
            *           *
          *               *
        *                   *
      *                       *
    *                           *
  *                               *
*                                   *

Vous définirez des sous-programmes de quelques lignes et au plus deux niveaux d’imbrication. Vous ferez attention à ne jamais écrire deux fois les mêmes instructions. Pour ce faire, complétez le code source suivant.

package procedural;

import java.util.Scanner;

public class GeometrieVide
{

 /*
  * Affiche le caractère c
  */

 public static void afficheCaractere(char c)
 {
 }

 /* 
  * Affiche n fois le caractère c, ne revient pas à la ligne 
  * après le dernier caractère.
  */

 public static void ligneSansReturn(int n, char c)
 {
 }

 /* 
  * Affiche n fois le caractère c, revient à la 
  *  ligne après le dernier caractère.
  */

 public static void ligneAvecReturn(int n, char c)
 {
 }

 /* 
  * Affiche n espaces.
  */

 public static void espaces(int n)
 {
 }

 /* 
  * Affiche le caractère c à la colonne i, ne revient 
  * pas à la ligne après.
  */

 public static void unCaractereSansReturn(int i, char c)
 {
 }

 /*
  *  Affiche le caractère c à la colonne i,
  *  revient à la ligne après.
  */

 public static void unCaractereAvecReturn(int i, char c)
 {
 }

 /* Affiche le caractère c aux colonnes i et j,
  * revient à la ligne après.
  */

 public static void deuxCaracteres(int i, int j, char c)
 {
 }

 /*
  *  Affiche un carré de côté n.
  */

 public static void carre(int n)
 {
 }

 /* Affiche un chapeau dont la pointe - 
  * non affichée - est sur la colonne centre, 
  * avec les caractères c.
  */

 public static void chapeau(int centre, char c)
 {
 }

 /* 
  * Affiche un chapeau à l'envers avec des caractères c, 
  * la pointe - non affichée - est à la colonne centre.
  */

 public static void chapeauInverse(int centre, char c)
 {
 }

 /* 
  * Affiche un losange de côté n.
  */

 public static void losange(int n)
 {
 }

 /*
  *  Affiche une croix de côté n.
  */

 public static void croix(int n)
 {
 }

 public static void main(String[] args)
 {
  Scanner scanner = new Scanner(System.in);
  int taille;
  System.out.println("Saisissez la taille des figures : ");
  taille = scanner.nextInt();
  scanner.close();
  carre(taille);
  losange(taille);
  croix(taille);
 }
}  

Télécharger le fichier

Corrigé

2.6.3  Arithmétique

Exercice 3 chiffres et nombres

Rappelons que a % b est le reste de la division entière de a par b.

1. Écrire la fonction static int unites(int n) retournant le chiffre des unités du nombre n.
2. Écrire la fonction static int dizaines(int n) retournant le chiffre des dizaines du nombre n.
3. Écrire la fonction static int extrait(int n, int p) retourant le p-ème chiffre de représentation décimale de n en partant des unités.
4. Écrire la fonction static int nbChiffres(int n) retournant le nombre de chiffres que comporte la représentation décimale de n.
5. Écrire la fonction static int sommeChiffres(int n) retournant la somme des chiffres de n.

Exercice 4 Nombres amis

Soient a et b deux entiers strictement positifs. a est un diviseur strict de b si a divise b et a ≠ b. Par exemple, 3 est un diviseur strict de 6. Mais 6 n’est pas un diviseur strict 6. a et b sont des nombres amis si la somme des diviseurs stricts de a est b et si la somme des diviseurs de b est a. Le plus petit couple de nombres amis connu est 220 et 284.

1. Écrire une fonction static int sommeDiviseursStricts(int n), elle doit renvoyer la somme des diviseurs stricts de n.
2. Écrire une fonction static boolean sontAmis(int a, int b), elle doit renvoyer true si a et b sont amis, false sinon.

Exercice 5 Nombres parfaits

Un nombre parfait est un nombre égal à la somme de ses diviseurs stricts. Par exemple, 6 a pour diviseurs stricts 1, 2 et 3, comme 1 + 2 + 3 = 6, alors 6 est parfait.

1. Est-ce que 18 est parfait ?
2. Est-ce que 28 est parfait ?
3. Que dire d’un nombre ami avec lui-même ?
4. Écrire la fonction static boolean estParfait(int n), elle doit retourner true si n est un nombre parfait, false sinon.

Exercice 6 Nombres de Kaprekar

Un nombre n est un nombre de Kaprekar en base 10, si la représentation décimale de n² peut être séparée en une partie gauche u et une partie droite v tel que u + v = n. 45² = 2025, comme 20 + 25 = 45, 45 est aussi un nombre de Kaprekar. 4879² = 23804641, comme 238 + 04641 = 4879 (le 0 de 046641 est inutile, je l’ai juste placé pour éviter toute confusion), alors 4879 est encore un nombre de Kaprekar.

1. Est-ce que 9 est un nombre de Kaprekar ?
2. Écrire la fonction static int sommeParties(int n, int p) qui découpe n est deux nombres dont le deuxième comporte p chiffres, et aui retourne leur somme. Par exemple,

   sommeParties(12540, 2) = 125 + 40 = 165

3. Écrire la fonction static boolean estKaprekar(int n)

Corrigé

2.6.4  Passage de tableaux en paramètre

Exercice 7 Somme

Ecrire une fonction public static int somme(int[] T) retournant la somme des éléments de T.

Exercice 8 Minimum

Ecrire une fonction public static int min(int[] T) retournant la valeur du plus petit élément de T.

Exercice 9 Recherche

Ecrire une fonction public static bool existe(int[] T, int k) retournant true si et seulement si k est un des éléments de T.

Exercice 10 Somme des éléments pairs

Ecrivez le corps de la fonction public static int sommePairs(int[] T), sommePairs(T) retourne la somme des éléments pairs de T. N’oubliez pas que a%b est le reste de la division entière de a par b.

Exercice 11 Vérification

Ecrivez le corps de la fonction public static bool estTrie(int[] T), estTrie(T) retourne vrai si et seulement si les éléments de T sont triés dans l’ordre croissant.

Exercice 12 Permutation circulaire

Ecrire une fonction public static void permutation(int[] T) effectuant une permutation circulaire vers la droite des éléments de T.

Exercice 13 Miroir

Ecrire une fonction public static void miroir(int[] T inversant l’ordre des éléments de T.

2.6.5  Décomposition en facteurs premiers

On rappelle qu’un nombre est premier s’il n’est divisible que par 1 et par lui-même. Par convention, 1 n’est pas premier.

1. Écrivez une fonction public static bool estPremier(int x, int[] premiers, int k) retournant vrai si et seulement si x est premier. Vous vérifierez la primarité de x en examinant les restes des divisions de x par les k premiers éléments de premiers. On suppose que k est toujours supérieur ou égal à 1.
2. Modifiez la fonction précédente en tenant compte du fait que si aucun diviseur premier de x inférieur à √x n’a été trouvé, alors x est premier
3. Écrivez une fonction public static int [] trouvePremiers(int n) retournant un tableau contenant les n premiers nombres premiers.
4. Écrivez une fonction public static int[] decompose(int x, int[] premiers) retournant un tableau contenant la décomposition en facteurs premiers du nombre x, sachant que T contient les n premiers nombres premiers. Par exemple, si x = 108108, alors on décompose n en produit de facteurs premiers de la sorte

   108108 = 2*2*3*3*3*7*11*13 = 22*33*50*71*111*131*170*190* … *Z0

   (où Z est le n-ième nombre premier). On représente donc x de façon unique par le tableau à n éléments suivant :

   {2, 3, 0, 1, 1, 1, 0, 0, 0, …, 0}

5. Écrivez une fonction public static int recompose(int[] decomposition, int [] premiers) effectuant l’opération réciproque de celle décrite ci-dessus.
6. Écrivez une fonction public static int[] pgcd(int[] T, int[] K) prenant en paramètre les décompositions en facteurs premiers T et K de deux nombres, retournant la décomposition en facteurs premiers du plus grand commun diviseur de ces deux nombres.
7. Écrivez une fonction public static int pgcd(int i, int j) prenant en paramètres deux nombres i et j, et combinant les fonctions précédentes pour retourner le pgcd de i et j. Vous poserez n suffisamment grand pour le calcul puisse fonctionner correctement.

2.6.6  Pour le sport

Exercice 14 Conversion chiffres/lettres

Écrire un sous-programme prenant un nombre en paramètre et l’affichant en toutes lettres. Rappelons que 20 et 100 s’accordent en nombre s’ils ne sont pas suivis d’un autre nombre (ex. : quatre-vingts, quatre-vingt-un). Mille est invariable (ex. : dix-mille) mais pas million (ex. : deux millions) et milliard (ex. : deux milliards). Depuis 1990, tous les mots sont séparés de traits d’union (ex. : quatre-vingt-quatre), sauf autour des mots mille, millions et milliard (ex. : deux mille deux-cent-quarante-quatre, deux millions quatre-cent-mille-deux-cents). (source : http://www.leconjugueur.com/frlesnombres.php).

Corrigé