Exercice avec matrices, ArrayList
Bonjour tout le monde !
J'essaie de faire l'exercice suivant (gros résumé):
1) Créer une matrice binaire (juste avec des 1 et des 0) en :
a/ entrant une chaine de caractère contenant une suite de 0, de 1 et d'espaces
b/ utiliser "split" pour diviser cette chaîne en un certain nombre de lignes, en se servant des espaces comme séparateurs (je sais pas si j'explique parfaitement ce que fait split, mais j'ai réussi à m'en servir en tout cas).
2) Faire afficher par le programme les "tranches maximales"(drôle de nom) de la matrice, via ce procédé (extrait de l'énoncé) :
" Le programme fourni déclare une variable maxConsecutifList sous la forme d’un tableau dynamique de Integer. Il s’agit :
1/ de stocker dans maxConsecutifList les indices des lignes contenant la plus grande séquence de ’1’ consécutifs dans la matrice;
2/ et d’afficher le contenu de maxConsecutifList"
Moyennant tout un tas de vérification préalables : que la matrice ne contienne que des 1 ou des 0, qu'elle ne soie pas vide, etc. ça j'y suis arrivé sans trop de difficultés (je progresse, ouaiiiis :D ). C'est le point 2 qui me pose plus souci, première fois que je manipule les array list. J'ai essayé plusieurs choses qui pour l'instant ne marchent pas. Voici mon code actuel :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
| import java.util.ArrayList;
import java.util.Scanner;
class TrancheMax {
private static Scanner clavier = new Scanner(System.in);
public static void main(String[] args) {
// Entree de la matrice
System.out.println("Saisie de la matrice :");
String matrice = clavier.nextLine();
System.out.format("Matrice saisie :\n%s\n", matrice);
// stocke les indices des lignes contenant la plus grande sequence de
// '1' consecutifs dans la matrice
ArrayList<Integer> maxConsecutifList = new ArrayList<Integer>();
/*******************************************
* Completez le programme a partir d'ici.
*******************************************/
// On vérifie que la matrice n'est pas vide
if(matrice.length()==0){
System.out.println("Matrice vide!");
return;
}
// On vérifie que les lignes ne sont constituées que de 0, de 1, et d'espaces
for(int i=0; i<matrice.length(); ++i)
{
if(matrice.charAt(i) != '0' && matrice.charAt(i) != '1' && matrice.charAt(i) != ' ')
{
System.out.println("Matrice invalide, seulement '1' , '0' et ' ' admis!");
return;
}
}
// On splitte la matrice
String[] lignes = matrice.split(" {1,}");
// On vérifie que les lignes sont de même longueur
for(int i=1; i<lignes.length; ++i)
{
if(lignes[i-1].length() != lignes[i].length())
{
System.out.println("Matrice invalide, lignes de longueurs differentes!");
return;
}
}
// On procède au comptage
// En cours d'écriture
int nbCourant=0;
int nbMax =0;
for(int i=0; i<matrice.length(); ++i){
if(matrice.charAt(i) == '1'){
nbCourant +=1;
if(nbMax <= nbCourant){
nbMax = nbCourant;
}
} else {
nbCourant = 0;
}
}
System.out.println("Suite la plus longue de 1 (nbMax) :" + nbMax);
// Comment faire le lien entre nbMax et maxConsecutifList ?
/*******************************************
* Ne rien modifier apres cette ligne.
*******************************************/
if (maxConsecutifList.isEmpty()) {
System.out.println("Pas de lignes avec des 1!");
} else {
System.out.println("Ligne(s) avec le plus de 1 consecutifs:");
for (Integer index : maxConsecutifList) {
System.out.println(index);
}
}
}
} |
Comme vous le voyez j'ai une piste (que j'ai trouvé sur le forum de mon cours) que j'ai réussi à coder, mais ensuite je me demande un peu comment continuer. Il faut que j'arrange quoi ? Et si 'est pas trop demander, c'est quoi ce "index :" à la fin dans Integer index : maxConsecutifList ? Je suis en train de revoir mon cours mais j'ai pas encore trouvé.
Et pour info, la piste que j'ai trouvé sur le forum de mon cours dis ceci :
si tu testes 1100011001000111000
Tu vas parcourir les valeurs les unes après les autres.
tu initialises nbMax=0; nbCourant=0;
Tu incrémentes nbCourant tant que tu as des 1, donc arrivé au rang 2, où il y a un 0, tu auras donc nbCourant=2 (les 2 premiers "1").
nbCourant > nbMax, donc nbMax=nbCourant. (on sauvegarde la valeur maximale)
on remet nbCoiurant a 0, et on continue.
arrivé au rang 5, on recommence a incrémenter nbCourant jusqu'a la fin de la série de "1", soit jusqu'au rang 7
Là, on a nbMax=2, et nbCourant=2.
Donc on ne change pas nbMax, et on remet nbCourant à 0.
la série suivante de "1" nous donnera ,nbCourant=1, donc pareil, on ne change pas.
la dernière série de "1" nous donnera nbCourant=3.
On aura donc nbCourant>nbMax, donc on stocke nbCourant dans nbMax, et on continue.
Arrivé a la fin, tu auras donc sauvegardé le noimbre maximum de "1" consecutifs dans nbMax.
