Durée : 2 h

1- OBJECTIFS

• Maîtriser les types primitifs, les expressions, et les instructions if et boucles en Java (syntaxe et sémantique)

Nota : le travail demandé doit être terminé, en séance ou hors séance.

2.1- Types primitifs et expressions

Que valent les expressions suivantes :

1 + 2 / 3
47 % 2
5.0 + 2 / 3
10 + 2.0 / 3

Soit la déclaration :
          boolean ok ;
Pour la suite, les quatres variables w, x, y et z sont toutes supposées déclarées, du même type primitif (int, double, char ou boolean), et initialisées ; la variable d est supposée déclarée de type double et initialisée.

A -  ok = ( x == y || z || w ) ;
// ok prend la valeur true ssi la valeur de x est égale à l’une des valeurs de y, z ou w

B -  ok = ( x < y < z ) ;
// ok prend la valeur true ssi les valeurs de x, y et z sont strictement croissantes

C -  ok = ( (int)x  / (int)y > 1 ) ;
// ok prend la valeur true ssi la valeur de x convertie en entier est supérieure à la valeur entière de y convertie en entier (on suppose (int)y non nul )

D -  ok = ( x = y ) ;
// ok prend la valeur true ssi les valeurs de x et y sont égales

E -  ok = ( (Math.sqrt(d) < 100) && (d > 0) ) ;
// ok prend la valeur false ssi d<=0 ou racine_carrée(d)>=100

• Identificateur de variable vs constante littérale

Soient les déclarations :
          boolean ok ;
     char a, b, c ;
et les instructions :
          ok = false ;
     a = lire(); // lire est supposée définie et correctement employée
     b = lire();
     c = lire();
On suppose que l’utilisateur fournit trois lettres. On veut que ok prenne la valeur true si et seulement si les deux     premières sont la lettre minuscule c.

A -  if ( ’a’ == ’c’ &&  ’b’== ’c’ ) ok = true ;
B -  if ( a == c  &&  b == c )       ok = true ;
C -  if ( a == ’b’ &&  b == ’c’ )    ok = true ;
D -  if ( a == b  &&  b == ’c’ )     ok = true ;
E -  if ( a == ”c” &&  b == ”c” )    ok = true ;

• Soit à convertir un chiffre hexadécimal en nombre décimal.

On considère les déclarations suivantes :
char hexa ;
int dec ;
Pour la suite, on supposera que la variable hexa aura été initialisée.

A-  if (hexa >= '0' && hexa <= 'F') dec = (int)hexa ;

B- if ('0' <= hexa <= '9')      dec = (int)hexa - (int)'0' ;
   else if ('A' <= hexa <= 'F') dec = (int)hexa - (int)'A' + 10 ;

C-  if (hexa >= 0 && hexa <= 9)      dec = (int)hexa - (int)0;
   else if (hexa >= A && hexa <= F) dec = (int)hexa - (int)A;

D-  if (hexa >= '0' && hexa <= '9')     
        dec = (int)hexa - (int)'0' ;
   else if (hexa >= 'A' && hexa <= 'F')
            dec = (int)hexa - (int)'A' ;

E-  if (hexa >= '0' && hexa <= '9')
            dec = (int)hexa - (int)'0' ;
   else if (hexa >= 'A' && hexa <= 'F')
          dec = (int)hexa - (int)'A' + 10;

2.2.1- if-else imbriqués (1)

On considère l’algorithme en pseudo-langage suivant (le symbole <-- dénote l'affectation) :
          Si a < b alors
                Si b < c alors a <-- a + 1 FinSi
              sinon
                b <-- b + 1
     FinSi
Il sera correctement traduit en Java par :

A -  if ( a < b ) if ( b < c ) a = a + 1 ;
    else b = b + 1 ;

B -  if ( a >= b )     b = b + 1 ;
    else if ( b < c ) a = a + 1 ;

C -  if ( (a<b) && (b<c) )  a = a + 1 ;
    if ( !(a<b) )          b = b + 1 ;

D -  if ( (a<b) && (b<c) )  a = a + 1 ;
    else  b = b + 1 ;

E -  if ( a < b ) { if ( b < c ) a = a + 1 ; }
    else  { b = b + 1 ; }

On considère l'algorithme en pseudo-langage suivant :
          Si a=b alors
        Si b=c alors Si e=f alors afficher 1 FinSi
               sinon afficher 2
        FinSi
     FinSi
Chacune des traductions Java suivantes est-elle possible ? (on suppose la méthode afficher définie et correctement employée)

A -  if (a==b)
       if (b!=c) afficher(2);
       else      if (e==f) afficher(1);

B -  if (a==b) {
       if (b==c) {
          if (e==f) afficher(1);
       }
       else afficher(2);
    }

C -  if (a==b) {
       if (b==c)  if (e==f) afficher(1);
       else afficher(2);
    }

D -  if (a==b)
       if (b==c) { if (e==f) afficher(1); }
       else afficher(2);

E -  if (a==b)
       if (b==c)  if (e==f) afficher(1);
       else afficher(2);

2.3.1- Boucle for

2.3.2- Boucle while

On suppose les variables k, x, y et z préalablement déclarées de type int et initialisées.
Soit l’algorithme suivant :
          k = x ;
     while ((k < y) || (k > z)) {
        System.out.println("*") ;
        k = k+1 ;
     }

A -  Si y < z  et  x appartient à [y, z]
       alors l’algorithme se termine mais sans rien afficher

B -  Si y < z  et  x appartient à [y, z]
       alors l’algorithme s’arrête après avoir affiché (z-x+1) caractères *

C -  Si x > z  alors l’algorithme entre dans une boucle infinie

D -  Si x < y  alors l’algorithme se termine mais sans rien afficher

E -  Si x < y  alors l’algorithme s’arrête après avoir affiché (y-x) caractères *

Soient a, b, a1, b1, a2, b2 des variables de type entier. On suppose a1, b1, a2, et b2 initialisées.
Soit l'algorithme 1 suivant :
          a = a1 ;
     b = b1 ;
     while ( a > b  &&  a > 0 ) {
        a = a + 1 ;
        b = b - 1 ;
     }
Soit l'algorithme 2 suivant :
          a = a2 ;
     b = b2 ;
     do {
        a = a + 1 ;
        b = b - 1 ;
     } while ( a > b  &&  a > 0 ) ;
On dira que ces deux algorithmes sont équivalents pour un même quadruplet de valeurs initiales (a1, b1, a2, b2) ssi :

- soit les deux algorithmes bouclent à l'infini
- soit ils fournissent à la fin la même valeur pour a et la même valeur pour b.

A-  Quel que soit (a1, b1, a2=a1, b2=b1), ces deux algorithmes sont équivalents
B-  Quel que soit (a1, b1, a2=a1-1, b2=b1+1), ces deux algorithmes sont équivalents
C-  Quel que soit (a1, b1, a2=a1, b2=b1)  avec 0 < b1 < a1, ces deux algorithmes sont équivalents
D-  Il existe (a1, b1, a2, b2) tel que :

- aucun des deux algorithmes ne boucle "à l'infini"
- ET les valeurs finales de a et b sont égales à leurs valeurs d’initialisation respectives

E-  Si on remplace la dernière ligne de l'algorithme 2  par la ligne suivante :
     } while ( a <= b  || a <= 0 ) ;
alors, quel que soit (a2, b2), l'algorithme 2 n'entrera jamais dans une boucle infinie

L'instruction
          do INSTRUCTION_SIMPLE ; while(CONDITION) ;

A -  est toujours équivalente à la séquence :
        INSTRUCTION_SIMPLE ;
        while(CONDITION) INSTRUCTION_SIMPLE ;

B -  est toujours équivalente à la séquence :
        INSTRUCTION_SIMPLE ;
        while(!CONDITION) INSTRUCTION_SIMPLE ;

C -  est toujours équivalente à la séquence :
        while(!CONDITION)
            INSTRUCTION_SIMPLE ;
            INSTRUCTION_SIMPLE ;

D -  est toujours équivalente à  :
        if(CONDITION)  { INSTRUCTION_SIMPLE ;  }
        else { while(CONDITION) INSTRUCTION_SIMPLE ;  }

E -  ne peut jamais boucler à l’infini

Par la suite, réaliser d'abord les algorithmes en pseudo-langage avant de les traduire en Java.

Le niveau de difficulté de chaque exercice (algorithme ou/et programmation) est spécifié par un nombre d'étoiles :
        *  facile
        **  peu difficile
        ***  assez difficile
        ****  difficile ou assez long à réaliser

2.4.1- Conjecture Hongroise (*)

Soit la suite d'entiers définie par :
          h₀ = un entier naturel non nul
          h_i+1 = h_i / 2     si h_i est pair
          h_i+1 = 3*h_i + 1 si h_i est impair

Il est conjecturé que cette suite finit toujours par entrer dans le cycle "4  2  1" quelle que soit la valeur h₀. On n'a trouvé aucun contre-exemple, mais cette propriété n'a jamais été démontrée.

Exemple avec h₀ = 3 :      3  10  5  16  8  4  2  1  4  2  1  4  2  1 ...

Ecrire en Java une méthode testant la validité de cette conjecture pour toutes les valeurs de h₀ d'une certaine plage de valeurs :

- paramètres : deux entiers naturels non nuls nmin et nmax, nmin étant supposé au plus égal à nmax ;
- valeur de retour : un booléen, true ssi la conjecture est vraie pour toute valeur h₀ du segment [nmin, nmax]

Soit la suite d'entiers définie par :
          n₀ = un entier naturel non nul multiple de 3
          n_i = somme des cubes des chiffres de n_i-1

Théorème : cette suite devient constante au bout d'un certain temps (c'est-à-dire qu'à partir d'un certain rang i, n_i = n_i-1), et cette constante est indépendante du choix de n₀.

Ecrire en Java une méthode déterminant la valeur de cette constante par calcul des n_i successifs :

- paramètre : un entier naturel n supposé non nul et multiple de 3

- valeur de retour : la valeur de convergence de la suite
- contrainte de réalisation : en supposant que n comporte k chiffres (la détermination de k est inutile ! ), les différents chiffres de n seront déterminés par k divisions successives par 10 et non par k divisions successives par des puissances consécutives de 10

Ecrire en Java une méthode déterminant, à partir d'une date quelconque, la date du dernier dimanche du mois en question :
- paramètres : une date de référence définie par 4 données
° le jour, de type char
° le quantième, de type int
° le mois, de type int
° l'année, de type int
- valeur de retour : le quantième du dernier dimanche du mois concerné.
- contrainte de réalisation : ne pas utiliser de boucle (car non nécessaire!) !

Exemple :

Avec la donnée d'entrée : j 9 12 1999 (c'est-à-dire jeudi 9 décembre 1999),
le résultat est : 26 (car le dernier dimanche de décembre 1999 tombe le 26).