Correction du TP n°2

Exercice 1

Le parcours du robot première version.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class Robot {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Lecture au clavier des largeurs du parcours */
/* coteCarre : entier */
/* largeurDamier : entier */
public static void parcourt(int coteCarre,int largeurDamier) throws IOException {
int x,y; // Position instantanee du robot
int i; // Indice de boucle for
/* Lecture au clavier des positions initiales en x et y */
System.out.print("Position x initiale : ");
x = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Position y initiale : ");
y = Integer.valueOf(flux.readLine()).intValue();
/* Si les donnees du probleme sont correctes */
if ( ( x >= 1 ) && ( x <= largeurDamier ) &&
( y >= 1 ) && ( y <= largeurDamier ) &&
( x+coteCarre <= largeurDamier ) &&
( y-coteCarre >= 1 ) ) {
/* Boucle de deplacement vers la droite */
for ( i = 1 ; i <= coteCarre ; i++ ) {
x = x+1;
System.out.println(x+","+y); }
/* Boucle de deplacement vers le bas */
for ( i = 1 ; i <= coteCarre ; i++ ) {
y = y-1;
System.out.println(x+","+y); }
/* Boucle de deplacement vers la gauche */
for ( i = 1 ; i <= coteCarre ; i++ ) {
x = x-1;
System.out.println(x+","+y); }
/* Boucle de deplacement vers le bas */
for ( i = 1 ; i <= coteCarre ; i++ ) {
y = y+1;
System.out.println(x+","+y); } }
else {
/* Affichage en cas de probleme avec les donnees */
System.out.println("Erreur dans les donnees du probleme"); }
}
/* Fonction principale */
public static void main(String [] args) throws IOException {
/* Lecture au clavier des largeurs du parcours */
/* et du damier */
System.out.print("Cote du parcourt : ");
int c = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Largeur du damier : ");
int l = Integer.valueOf(flux.readLine()).intValue();
/* Lancement du parcours */
parcourt(c,l);
}
}

Robot.java

Le parcours du robot seconde version.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class Robot2 {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Lecture au clavier des largeurs du parcours */
/* coteCarre : entier */
/* largeurDamier : entier */
public static void parcourt(int coteCarre,int largeurDamier) throws IOException {
int x,y; // Position instantanee du robot
int i; // Indice de boucle for
int xinc = 1; // Deplacement elementaire en x entre deux etapes
int yinc = 0; // Deplacement elementaire en y entre deux etapes
/* x et y sont respectivement initialises a 1 et 0 */
/* pour signifier un deplacement vers la droite */
/* en debut de parcours */
/* Lecture au clavier des positions initiales en x et y */
System.out.print("Position x initiale : ");
x = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Position y initiale : ");
y = Integer.valueOf(flux.readLine()).intValue();
/* Si les donnees du probleme sont correctes */
if ( ( x >= 1 ) && ( x <= largeurDamier ) &&
( y >= 1 ) && ( y <= largeurDamier ) &&
( x+coteCarre <= largeurDamier ) &&
( y-coteCarre >= 1 ) ) {
/* Boucle de gestion des deplacements : */
/* 4*coteCarre deplacements elementaires */
for ( i = 1 ; i <= coteCarre*4 ; i++ ) {
/* Deplacements en x et en y correspondant */
/* a un deplacement elementaire */
x = x+xinc;
y = y+yinc;
System.out.println(x+","+y);
/* Si on arrive dans le coin superieur droit, */
/* le deplacement se fait maintenant vers le bas */
if ( i == coteCarre ) {
xinc = 0;
yinc = -1; }
/* Si on arrive dans le coin inferieur droit, */
/* le deplacement se fait maintenant vers la gauche */
if ( i == coteCarre*2 ) {
xinc = -1;
yinc = 0; }
/* Si on arrive dans le coin inferieur gauche, */
/* le deplacement se fait maintenant vers le haut */
if ( i == coteCarre*3 ) {
xinc = 0;
yinc = 1; } } }
else {
/* Affichage en cas de probleme avec les donnees */
System.out.println("Erreur dans les donnees du probleme"); }
}
/* Fonction principale */
public static void main(String [] args) throws IOException {
/* Lecture au clavier des largeurs du parcours */
/* et du damier */
System.out.print("Cote du parcourt : ");
int c = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Largeur du damier : ");
int l = Integer.valueOf(flux.readLine()).intValue();
/* Lancement du parcours */
parcourt(c,l);
}
}

Robot2.java

Exercice 2

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class CalculMax {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Fonction de calcul du maximum de deux entiers */
/* v1,v2 : entiers a traiter */
/* Resultat de la fonction : entier */
public static int max(int v1,int v2) {
/* Comparaison de v1 et v2 pour retourner */
/* le plus grand des deux */
if ( v1 >= v2 )
return(v1);
else
return(v2);
}
/* Fonction de calcul du maximum de trois entiers */
/* v1,v2,v3 : entiers a traiter */
/* Resultat de la fonction : entier */
public static int max(int v1,int v2,int v3) {
/* Comparaison de v1 vis a vis de v2 et v3 */
/* pour le retourner s'il leur est superieur ou egal */
if ( ( v1 >= v2 ) && ( v1 >= v3 ) )
return(v1);
else
/* Si ce n'est pas v1, on compare v2 et v3 */
/* pour retourner le plus grand des deux */
if ( v2 >= v3 )
return(v2);
else
return(v3);
}
/* Fonction de calcul du maximum de trois entiers */
/* v1,v2,v3 : entiers a traiter */
/* Resultat de la fonction : entier */
public static int max2(int v1,int v2,int v3) {
/* Le maximum de trois valeur est le maximum */
/* de la premiere valeur et du maximum des deux autres */
/* valeurs */
return(max(v1,max(v2,v3)));
}
/* Fonction principale */
public static void main(String [] args) throws IOException {
/* Lecture au clavier des trois entiers a traiter */
System.out.print("Premier nombre : ");
int v1 = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Deuxieme nombre : ");
int v2 = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Troisieme nombre : ");
int v3 = Integer.valueOf(flux.readLine()).intValue();
/* Calcul et affichage du maximum */
/* des deux premieres valeurs */
int max2 = max(v1,v2);
System.out.println("La valeur maximale de "+v1+" et "+v2+" est "+max2);
/* Calcul et affichage du maximum des trois valeurs */
int max3 = max(v1,v2,v3);
System.out.println("La valeur maximale de "+v1+", "+v2+" et "+v3+" est "+max3);
/* Calcul et affichage du maximum des trois valeurs */
max3 = max2(v1,v2,v3);
System.out.println("La valeur maximale de "+v1+", "+v2+" et "+v3+" est "+max3);
}
}

CalculMax.java

Exercices supplémentaires

Exercice 3

Dans la première méthode, on tente de définir une autre méthode "inline". Cette manipulation est interdite. Il faut sortir la seconde méthode de la première.

Dans la seconde méthode, l'entête fait apparaître qu'un entier doit être retourné. Or aucune valeur à retourner n'est explicitement indiquée via return. Ajouter cette instruction.

Dans la dernière méthode, l'entête ne fait pas apparaître de valeur retournée. Or l'instruction return est utilisée. Soit elle doit être supprimée, soit l'entête doit être modifié en int produit().

Exercice 4

Application lancée par la commande java Pg0502.

Résultat à l'écran:
a = 12
a = 14
Resultat 25
a = 3
a = 5
a = 7
a = 6
a = 8
Resultat 13

/* Redacteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
public class Pg0502 {
/* Fonction a */
/* i : entier a traiter */
/* Resultat de la fonction : entier */
public static int a(int i) {
System.out.println("a = "+i);
return(i+b(i+2));
}
/* Fonction b */
/* j : entier a traiter */
/* Resultat de la fonction : entier */
public static int b(int j) {
System.out.println("a = "+j);
return(j-1);
}
/* Fonction principale */
public static void main(String [] args) {
int u = a(12);
System.out.println("Resultat "+u);
u = a(b(a(3)));
System.out.println("Resultat "+u);
}
}

Pg0502.java

Exercice 5

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class Pgcd {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Fonction de calcul du minimum de deux entiers */
/* v1,v2 : entiers a traiter */
/* Resultat de la fonction : entier */
public static int min(int v1,int v2) {
if ( v1 <= v2 )
return(v1);
return(v2);
}
/* Fonction de calcul du pgcd de deux entiers */
/* a,b : entiers a traiter */
/* Resultat de la fonction : entier */
public static int pgcd(int a,int b) {
/* Calcul du minimum de a et b et affectation */
/* de cette valeur comme valeur initiale du calcul */
int v = min(a,b);
/* Boucle tant que de calcul */
/* Deux conditions composees par ou */
/* pour la continuation du calcul */
/* Si l'une des deux est infirmee, la boucle s'arrete */
while ( ( v > 1 ) &&
( ( (a%v) != 0 ) || ( (b%v) != 0 ) ) ) {
/* Decrement de v */
v = v-1; }
return(v);
}
/* Fonction principale */
public static void main(String [] args) throws IOException {
/* Lecture au clavier des deux entiers a traiter */
System.out.print("Premiere valeur : ");
int v1 = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Seconde valeur : ");
int v2 = Integer.valueOf(flux.readLine()).intValue();
/* Calcul et affichage du pgcd de ces deux entiers */
System.out.println("Le PGCD de "+v1+" et "+v2+" est "+pgcd(v1,v2));
}
}

Pgcd.java

Exercice 6

L'algorithme brut.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
public class TracageAlgorithme {
/* Fonction principale */
/* Algorithme brut */
public static void main(String [] args) {
int k,i,j;
k = -4;
i = 0;
while ( k < 0 ) {
for ( j = 1 ; j <= -k ; j = j+2 ) {
i = i+k*j; }
k = k+1; }
System.out.println(i);
}
}

TracageAlgorithme.java

L'algorithme muni des appels de fonction d'affichage simulant la trace.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
public class TracageAlgorithme2 {
public static int cpt = 1;
/* Fonction de generation d'une chaine de caracteres */
/* representant un entier avec formatage de texte */
/* justifie a gauche (complement avec des espaces) */
/* a concurence de n caracteres */
/* val : valeur a transformer en texte */
/* n : nombre de caracteres a generer */
/* Resultat de la fonction : String */
public static String formatEspaces(int val,int n) {
String v =""+val;
int l = v.length();
if ( l == n ) {
return(v); }
if ( l <= n ) {
String s = new String();
for ( int i = 0 ; i < n-l ; i++ )
s += " ";
return(s+v); }
return(v.substring(0,n));
}
/* Fonction d'affichage d'une ligne de la trace */
/* l : message a afficher */
/* k : variable k dont le contenu est a afficher */
/* i : variable i dont le contenu est a afficher */
/* j : variable j dont le contenu est a afficher */
public static void afficheTrace(String l,int k,int i,int j) {
System.out.println(cpt+l+formatEspaces(k,3)+" "+
formatEspaces(i,4)+" "+
formatEspaces(j,2));
cpt++;
}
/* Fonction principale */
/* Algorithme avec trace */
/* sous forme d'affichage a l'ecran */
public static void main(String [] args) {
int k,i,j = -100;
k = -4;
i = 0;
afficheTrace(" 05 ",k,i,j);
while ( k < 0 ) {
afficheTrace(" 06 ",k,i,j);
for ( j = 1,afficheTrace(" 07 ",k,i,j) ;
j <= -k ;
j = j+2,afficheTrace(" 07 ",k,i,j) ) {
i = i+k*j;
afficheTrace(" 08 ",k,i,j);
afficheTrace(" 09 ",k,i,j); }
k = k+1;
afficheTrace(" 10 ",k,i,j);
afficheTrace(" 11 ",k,i,j); }
afficheTrace(" 06 ",k,i,j);
afficheTrace(" 12 ",k,i,j);
System.out.println(i);
afficheTrace(" 13 ",k,i,j);
}
}

TracageAlgorithme2.java

Exercice 7

Cette application détermine et affiche les coordonnées des pixels à afficher pour tracer un arc de 1/8 de cercle sur un écran bitmap. Le reste du cercle peut être obtenu par symétries.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class ArcCercle {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Fonction de determination des pixels */
/* d'un arc de 1/8 de cercle centre sur l'origine */
/* r : rayon du cercle (en pixels) */
public static void arcCercle(int r) {
int x,y,d;
x = 0;
y = r;
d = 1-r;
System.out.println(x+","+y);
while ( y > x ) {
if ( d < 0 )
d = d+2*x+3;
else {
d = d+2*(x-y)+5;
y = y-1; }
x = x+1;
System.out.println(x+","+y); }
}
/* Fonction principale */
public static void main(String [] args) throws IOException {
/* Lecture au clavier du rayon de l'arc */
/* de 1/8 de cercle a tracer */
System.out.print("Rayon de votre cercle : ");
int r = Integer.valueOf(flux.readLine()).intValue();
/* Lancement de la fonction de trace */
arcCercle(r);
}
}

ArcCercle.java

Auteur: Nicolas JANEY
UFR Sciences et Techniques
Université de Besançon
16 Route de Gray, 25030 Besançon
nicolas.janey@univ-fcomte.fr