加倍矩陣

Question

我創建了一個二維矩陣並用隨機數填充它。然後我打印出來了。我需要幫助創建第二個矩陣，其大小是第一個矩陣的兩倍，並且用第一個矩陣（現在是2×2）中的數字填充。例如：

起始基體：

3 4 
2 1 

一倍矩陣：

3 3 4 4 

3 3 4 4 

2 2 1 1 

2 2 1 1 

Answer 1

import java.util.Scanner; 
import java.util.Random; 


public class MatrixDoubler { 
    public static void main(String[] arg) { 
     Scanner keyboard = new Scanner(System.in); 
     Random rand = new Random(); 

     System.out.println("Enter the size of the matrix"); 

     int size = keyboard.nextInt(); 
     int A[][] = new int[size][size]; 

     for (int row = 0; row < size; ++row) { 
      for (int col = 0; col < size; ++col) { 
       A[row][col] = rand.nextInt(10); 
      } 
     } 

     System.out.println("Matrix A:"); 
     printMatrix(A); 

     int[][] B = doubleMatrix(A); 

     System.out.println("Matrix B:"); 
     printMatrix(B); 
    } 

    private static int[][] doubleMatrix(int[][] A) { 
     int rows = A.length; 
     assert(rows > 0); 
     int cols = A[0].length; 
     assert(cols > 0); 

     int B[][] = new int[rows * 2][cols * 2]; 

     for (int row = 0; row < rows * 2; ++row) { 
      for (int col = 0; col < cols * 2; ++col) { 
       B[row][col] = A[row/2][col/2]; 
      } 
     } 

     return B; 
    } 

    private static void printMatrix(int[][] M) { 
     for(int i = 0; i < M.length; i++) { 
      for(int j = 0; j < M.length; j++) { 
       System.out.print(M[i][j] + " "); 
      } 

      System.out.println(); 
     } 
    } 
} 

Answer 2

我不知道這是你在找什麼，但試試這個：

for (int i = 0; i < newMatrix.length; i++) { 
    for (int j = 0; j < newMatrix.length; j++) { 
     newMatrix[i][j] = matrix[i/size][j/size]; 
    } 
} 

注意：此代碼肯定不是最好的解決方案，但快速簡單。它只適用於兩個尺寸相同的尺寸，如果newMatrix不是matrix的兩倍，它將不起作用。如果總是隻是「加倍」一個矩陣，它應該可以正常工作。

---

輸出：
如果選擇大小爲2比它會輸出：

Enter the size of the matrix 
2 
The Matrix is 
3 5 
5 2 
The newMatrix is 
3 3 5 5 
3 3 5 5 
5 5 2 2 
5 5 2 2 

和大小3這將是例如

Enter the size of the matrix 
3 
The Matrix is 
4 4 3 
5 9 4 
7 4 1 
The newMatrix is 
4 4 4 4 3 3 
4 4 4 4 3 3 
5 5 9 9 4 4 
5 5 9 9 4 4 
7 7 4 4 1 1 
7 7 4 4 1 1 

目前還不清楚是什麼你問，但我希望這有助於（：

Answer 3

在Java 8中，您可以使用地圖和收集器輕鬆處理此操作。這是一個完整的例子：

public class DoubleMatrix { 
    public static void main(String[] args) { 
    List<List<Integer>> startingMatrix = Arrays.asList(
     Arrays.asList(3, 4), 
     Arrays.asList(2, 1) 
    ); 

    List<List<Integer>> doubleMatrix 
     = startingMatrix.stream() 
         .map(innerList -> { //For each list 
          List<Integer> doubled = innerList.stream() 
                  .map(element -> Arrays.asList(element, element)) //Return a list doubling each element 
                  .flatMap(l -> l.stream()) //Flatten out/join all doubled lists 
                  .collect(Collectors.toList()); 
          return Arrays.asList(doubled, doubled); //Double the list 
         }) 
         .flatMap(l -> l.stream()) 
         .collect(Collectors.toList()); //Collect into a final list 

    System.out.println(doubleMatrix); 
    } 
} 

這避免了需要知道的名單事先的大小，也是寬容的存在是你的矩陣的寬度和高度之間的差異 - 只需在兩個方向上加倍的每一個元素。