Muster in 2D-Array finden

[BDA]

Hallo!

Ich versuche im Moment, bestimmte (in einem Array gespeicherte) Muster in einem anderen Array zu finden. Die "große Liste" cells ist eine 2D-Liste von booleans. Ich übergebe der Methode ein Muster, wobei eine 0 für false, eine 1 für true und eine 2 für eins von beidem steht. Die Methode gibt 2 Integer als Array zurück, und zwar die x + y Koordinate des (ersten) gefundenen Musters. Ein Beispiel für ein Muster:

 { { 1, 1, 1, 1 , 2, 0, 1}}

Das Problem: er erkennt das Muster auch, wenn es rotiert ist (um 90°). Wahrscheinlich habe ich einfach irgendwo nicht nachgedacht... Kann mir einer von euch helfen? *-* Falls etwas sinnlos erscheint, es hat alles seinen Sinn! Ich weiß, der Code könnte effizienter sein, aber erstmal ist mir wichtig das er funktioniert...

private int[] checkForPatterns(int[][] pattern) {

		for (int x = 0; x < cells.length; x++) {
			for (int y = 0; y < cells[0].length; y++) {
				int counter = 0;
				for (int pX = 0; pX < pattern.length; pX++) {
					for (int pY = 0; pY < pattern[0].length; pY++) {
						System.out.println(pattern.length + " + "
								+ pattern[0].length);
						try {
							switch (pattern[pX][pY]) {
							case 0:
								if (cells[x + pX][y + pY] == false)
									counter++;
								break;
							case 1:
								if (cells[x + pX][y + pY] == true)
									counter++;
								break;
							case 2:
								counter++;
								break;
							}
						} catch (Exception e) {
						}
					}
				}
				if (counter == pattern.length * pattern[0].length) {
					return new int[] { x, y };
				}
			}
		}

		return null;
	}

MFG, me

 

[Flown]

Also nocheinmal alles zusammenzufassen: Du hast ein 2D Array und da sind irgendwelche Wert (0-2) und du willst nach einem gewissen Muster ausschau halten.

Soll das Muster nur horizontal funktionieren? Oder soll es auch in jede Richtung gelten?

Oder sagen wir so, wenn du so ein Pattern {{2, 2, 2, 2, 1}} erstellst, dann soll es nur horizontal und wenn du {{2},{2},{2},{1}} erstellst soll es vertikal gesucht werden?

 

[BDA]

Also nocheinmal alles zusammenzufassen: Du hast ein 2D Array und da sind irgendwelche Wert (0-2) und du willst nach einem gewissen Muster ausschau halten.

Soll das Muster nur horizontal funktionieren? Oder soll es auch in jede Richtung gelten?

Oder sagen wir so, wenn du so ein Pattern {{2, 2, 2, 2, 1}} erstellst, dann soll es nur horizontal und wenn du {{2},{2},{2},{1}} erstellst soll es vertikal gesucht werden?

Genau so, habe es wahrscheinlich nur ein bisschen undurchsichtig erklärt...

 

[Flown]

Sowas in derer Art?

Spoiler: Code

import java.util.Arrays;

public class ArrayPatternMatcher {
	
	public static void main(String[] args) {
		
		boolean[][] testGrid = {{false, false, true, true},
								{true, false, true, false},
								{false, false, false, false}};
		int[][] pattern = {{2}, {0}, {0}};
		
		System.out.println(Arrays.toString(findPatternInGrid(testGrid, pattern)));
		
	}
	
	public static int[] findPatternInGrid(boolean[][] grid, int[][] pattern) {
		int[] result = null;
		for(int i = 0; i < grid.length; i++) {
			for(int j = 0; j < grid[i].length; j++) {
				if(findPatternInGridAt(i, j, grid, pattern)) {
					return new int[] {i, j};
				}
			}
		}
		return result;
	}
	
	private static boolean findPatternInGridAt(int x, int y, boolean[][] grid, int[][] pattern) {
		for(int i = 0; i < pattern.length; i++) {
			if(pattern.length > grid.length - x) return false;
			if(pattern[i].length > grid[i].length - y) return false;
			for(int j = 0; j < pattern[i].length; j++) {
				switch(pattern[i][j]) {
				case 0:
					if(grid[x+i][y+j]) {
						return false;
					}
					break;
				case 1:
					if(!grid[x+i][y+j]) {
						return false;
					}
					break;
				}
			}
		}
		return true;
	}

}

 

[BDA]

Sowas in derer Art?

Spoiler: Code

import java.util.Arrays;

public class ArrayPatternMatcher {
	
	public static void main(String[] args) {
		
		boolean[][] testGrid = {{false, false, true, true},
								{true, false, true, false},
								{false, false, false, false}};
		int[][] pattern = {{2}, {0}, {0}};
		
		System.out.println(Arrays.toString(findPatternInGrid(testGrid, pattern)));
		
	}
	
	public static int[] findPatternInGrid(boolean[][] grid, int[][] pattern) {
		int[] result = null;
		for(int i = 0; i < grid.length; i++) {
			for(int j = 0; j < grid[i].length; j++) {
				if(findPatternInGridAt(i, j, grid, pattern)) {
					return new int[] {i, j};
				}
			}
		}
		return result;
	}
	
	private static boolean findPatternInGridAt(int x, int y, boolean[][] grid, int[][] pattern) {
		for(int i = 0; i < pattern.length; i++) {
			if(pattern.length > grid.length - x) return false;
			if(pattern[i].length > grid[i].length - y) return false;
			for(int j = 0; j < pattern[i].length; j++) {
				switch(pattern[i][j]) {
				case 0:
					if(grid[x+i][y+j]) {
						return false;
					}
					break;
				case 1:
					if(!grid[x+i][y+j]) {
						return false;
					}
					break;
				}
			}
		}
		return true;
	}

}

Das klappt jetzt, danke!!!