Fatal编程技术网
  • java/
  • Java 从特定方向的矩阵中提取所有对角线的列表

Java 从特定方向的矩阵中提取所有对角线的列表

java matrix

Java 从特定方向的矩阵中提取所有对角线的列表,java,matrix,Java,Matrix,我试图从矩阵中提取某个方向上的所有对角线，例如右下角 对于以下矩阵： A B C D E F G H I L M N 预期的结果应该是 [ [A F M], [B G N], [C H], [D], [E L], [I] ] 一般做法是受欢迎的 我使用的语言是Java 谢谢 编辑 String[] grid = {"SUGAR", "GLASS", "MOUSE"}; for( in

我试图从矩阵中提取某个方向上的所有对角线，例如右下角

对于以下矩阵：

A   B   C   D
E   F   G   H
I   L   M   N
预期的结果应该是

[ [A F M], [B G N], [C H], [D], [E L], [I] ]
一般做法是受欢迎的

我使用的语言是Java

谢谢

编辑

String[] grid = {"SUGAR", 
                 "GLASS", 
                 "MOUSE"};

for( int k = 0; k < grid.length; k++ )
{   
    StringBuffer buffer = new StringBuffer( );

    for( int i = 0; i < grid.length
                && i+k < grid[0].length( ); i++ )
    {
        buffer.append( grid[i].charAt(i+k) );
    }

    trie.addWord( buffer.toString() );
}
存储在trie中的预期字符串（顺序无关紧要）

可以使用二维数组表示矩阵

char[][]矩阵=char[][]

然后，您可以使用for循环对其进行迭代，并提取您想要的输出，算法的输入将是您想要的对角线方向

例如：；一个可能的输入是右下角

根据可能的输入，您必须决定如何迭代循环初始条件和终止条件

从最后一列第一行字符开始

r=0，c=coulmn_计数-1

终止条件将是第一列最后一行索引处的字符

r=行数-1，c=0

读取最后一行或最后一列的字符时，每次迭代都是子循环的终止

如果数据是表格形式，您可以只扫描第一列的矩阵，然后左扫第一行

final String[M][N] mtx = { ... };

public List<List<String>> diagonalize() {
    final List<List<String>> diags = new ArrayList<>();
    for (int row = M - 1; row > 1; --row) {
        diags.add(getDiagonal(row, 0));
    }
    for (int col = 0; col < N; ++col) {
        diags.add(getDiagonal(0, col));
    }
    return diags;
}

private List<String> getDiagonal(int x, int y) {
    final List<String> diag = new ArrayList<>();
    while (x < M && y < N) {
        diag.add(mtx[x++][y++]);
    }
    return diag;
}

final String[M][N]mtx={…}；
公共列表对角化（）{
最终列表图=新的ArrayList（）；
对于（int row=M-1；row>1；--row）{
diags.add（getdiagnostic（行，0））；
}
用于（整数列=0；列
这是一个需要解决的有趣问题

很容易陷入嵌套循环中

我注意到，如果我把这些单词放在一个字符串中，就会出现一种模式

以OP为例，三个单词“SUGAR”、“GLASS”、“MOUSE”被连接在一起形成SUGARGLASSMOUSE

下面是我需要从连接字符串中获取的字符的从零开始的字符位置。我已经把它们排好了，这样你就可以更容易地看到图案

          10     M
     5    11     GO
0    6    12     SLU
1    7    13     UAS
2    8    14     GSE
3    9           AS
4                R
看到模式了吗？我有3个索引，由5个迭代组成。我有3个单词，由5个字母组成

对角线单词的数量为
字母+单词-1
。我们减去1，因为字符位置0的第一个字母只使用一次

以下是我进行的一次测试的结果

[ "SUGAR" "GLASS" "MOUSE" "STATE" "PUPIL" "TESTS" ]
[ "T" "PE" "SUS" "MTPT" "GOAIS" "SLUTL" "UASE" "GSE" "AS" "R" ]

[ "SUGAR" "GLASS" "MOUSE" ]
[ "M" "GO" "SLU" "UAS" "GSE" "AS" "R" ]
下面是代码：

import java.util.ArrayList;
import java.util.List;

public class Matrix {

    public static final int DOWN_RIGHT = 1;
    public static final int DOWN_LEFT = 2;
    public static final int UP_RIGHT = 4;
    public static final int UP_LEFT = 8;

    public String[] getMatrixDiagonal(String[] grid, int direction) {
        StringBuilder builder = new StringBuilder();
        for (String s : grid) {
            builder.append(s);
        }
        String matrixString = builder.toString();

        int wordLength = grid[0].length();
        int numberOfWords = grid.length;
        List<String> list = new ArrayList<String>();


        if (wordLength > 0) {
            int[] indexes = new int[numberOfWords];

            if (direction == DOWN_RIGHT) {
                indexes[0] = matrixString.length() - wordLength;
                for (int i = 1; i < numberOfWords; i++) {
                    indexes[i] = indexes[i - 1] - wordLength;
                }

                int wordCount = numberOfWords + wordLength - 1;

                for (int i = 0; i < wordCount; i++) {
                    builder.delete(0, builder.length());
                    for (int j = 0; (j <= i) && (j < numberOfWords); j++) {
                        if (indexes[j] < wordLength * (wordCount - i)) {
                            char c = matrixString.charAt(indexes[j]);
                            builder.append(c);
                            indexes[j]++;
                        }
                    }
                    String s = builder.reverse().toString();
                    list.add(s);
                }
            }

            if (direction == DOWN_LEFT) {
                // Exercise for original poster
            }

            if (direction == UP_RIGHT) {
                // Exercise for original poster
            }

            if (direction == UP_LEFT) {
                // Exercise for original poster
                // Same as DOWN_RIGHT with the reverse() removed
            }
        }

        return list.toArray(new String[list.size()]);
    }

    public static void main(String[] args) {
        String[] grid1 = { "SUGAR", "GLASS", "MOUSE", "STATE", "PUPIL", "TESTS" };
        String[] grid2 = { "SUGAR", "GLASS", "MOUSE" };

        Matrix matrix = new Matrix();
        String[] output = matrix.getMatrixDiagonal(grid1, DOWN_RIGHT);
        System.out.println(createStringLine(grid1));
        System.out.println(createStringLine(output));

        output = matrix.getMatrixDiagonal(grid2, DOWN_RIGHT);
        System.out.println(createStringLine(grid2));
        System.out.println(createStringLine(output));
    }

    private static String createStringLine(String[] values) {
        StringBuilder builder = new StringBuilder();
        builder.append("[ ");

        for (String s : values) {
            builder.append("\"");
            builder.append(s);
            builder.append("\" ");
        }

        builder.append("]");

        return builder.toString();
    }

}

import java.util.ArrayList；
导入java.util.List；
公共类矩阵{
公共静态最终整数向下\右=1；
公共静态最终整数向下_左=2；
公共静态最终整数=4；
公共静态最终整数=8；
公共字符串[]getMatrixDiagonal（字符串[]网格，整数方向）{
StringBuilder=新的StringBuilder（）；
用于（字符串s:网格）{
建造商。附加；
}
字符串matrixString=builder.toString（）；
int-wordLength=grid[0].length（）；
int numberOfWords=grid.length；
列表=新的ArrayList（）；
如果（字长>0）{
int[]索引=新的int[numberOfWords]；
如果（方向==向下\向右）{
索引[0]=matrixString.length（）-wordLength；
for（int i=1；iString[]grid={“SUGAR”，
“玻璃”，
“老鼠”}；
System.out.println（“结果：+Arrays.toString（对角线（网格））；
公共静态字符串[]对角线（字符串[]网格）{
int nrows=网格长度；
int ncols=grid[0]。长度（）；
int nwords=ncols+nrows-1；
String[]words=新字符串[nwords]；
int-iword=0；
for（int col=0；col
首先是列上第一个元素的循环。然后是行上的循环，跳过第0行。 两个循环中的代码都非常对称。 没什么太难的。假设所有的字符串都有相同的长度

作为一个循环：

public static String[] diagonals(String[] grid) {
    int nrows = grid.length;
    int ncols = grid[0].length();
    int nwords = ncols + nrows - 1;
    String[] words = new String[nwords];

    // Position of first letter in word:
    int row = 0;
    int col = ncols - 1;

    for (int iword = 0; iword < nwords; ++iword) {
        int n = Math.min(nrows - row, ncols - col);
        char[] word = new char[n];
        for (int i = 0; i < n; ++i) {
            word[i] = grid[row + i].charAt(col + i);
        }
        words[iword] = new String(word);

        if (col > 0) {
            --col;
        } else {
            ++row;
        }
    }
    return words;
}

公共静态字符串[]对角线（字符串[]网格）{
int nrows=网格长度；
int ncols=grid[0]。长度（）；
int nwords=ncols+nrows-1；
String[]words=新字符串[nwords]；
//单词中第一个字母的位置：
int行=0；
int col=ncols-1；
for（int-iword=0；iword0）{
--上校；
}否则{
++行；
}
}
返回单词；
}

word
的声明可以被带到循环之外。只需使用（行、列）左侧和顶部边缘行走即可。

@bhavik我尝试过使用各种for循环来实现这一点，但长期以来我没有找到一种方法使其工作。这是更大程序的一部分 
import java.util.ArrayList;
import java.util.List;

public class Matrix {

    public static final int DOWN_RIGHT = 1;
    public static final int DOWN_LEFT = 2;
    public static final int UP_RIGHT = 4;
    public static final int UP_LEFT = 8;

    public String[] getMatrixDiagonal(String[] grid, int direction) {
        StringBuilder builder = new StringBuilder();
        for (String s : grid) {
            builder.append(s);
        }
        String matrixString = builder.toString();

        int wordLength = grid[0].length();
        int numberOfWords = grid.length;
        List<String> list = new ArrayList<String>();


        if (wordLength > 0) {
            int[] indexes = new int[numberOfWords];

            if (direction == DOWN_RIGHT) {
                indexes[0] = matrixString.length() - wordLength;
                for (int i = 1; i < numberOfWords; i++) {
                    indexes[i] = indexes[i - 1] - wordLength;
                }

                int wordCount = numberOfWords + wordLength - 1;

                for (int i = 0; i < wordCount; i++) {
                    builder.delete(0, builder.length());
                    for (int j = 0; (j <= i) && (j < numberOfWords); j++) {
                        if (indexes[j] < wordLength * (wordCount - i)) {
                            char c = matrixString.charAt(indexes[j]);
                            builder.append(c);
                            indexes[j]++;
                        }
                    }
                    String s = builder.reverse().toString();
                    list.add(s);
                }
            }

            if (direction == DOWN_LEFT) {
                // Exercise for original poster
            }

            if (direction == UP_RIGHT) {
                // Exercise for original poster
            }

            if (direction == UP_LEFT) {
                // Exercise for original poster
                // Same as DOWN_RIGHT with the reverse() removed
            }
        }

        return list.toArray(new String[list.size()]);
    }

    public static void main(String[] args) {
        String[] grid1 = { "SUGAR", "GLASS", "MOUSE", "STATE", "PUPIL", "TESTS" };
        String[] grid2 = { "SUGAR", "GLASS", "MOUSE" };

        Matrix matrix = new Matrix();
        String[] output = matrix.getMatrixDiagonal(grid1, DOWN_RIGHT);
        System.out.println(createStringLine(grid1));
        System.out.println(createStringLine(output));

        output = matrix.getMatrixDiagonal(grid2, DOWN_RIGHT);
        System.out.println(createStringLine(grid2));
        System.out.println(createStringLine(output));
    }

    private static String createStringLine(String[] values) {
        StringBuilder builder = new StringBuilder();
        builder.append("[ ");

        for (String s : values) {
            builder.append("\"");
            builder.append(s);
            builder.append("\" ");
        }

        builder.append("]");

        return builder.toString();
    }

}

    String[] grid = {"SUGAR", 
             "GLASS", 
             "MOUSE"};
    System.out.println("Result: " + Arrays.toString(diagonals(grid)));

public static String[] diagonals(String[] grid) {
    int nrows = grid.length;
    int ncols = grid[0].length();
    int nwords = ncols + nrows - 1;
    String[] words = new String[nwords];
    int iword = 0;
    for (int col = 0; col < ncols; ++col) {
        int n = Math.min(nrows, ncols - col);
        char[] word = new char[n];
        for (int i = 0; i < n; ++i) {
            word[i] = grid[i].charAt(col + i);
        }
        words[iword] = new String(word);
        ++iword;
    }
    for (int row = 1; row < nrows; ++row) {
        int n = Math.min(ncols, nrows - row);
        char[] word = new char[n];
        for (int i = 0; i < n; ++i) {
            word[i] = grid[row + i].charAt(i);
        }
        words[iword] = new String(word);
        ++iword;
    }
    assert iword == nwords;
    return words;
}

Result: [SLU, UAS, GSE, AS, R, GO, M]

public static String[] diagonals(String[] grid) {
    int nrows = grid.length;
    int ncols = grid[0].length();
    int nwords = ncols + nrows - 1;
    String[] words = new String[nwords];

    // Position of first letter in word:
    int row = 0;
    int col = ncols - 1;

    for (int iword = 0; iword < nwords; ++iword) {
        int n = Math.min(nrows - row, ncols - col);
        char[] word = new char[n];
        for (int i = 0; i < n; ++i) {
            word[i] = grid[row + i].charAt(col + i);
        }
        words[iword] = new String(word);

        if (col > 0) {
            --col;
        } else {
            ++row;
        }
    }
    return words;
}