Ajouter des tableaux de différentes longueurs

Question

J'ai deux tableaux:

int [] array1 = {2, 4, 5}; 
int [] array2 = {1, 4, 6, 5, 2, 1}; 

Je veux ajouter ces deux tableaux, je veux ce résultat:

int [] result = {3, 8, 11, 5, 2, 1}; 

Mais, quelle est la longueur du résultat du tableau? , array1.length ou array2.length?

Mais, j'ai un mec, si je peux amplied le premier tableau, ainsi:

int [] array1 = {2, 4, 5, 0, 0, 0}; 

Désolé mon mauvais anglais, je vous remercie beaucoup!

Answer 1

public int[] addArrays(int[] a1, int[] a2) { 
    int[] result; 
    int[] smallPtr; 

    if (a1.length <= a2.length){ 
    result = Arrays.copyOf(a2); 
    smallPtr = a1; 
    } else { 
    result = Arrays.copyOf(a1); 
    smallPtr = a2; 
    } 

    for (int i = 0; i < smallPtr.length; i++) { 
    result[i] += smallPtr[i]; 
    } 

    return result; 
} 

La boucle est assez for code standard pour ajouter simplement des éléments des tableaux, un par un. La "magie" se passe dans l'instruction if/else ci-dessus avec result et smallPtr;

result est assez explicite, à savoir le tableau de résultats qui sera retourné au client. smallPtr est un "pointeur" vers le plus petit des deux tableaux. Le bloc if/else essaie alors simplement de déterminer quel tableau est le plus petit et place celui-ci à smallPtr tout en faisant une copie du plus grand tableau. Ensuite, il suffit de parcourir le petit tableau et d'ajouter ces éléments à la copie du grand tableau, en nous donnant la réponse.

Il existe plusieurs façons d'aborder ce problème. Une façon est d'avoir juste des tonnes de if instructions à l'intérieur d'un pour loop qui vérifie simplement les conditions aux limites des tableaux pour prévenir IndexOutOfBoundsException s. Cette solution tente cependant de rendre le code laconique (et, espérons-le, plus facile à lire et à comprendre) en ayant juste un bloc if/else.

Answer 2

I have two arrays:

int [] array1 = {2, 4, 5}; int [] array2 = {1, 4, 6, 5, 2, 1};

I want add these two arrays, I want this result:

int [] result = {3, 8, 11, 5, 2, 1};

Les principaux défis sont:

• comment déterminer la taille du tableau de résultat
• comment gérer des réseaux asymétriques

Le premier défi est facilement résolu en tant que maximum des deux longueurs de tableau. Résoudre le second défi nécessite simplement de gérer le cas où un élément dans un tableau n'a pas de partenaire dans l'autre. Voici une solution:

public int[] addArrays(int[] array1, int[] array2) { 
    int maxLength = (array1.length > array2.length) ? array1.length : array2.length; 
    int index = 0; 
    int[] sums = new int[maxLength]; 


    while (index < maxLength) { 
     sums[index] = (index < array1.length) ? array1[index] : 0; 
     sums[index] += (index < array2.length) ? array2[index] : 0; 
     index++; 
    } 
    return sums; 
} 

Notez comment l'utilisation de l'opérateur ternaire rend ce code plus lisible que ce serait le cas avec le bloc if-then.