Sum of 2 different 2D arrays

Question

I need help writing a method to find out a sum of 2 different sized 2D arrays.

public static int[][] summary(int[][] tab1, int[][] tab2, int x) {
    int[][] finalTab = new int[4][5]; // I took sizes of bigger one
    if (x < 0) {
        for (int i = 0; i < finalTab.length - 1; i++) {
            for (int j = 0; j < finalTab[i].length - 1; j++) {
                finalTab[i][j] = tab1[i][j] + tab2[i][j];
                if (tab1[i][j] == 0) {
                    finalTab[i][j] = tab2[i][j];
                }
            }
        }
        for (int i = 0; i < finalTab.length; i++) {
            for (int j = 0; j < finalTab[i].length; j++) {
                System.out.print(" " + finalTab[i][j] + " ");
            }
            System.out.println();
        }
    }
    return finalTab;
}

Input is:

int[][] tab1 = {
        {2, 4, 6, 8},
        {2, 4, 6, 8},
        {2, 4, 6, 8}};

int[][] tab2 = {
        {1, 3, 5, 7, 9},
        {1, 3, 5, 7, 9},
        {1, 3, 5, 7, 9},
        {1, 3, 5, 7, 9}};

Output is:

 3  7  11  15  0 
 3  7  11  15  0 
 3  7  11  15  0 
 0  0  0  0  0

Output should be:

 3  7  11  15  9
 3  7  11  15  9
 3  7  11  15  9
 1  3  5  7  9

How can I replace all of 0 with numbers corresponding to the index of tab2?

score 3 · Accepted Answer · edited Dec 20 '20 at 09:29

you can do it more generic

public static int[][] summary(int[][] tab1, int[][] tab2, int x) {
    int maxLenX = tab1.length > tab2.length ? tab1.length : tab2.length;
    int maxLenY = tab1[0].length > tab2[0].length ? tab1[0].length : tab2[0].length;
    int[][] finalTab = new int[maxLenX][maxLenY]; // i took sizes of bigger one
    if (x < 0) {
        for (int i = 0; i <= finalTab.length - 1; i++) {
            for (int j = 0; j <= finalTab[i].length - 1; j++) {
                if (i > tab1.length - 1 || j > tab1[i].length - 1) {
                    finalTab[i][j] = tab2[i][j];
                } else if (i > tab2.length - 1 || j > tab2[i].length - 1) {

                    finalTab[i][j] = tab1[i][j];
                } else {
                    finalTab[i][j] = tab1[i][j] + tab2[i][j];
                }
            }
        }
        for (int i = 0; i < finalTab.length; i++) {
            for (int j = 0; j < finalTab[i].length; j++) {
                System.out.print(" " + finalTab[i][j] + " ");
            }
            System.out.println();
        }
    }
    return finalTab;
}

so you can call it wether like that

summary(tab2, tab1, -1);

or

summary(tab1, tab2, -1);

score 3 · Answer 2 · answered Dec 19 '20 at 20:02

This is a more straight-forward solution:

for (int i = 0; i < finalTab.length; i++) 
    for (int j = 0; j < tab1[i].length; j++) {
        int v1 = (i<tab1.length && j<tab1[i].length) ? tab1[i][j] : 0;
        int v2 = (i<tab2.length && j<tab2[i].length) ? tab2[i][j] : 0;
        finalTab[i][j] = v1 + v2;
    }

score 1 · Answer 3 · 2020-12-25T21:13:47.220

You can use IntStream.of(int...) method to concatenate two elements from different sources:

int[][] tab1 = {
        {2, 4, 6, 8},
        {2, 4, 6, 8},
        {2, 4, 6, 8}};

int[][] tab2 = {
        {1, 3, 5, 7, 9},
        {1, 3, 5, 7, 9},
        {1, 3, 5, 7, 9},
        {1, 3, 5, 7, 9}};

int[][] tab3 = IntStream
        // iterate over indices of tab2,
        // because it is biggest array
        .range(0, tab2.length).mapToObj(i ->
                IntStream.range(0, tab2[i].length).map(j ->
                        // for each cell concatenate element
                        // from tab2 with element from tab1
                        // if exists, or with 0 otherwise
                        IntStream.of(tab2[i][j],
                                i < tab1.length && j < tab1[i].length ?
                                        tab1[i][j] : 0)
                                // sum of two
                                // elements
                                .sum())
                        .toArray())
        .toArray(int[][]::new);

Arrays.stream(tab3).map(Arrays::toString).forEach(System.out::println);
// [3, 7, 11, 15, 9]
// [3, 7, 11, 15, 9]
// [3, 7, 11, 15, 9]
// [1, 3, 5, 7, 9]

^{See also:

• Adding up all the elements of each column in a 2d array

• Rotating an int Array in Java using only one semicolon}

score 0 · Answer 4 · edited Dec 20 '20 at 08:12

I made it this way:

for (int i = 0; i < finalTab.length; i++)
    for (int j = 0; j < finalTab[i].length; j++)
        if (tab1.length > tab2.length) {
            finalTab[i][j] = tab1[i][j];
        } else
            finalTab[i][j] = tab2[i][j];

for (int i = 0; i < tab1.length; i++) {
    for (int j = 0; j < tab1[i].length; j++) {
        finalTab[i][j] = tab1[i][j] + tab2[i][j];
    }
}

score 0 · Answer 5 · answered Feb 13 '21 at 11:03

You can use Stream#reduce method to sum two or more arrays:

public static int[][] sumArrays(int[][]... arrays) {
    return Arrays.stream(arrays).reduce((arr1, arr2) -> IntStream
        // iterate over the indices of
        // the rows of the largest array
        .range(0, Math.max(arr1.length, arr2.length))
        .mapToObj(i -> IntStream
            // iterate over the indices of
            // the cells of the largest row
            .range(0, Math.max(
                    i < arr1.length ? arr1[i].length : 0,
                    i < arr2.length ? arr2[i].length : 0))
            // sum the elements of two rows if exist, or 0 otherwise
            .map(j -> (i < arr1.length && j < arr1[i].length ? arr1[i][j] : 0) +
                    (i < arr2.length && j < arr2[i].length ? arr2[i][j] : 0))
            .toArray())
        .toArray(int[][]::new))
        .orElse(null);
}

public static void main(String[] args) {
    int[][] tab0 = {
            {3, 5, 7},
            {3, 5, 7}};

    int[][] tab1 = {
            {2, 4, 6, 8},
            {2, 4, 6, 8},
            {2, 4, 6, 8}};

    int[][] tab2 = {
            {1, 3, 5, 7, 9},
            {1, 3, 5, 7, 9},
            {1, 3, 5, 7, 9},
            {1, 3, 5, 7, 9}};

    int[][] tab3 = sumArrays(tab0, tab1, tab2);

    // formatted output
    Arrays.stream(tab3).map(row -> Arrays.stream(row)
            .mapToObj(i -> String.format("%2d", i))
            .collect(Collectors.joining(", ", "{", "}")))
            .forEach(System.out::println);
}

Output:

{ 6, 12, 18, 15,  9}
{ 6, 12, 18, 15,  9}
{ 3,  7, 11, 15,  9}
{ 1,  3,  5,  7,  9}

Bargros · Answer 6 · 2021-06-16T11:47:44.250

Simply checking that i(first dimension) and j (second dimention) don't exceed the length of those of tab1, should do the trick.

private static int[][] summary(int[][] tab1, int[][] tab2, int x) {
        var finalTab = new int[4][5];
        if (x > 0) {
            var tab1SecondDimensionLength = tab1[0].length;
            for(var i = 0; i < finalTab.length; ++i) {
                for(var j = 0; j < finalTab[i].length; ++j) {
                    var tab1Val = i < tab1.length ? j >= tab1SecondDimensionLength ? 0 : tab1[i][j] : 0;
                    
                    if (tab1Val > 0) {
                        finalTab[i][j] = tab1Val + tab2[i][j];
                    } else {
                        finalTab[i][j] = tab2[i][j];
                    }
                }
            }
            
            for (int i = 0; i < finalTab.length; i++) {
                for (int j = 0; j < finalTab[i].length; j++) {
                    System.out.print(" " + finalTab[i][j] + " ");
                }
                System.out.println();
            }
        }
        
        return finalTab;
    }

Output:

3  7  11  15  9
3  7  11  15  9
3  7  11  15  9
1  3  5  7  9

Sum of 2 different 2D arrays

6 Answers6

Linked