Arrays vergleichen

überlebender

Aktives Mitglied
Man kann natürlich auch einfach streichen.

  1. Sind die Arrays A und B gleich lang? Falls nicht, gib false zurück.
  2. Für jedes Element aus A: suche ein Element mit dem gleichen Wert in B. Falls gefunden: streiche, das Element, ansonsten gib false zurück.
  3. Gib true zurück.
Beispiel:

A={1,2,3,4,5,1}, B={5,1,3,2,1,4}

Arrays sind gleich lang, also weiter.

1. Element aus A = 1 -> streiche das erste Vorkommen von 1 aus B -> B = {5,-,3,2,1,4}
2. Element aus A = 2 -> streiche das erste Vorkommen von 2 aus B -> B = {5,-,3,-,1,4}
3. Element aus A = 3 -> streiche das erste Vorkommen von 3 aus B -> B = {5,-,-,-,1,4}
4. Element aus A = 4 -> streiche das erste Vorkommen von 4 aus B -> B = {5,-,-,-,1,-}
5. Element aus A = 5 -> streiche das erste Vorkommen von 5 aus B -> B = {-,-,-,-,1,-}
6. Element aus A = 1 -> streiche das erste Vorkommen von 1 aus B -> B = {-,-,-,-,-,-}

Da jedes Element aus A in B gestrichen werden konnte -> true

Wäre z. B. B = {5,1,3,2,6,4} gewesen, dann hätte im 6. Schritt die zweite 1 aus A nicht in B gestrichen werden können -> false.
Ich habe mich jetzt nochmal hingesetzt und versucht, das Problem zu lösen. Hab mit dem von dir beschriebenen Ansatz angefangen und konnte die Aufgabe jetzt in einem ziemlich simplen und überschaubaren Code lösen:
Java:
public class A5_main {

public static boolean compareArraysVal(int [] a, int [] b) {
     
     
        Arrays.sort(a);
        Arrays.sort(b);
        if (a.length == b.length && Arrays.equals(a,b)) {
            return true;
        }
        return false;
}

public static void main (String [] args) {
        int[] a = {5,4,3,2,1};
        int[] b = {1,2,3,4,5};
         System.out.println(compareArraysVal(a, b));
         System.out.println(compareArraysVal(a, a));
    }}


Wenn ich diesen Code ausführe, bekomme ich zweimal true, also Reihenfolge egal, nur gleiche Länge und gleiche Werte werden geprüft.
Natürlich habe ich hier eine Abkürzung genommen, aber ich habe auch versucht, die Aufgabe ohne die Abkürzung zu lösen.

Java:
 public class A5_main


public static boolean compareArraysVal(int [] a, int [] b) {
     
        Arrays.sort(a);
        Arrays.sort(b);
        if (a.length == b.length) {    //Prüfung auf gleiche Länge
            return true;
        }
            return false;
        }
 
    int [] c = new int [a.length -1];   // zweites Arrays von a -1, um die Werte streichen zu können
    int [] d = new int [b.length -1];   //zweites Array für b -1, um die Werte streichen zu können
    int removeIndex = 0;                // Index, der gestrichen werden soll
 
    for (int i =0; i < removeIndex; i++) {
        for(removeIndex = 0; removeIndex < a.length && removeIndex < b.length; removeIndex++);  // ist der Index kleiner als die Länge a, dann Index erhöhen. Index soll hier erhöht werden, da das Programm ja sonst nicht starten würde (mit 0)                                                                                                                                    

    }
        c[i] = a[i];    // Index des neuen arrays -1 = dem Index von a
        d[i] = b[i];
    }
    for (int i = removeIndex +1; i < a.length && i < b.length; i++) {
        c[i-1] = a[i];     // hier soll der  Index von a entfernt und an c zugewiesen werden
        d[i-1] = b[i];
    }
}

public static void main (String [] args) {
    int[] a = {5,4,3,2,1};
    int[] b = {1,2,3,4,5};
     System.out.println(compareArraysVal(a, b));
     System.out.println(compareArraysVal(a, a));
}}



Ich kann das Programm jetzt nicht prüfen, weil sich einige Fehler eingeschlichen haben z.B. in Z.17&18: "a cannot be resolved into a variable", aber das liegt wahrscheinlich an einer fehlerhaften Zeichensetzung.

Mich würde jetzt nur interessieren, ob die Idee richtig war, ich habe ja bereits einen funktionierenden Code.
 

mihe7

Top Contributor
und konnte die Aufgabe jetzt in einem ziemlich simplen und überschaubaren Code lösen:
Das ist aber der Ansatz über das Sortieren :) Das Sortieren wollte ich ja gerade umgehen.

weil sich einige Fehler eingeschlichen haben z.B. in Z.17&18: "a cannot be resolved into a variable", aber das liegt wahrscheinlich an einer fehlerhaften Zeichensetzung.
Das liegt an der schlechten Formatierung. Wenn Du ordentlich einrücken würdest, würdest Du sofort sehen, dass die Methode compareArrayVal() in Zeile 12 endet, der folgende Code also unzulässigerweise außerhalb einer Methode liegt.

Die Frage, wie "gestrichen" wird, hatte ich offen gelassen. Das kann man z. B. mit einem boolean Array lösen:
Java:
public static boolean compareArrayVals(int[] a, int[] b) {
    if (a.length != b.length) {
        return false;
    }

    int n = a.length;
    boolean gestrichen[] = new boolean[n];

    for (int wert : a) {
        // suche das erste Element in b mit dem Wert wert,
        // das noch nicht gestrichen wurde
        int ix = 0;
        while (ix < n && (gestrichen[ix] || b[ix] != wert)) {
            ix++;
        }

        // wurde ein solches Element gefunden?
        if (ix < n) {
            gestrichen[ix] = true; // streichen
        } else {
            return false; // ansonsten sind die Array unterschiedlich
        }
    }

    // alle Werte aus a konnten in b gestrichen werden -> Arrays "gleich"
    return true;
}
Anzumerken wäre noch, dass man den kommentierten Code durch entsprechende Methoden ersetzen würde. Natürlich ist das Streichen nur eine Möglichkeit. Man kann z. B. auch Elemente im Array vertauschen, oder eben auch sortieren.
 

Oneixee5

Top Contributor
Also das:
Java:
public static boolean compareArraysVal(int [] a, int [] b) {
 
 
        Arrays.sort(a);
        Arrays.sort(b);
        if (a.length == b.length && Arrays.equals(a,b)) {
            return true;
        }
        return false;
}
kann man auch einfach so schreiben:
Java:
public static boolean compareArraysVal(int [] a, int [] b) {
        Arrays.sort(a);
        Arrays.sort(b);
        return Arrays.equals(a,b);
}
Der Längenvergleich wird da schon mit erledigt. Bei den meisten Anfängeraufgaben dürfen aber die Methoden aus dem JDK nicht verwendet werden, da der Umgang mit Schleifen geübt werden soll.

Durch das sortieren wird aber die Anforderung: "wenn die Werte, die in a und in b enthalten sind, gleich sind und gleich oft vorkommen und in der gleichen Reihenfolge in den jeweiligen Arrays enthalten sind." nicht erfüllt, die Reihenfolge wird ja u.U. verändert und ist damit nicht mehr vergleichbar.

Also einfach:
Java:
public static boolean compareArraysVal(int [] a, int [] b) {
        return Arrays.equals(a,b);
}

dann kann man noch ins JDK schauen, was Arrays.equals eigentlich macht:
Java:
    /**
     * Returns <tt>true</tt> if the two specified arrays of ints are
     * <i>equal</i> to one another.  Two arrays are considered equal if both
     * arrays contain the same number of elements, and all corresponding pairs
     * of elements in the two arrays are equal.  In other words, two arrays
     * are equal if they contain the same elements in the same order.  Also,
     * two array references are considered equal if both are <tt>null</tt>.<p>
     *
     * @param a one array to be tested for equality
     * @param a2 the other array to be tested for equality
     * @return <tt>true</tt> if the two arrays are equal
     */
    public static boolean equals(int[] a, int[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i<length; i++)
            if (a[i] != a2[i])
                return false;

        return true;
    }
Also genau das, auf was du die ganze Zeit hingewiesen wurdest.
 
Zuletzt bearbeitet:

KonradN

Super-Moderator
Mitarbeiter
Durch das sortieren wird aber die Anforderung: "wenn die Werte, die in a und in b enthalten sind, gleich sind und gleich oft vorkommen und in der gleichen Reihenfolge in den jeweiligen Arrays enthalten sind." nicht erfüllt,
Diese Anforderung war im Thread abgehakt und es wurde dann die Frage behandelt, wie man vorgeht, wenn die Reihenfolge keine Rolle spielen soll. Wir hatten uns daher von den ursprünglichen Anforderungen entfernt.
 

überlebender

Aktives Mitglied
Das ist aber der Ansatz über das Sortieren :) Das Sortieren wollte ich ja gerade umgehen.


Das liegt an der schlechten Formatierung. Wenn Du ordentlich einrücken würdest, würdest Du sofort sehen, dass die Methode compareArrayVal() in Zeile 12 endet, der folgende Code also unzulässigerweise außerhalb einer Methode liegt.

Die Frage, wie "gestrichen" wird, hatte ich offen gelassen. Das kann man z. B. mit einem boolean Array lösen:
Java:
public static boolean compareArrayVals(int[] a, int[] b) {
    if (a.length != b.length) {
        return false;
    }

    int n = a.length;
    boolean gestrichen[] = new boolean[n];

    for (int wert : a) {
        // suche das erste Element in b mit dem Wert wert,
        // das noch nicht gestrichen wurde
        int ix = 0;
        while (ix < n && (gestrichen[ix] || b[ix] != wert)) {
            ix++;
        }

        // wurde ein solches Element gefunden?
        if (ix < n) {
            gestrichen[ix] = true; // streichen
        } else {
            return false; // ansonsten sind die Array unterschiedlich
        }
    }

    // alle Werte aus a konnten in b gestrichen werden -> Arrays "gleich"
    return true;
}
Anzumerken wäre noch, dass man den kommentierten Code durch entsprechende Methoden ersetzen würde. Natürlich ist das Streichen nur eine Möglichkeit. Man kann z. B. auch Elemente im Array vertauschen, oder eben auch sortieren.
Hab jetzt versucht, den kommentierten Code mit den entsprechenden Methoden zu ersetzen.

Ich bin nicht weit gekommen und dazu ist der Code auch noch falsch. Ich glaube, dass ist noch zu hoch für mich und ich muss mich erstmal darum kümmern, die Aufgabenblätter zu erledigen, statt zu viel Zeit mit den verschiedenen Möglichkeiten, einen Code zu schreiben, zu verbringen.

Java:
package a5;

import java.util.Arrays;

    public class A5_main {

    public static boolean compareArraysVal(int [] a, int [] b) {
        
        
        if (a.length != b.length) {
            return false;
        }
        int n = a.length;
        boolean gestrichen [] = new boolean [n];
        
        for (int wert : a) {
            
            if (int [a] < n &&  a != b; a++) {  // Meine Ergänzung/Idee:
                 b++;                                   // Wenn ein Wert aus a kleiner ist als die Länge,
                                                         // und array a ungleich array b ist, dann soll der nächste Wert aus a geprüft werden
            }   
        int ix = 0;
        while (ix < n && (gestrichen[ix] || b[ix] != wert)) {
            ix++;
        }

        // wurde ein solches Element gefunden?
        if (ix < n) {
            gestrichen[ix] = true; ix-- // soll das gleiche Element entfernen
        } else {
            return false; // ansonsten sind die Array unterschiedlich
        }
    }

    // alle Werte aus a konnten in b gestrichen werden -> Arrays "gleich"
    return true;
}
 

KonradN

Super-Moderator
Mitarbeiter
Sorry, aber Dein Code macht so keinen Sinn. Und Du hast da sehr viel vermischt in Zeile 18. Da hast Du ein if, aber teilweise scheint es, als wolltest Du eine for Schleife. Aber eine Variable deklarierst Du da auch nicht... Dann das a++ macht keinen Sinn, denn a ist doch eines der Arrays.
 

mihe7

Top Contributor
Ich war verwirrt, weil du geschrieben hast, dass man den Code mit den entsprechenden Methoden ersetzen soll und hab versucht, da noch irgendwas reinzubasteln.
Ach so. Das war nur der obligatorische Wink auf Clean Code. Wenn man - wie in diesem Fall - mit Kommentaren erklärt, was der Code macht, dann ist das ein sicheres Zeichen dafür, dass man den kommentierten Code in Methoden auslagern sollte.

Zum Beispiel habe ich hier
Java:
        // suche das erste Element in b mit dem Wert wert,
        // das noch nicht gestrichen wurde
        int ix = 0;
        while (ix < n && (gestrichen[ix] || b[ix] != wert)) {
            ix++;
        }
im Kommentar erklärt, was der kommentierte Code macht. Ein Kommentar ist aber toter Text und statt hier großartig zu erklären, was das Ding macht, kann man den Spaß auch einfach in eine Methode auslagern und den Kommentar (inkl. des Codes) ersetzen durch:
Java:
    int ix = sucheZuStreichendesElement(wert, b, gestrichen);

Wenn man das vervollständigt, dann sieht die Schleife so aus:
Java:
    for (int wert : a) {
        int ix = sucheZuStreichendesElement(wert, b, gestrichen);
        if (elementGefunden(ix)) {
            gestrichen[ix] = true; 
        } else {
            return false; 
        }
    }
Das ist noch nicht wirklich schön, aber zumindest wird dem Leser mit einem Blick auf den Code (nicht Kommentar!) nun wesentlich schneller deutlich, worum es in der Schleife geht.

Warum ist der Code immer noch nicht wirklich schön? Weil das "Streichen" ein Implementierungsdetail ist, auf das hier sehr stark Bezug genommen wird. Das kann man ändern, führt hier aber etwas zu weit.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
Ü Methoden Arrays vergleichen - Methode Allgemeine Java-Themen 1
D Erste Schritte Arrays vergleichen und die zahlen die nur einmal vorkommen ausgeben Allgemeine Java-Themen 5
AssELAss Zwei Arrays / ArrayLists inhaltlich vergleichen Allgemeine Java-Themen 2
Dechasa Vergleichen von zwei Arrays Allgemeine Java-Themen 4
Y inhalte aus 2 unterschiedlichen Arrays miteinander vergleichen Allgemeine Java-Themen 12
S Mehrdimensionale Arrays Vergleichen Allgemeine Java-Themen 2
B Vergleichen von arrays macht Probleme Allgemeine Java-Themen 2
J Arrays vergleichen mit equals Allgemeine Java-Themen 8
Ü Eurobeträge in möglichst wenig Scheine/Münzen zerlegen (2D-Arrays) Allgemeine Java-Themen 27
Buroto Arrays generator Allgemeine Java-Themen 10
B Arrays von Methoden möglich? Allgemeine Java-Themen 44
rosima26 Bester Sortieralgorithmus für kurze Arrays Allgemeine Java-Themen 40
B Lottospiel, genug Reihen tippen für 3 Richtige (Spaß mit Arrays)? Allgemeine Java-Themen 46
Muatasem Hammud Erstellung von Testdaten für Arrays Allgemeine Java-Themen 6
Junger_Basileus Attribute, Arrays, Schleifen Allgemeine Java-Themen 9
P Generics und Arrays Allgemeine Java-Themen 6
O Arrays an DOCX-Stamper Library übergeben Allgemeine Java-Themen 1
L ArrayList mit String Arrays in ein Array umwandeln Allgemeine Java-Themen 1
R Zeilen eines 2d Arrays abwechselnd links und rechts mit Nullen auffüllen Allgemeine Java-Themen 14
R Spalten/Zeilen verschieben in zweidimensionalen Arrays? Allgemeine Java-Themen 3
kodela Inhalt eines Arrays ändert sich mysteriös Allgemeine Java-Themen 2
W Spaß mit Arrays Allgemeine Java-Themen 1
W Reflexion und Arrays Allgemeine Java-Themen 7
S Problem mit Arrays Allgemeine Java-Themen 1
J int Werte in einer anderen Klasse in Arrays speichern Allgemeine Java-Themen 3
Neoline Interpreter-Fehler Probleme mit Arrays.toString Allgemeine Java-Themen 7
H Zweidimensionale Arrays Allgemeine Java-Themen 6
Neoline Methoden Zwei Arrays abwechselnd zusammenführen Allgemeine Java-Themen 15
J Methoden clone(), arraycopy(): ein- und zweidimensionale Arrays Allgemeine Java-Themen 8
D Übereinstimmungen in Arrays Allgemeine Java-Themen 5
B Arrays mit Text und Zahlen füllen Allgemeine Java-Themen 3
B Spalten eines 2d-Arrays Allgemeine Java-Themen 2
J Arrays auf gleichheit untersuchen funktioniert nicht Allgemeine Java-Themen 11
N 2 Arrays abwechselnd verbinden Allgemeine Java-Themen 13
J private and arrays Allgemeine Java-Themen 2
T Alle Kombinationen aus zwei Arrays Allgemeine Java-Themen 8
RalleYTN Datentypen Herausfinden ob Object ein Array ist ohne den Typen des Arrays zu kennen? Allgemeine Java-Themen 12
R Rückgabe eines Arrays durch Funktion Allgemeine Java-Themen 9
H Datentypen Typ eines Arrays überprüfen Allgemeine Java-Themen 9
C Zweidimensionale Arrays - Quadratisch? Allgemeine Java-Themen 4
A Lineare Interpolation mit zwei Arrays Allgemeine Java-Themen 4
S Datentypen Warum ist bei Arrays die Länge als Property aufrufbar? Allgemeine Java-Themen 1
DanielsLPecke Java Arrays an andere Java Programme schicken und zurück Allgemeine Java-Themen 5
H Arrays Allgemeine Java-Themen 4
J NullPointerExeption bei Inizialisierung eines Arrays Allgemeine Java-Themen 3
D Größe der Zahlenkombinationen eines Arrays begrenzen Allgemeine Java-Themen 3
B automatisch benannte arrays erstellen Allgemeine Java-Themen 9
M Arrays.sort Problem Allgemeine Java-Themen 2
F Arrays Allgemeine Java-Themen 2
F Arrays Allgemeine Java-Themen 4
N Werte aus Arrays auslesen funktioniert nicht Allgemeine Java-Themen 5
F mehrdimensionale Arrays Allgemeine Java-Themen 4
A Methoden Generische Methode mit Arrays - Source Compatibility 1.7 benötigt, wieso? Allgemeine Java-Themen 3
S Java Problem bei der Rückgabe eines Arrays Allgemeine Java-Themen 19
I Verschiedene Arrays auslesen Allgemeine Java-Themen 6
R Wie kann man diese Methoden in arrays etablieren? Allgemeine Java-Themen 8
C Best Practice [Arrays] Wie sinnvoll prüfen, ob Array primitive Datentypen enthält? Allgemeine Java-Themen 6
C Best Practice Tiefe Kopie eines Arrays unbekannter Dimension und unbekannten Typs Allgemeine Java-Themen 4
R kann man irgendwie mit Arrays mit Eingabefenstern und Schleifen Werte abklappern? Allgemeine Java-Themen 2
R Was los mit dieser Aufgabe? Arrays mit Schachbrettmustern? Allgemeine Java-Themen 10
M Eingabe von Arrays geht über gewünschte Anzahl hinaus Allgemeine Java-Themen 2
K Methoden Arrays auf true Werte prüfen Allgemeine Java-Themen 4
T String Arrays aus den Argumenten auslesen Allgemeine Java-Themen 3
E ArrayIndexOutOfBounds - mehrdimensionale Arrays Allgemeine Java-Themen 6
D Arrays überschreiben sich Allgemeine Java-Themen 2
C Klonen von Arrays/ Matrizenrechnung Allgemeine Java-Themen 2
K Mehrere Arrays auf einmal erstellen Allgemeine Java-Themen 2
P Arrays erzeugen Allgemeine Java-Themen 5
R ListIterator über mehrere Arrays Allgemeine Java-Themen 13
S Variablen Dynamische Arrays Allgemeine Java-Themen 2
O Variablen System.getenv: Sinnlose Werte, Arrays?! Allgemeine Java-Themen 6
C Arrays.asList() - Problem Allgemeine Java-Themen 3
M problem mit speicherbedarf von arrays Allgemeine Java-Themen 14
B Generics und primitve arrays Allgemeine Java-Themen 6
V Umbennen von Arrays Allgemeine Java-Themen 7
M Einfluss von Caching auf die Performance (große Arrays) Allgemeine Java-Themen 24
A Frage zu Arrays Allgemeine Java-Themen 6
S Werte aus 2 eindimensionale boolean arrays mithilfe von logischen operatoren berechnen Allgemeine Java-Themen 6
R Methoden Rückgabe Arrays aufangen Allgemeine Java-Themen 29
T Arrays erstellen Allgemeine Java-Themen 3
C Zwei Arrays vereinen Allgemeine Java-Themen 3
J Array Sortierung auf andere Arrays anwenden Allgemeine Java-Themen 6
D Vertauschen von arrays vom Typ String Allgemeine Java-Themen 2
BattleMaster246 Arrays funktionieren nicht Allgemeine Java-Themen 6
S "Arrays" mit String-Key? Allgemeine Java-Themen 3
L verkettete Listen oder Arrays + Indexlisten effizienter? Allgemeine Java-Themen 3
S Überprüfung/Parsen eines Byte-Arrays Allgemeine Java-Themen 9
Developer_X Aus Datei in Arrays laden-Problem Allgemeine Java-Themen 5
O Problem beim Ausgeben von Arrays Allgemeine Java-Themen 9
G Arrays.toString Allgemeine Java-Themen 4
S to string mit arrays Allgemeine Java-Themen 10
S Objekte mit Arrays Allgemeine Java-Themen 9
Meldanor Mehrdimensionale Arrays : Zugriff auf n-tes Array Allgemeine Java-Themen 5
K Arrays.asList und primitive Typen Allgemeine Java-Themen 2
P Beschreibung eines Arrays Allgemeine Java-Themen 3
S Rücklieferung eines String-Arrays über Methode? Allgemeine Java-Themen 3
lacco Speicherverbrauch von Arrays Allgemeine Java-Themen 2
J Mit mehrdimensionalen Integer-Arrays arbeiten Allgemeine Java-Themen 17
knuckles12 null pointer exception bei arrays Allgemeine Java-Themen 6
H2SO3- dynamisches anlegen der dimensionaltität eines arrays Allgemeine Java-Themen 6

Ähnliche Java Themen


Oben