Java对角矩阵

Question

我一直想知道如何从左下角对角地包装一个字符串到矩阵中。 例如：

String str = "123456789"; 

//Output matrix: 
// 479 
// 258 
// 136 

//Or if str = "123456789123456"; 

//Output would be: 

// 2 
// 73 
// 484 
// 2595 
// 13616 

这是我到目前为止有：

 int index = 0; 
    for(int i = 0; i < matrix.length; i++) 
    { 
     for(int k = matrix.length - 1; k > -1; k--) 
     { 
      if(index == word.length()) 
       break; 
      matrix[k][i] = "" + str.charAt(index); 
      index++; 
     } 
    } 

Answer 1

这是合理有效的实施，我认为这是比较容易理解的。

这段代码在连续的对角线上循环，当当前位置在矩阵内时，它将从字符串中分配下一个字符。

在下面的图表中，问号位置在对角线上，但它们不在矩阵内。这些问号位置的输入字符串中没有字符。

Diagonal Matrix 
    4  ? 
    3  ?? 
    2  479 
    1  258? 
    0  136?? 

环路经过升序排列行，但分配给每一行反转，因为你的矩阵是从索引阵列的普通Java的方式来看待时，倒置完成：matrix[size - row - 1]，而不是matrix[row]。

这种方式没有必要在对角线的上方和下方进行特殊处理。

public static void main(String[] args) throws Exception { 
    String str = "123456789"; 
    int size = 3; 

    int[][] matrix = new int[size][size]; 
    { 
     int index = 0; 
     for (int diagonal = 0; diagonal < size * 2 - 1; diagonal++) { 
      int row = diagonal; 
      int column = 0; 
      while (row >= 0) { 
       if (row < size && column < size) { 
        matrix[size - row - 1][column] = Character.getNumericValue(str.charAt(index++)); 
       } 
       row--; 
       column++; 
      } 
     } 
    } 
} 

它也适用于较大尺寸的矩阵（4×4，5×5等），但你只能编码值高达字符串中的9 - 如果你想要更高的价值，这是更好地编码他们在一个逗号分隔字符串并将字符串拆分为一个字符串数组。

Answer 2

不做出关于效率的要求在这里，但只要它应该工作作为字符串适合一个方阵：

static char[][] toDiag(String s) 
{ 
    int sideLen = (int) Math.sqrt(s.length()); // assume string fits into 
               // square matrix 
    char[][] m = new char[sideLen][sideLen]; 
    int index = 0; 
    //fill lower-left section of array 
    for (int i = m[0].length - 1; i >= 0; i--) 
    { 
     for (int k = 0; k <= m[0].length-1-i; k++) 
     { 
      m[i+k][k] = s.charAt(index++); 
     } 
    } 
    //fill upper-right section of array 
    for (int i = sideLen%2==1?sideLen/2:sideLen/2 -1; i <= m[0].length; i++) 
    { 
     for (int k = 0; k <= m[0].length-1-i; k++) 
     { 
      m[k][i+k] = s.charAt(index++); 
     } 
    } 
    return m; 
} 

Answer 3

public static void main(String[] args) 
{ 
    String inString = "123456789"; 
    int N = (int) Math.sqrt((double) inString.length()); 
    int out[][] = new int[N][N]; 
    int index=0; 

    //fills elements below the diagonal 
    for(int i=0;i<N-1;i++) 
     for(int j=0;j<=i;j++) 
      out[N-1-i+j][j] = Character.getNumericValue(inString.charAt(index++)); 

    //fills the diagonal 
    for(int i=0;i<N;i++) 
     out[i][i] = Character.getNumericValue(inString.charAt(index++)); 

    //fills elements above the diagonal 
    for(int i=N-2;i>=0;i--) 
     for(int j=0;j<=i;j++) 
      out[j][N-1-i+j] = Character.getNumericValue(inString.charAt(index++)); 

    //prints the output 
    for(int i=0;i<N;i++) 
    { 
     for(int j=0;j<N;j++) 
     { 
      System.out.print(out[i][j] + "\t"); 
     } 
     System.out.println(); 
    } 
}