Discussion :

[MinHoo]

Bonjour à tous!
J'ai un souci avec mon exercice. Je suis bloqué depuis 2 jours et j'arrive pas à trouver la solution pour la dernière question. Le programm marche mais quand j'ai fait une somme de 2 tableaux x =[ 1,0,0] et y =[2,0] ça donne le résultat suivant: [I@7852e922
Merci pour vos aides

Exercice 2 :
1.Ecrire une fonction static int[] ajouteZeroAGauche(int[] t, int p)qui prend un tableau t d’entiers et retourne un nouveau tableau formé a partir de t en rajoutant p zeros a gauche. Par exemple si t est [1,2,3] alors ajouteZeroAGauche(t,3) retourne le tableau [0,0,0,1,2,3].

2. Ecrire une fonction static int[] tronqueZeroAGauche(int[] t) qui retourne un nouveau tableau formé a partir de t en supprimant tous les zeros qui sont à gauche dans t, si il y en a. Exemples : si le tableau ne commence pas par un 0, comme par exemple le tableau [3,0,4], alors elle retourne une copie [3,0,4], mais si il y a des zeros au d ́ebut, elle les supprime - par exemple sur [0,0,1,2,0,4], elle retourne un nouveau tableau [1,2,0,4].

3. Ecrire un main dans votre classe pour tester ces fonctions. Vous devez créer un tableau d’entiers (avec les valeurs que vous voulez), puis lui appliquer la première fonction et appliquer la seconde au r ́esultat obtenu. Vous pourrez alors afficher les tableaux pour voir si ca fonctionne bien. Pour afficher un tableau t, on pourra utiliser l’instruction Arrays.toString(t) qui retourne une chaine de caract`eres repr ́esentant le tableau.

4. On considère dans cette question des tableaux d’entiers compris entre 0 et 9, représentant des entiers en écriture décimale. Par exemple le tableau [1,4,5] correspond à l’entier 145 et le tableau [2,0,1] à l’entier 201.
Vous devez écrire une fonction static int[] somme(int[] t1, int[] t2) calculant l’addition de deux entiers vus comme des tableaux comme expliqué ci dessus. Par exemple, puisque 145+201=346, somme([1,4,5],[2,0,1]) doit retourner le tableau [3,4,6].
On se dit qu’il suffit d’additionner case par case comme sur l’exemple précédent. Attention à quelques difficultés auxquelles vous devrez penser :
— Les retenues. Si on additionne [1,5] et [1,6], on veut [3,1] et pas [2,11] ! ! !
— Un peu dans la meme idée que les retenues, dans certains cas, il faudra à cause retourner
un tableau plus long : par exemple, pour [5,0] et [5,0], la somme est [1,0,0].
— Si les tableaux n’ont pas la meme taille au d ́epart, comme par exemple pour [1,0,0] et [2,0], il vaut mieux faire en sorte qu’ils aient la meme taille avant de les additionner pourque les indices co ̈ıncident. Vous pourrez penser a utiliser une des fonctions précédentes.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
import java.util.Arrays;
 
public class Exo2{
    // Etape 1:
    public static int[] ajouteZeroAGauche(int[] t, int p){
        int[] Newtable1 = new int [t.length + p];
        for(int i = 0; i < p; i++){
            Newtable1[i] = 0;
        }
        for(int j = p; j < Newtable1.length; j++){
            Newtable1[j] = t[j-p];
        }
        return Newtable1;
    }
 
    // Etape 2:
    public static int[] tronqueZeroAGauche(int[] t){
        int cpt = 0;
        int i = 0;
        boolean flag = false;
        while (!flag && i < t.length){
            if(t[i] == 0){
                cpt++;
                i++;
            }else{
                flag = true;
            }
        }
        int[] Newtable2 = new int[t.length - cpt];
        for(int j = 0; j < Newtable2.length; j++){
            Newtable2[j] = t[j+cpt];
        }
        return Newtable2;
    }
 
    // Etape 3:
    public static void main(String[] args){
        int[] tableau = {1,2,3,4,5};
        int[] table1 = ajouteZeroAGauche(tableau,4);
        System.out.println(Arrays.toString(table1));
        int[] table2 = tronqueZeroAGauche(table1);
        System.out.println(Arrays.toString(table2));
        int[] x = {1,0,0};
        int[] y = {2,0};
        somme(x,y);
        System.out.println(somme(x,y));
    }
 
    // Etape 4:
    public static int[] somme(int[] t1, int[] t2){
        int[] Tab = new int[t1.length];
        if(t1.length > t2.length){
            int[] Newt2 = ajouteZeroAGauche(t2,t1.length - t2.length);
            Tab = new int[t1.length];
            for(int i = 0; i < t1.length; i++){
                Tab[i] = t1[i] + Newt2[i];
            }
        }else if(t1.length < t2.length){
            int[] Newt1 = ajouteZeroAGauche(t1,t2.length - t1.length);
            Tab = new int[t2.length];
            for(int i = 0; i < t2.length; i++){
                Tab[i] = Newt1[i] + t2[i];
            }
        }else {
            Tab = new int[t1.length];
            for(int i = 0; i < t1.length; i++){
                Tab[i] = t1[i] + t2[i];
            }
        }
        return Tab;
    }
}

[joel.drigo]

Salut,

Tout comme tu as utilisé Arrays.toString() pour pouvoir afficher table1 et table2, il faut que tu utilises Arrays.toString() sur le résultat de somme, un tableau, pour afficher les valeurs qu'il contient et non le résultat de sa méthode toString().

[MinHoo]

Salut,

Tout comme tu as utilisé Arrays.toString() pour pouvoir afficher table1 et table2, il faut que tu utilises Arrays.toString() sur le résultat de somme, un tableau, pour afficher les valeurs qu'il contient et non le résultat de sa méthode toString().

Merci pour ton aide. Ca marche très bien.
Mais j'ai encore un problème avec ces 2 problèmes:

— Les retenues. Si on additionne [1,5] et [1,6], on veut [3,1] et pas [2,11] ! ! !
— Un peu dans la meme idée que les retenues, dans certains cas, il faudra à cause retourner
un tableau plus long : par exemple, pour [5,0] et [5,0], la somme est [1,0,0].

[joel.drigo]

Pour la retenue, il suffit de faire comme tu ferais à la main : si le résultat de la somme est supérieur ou égale à 10, alors tu mets le chiffre des unités dans le résultat, et tu mets de côté le chiffre des dizaines que tu vas ajouter lors de la somme de la colonne suivante....
Pour calculer la partie unité et la partie dizaine, on peut utiliser le modulo (le reste de la division entière), on est sur que ça fonctionne.
Sinon, pour simplifier, le plus grand chiffre est 9, donc la plus grande somme 9+9 vaut 18; 8 avec une retenue de 1. 18+1, ça fait 19, donc 9 avec retenue de 1. Donc, à priori la retenue max est 1. Donc on peut calculer la partie unité par différence (-10).

En gros, l'algo, c'est :

Code pseudojava :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int retenue=0;
int n=nombre de chiffres - 1
int i= n;
 
tant que i>=0 faire
 
resultat[i]=nombre1[i]+nombre2[i]+retenue
 
retenue=0
si resultat[i]>9 alors
   // retenue
   resultat[i] = ...
   retenue= ...
fin si
 
i--
fin tant que
 
 
si retenue!=0 alors
   // on a un tableau plus grand à faire pour y mettre la valeur de la retenue
fin si

Pour "agrandir" le tableau, on ne peut pas en Java. Il faut donc créer un nouveau tableau et copier l'ancien dans le nouveau, selon ce que tu es autorisé d'utiliser pour ton exercice :

1. à la "mano", par boucle
2. en utilisant System.arraycopy()
3. en utilise Arrays.copyOf ()

[MinHoo]

grace à ton aide, j'ai fini mon exercice. Génial!! Merci beaucoup!!!
Topic closed!!!