Solution.java

import java.util.Arrays;
import java.util.stream.IntStream;

class Solution {
    public int[][] matrixReshape(int[][] originalMatrix, int targetRows, int targetCols) {
        int totalElements = originalMatrix.length * originalMatrix[0].length;
        if (totalElements != targetRows * targetCols) {
            return originalMatrix;
        }

        int[] allElements = Arrays.stream(originalMatrix)
                .flatMapToInt(Arrays::stream)
                .toArray();

        return IntStream.range(0, targetRows)
                .mapToObj(row -> rowElements(allElements, row, targetCols))
                .toArray(int[][]::new);
    }

    private int[] rowElements(int[] elements, int row, int cols) {
        int start = row * cols;
        return Arrays.copyOfRange(elements, start, start + cols);
    }
}

Solution.kt

class Solution {
    fun matrixReshape(
        originalMatrix: Array<IntArray>,
        targetRowCount: Int,
        targetColumnCount: Int,
    ): Array<IntArray> {
        val flattened = originalMatrix.flatMap(IntArray::asList)
        
        if (flattened.size != targetRowCount * targetColumnCount) return originalMatrix

        return flattened
            .chunked(targetColumnCount)
            .map(List<Int>::toIntArray)
            .toTypedArray()
    }
}

Solution.rb

def matrix_reshape(originalMatrix, targetRowCount, targetColumnCount)
  
  elements = originalMatrix.flatten
  
  return originalMatrix if elements.size != targetRowCount * targetColumnCount

  elements.each_slice(targetColumnCount).to_a
end

Solution.scala

object Solution {
  def matrixReshape(
    originalMatrix: Array[Array[Int]],
    targetRowCount: Int,
    targetColumnCount: Int
  ): Array[Array[Int]] = {
    val flattenedElements = originalMatrix.flatten
    if (flattenedElements.length != targetRowCount * targetColumnCount)
      originalMatrix
    else
      flattenedElements.grouped(targetColumnCount).toArray
  }
}