Array nach Zehnen durchsuchen.

[Masumania]

Hallo und noch frohe Weihnacht ,
ich habe folgende Aufgabe zu lösen und habe folgende Aufgabe zu lösen.

Aufgabe:
Schreiben Sie eine Klasse "WithoutTen" mit einer Methode "withoutTen", die ein int-Array als Eingabe erhält und auch wieder zurückgibt. Die Methode durchsucht das Array nach Zehnen und entfernt diese. Die nachfolgenden Elemente sollen dann nach links durchrücken. Die fehlenden Zehnen werden am Ende des Arrays durch Nullen ausgeglichen. Zum Beispiel aus {1, 10, 10, 2} wird {1, 2, 0, 0}.

Ich habe momentan wirklich keine Ahnung wie ich anfangen soll. Kann ich die Aufgabe mit einer for-Schleife lösen ? Kann mir hier vll jmd. helfen ?

 

[Tarrew]

Also als Anfang erstmal Klasse und Methode erstellen. Die Idee mit der for-Schleife ist schon richtig:

public class WithoutTen {

    public int[] withoutTen(int[] array) {
        for (int i = 0; i < array.length; i++) {
            //mache etwas
        }   
        return array;
    }
}

Innerhalb der Schleife überprüfst du ob das aktuelle Element eine 10 ist. Wenn ja dann rückst du den Rest des Arrays um eine Position nach vorne.

 

[Masumania]

Jetzt muss ich doch nur noch mein Array festlegen und mit der main-Methode starten?

 

[Tarrew]

Die main-Methode könnte so aussehen:

    public static void main(String[] args) {
        WithoutTen withoutTen = new WithoutTen();
        System.out.println(Arrays.toString(withoutTen.withoutTen(new int[]{1, 2, 3, 10, -3, 10, 5})));
    }

Das eigentlich Wichtige musst du aber noch implementieren. Nämlich das Löschen der 10en und das verschieben das Array innerhalb der for-Schleife.

 

[Masumania]

also mit Remove() und dann den Index der beiden zehnen ?

 

[Tarrew]

Also eine Remove-Methode ist mir nicht bekannt, außer ihr habt irgendwelche Hilfsfunktionen von eurem Lehrer bekommen. Sollte natürlich mit beliebig vielen 10en funktionieren.

 

[Masumania]

Wir haben nur diese Aufgabe bekommen und auch in meinen Unterlagen finde ich keinen gescheiten Ansatz.

 

[Tarrew]

Angenommen du hast dieses Array:
[1][2][3][10][5][7]
Du iterierst über das Array mit der for-Schleife und findest am 3. Index die erste 10.
Dann musst du über den Rest des Array iterieren und jede verbleibende Zahl um einen Index nach vorne ziehen:
[1][2][3][5][7][7].
Die letzte Zahl kannst du dann immer mit 0 ersetzen:
[1][2][3][5][7][0].

 

[Masumania]

public class Versuch {


public static void main(String[] args) {


int[] feld = new int[10];


feld[0] = 12;

feld[1] = 10;

feld[2] = 10;

feld[3] = 231;

feld[4] = 10;

feld[5] = 7;

feld[6] = 4;

feld[7] = 8;

feld[8] = 10;

feld[9] = 6;


/* for (int i = 0; i < 10; i++) {

if (feld = 10)

feld = 0; // man kann primitiven Datentypen kein null zuweisen.

}*/


for (int i = 0; i < 10; i++) {

if(feld != 10){

System.out.print(" " + feld);

}



}


}


}

 

[Xyz1]

Die letzte Zahl kannst du dann immer mit 0 ersetzen:

theoretisch könnten an die letzten Stellen auch die Zehnen.

 

[Tarrew]

theoretisch könnten an die letzten Stellen auch die Zehnen.

Dann müsste man die am Ende ja nochmal Ersetzen. Erscheint mir irgendwie unnötig.

 

[Masumania]

Ich habe es jetzt geschafft das er statt der Zehn eine Null anzeigt aber sortiert kriege ich es nicht

 

[Tarrew]

Du musst die 10 nicht durch eine 0 ersetzen und es auch nicht sortieren.
Du musst lediglich alle nachfolgenden Zahlen nach vorne ziehen und die letzte Zahl auf 0 setzen.

Eine einzige Zahl nach vorne ziehen geht so:

array[j]=array[j+1];

Wenn du das in eine Schleife packst, und bei dem Index von der gefunden 10 anfängst, dann schiebst du das ganze Array ausgehend von der Position um eine Stelle nach links.

 

[Masumania]

Jetzt bin ich völlig durcheinander.

 

[Tarrew]

Angenommen du hast dieses Array:
[1][2][3][10][5][7]
Du iterierst über das Array mit der for-Schleife und findest am 3. Index die erste 10.
Dann musst du über den Rest des Array iterieren und jede verbleibende Zahl um einen Index nach vorne ziehen:
[1][2][3][5][7][7].
Die letzte Zahl kannst du dann immer mit 0 ersetzen:
[1][2][3][5][7][0].

Ich zitiere mich nochmal selbst. Wie hast du denn versucht dieses Vorgehen umzusetzen?

 

[Xyz1]

und die letzte Zahl auf 0 setzen.

würd man sie auf 10 setzen, könnte man sie hinterher aber leichter eliminieren...

 

[Tarrew]

würd man sie auf 10 setzen, könnte man sie hinterher aber leichter eliminieren...

Bezweifel ich, aber ich schließe nicht aus, dass das für dich persönlich einfacher sein mag.

 

[Xyz1]

Was gibt es daran zu bezweifeln? Gibt es x Vorkommen von Zehn, dann ist die Länge des neuen Arrays nur noch n-x. wobei x nicht mal bekannt sein muss, dafür steht dann der nicht-magic value Zehn. Alles Andere ist kein vernünftiger "Ansatz", um Algorithmen zu designen. Lernt man eigentlich in jeder vernünftigen Höheren Algorithmen-Vorlesung.

 

[Tarrew]

theoretisch könnten an die letzten Stellen auch die Zehnen.

Wenn ich aus einem Array alle Zehnen entfernen möchte und das Array dann mit Nullen auffülle, warum sollte ich eine 10 beim Ersetzen dann erst an die letzte Stelle schreiben, um sie dann am Ende nochmal Ersetzen zu müssen. Das macht keinen Sinn. Keine Ahnung was du für Vorlesungen hattest, sorry.

 

[thecain]

Waum sollte das neue Array n-x sein? nur weil da eine 0 drin steht, wird das array nicht kleiner

 

[Xyz1]

um sie dann am Ende nochmal Ersetzen zu müssen.

Weil das Array dann nur noch einmal verkleinert werden muss, und die Laufzeit nicht quadratisch wächst.

Keine Ahnung was du für Vorlesungen hattest, sorry.

Nur die Besten, kannst du mir glauben - auch, wenn du selber keine hattest.

Waum sollte das neue Array n-x sein? nur weil da eine 0 drin steht, wird das array nicht kleiner

Könnte es aber im nächsten Schritt.

 

[Masumania]

public class Versuch {

public static void main(String[] args) {

int[] feld = new int[10];

feld[0] = 12;
feld[1] = 10;
feld[2] = 10;
feld[3] = 231;
feld[4] = 10;
feld[5] = 7;
feld[6] = 4;
feld[7] = 8;
feld[8] = 10;
feld[9] = 6;



for (int i = 0; i < 10; i++) {
if (feld == 10)
feld = 0; }

for (int i = 0; i < 10; i++) {
if(feld != 10){
System.out.print(" " + feld);
}


}
}

}
Das hier habe ich bis jetzt.
Daraus ergibt sich eine Zahlenreihe von : 12 0 0 231 0 7 4 8 0
Jetzt möchte ich die 0- en nach am Ende stehen haben.
Welchen genauen Befehl muss ich wo genau einsetzen?
Danke für die Hilfe!

 

[Tarrew]

Weil das Array dann nur noch einmal verkleinert werden muss, und die Laufzeit nicht quadratisch wächst.


Nur die Besten, kannst du mir glauben - auch, wenn du selber keine hattest.


Könnte es aber im nächsten Schritt.

Das Array soll garnicht verkleinert werden. Bevor du irgendwas postest, tuh uns bitte einen Gefallen und lies dir die Aufgabe erstmal richtig durch. Ist mir schon öfters aufgefallen, dass du das leider nicht tust.

Vorlesungen hatte ich übrigens auch

Daraus ergibt sich eine Zahlenreihe von : 12 0 0 231 0 7 4 8 0
Jetzt möchte ich die 0- en nach am Ende stehen haben.
Welchen genauen Befehl muss ich wo genau einsetzen?
Danke für die Hilfe!

Es bringt dir nichts die 10en durch 0en zu ersetzen, das ist falsch.
Du kannst ja auch in der Mitte des Arrays Nullen haben, die du dann auch ans Ende verschieben würdest, obwohl dort vorher keine 10 stand.

 

[Masumania]

Wie genau sieht der Verschiebungsbefehl aus?

 

[Tarrew]

Du musst die 10 nicht durch eine 0 ersetzen und es auch nicht sortieren.
Du musst lediglich alle nachfolgenden Zahlen nach vorne ziehen und die letzte Zahl auf 0 setzen.

Eine einzige Zahl nach vorne ziehen geht so:

array[j]=array[j+1];

Wenn du das in eine Schleife packst, und bei dem Index von der gefunden 10 anfängst, dann schiebst du das ganze Array ausgehend von der Position um eine Stelle nach links.

Mal ein Beispiel:

for (int i = 0; i < array.length - 1; i++) {
    array[i] = array[i + 1];
}
array[array.length - 1] = 0;

Damit verschiebst du ein ganzes Array um eine Position nach links und setzt die letzte Stelle auf 0.

Es gibt keinen "Verschiebungsbefehl" in diesem Sinne. Man könnte so etwas mit System.arraycopy erreichen, aber dir fehlen offensichtlich elementare Grundlagen, sodass die Schleife etwas anschaulicher sein sollte.

 

[Xyz1]

Ich schreibe es jetzt komplett (nach deinem Kenntnisstand) auf, sonst wird es ein Endlos Thema:

    public static void main(String[] args) {
        int[] feld = new int[10];

        feld[0] = 12;
        feld[1] = 10;
        feld[2] = 10;
        feld[3] = 231;
        feld[4] = 10;
        feld[5] = 7;
        feld[6] = 4;
        feld[7] = 8;
        feld[8] = 10;
        feld[9] = 6;

        int c = 0;

        for (int i = 0; i < feld.length - c;) {
            if (feld[i] == 10) {
                for (int j = i; j < feld.length - 1; j++) {
                    feld[j] = feld[j + 1];
                }
                feld[feld.length - 1] = 10;
                c++;
            } else {
                i++;
            }
        }

        System.out.println(Arrays.toString(feld));

        int[] neuesFeld = new int[feld.length - c];
        for (int i = 0; i < feld.length - c; i++) {
            neuesFeld[i] = feld[i];
        }

        System.out.println(Arrays.toString(neuesFeld));
    }

[12, 231, 7, 4, 8, 6, 10, 10, 10, 10]
[12, 231, 7, 4, 8, 6]

Wählte man jetzt 0 als magic value, dürfte 0 auch nicht im Array vorkommen, wenn die Ausgabe eindeutig sein soll.