Zwei Integer Arrays "kombinieren"

[Cygan93]

Hallo,
ich komme bei folgender Aufgabe nicht so wirklich weiter.
Implementieren sie eine Javamethode diff die zwei Arrays a und b übergeben bekommt. Das Array c soll alle zahlen aus a, die nicht in b vorkommen, und alle zahlen aus b, die nicht in a vorkommen, enthalten.
Z.B: a=[1,2,3,4] b=[2,5,1] soll rauskommen: [3,4,5].

Meine Idee:
In das Array c werden alle eintrage von Array a gespeichert.
Nun vergleiche ich Array c mit Array b und falls ein Element gleich ist lösche ich dieses aus dem Array c. Falls eine Zahl aus b nicht gleich mit einer Zahl aus Array c ist füge ich es hinzu.
Aber wie mache ich das? Spontan würde ich das jetzt mit zwei for schleifen. Ungefähr so:

public class Arrays{
	public static int[] diff(int[] a, int[] b) {
		int[] c = {};
		for (int i = 0; i <= a.length; i++) {
			for (int j = 0; j <= b.length; j++) {

			}

		}
		return c;
	}
}

Wie mache ich weiter? Oder bin ich total auf dem holzweg?

 

[ninonino]

Hier eine kleine Hilfsmethode.
( nicht getestet müsste aber funktionieren)

	public boolean onlyOnce(int check ,int[]a,int[]b){
		if (( Arrays.asList(a).contains(check))&&(Arrays.asList(b).contains(check))){
			return false ;
				
			}
		return true ;

	}

vielleicht kommst du damit weiter...

 

[Cygan93]

Ist diese Methode universell?
Ich müsste ja für int check viele unterschiedliche Werte eingeben und es könnte passieren das ich einen Wert der in a oderb enthalten ist vergesse.

 

[ninonino]

ich würde diese methode einmal über jedes array laufen lassen und die Zahlen,bei denen onlyOnce = true ergibt dann in c speichern.

 

[ninonino]

so etwa :

	public ArrayList<Integer> getSingleInts(int[]a,int[]b){
		ArrayList<Integer> nurEinMal = new ArrayList<>();
		Arrays.stream(a).filter(e -> onlyOnce(e,a,b))
						.forEach(e -> nurEinMal.add(e));
		Arrays.stream(b).filter(e -> onlyOnce(e,a,b))
						.forEach(e -> nurEinMal.add(e));
		return nurEinMal  ;
		
	}

Als Ergebnis hättest du dann eine ArrayList mit INTEGER werten ( nicht int ).
sonst so :

	public int[] getNurEinMal(int[]a,int[]b){
		int[]c = new int[a.length+b.length];
		int indexInC = 0 ;
		for ( int i = 0 ; i < a.length ; i++){
			if( onlyOnce(a[i],a,b)){
				c[indexInC]= a[i];
				indexInC++;
			}
		}
		for ( int i = 0 ; i < b.length ; i++){
			if( onlyOnce(b[i],a,b)){
				c[indexInC]= b[i];
				indexInC++;
			}
		}
		return c ;
	}

 

[Cygan93]

Hm da blicke ich nicht so ganz durch!
Ich dachte da an soetwas:

package Arrays;

public class Arrays {
	public static int[] diff(int[] a, int[] b) {
		int[] c = {};
		for (int i = 0; i <= a.length; i++) {
			for (int j = 0; j <= b.length; j++) {
				if (a.equals(b)) {
                            // Hier sollen jetzt die Werte in c gespeichert werden
				}

			}

		}
              return c;
	}

	public boolean equal(int[] a, int[] b) {
		for (int i = 0; i <= a.length; i++) {
			for (int j = 0; j <= b.length; j++) {
				if (a[i] == b[j]) {
					return false;
				}

			}

		}
		return true;
	}
}

Aber ich weiß nicht wie ich jetzt welche Werte in c speichern soll

 

[Flown]

Warum hier immer die Lösungen und kein Weg zum Verständnis posten. Die besten Errungenschaften sind die eigenen!

Also ich helf dir mal das zu verstehen.

Pseudocode + Prosa:

public static int[] diff(int[] a, int[] b) {
  // Wieviele Elemente kann c im schlimmsten Fall beinhalten?
  int[] c = new int[???];
  // Zähler damit man weiß, wieviele Elemente bis jetzt zu c hinzugefügt wurden
  int elements = 0;
  // Wenn wir alle Werte aus a mit b vergleichen und Buch führen welche Elemente in a und in b vorhanden sind,
  // sparen wir uns nacher eine Menge Schleifendurchläufe
  boolean[] isDuplicate = new boolean[b.length];
  for(int i: 0...a.length-1) {
    // Wir laufen immer das ganze Array durch und müssen mitführen, ob wir einmal ein Duplikat gefunden hätten.
    boolean duplicateFound = false;
    for(int j: 0...b.length-1) {
      if(a[i] == b[j]) {
        isDuplicate[j] = true;
        duplicateFound = true;
      }
    }
    if(!duplicateFound) {
      c[elements++] = a[i];
    }
  }
  // Alle Elemente aus a sind jetzt in c vorhanden, die nicht in b vorkommen. Jetzt müssen wir noch die Elemente aus
  // b in c schreiben. Da wir mit dem boolean-Array sichergestellt haben, welche Elemente Duplikate sind, fügen wir nur
  // die Elemente hinzu, die keine sind, denn diese sind implizit nicht in a vorgekommen (logisch).
  for(int i: 0...b.length-1) {
    if(!isDuplicate[i]) {
      c[elements++] = b[i];
    }
  }
  // Jetzt noch c mit richtiger Länge zurückgeben: Option 1) neues Array erstellen, System.arraycopy; Option 2) 
  // Arrays.copyOf
  return Arrays.copyOf(c, elements);
}

Bei weiteren Fragen, her damit!

 

[Cygan93]

Hallo,
erstmal vielen dank für diesen post denn nur die Lösung zu zeigen bringt wirklich nichts 🙂
Ich habe ein Frage:
Die beiden aufrufe isDuplicate und duplicate found sind methoden richtig? Diese muss ich noch implementieren oder?
LG

 

[Flown]

Nein das eine ist eine boolean Variable und das andere ein boolean Array

 

[Cygan93]

Ahh okay wusste garnicht das das geht! Danke 🙂
Noch eine Frage du schreibst: // Wieviele Elemente kann c im schlimmsten Fall beinhalten?
Die Antwort ist unendlich. Kann ich nicht c als leeres array angeben das stetig gefüllt wird?

 

[Flown]

Nein du kannst bei Arrays nur einmal die Größe festlegen. Das heißt es muss im vorhinein schon klar sein wie groß es werden kann.

Also unendlich ist theoretisch möglich. Aber ich meinte im Bezug auf ein gegebenes a und b.