Question

我正在尝试编写一个执行以下操作的方法：将数组A的每次出现替换为数组B，其中A位于2D数组C内，然后返回修改后的数组。 A，B和C是整数的二维数组。

给定一个矩形数组c和另一个矩形数组a，其大小为＆lt; = 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]

Answer 2

下面说明一种解决方案。请注意，我没有考虑优化代码以最小化模式检查。我相信找到模式会有更好的算法。我采用了一种天真的方法来验证每个节点上的模式。代码中的注释。

//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 int[][] replacePattern(int[][] a, int[][] b, int[][] c) {

        //first make d as copy of array c
        int[][] d = new int[c.length][c[0].length];
        for (int i = 0; i < c.length; i++) {
            for (int j = 0; j < c[0].length; j++) {
                d[i][j] = c[i][j];
            }
        }

        //now scan array c for appearance of a. go over every node and on each node initiate a check if the pattern happens at that node
        //note the scan is done as long as we don't step out of array c dimensions
        for (int i = 0; i < c.length - a.length + 1; i++) {
            for (int j = 0; j < c[0].length - a[0].length + 1; j++) {
                //we verify pattern on each node as it can start on each of them
                boolean isPatternOcurring = true;
                for (int m = 0; m < a.length && isPatternOcurring; m++) {
                    for (int n = 0; j < a[0].length; n++) {
                        if (c[i + m][j + n] != a[m][n]) {
                            isPatternOcurring = false;
                            break;
                        }
                    }
                }

                //if pattern occurs, then copy b into d
                if (isPatternOcurring) {
                    for (int m = 0; m < b.length; m++)
                        for (int n = 0; j < b[0].length; n++) 
                            d[i + m][j + n] = b[m][n]; 


                }
            }
        }


        return d;

    }

用另一种模式替换二维数组中的模式

2 个答案: