Matrix Elemente vergleichen

[Mika34]

Hallo Freunde der Sonne,

Ich melde mich mal wieder mit einem grundlegenden Problem im Allgemeinen, welches in meinem Java Buch für Anfänger nicht ausreichend thematisiert wird.
Sagen wir ich habe ein zwei dimensionales Array, welches eine 6x6 Matrix darstellt. Nun möchte ich in diesem 6x6 Array in jeder Spalte bzw. Zeile jeweils 4 Elemente der Matrix vergleichen. Um die Diagonalelemente zu vergleichen, habe ich mittlerweile verstanden, jedoch fehlt mir momentan noch das Verständnis wie man darauf kommt die Zeilen bzw. Spalten auszuegeben.

Es geht hier nur um die Herangehensweise, wie man hoffentlich meinen Beispiel der Prüfung der Diagonalelemente entnehmen kann. 🙂

Über jede Hilfe wäre ich dankbar 🙂)

for(int i = 0; i < array.length - 2; i++){
    for(int j = 0; j < array.length - 2; j++)
        if((array[i][j].equals("2")) && (array[i+1][j+1].equals("55")) &&
           (array[i+2][j+2].equals("4444")) && (array[i+3][j+3].equals("2"))){
            System.out.println("Hi");
        }
    }
}

 

[Xyz1]

Es ist noch unverständlich, was Du machen möchtest... Die Form der Matrix ausgeben, also zum Beispiel 6x6 oder 6x5?

Nun möchte ich in diesem 6x6 Array in jeder Spalte bzw. Zeile jeweils 4 Elemente der Matrix vergleichen. Um die Diagonalelemente zu vergleichen, habe ich mittlerweile verstanden, jedoch fehlt mir momentan noch das Verständnis wie man darauf kommt die Zeilen bzw. Spalten auszuegeben.

Es gibt doch immer nur eine Hauptdiagonale - oder?

 

[Xyz1]

Habe mal damit angefangen - aber gerade selber Probleme die Hauptdiagonale zu berechnen:

class Matrix {
	String[][] m = null;

	Matrix(String[][] p_m) {
		m = p_m;
	}

	int getRows() {
		return m.length;
	}

	int getCols() {
		return m[0].length;
	}

	List<Integer> getForm() {
		return List.of(getRows(), getCols());
	}

	List<String> getDiag(int i) {
		ArrayList<String> l = new ArrayList<String>();
		int x = getRows() - 1 - i / 2;
		int y = (i + 1) / 2;
		for (; x >= 0 && y >= 0; x--, y--) {
			l.add(m[x][y]);
		}
		Collections.reverse(l);
		return l;
	}

	List<List<String>> getAllDiags() {
		ArrayList<List<String>> l = new ArrayList<List<String>>();
		for (int i = 0; i < getCols() * 2 - 1; i++) {
			l.add(getDiag(i));
		}
		return l;
	}

	void printInfo() {
		System.out.println("Form " + getForm());
		System.out.println("Diags");
		for (List<String> l : getAllDiags()) {
			System.out.println(l);
		}
	}
}

	public static void main(String[] args) throws IOException {
		new Matrix(new String[][] {{ "1", "2", "3" }, { "4", "5", "6" }, { "7", "8", "9" }}).printInfo();
	}

Form [3, 3]
Diags
[7]
[4, 8]
[1, 5]
[2, 6]
[3]

Die Ausgabe müsste eigentlich sein

Form [3, 3]
Diags
[7]
[4, 8]
[1, 5 , 9]
[2, 6]
[3]

Sieht jemand den Fehler?

 

[Mika34]

Nein, ich habe beispielsweise 4 Werte, welcher in meiner 6x6 Matrix vorkommen können. Nun möchte ich prüfen, ob diese 4 Elemente diagonal vorkommen sprich beispielsweise bei (2,0),(3,1),(4,2),(5,3) oder auf anderen Diagonale, welche sich durch die 4 Elemente ergeben

 

[Xyz1]

Na dann mach das doch einfach. 🙂

 

[Mika34]

Damit fahre ich komplett gegen die Wand, deswegen habe ich euch gefragt, ob einer von euch schon einmal so etwas implementiert hat.

 

[httpdigest]

Deine aktuelle Lösung aus deinem ersten Post ist doch schon gar nicht schlecht. Du prüfst da alle möglichen Diagonalen in die positive x und y Richtung. Jetzt fehlen doch nur noch die drei anderen Richtungen.

 

[httpdigest]

Ich empfehle dir, dir wirklich mal selber Gedanken zu machen. Zum Beispiel könntest du, statt alle vier Diagonalen manuell/per Hand abzuprüfen, auch eine Schleife der Länge 4 nehmen und einen berechneten Faktor für die Laufrichtung und für den Offset der Indizes verwenden, so dass du mit einer Methode alle der vier möglichen Diagonalen prüfen kannst.
Das könnte z.B. so aussehen (ich hab's mal gebaut und extra etwas obfuscated, damit du dir mal selber Gedanken machst):

Spoiler

public class DiagonaleInMatrixFinden {
  public static <T> boolean containsDiagonale(T[][] arr, T[] diag) {
    for (int y = 0; y <= arr.length - diag.length; y++)
      for (int x = 0; x <= arr[y].length - diag.length; x++)
        for (int d = 0; d < 4; d++)
          if (checkDiagonale(arr, diag, y, x, d))
            return true;
    return false;
  }
  private static <T> boolean checkDiagonale(T[][] arr, T[] diag, int y, int x, int d) {
    int ox = d >>> 1, oy = d & 1, sx = 1 - (ox << 1), sy = 1 - (oy << 1);
    for (int i = 0; i < diag.length; i++)
      if (!arr[(y + i) * sy + (arr.length - 1)    * oy]
              [(x + i) * sx + (arr[y].length - 1) * ox].equals(diag[i]))
        return false;
    return true;
  }
  public static void main(String[] args) {
    Integer[][] arr = {
      { 0,  1,  2,  3,  4,  5},
      { 6,  7,  8,  9, 10, 11},
      {12, 13, 14, 15, 16, 17},
      {18, 19, 20, 21, 22, 23},
      {24, 25, 26, 27, 28, 29},
      {30, 31, 32, 33, 34, 35}
    };
    Integer[] diag = {33, 26, 19, 12};
    System.out.println(containsDiagonale(arr, diag));
  }
}

 

[Mika34]

Hi httpdigest,
Ich habe mir deine Lösung noch einmal angeschaut, jedoch werde ich einfach nicht schlauer davon. Auch verstehe ich deinen Bezug zum Codeschnipsel von mir nicht, kannst du mich etwas aufklären bzw. mir den Rohbau davon erklären

 

[httpdigest]

Mein Code ist einfach eine Lösung für dein Problem, bzw. meiner Interpretation deines Problems, weil du hierfür noch keine exakte/formale Beschreibung gegeben hast. Der Code sucht an allen möglichen Positionen der Matrix entlang der vier möglichen Diagonalen (zwei Diagonalen vorwärts und dieselben Diagonalen rückwärts) das Muster, gegeben durch den Vektor aus 4 Elementen. Wobei der Code so generisch ist, dass er mit Vektoren und Matrizen beliebiger Größe funktioniert.
Die Schleifen über `y` und über `x` sind einfach für alle gültigen Positionen in der Matrix, an der eine der vier möglichen Diagonalen starten kann (wobei für die Diagnalen, die "rückwärts" in einer der beiden Dimensionen laufen, ein entsprechender Offset in der Methode `checkDiagnoale` ermittelt wird, um "von hinten" in der Matrix zu beginnen).
Die Schleife über `d` (0..3) identifiziert jeweils eine der vier Diagonalen.
Die Methode `checkDiagonale` prüft, ob an der Stelle `(y, x)` in der Matrix und der Diagonalen `d` ein Match gefunden wird.

 

[Mika34]

Vielen Dank für die Aufklärung, weil ich war mir nicht sicher, ob ich deinen Code nur falsch verstehe oder der Fallgar nicht aufgegriffen wurde, falls es sich um eine Diagonale handelt, welche sich abseits der Hauptdiagonalen befindet. Da dies auch der Fall ist, versuche ich es mal mit meinem neugewonnen Wissen dies umzusetzen 🙂. Aber nochmals vielen Dank

 

[Mika34]

Mein Code ist einfach eine Lösung für dein Problem, bzw. meiner Interpretation deines Problems, weil du hierfür noch keine exakte/formale Beschreibung gegeben hast. Der Code sucht an allen möglichen Positionen der Matrix entlang der vier möglichen Diagonalen (zwei Diagonalen vorwärts und dieselben Diagonalen rückwärts) das Muster, gegeben durch den Vektor aus 4 Elementen. Wobei der Code so generisch ist, dass er mit Vektoren und Matrizen beliebiger Größe funktioniert.
Die Schleifen über `y` und über `x` sind einfach für alle gültigen Positionen in der Matrix, an der eine der vier möglichen Diagonalen starten kann (wobei für die Diagnalen, die "rückwärts" in einer der beiden Dimensionen laufen, ein entsprechender Offset in der Methode `checkDiagnoale` ermittelt wird, um "von hinten" in der Matrix zu beginnen).
Die Schleife über `d` (0..3) identifiziert jeweils eine der vier Diagonalen.
Die Methode `checkDiagonale` prüft, ob an der Stelle `(y, x)` in der Matrix und der Diagonalen `d` ein Match gefunden wird.

Habs mittlerweile verstanden! 🙂). Ohje, du kannst dir nicht vorstellen, was für ein Gefühl es ist! 🙂
Danke