Unité IN3S02 - TD1
Enoncé

Durée : 2 h

1- OBJECTIFS

2- TRAVAIL A REALISER

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

2.1- Types primitifs et expressions

2.1.1- Types et expressions numériques
Que valent les expressions suivantes :
1 + 2 / 3
47 % 2
5.0 + 2 / 3
10 + 2.0 / 3
2.1.2- Type booléen et expressions logiques
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
2.1.3- Type char
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 ;

2.2- Instructions if

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 ; }

2.2.2 - if-else imbriqués (2)
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- Instructions de boucle

2.3.1- Boucle for

Après exécution de l'algorithme suivant, que vaut x en fonction de x0 ?
double x = x0 ;
for (int i = 1 ; i < x0 ; i++)  x = x * x0 ;

Vérifier avec différentes valeurs de x0, par exemple : 0.0, 1.0, 2.0, 3.0, 3.4, 3.7

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 *

2.3.3- Boucles while vs do-while (1)
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
2.3.4- Boucles while vs do-while (2)
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

2.4- Exercices de synthèse

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 (*)

2.4.2- Suite "somme des cubes des chiffres du terme précédent" (*)
Soit la suite d'entiers définie par :
          n0 = un entier naturel non nul multiple de 3
          ni = somme des cubes des chiffres de ni-1
Théorème : cette suite devient constante au bout d'un certain temps (c'est-à-dire qu'à partir d'un certain rang i, ni = ni-1), et cette constante est indépendante du choix de n0.

Ecrire en Java une méthode déterminant la valeur de cette constante par calcul des ni 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
2.4.3- Dernier dimanche du mois (**)