Problème avec mon programme

Bonjour,

Je sollicite votre aide pour un exercice en java que je dois rendre demain, cela fait 2 jours que je galère sans trouver de solution, merci de bien vouloir maider.
J'ai deux tableaux tab1 et tab2 de même taille;
le tableau tab1 est ordonné, et je veux le parcourir de façon dans le tableau tab 2 retourner la valeur minimale entre les deux valeurs correspondant aux mêmes index du tab1 en double.
tab1: [0, 0, 1, 2, 2, 3, 4, 4, 5]
tab2 : [2, 4, 1, 1, 4, 0, 3, 2, 2]
Dmin( s[0] ) = min( deviation( s[0], t[2] ), deviation( s[0], t[4] ) )
= min( 2, 4 ) = 2
Dmin( s[1] ) = min( deviation( s[1], t[0] ) )
= min( 1 ) = 1
Dmin( s[2] ) = min( deviation( s[2], t[1] ), deviation( s[2], t[6] ) )
= min( 1, 4 ) = 1
Dmin( s[3] ) = min( deviation( s[3], t[3] ) )
= min( 0 ) = 0
Dmin( s[4] ) = min( deviation( s[4], t[1] ), deviation( s[4], t[6] ) )
= min( 3, 2 ) = 2
Dmin( s[5] ) = min( deviation( s[5], t[7] ) )
= min( 2 ) = 2

normalement j'aurai un autre tableau de sortie :
tab3: [2,1,1,0,2,2]
mon code
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 static void paires(ArrayList<String> tab1, ArrayList<String> tab3) { ArrayList<Integer> tab3 = new ArrayList<>(); for (int i = 0; i < tab.size(); i++) { if (tab.get(i) == tab.get(nbr)) min = tab2.get(nbr); { if (tab.get(i) > tab.get(nbr)) { if (tab2.get(i) > tab2.get(nbr)) { min = tab2.get(i); } nbr++; } } } valeur.add(nbr, min); } System.out.println(tab3); }
Merci infiniment....

Salut,

Pour commencer énoncer les choses clairement.
Que peut bien vouloir dire la phrase :

Citation:

Envoyé par aladin15

et je veux le parcourir de façon dans le tableau tab 2 retourner la valeur minimale entre les deux valeurs correspondant aux mêmes index du tab1 en double.

.
Et pourquoi tu parles de tab1[] et tab2[] en entrée et tu montres des formules qui dépendent de s[] et t[] ? C'est quoi le rapport entre s, t, tab1 et tab2 ?

Et tu introduis une notion, déviation, sans expliquer ce que c'est... on peut le deviner, mais ce serait mieux que tu le définisses explicitement. Et comment obtenir les valeurs intermédiaires des formules que tu montres, qui ne sont pas dans le tableau en entrée (les indices de t). La notation en tableau semble impropre vu le résultat final ( abs(s[?]-t[?]) ).
Ensuite, tu montres un bout de code

qui n'est pas cohérent : pourquoi des ArrayList<String> en paramètres, alors que tout ce que tu montres dans ton énoncé sont des tableaux de int.
et pourquoi c'est tab1 et tab3 et pas tab1 et tab2 ?
qui présentent des variables dont on ne sait rien, puisqu'on a pas leur déclaration : nbr ? min ? tab ? tab2 ?
La méthode paires a un paramètre tab3 et une variable tab3, ce qui est impossible en Java.

Pour résoudre un problème complexe, on le divise en plusieurs problèmes, plus simples. Et on les résout, un à un, étape par étape.

De ce que je comprends en interprétant le résultat final par rapport aux entrées, et ce que je pense interpréter de ce que tu décris, sans tenir des formules que tu indiques qui sont incohérentes pour moi.
On a deux tableaux de int en entrée :
Code:

1 2 3 int[] tab1 = { 0, 0, 1, 2, 2, 3, 4, 4, 5 }; int[] tab2 = { 2, 4, 1, 1, 4, 0, 3, 2, 2 };
On cherche à déterminer pour chaque valeur de tab1, une valeur. Il y a 6 valeurs différentes dans tab1.
Donc on déclare un tableau résultat :

Code:

int[] tab3 = new int[6];

On pourrait faire une boucle sur tab1 pour déterminer la taille du tableau tab3. La taille de tab3, c'est la valeur la plus grande de tab1, plus 1. On va partir du principe qu'il n'y a pas de trou, et, comme tu le précises que le tableau soit ordonné (mais ça n'a pas grande importance).
On parcourt donc ce tableau tab3, ce qui donne les valeurs de tab1 :
Code:

1 2 3 for(int i=0; i<tab3.length; i++) { // on parcourt les valeurs possibles de tab1 }
Ensuite, on va chercher les index de ces valeurs dans tab1 :
Code:

1 2 3 4 5 6 7 8 for(int i=0; i<tab3.length; i++) { // on parcourt les valeurs possibles de tab1 for(int j=0; j<tab1.length; j++) { if ( tab1[j]==i ) { //on a trouvé i dans tab1 } } }
On veut les valeurs de tab2 dont l'index est celui des i dans tab1 :
Code:

1 2 3 4 5 6 7 8 9 for(int i=0; i<tab3.length; i++) { // on parcourt les valeurs possibles de tab1 int min=Integer.MAX_VALUE; for(int j=0; j<tab1.length; j++) { if ( tab1[j]==i ) { //on a trouvé i dans tab1 // tab2[j] c'est la valeur de tab2 qui nous intéresse (à l'index de i dans tab1, soit j) } } }
On veut la plus petite des valeurs de tab2[j]. Qu'on va appeler min (donc stocker dans une variable min). Pour calculer le minimum d'une liste de valeur, on initialise min à la valeur maximale quelle peut avoir, Integer.MAX_VALUE par exemple, et pour chaque valeur on prend la plus petite entre cette valeur et le min précédemment obtenu :
Code:

1 2 3 4 5 6 7 8 9 10 for(int i=0; i<tab3.length; i++) { // on parcourt les valeurs possibles de tab1 int min=Integer.MAX_VALUE; // la valeur la plus grande possible pour un int for(int j=0; j<tab1.length; j++) { if ( tab1[j]==i ) { //on a trouvé i dans tab1 min = Math.min(tab2[j],min); // la valeur la plus petite entre la valeur courante de tab2 à l'index j et le min précédent } } }
Il ne nous reste plus qu'à stocker la valeur min dans tab3 :
Code:

1 2 3 4 5 6 7 8 9 10 11 for(int i=0; i<tab3.length; i++) { // on parcourt les valeurs possibles de tab1 int min=Integer.MAX_VALUE; // la valeur la plus grande possible pour un int for(int j=0; j<tab1.length; j++) { if ( tab1[j]==i ) { //on a trouver i dans tab1 min = Math.min(tab2[j],min); // la valeur la plus petite entre la valeur courante de tab2 à l'index j et le min précédent } } tab3[i]=min; // on stocke la valeur dans tab3 }
et à afficher le tableau tab3 :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 for(int i=0; i<tab3.length; i++) { // on parcourt les valeurs possibles de tab1 int min=Integer.MAX_VALUE; // la valeur la plus grande possible pour un int for(int j=0; j<tab1.length; j++) { if ( tab1[j]==i ) { //on a trouvé i dans tab1 min = Math.min(tab2[j],min); // la valeur la plus petite entre la valeur courante de tab2 à l'index j et le min précédent } } tab3[i]=min; // on stocke la valeur dans tab3 } System.out.println(Arrays.toString(tab3)); // on affiche le résultat
Ce qui donne :
[2, 1, 1, 0, 2, 2]
Ce qui semble bien être le résultat attendu

Citation:

Envoyé par aladin15

normalement j'aurai un autre tableau de sortie :
tab3: [2,1,1,0,2,2]

Merci bcp joel.drigo , vous m'avez sauvé, j'ai mis trop de nom de variables parce que je l'ai modifié mille fois, mais j'ai pas pensé a mettre une valeur max dans le min. merci bcp une autre fois ca marche tres bien.