Merging two 2D arrays (M + N)

Question

I am a first year programming trying to solve this challenge that was given to us students at uni.

Question image

There's a typo at where it says (N + K) whereas in fact it's actually (M+K) columns.

My attempt for this question goes as follows

public static int[][] mergeArrays(int[][] arrayA, int[][] arrayB){
    int rows = 3;
    int columns = arrayA[0].length + arrayB[0].length;      
    int[][] mergedArray = new int[rows][columns];
    int k = 0;
    for (int i = 0; i < rows; i++)
    {
        for ( int j = 0  ; j < columns; j++)
        {
            try
            {
                mergedArray[i][j] = arrayA[i][j];
            }
            catch (ArrayIndexOutOfBoundsException e)
            {
                mergedArray[i][j] = arrayB[i][k];
                k += 1;
            }
        }
    }
    return mergedArray;
}

public static void main(String [] args)
{
    int [][] a1 = { {1,2,3,3,3} , {3,2,1,6,3} , {4,5,6,1,3}  };
    int [][] a2 = { {1,9,7,2,3} , {0,7,8,3,2} , {3,8,9,7,2} };

    int[][] m = mergeArrays(a1,a2);
    for (int[] x : m)
    {
        for (int y : x)
        {
            System.out.print(y + " ");
        }
        System.out.println();
     }
}

The program doesn't work for some reason. I don't know what's wrong with my approach here. Would really appreciate if someone helps me out.

Answer 1

You are not merging it properly. Your logic is that if arrayA column index is out of bounds, you are adding from arrayB's columns. But what if that is also out of bounds, as in your case. Since you are always incrementing its index k. You could simply iterate over 2 arrays separately and merge into resulting array.

public static int[][] mergeArrays(int[][] arrayA, int[][] arrayB) {
        int rows = 3;
        int columns = arrayA[0].length + arrayB[0].length;
        int[][] mergedArray = new int[rows][columns];
        int k = 0;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < arrayA[0].length; j++) {
                mergedArray[i][k++] = arrayA[i][j];
            }
            for (int j = 0; j < arrayB[0].length; j++) {
                mergedArray[i][k++] = arrayB[i][j];
            }
            k=0;
        }
        return mergedArray;
    }

Answer 2

Since you're a student I think to better if we give a hint, but since the solution is already there you can check this one as well:

public static int[] merge(int[] first,int[] second) {
    return ArrayUtils.addAll(first, second);
}

public static void main(String[] args) {
    int [][] a1 = { {1,2,3,3,3} , {3,2,1,6,3} , {4,5,6,1,3}};
    int [][] a2 = { {1,9,7,2,3} , {0,7,8,3,2} , {3,8,9,7,2}};
    int [][] a3 = new int[a1.length][];

    for (int i = 0; i < a1.length; i++) {
        a3[i] = merge(a1[i],a2[i]);
    }
    for (int[] ints : a3) {
        StringJoiner joiner = new StringJoiner(",","[","]");
        for (int i1 : ints) {
            joiner.add(i1+"");
        }
        System.out.println(joiner.toString());
    }
}

Answer 3

Without using any libraries, in a manual way, here is my working answer.
I didn't use any of them, since we were not allowed, when I was a student.

public class Main {
    private static int[][] mergeArrays(int[][] a1, int[][] a2) {
        // Count rows and cols length.
        int rows = a1.length;
        int cols_a1 = a1[0].length;
        int cols_a2 = a2[0].length;

        // Total number of cols
        int cols = cols_a2 + cols_a1;

        int [][] merged = new int[rows][cols];


        for (int i = 0; i < rows ; ++i) {
            for (int j = 0; j < cols_a1; ++j) {
                merged[i][j] = a1[i][j];

            }
            // To not overwrite values,
            // the trick is to add an offset, while assigning,
            // which is the amount of elements (cols_a1) used by the previous loop.
            // Basically, we are shifting the k-index by this constant,
            // as to not overwrite the values assigned from the previous 
            // inner loop.
            for (int k = 0; k < cols_a2; ++k) {
                merged[i][cols_a1 + k] = a2[i][k];
            }
        }
        // Return the merged array
        return merged;
    }

    // I refactored your good printing code into a method, for readability.
    private static void print2darray(int[][] array2d) {
        for (int[] x : array2d) {
            for (int y : x) {
                System.out.print(y + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        int [][] a1 = {{1,2,3,3,3} , {3,2,1,6,3} , {4,5,6,1,3}};
        int [][] a2 = {{1,9,7,2,3} , {0,7,8,3,2} , {3,8,9,7,2}};
        int [][] merged = mergeArrays(a1, a2);
        print2darray(merged);
    }
}

The result is the same, as expected, from your question image:

1 2 3 3 3 1 9 7 2 3
3 2 1 6 3 0 7 8 3 2 
4 5 6 1 3 3 8 9 7 2