Matrix Manipulation and Submatrix Concatenation in Kotlin

Lesson 3

Introduction

Hello Coder! In this unit's engaging programming lesson, we're going to traverse the world of two-dimensional matrices using Kotlin. We'll leverage Kotlin's concise and expressive syntax to combine submatrices from two different matrices into a new one. This might sound challenging at first, but with Kotlin's powerful features, we'll tackle it efficiently, step by step.

Task Statement

Are you ready for the task? Here it is: Imagine having two different 2D arrays, A and B. Our job is to devise a Kotlin function — let's name it submatrixConcatenation — which takes these two matrices as inputs, along with the coordinates specifying submatrices within A and B. This function will stitch the two chosen submatrices together to form a new one, C. The submatrices from A and B should have the same number of rows, and in the final matrix C, elements from A's submatrix should appear on the left and those from B's submatrix should be on the right.

Let's visualize this with a couple of matrices.
Given the matrix A as:

Plain text
1{{1, 2, 3, 4},
2 {5, 6, 7, 8},
3 {9, 10, 11, 12}}

and the matrix B as:

Plain text
1{{11, 12, 13},
2 {14, 15, 16},
3 {17, 18, 19}}

If we select 2x2 submatrices from each (comprising the 2nd to 3rd rows and 2nd to 3rd columns from A, and 1st to 2nd rows and 1st to 2nd columns from B), their concatenation would look like:

Plain text
1{{6, 7, 11, 12},
2 {10, 11, 14, 15}}

Solution Building: Step 1

Our first step toward the solution is to extract submatrices from A and B from the given coordinates. For this, we'll use Kotlin's loop constructs and array slicing abilities:

Kotlin
1fun submatrixConcatenation(
2    matrixA: Array<IntArray>,
3    matrixB: Array<IntArray>,
4    submatrixCoords: Array<IntArray>
5): Array<IntArray> {
6
7    val (startRowA, endRowA, startColA, endColA) = submatrixCoords[0]
8    val (startRowB, endRowB, startColB, endColB) = submatrixCoords[1]
9
10    val numRows = endRowA - startRowA + 1
11    val numColsA = endColA - startColA + 1
12    val numColsB = endColB - startColB + 1
13
14    val submatrixA = Array(numRows) { row ->
15        IntArray(numColsA) { col ->
16            matrixA[startRowA + row - 1][startColA + col - 1]
17        }
18    }
19
20    val submatrixB = Array(numRows) { row ->
21        IntArray(numColsB) { col ->
22            matrixB[startRowB + row - 1][startColB + col - 1]
23        }
24    }
25    
26    // At this point, we have extracted submatrices from matrixA and matrixB
27    return submatrixA // This is temporary. We'll continue in step 2.
28}

Solution Building: Step 2

Next, we need to stitch these submatrices together. We can achieve this by combining corresponding rows from both matrices into a new matrix using Kotlin's versatile constructs:

Kotlin
1fun submatrixConcatenation(
2    matrixA: Array<IntArray>,
3    matrixB: Array<IntArray>,
4    submatrixCoords: Array<IntArray>
5): Array<IntArray> {
6
7    val (startRowA, endRowA, startColA, endColA) = submatrixCoords[0]
8    val (startRowB, endRowB, startColB, endColB) = submatrixCoords[1]
9
10    val numRows = endRowA - startRowA + 1
11    val numColsA = endColA - startColA + 1
12    val numColsB = endColB - startColB + 1
13
14    val submatrixA = Array(numRows) { row ->
15        IntArray(numColsA) { col ->
16            matrixA[startRowA + row - 1][startColA + col - 1]
17        }
18    }
19
20    val submatrixB = Array(numRows) { row ->
21        IntArray(numColsB) { col ->
22            matrixB[startRowB + row - 1][startColB + col - 1]
23        }
24    }
25
26    val resultMatrix = Array(numRows) { row ->
27        IntArray(numColsA + numColsB) { col ->
28            if (col < numColsA) {
29                submatrixA[row][col]
30            } else {
31                submatrixB[row][col - numColsA]
32            }
33        }
34    }
35
36    return resultMatrix
37}
38
39fun main() {
40    val matrixA = arrayOf(
41        intArrayOf(1, 2, 3, 4),
42        intArrayOf(5, 6, 7, 8),
43        intArrayOf(9, 10, 11, 12)
44    )
45
46    val matrixB = arrayOf(
47        intArrayOf(11, 12, 13),
48        intArrayOf(14, 15, 16),
49        intArrayOf(17, 18, 19)
50    )
51
52    val submatrixCoords = arrayOf(
53        intArrayOf(2, 3, 2, 3),
54        intArrayOf(1, 2, 1, 2)
55    )
56
57    val result = submatrixConcatenation(matrixA, matrixB, submatrixCoords)
58    result.forEach { row -> println(row.joinToString(" ")) }
59    // Expected output:
60    // 6 7 11 12
61    // 10 11 14 15
62}

There we go! We've combined submatrices from two matrices into one, provided they have the same number of rows.

Lesson Summary

Congratulations! You've navigated the intricacies of matrix manipulation with Kotlin in this unit. This task required you to have a deep understanding of Kotlin's 2D arrays and its idiomatic constructs for array handling and loops. Through this exercise, not only have you enhanced your Kotlin skills, but you've also explored the conceptual complexities of submatrix operations.

Now, you're ready for some hands-on practice! In the following practice session, tackle more challenging problems that involve matrix manipulations. This lesson will serve as your handy guide as you explore similar challenges. Keep practicing, and soon you'll master matrix manipulation tasks with ease. Happy coding!

Enjoy this lesson? Now it's time to practice with Cosmo!

Practice is how you turn knowledge into actual skills.