Einzelne Werte aus einem Array vergleichen?

[Fabse]

Hi,

ich habe folgende 2 2D Arrays:

a                                             b

0 0 0 1 0 0                  ||           0 0 1 1 0 0 
0 0 1 1 0 0                  ||           0 1 1 1 1 0
0 1 0 1 0 0                  ||           0 1 0 1 0 0
0 0 0 1 0 0                  ||           0 0 0 1 1 0
0 0 0 1 0 0                  ||           0 0 0 1 1 0
0 0 0 1 0 0                  ||           0 1 0 1 1 0 
0 0 0 1 0 0                  ||           0 0 0 1 0 0
0 0 0 1 0 0                  ||           0 0 0 1 0 0

Jetzt möchte ich prüfen, ob in Array b überall eine 1 steht, wo auch in array a eine 1 steht. Das im array b an einigen Stellen eine 1 anstatt einer 0 steht ist uninteressant!! Die arrays sind "gleich" wenn sich alle "1en" aus dem a Array auch in dem b Array wiederfinden.

Muss ich mir jetzt echt alle Positionen des a Arrays wo eine 1 steht ausgeben lassen und diese Positionen dann mit dem b array vergleichen? Oder gehts auch einfacher? ArrayList? :bahnhof:

Danke

 

[nillehammer]

Im SE-API gibt es die Klasse

Arrays

mit diversen Hilfsmethoden.

Arrays.equals

für Vergleiche eindimensionaler Arrays und

Arrays.deepEquals

für vergleiche mehrdimensionaler Arrays. Doku gibts hier: Arrays (Java Platform SE 7 )
[EDIT]Oh Mist, habe den Zusatz mit den Nullen nicht gelesen. Warte, muss nachdenken...[/EDIT]
[EDIT]Habe mir grad den Quellcode von equals und deepEquals angesehen. Da wird auch schlicht durchiteriert. Einfacher geht es wohl nicht.[/EDIT]

 

[X5-599]

Hi,

ich habe folgende 2 2D Arrays:

a                                             b

0 0 0 1 0 0                  ||           0 0 1 1 0 0 
0 0 1 1 0 0                  ||           0 1 1 1 1 0
0 1 0 1 0 0                  ||           0 1 0 1 0 0
0 0 0 1 0 0                  ||           0 0 0 1 1 0
0 0 0 1 0 0                  ||           0 0 0 1 1 0
0 0 0 1 0 0                  ||           0 1 0 1 1 0 
0 0 0 1 0 0                  ||           0 0 0 1 0 0
0 0 0 1 0 0                  ||           0 0 0 1 0 0

Jetzt möchte ich prüfen, ob in Array b überall eine 1 steht, wo auch in array a eine 1 steht. Das im array b an einigen Stellen eine 1 anstatt einer 0 steht ist uninteressant!! Die arrays sind "gleich" wenn sich alle "1en" aus dem a Array auch in dem b Array wiederfinden.

Muss ich mir jetzt echt alle Positionen des a Arrays wo eine 1 steht ausgeben lassen und diese Positionen dann mit dem b array vergleichen? Oder gehts auch einfacher? ArrayList? :bahnhof:

Danke

Du könntest für jede "Zeile" des ArrayA eine dezimal Zahl in ein neues Array speichern. Das machst du genauso für das ArrayB. Aber anstatt diese Zahl in ein Array zu speichern, &-Verknüpfst du sie mit der Zahl aus dem neuen Array (für die aktuelle Zeile). Dieses Ergebnis muss gleich der Zahl aus dem neuen Array sein. Wenn nicht kannst du die Schleife abbrechen und sagen: Die ArraysA/B sind nicht gleich.


Schwer zu beschreiben in Textform. Grundansatz ist: Eine binäre UND-Verknüpfung der einzelnen "Zeilen" der ArraysA/B.

if((zeileB & zeileA) != zeileA)
    arraysAreEqual = false;

Weiss einer ne bessere Möglichkeit?

 

[Fabse]

@X5 ich glaub das ist aber logisch falsch die Idee, wenn ich sie richtig verstanden habe!?

Die Beispiel Arrays sind schon "gleich", weil alle 1en aus dem A array in dem B Array vorkommen.

Meine Idee wäre jetzt:

Ich geh durch das A Array, überall da wo eine 1 steht überprüfe ich sofort ob an der gleichen Stelle in Array B auch eine 1 steht, wenn ja gehts weiter bis das array fertig ist, wenn nein, sind die arrays nicht gleich und es wird abgebrochen.

 

[X5-599]

Ich sehe nicht wo das falsch sein soll. Hier mal etwas Code

public static void main(String[] args) throws ParseException
{
		int[][] a = new int[][]{
				{0,0,0,1,0,0},
				{0,0,1,1,0,0},
				{0,1,0,1,0,0},
				{0,0,0,1,0,0},
				{0,0,0,1,0,0},
				{0,0,0,1,0,0},
				{0,0,0,1,0,0},
				{0,0,0,1,0,0}};
		
		int[][] b = new int[][]{
				{0,0,1,1,0,0},
				{0,1,1,1,1,0},
				{0,1,0,1,0,0},
				{0,0,0,1,1,0},
				{0,0,0,1,1,0},
				{0,1,0,1,1,0},
				{0,0,0,1,0,0},
				{0,0,0,1,0,0}};
		
		int[] aNumbers = new int[a.length];
		for(int i = 0; i < a.length; i++)
		{
			String rowA = "";
			for(int j = 0; j < a[i].length; j++)
				rowA += a[i][j];
			
			aNumbers[i] = Integer.parseInt(rowA, 2);
		}
		
		boolean arraysEqual = true;
		for(int i = 0; i < b.length; i++)
		{
			String rowB = "";
			for(int j = 0; j < b[i].length; j++)
				rowB += b[i][j];
			int nRowB = Integer.parseInt(rowB, 2);
			
			if((nRowB & aNumbers[i]) != aNumbers[i])
			{
				arraysEqual = false;
				break;
			}
		}
		
		System.out.println("Array are equal: " + arraysEqual);
}

Was genau würde da denn nicht deiner Anforderung entsprechen? Im Grunde wird das selbe geprüft. Die 1sen aus Zeile x von ArrayA müssen in der Zeile x von ArrayB vorhanden sein. Zusätzliche 1sen in ArrayB sind egal.

 

[jgh]

...
Ich geh durch das A Array, überall da wo eine 1 steht überprüfe ich sofort ob an der gleichen Stelle in Array B auch eine 1 steht, wenn ja gehts weiter bis das array fertig ist, wenn nein, sind die arrays nicht gleich und es wird abgebrochen.

exakt...alles klar, oder brauchst du dabei noch Hilfe?

@ X5-599
was willst du da parsen und was haben da irgendwelche Strings verloren?

 

[Fabse]

Dann hab ich deinen Text oben falsch verstanden.
Jetzt mit dem Code ist es klarer

 

[X5-599]

exakt...alles klar, oder brauchst du dabei noch Hilfe?

@ X5-599
was willst du da parsen und was haben da irgendwelche Strings verloren?

Ich setzte die einzelnen "Zeilen" des Arrays zu einer Binär-Zahl um (als String). Diesen String parse ich dann in einen echten Integer und der wird dann &-Verknüpft. Das Ergebnis wird auf Gleichheit überprüft. Ist vielleicht nicht die eleganteste Methode, aber erfüllt die Anforderungen vom OP.
Da das ein anderer Ansatz ist als die einzelnen Inhalte per Indeces zu vergleichen, dachte ich mir ich erwähne es mal.

Besonders effizient ist es sicher nicht. Im schlimmsten Fall (wenn Gleichheit besteht) muss komplett über beide Arrays iteriert werden. man könnte aber vielleicht alles in einer Schleife machen. Anstatt die erzeugte Binärzahl aus ArrayA in ein neues Array zu speichern könnte man gleich über die erste Zeile von ArrayB iterieren und die daraus erzeugte Binärzahl gleich vergleichen. Dann wär auch beim ersten Unterschied Schluss.

Mir fällt grad auf, dass der Ansatz wohl doch nicht soo unterschiedlich ist. Ob ich nur über die einzelnen "Zellen" der Arrays iteriere und einzeln vergleiche oder alle "Zellen" einer Zeile als Binärzahl interpretiere und eine Bit-Maskierung anwende ist wohl ziemlich egal. Wobei meine Variante bestimmt schlechtere Performance bietet.

 

[jgh]

danke, aber die Frage war eher rheotorischer Natur^^...aber nichts für ungut, schön erklärt.

was ich damit meinte war...warum dieses geparse, ein einfacher Vergleich der int´s wäre imho viel einfacher, aber gut...der TO ist zufrieden, also passt dein Vorgehen.