java - 用另一个模式替换二维数组中的模式

Question

我正在尝试编写一个执行以下操作的方法:用数组 B 替换数组 A 的每个匹配项，其中 A 在二维数组 C 中，然后返回修改后的数组。 A、B、C为二维整数数组。

给定一个矩形数组 c 和另一个矩形数组 a，其中 a 的维度 <= c 的维度，找到与 a 匹配的 c 的子数组的第一个匹配项，并将该子数组替换为 b (其尺寸必须与 a 相同)。

public class ReplacePatterns {
    public static void main(String[] args){

    }
    //replace every instance of the pattern a with the pattern b inside c.
    //find a way to get the dimensions of a 2D array
    public static int[][] replacePattern(int[][] a, int[][] b, int[][] c){
        for(int i = 0; i < c.length; i++){
            for(int j = 0; j < c[0].length; j++){
                if(c[i][j] == a[i][j]){ //c[i][j] should match up with a[0][0].
                    int[][] d; //copy the array inside c to d.
                }
            }
        }
    }
}

Answer 1

所以，假设我正确理解了这个问题，你想要这样的东西:

public class ReplacePatterns {

    //replace every instance of the pattern a with the pattern b inside c.
    //find a way to get the dimensions of a 2D array
    public static int[][] replace(int[][] a, int[][] b, int[][] c){
        for(int i = 0; i < c.length; i++){
            for(int j = 0; j < c[0].length; j++){
                if(c[i][j] == a[0][0]){ //c[i][j] should match up with a[0][0].
                    // Start verifying the rest of A
                    boolean flag = true;
                    for (int k = 0; k < a.length; k++) {
                        for (int l = 0; l < a[k].length; l++) {
                            if ((i+k) >= c.length || (j+l) >= c[0].length) {
                                flag = false;
                                break;
                            }
                            if (c[i+k][j+l] != a[k][l]) {
                                flag = false;
                            }
                        }
                    }
                    // If all the values for A were exactly the same, then replace it all with whatever is in B
                    if (flag) {
                        for (int k = 0; k < a.length; k++) {
                            for (int l = 0; l < a[k].length; l++) {
                                c[i+k][j+l] = b[k][l];
                            }
                        }
                    }
                }
            }
        }
        return c;
    }

    public static String prettyPrint(int[][] c) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < c.length; i++){
            for(int j = 0; j < c[0].length; j++){
                sb.append("[" + c[i][j] + "]");
            }
            sb.append("\n");
        }
        sb.append("\n");
        return sb.toString();
    }

    public static void test(int[][] patternA, int[][] patternB, int[][] patternC) {
        System.out.println("Pattern A:");
        System.out.println(prettyPrint(patternA));
        System.out.println("Pattern B:");
        System.out.println(prettyPrint(patternB));
        System.out.println("  Array C:");
        System.out.println(prettyPrint(patternC));

        int[][] result = ReplacePatterns.replace(patternA, patternB, patternC);

        System.out.println("  Result:");
        System.out.println(prettyPrint(result));
    }

    public static void main(String[] args){
        int[][] patternA, patternB, patternC;

        System.out.println("Test1:");
        patternA = new int[][]{{1,1}, {1,1}};
        patternB = new int[][]{{3,3}, {3,3}};
        patternC = new int[][]{{0,1,1,1}, {1,1,1,1}, {0,1,1,1}};
        test(patternA, patternB, patternC);

        System.out.println("Test2:");
        patternA = new int[][]{{1,1}, {1,1}};
        patternB = new int[][]{{5,6}, {7,8}};
        patternC = new int[][]{{0,1,1,1,0,1}, {1,1,1,0,1,1,1}, {0,1,1,1,1,1,1}};
        test(patternA, patternB, patternC);
    }
}

我什至在其中包含了两个测试以进行确认，但我很确定它适用于一般情况。它可能效率低下，并且可能不适用于大型阵列，但在这种情况下它可以完成工作。

程序以图形方式输出三个给定的模式(A、B 和 C)，并打印出替换发生后 C 的外观。在第二次测试运行中，您应该看到如下内容:

Test2:
Pattern A:
[1][1]
[1][1]


Pattern B:
[5][6]
[7][8]


Array C:
[0][1][1][1][0][1]
[1][1][1][0][1][1]
[0][1][1][1][1][1]


Result:
[0][5][6][1][0][1]
[1][7][8][0][5][6]
[0][1][1][1][7][8]