Gibt die algorithmischen Dinge aus, die beim Reparieren des Systems im Geschäft gelernt wurden, anstatt Memos. Ursprünglich war es C #, aber da ich zu Hause keine C # -Umgebung habe, schreibe ich es in Java.
Ursprünglich war es kein Array, es war etwas komplizierter als ein Array, und es waren viele Elemente darin enthalten, aber um es einfach auszudrücken: ** Produktdaten ** (Name, Preis usw.) und sein ** Produktinventar * Es gab ein Array mit viel *.
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Produktname Lagermenge
Object[] syohin1 = {"Apfel", 5};
Object[] syohin2 = {"Traube", 20};
Object[] syohin3 = {"Mandarine", 0};
Object[] syohin4 = {"Kiwi", 10};
Object[] syohin5 = {"Banane", 15};
syohinList.add(syohin1);
syohinList.add(syohin2);
syohinList.add(syohin3);
syohinList.add(syohin4);
syohinList.add(syohin5);
//Überprüfen Sie die Restbestandsmenge des Produkts
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println(syohinList.get(i)[0] + "Restbestand:" + syohinList.get(i)[1]);
}
//Ausgabeergebnis
Apple Restbestand:5
Restlicher Traubenbestand:20
Mikan Restbestand:0
Kiwi Restbestand:10
Bananenreste:15
Eine meiner Aufgaben war es, eine ** Funktion zu implementieren, um Produkte mit 0 verbleibenden Beständen aus dem Array ** zu löschen.
Ich habe den Code sicher geschrieben, indem ich die for-Anweisung für die Häufigkeit des Arrays wiederholt und aus dem Array gelöscht habe, wenn der verbleibende Bestand 0 ist.
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Produktname Lagermenge
Object[] syohin1 = {"Apfel", 5};
Object[] syohin2 = {"Traube", 20};
Object[] syohin3 = {"Mandarine", 0};
Object[] syohin4 = {"Kiwi", 10};
Object[] syohin5 = {"Banane", 15};
syohinList.add(syohin1);
syohinList.add(syohin2);
syohinList.add(syohin3);
syohinList.add(syohin4);
syohinList.add(syohin5);
for ( int i = 0; i < syohinList.size(); ++i ) {
//Aus dem Array entfernen, wenn der Produktbestand 0 ist
if ((int)syohinList.get(i)[1] == 0) {
syohinList.remove(i);
}
}
//Überprüfen Sie die Restbestandsmenge des Produkts
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println(syohinList.get(i)[0] + "Restbestand:" + syohinList.get(i)[1]);
}
//Ausgabeergebnis
Apple Restbestand:5
Restlicher Traubenbestand:20
Kiwi Restbestand:10
Bananenreste:15
Ja, es ist weg. Aber eigentlich gibt es ein Problem.
Bei dieser Methode wird das Element ab dem 0. überprüft und aus dem Element gelöscht, wenn die Bedingung erfüllt ist (wenn der Bestand 0 ist). ** Unter bestimmten Bedingungen tritt jedoch ein Löschauslass auf. ** Insbesondere ** Wenn Elemente, die die Löschbedingungen erfüllen, nacheinander angezeigt werden. ** ** **
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Produktname Lagermenge
Object[] syohin1 = {"Apfel", 5};
Object[] syohin2 = {"Traube", 20};
Object[] syohin3 = {"Mandarine", 0}; //Ziel gelöscht werden
Object[] syohin4 = {"Kiwi", 0}; //Ziel gelöscht werden
Object[] syohin5 = {"Banane", 15};
syohinList.add(syohin1);
syohinList.add(syohin2);
syohinList.add(syohin3);
syohinList.add(syohin4);
syohinList.add(syohin5);
for ( int i = 0; i < syohinList.size(); ++i ) {
//Aus dem Array entfernen, wenn der Produktbestand 0 ist
if ((int)syohinList.get(i)[1] == 0) {
syohinList.remove(i);
}
}
//Überprüfen Sie die Restbestandsmenge des Produkts
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println(syohinList.get(i)[0] + "Restbestand:" + syohinList.get(i)[1]);
}
//Ausgabeergebnis
Apple Restbestand:5
Restlicher Traubenbestand:20
Kiwi Restbestand:0 //Es ist aus irgendeinem Grund nicht verschwunden
Bananenreste:15
Der Mikan ist verschwunden, die Kiwi jedoch nicht.
** Die Ursache war, dass das Element gelöscht und die nachfolgenden Elemente nach vorne verschoben wurden. ** ** **
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Produktname Lagermenge
Object[] syohin1 = {"Apfel", 5};
Object[] syohin2 = {"Traube", 20};
Object[] syohin3 = {"Mandarine", 0}; //Ziel gelöscht werden
Object[] syohin4 = {"Kiwi", 0}; //Ziel gelöscht werden
Object[] syohin5 = {"Banane", 15};
syohinList.add(syohin1);
syohinList.add(syohin2);
syohinList.add(syohin3);
syohinList.add(syohin4);
syohinList.add(syohin5);
//Überprüfen Sie die Restbestandsmenge des Produkts
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println("Array" + i + " " + syohinList.get(i)[0] + " " + "Restbestand:" + syohinList.get(i)[1]);
}
System.out.println("------------------------"); //Trennzeichen (um das Sehen zu erleichtern)
for ( int i = 0; i < syohinList.size(); ++i ) {
//Aus dem Array entfernen, wenn der Produktbestand 0 ist
if ((int)syohinList.get(i)[1] == 0) {
syohinList.remove(i);
}
}
//Bestätigen Sie die verbleibende Lagermenge des Produkts erneut
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println("Array" + i + " " + syohinList.get(i)[0] + " " + "Restbestand:" + syohinList.get(i)[1]);
}
//Ausgabeergebnis
Array 0 Äpfel Restbestand:5
Array 1 Traubenrestbestand:20
Array 2 Mikan Restbestand:0
Array 3 Kiwi Restbestand:0
Array 4 Bananen Restbestand:15
------------------------
Array 0 Äpfel Restbestand:5
Array 1 Traubenrestbestand:20
Array 2 Kiwi Restbestand:0 //Der Mikan verschwand und rutschte aus
Array 3 Bananen Restbestand:15 //Der Mikan verschwand und rutschte aus
Wenn Sie sich jede Schleife genauer ansehen,
//Erste Schleife: Array[0]Herausfinden
Array[0]Apple Restbestand:5 //Da der Restbestand nicht 0 ist, löschen Sie ihn nicht
Array[1]Restlicher Traubenbestand:20 //Ich habe es noch nicht überprüft
Array[2]Mikan Restbestand:0 //Ich habe es noch nicht überprüft
Array[3]Kiwi Restbestand:0 //Ich habe es noch nicht überprüft
Array[4]Bananenreste:15 //Ich habe es noch nicht überprüft
//Zweite Schleife: Array[1]Herausfinden
Array[0]Apple Restbestand:5 //Untersucht
Array[1]Restlicher Traubenbestand:20 //Da der Restbestand nicht 0 ist, löschen Sie ihn nicht
Array[2]Mikan Restbestand:0 //Ich habe es noch nicht überprüft
Array[3]Kiwi Restbestand:0 //Ich habe es noch nicht überprüft
Array[4]Bananenreste:15 //Ich habe es noch nicht überprüft
Das Problem beginnt hier.
//Dritte Schleife: Array[2]Herausfinden
Array[0]Apple Restbestand:5 //Untersucht
Array[1]Restlicher Traubenbestand:20 //Untersucht
Array[2]Mikan Restbestand:0 //Da der Restbestand 0 ist, löschen Sie ihn
Array[3]Kiwi Restbestand:0 //Ich habe es noch nicht überprüft
Array[4]Bananenreste:15 //Ich habe es noch nicht überprüft
Damit werden die Elemente des Arrays [2] gelöscht und die Elemente des Arrays 3 in das Array [2] und die Elemente des Arrays 4 in das Array [3] verschoben.
//Dritte Schleife: Array[2]Untersucht
Array[0]Apple Restbestand:5 //Untersucht
Array[1]Restlicher Traubenbestand:20 //Untersucht
Array[2]Kiwi Restbestand:0 //Ich habe es noch nicht überprüft
Array[3]Bananenreste:15 //Ich habe es noch nicht überprüft
Richtig, für die aktuelle Situation habe ich nach Array [2] gesucht, aber ** dieses Array [2] enthält Elemente, die ich noch nicht überprüft habe. ** ** **
//Vierte Schleife: Array[3]Herausfinden
Array[0]Apple Restbestand:5 //Untersucht
Array[1]Restlicher Traubenbestand:20 //Untersucht
Array[2]Kiwi Restbestand:0 //Ich habe es nicht überprüft, aber es wurde übersprungen
Array[3]Bananenreste:15 //Da der Restbestand nicht 0 ist, löschen Sie ihn nicht
Es fühlt sich an, als wäre es zwischen den Schleifen gut gelaufen. Als ich mich fragte, was passiert war, riet mir mein Senior, vom Maximalwert abzuziehen und aus der entgegengesetzten Richtung zu untersuchen. Das war's. Es ist, als hätte ich es vor langer Zeit im Unterricht gemacht. Danach wurde es jedoch aufgrund einer Designänderung unnötig, es zu verwenden, sodass ich es nicht implementierte. Ich war jedoch neugierig und dachte über die Bewegung zu Hause nach.
Ich habe diesen Code geschrieben.
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Produktname Lagermenge
Object[] syohin1 = {"Apfel", 5};
Object[] syohin2 = {"Traube", 20};
Object[] syohin3 = {"Mandarine", 0}; //Ziel gelöscht werden
Object[] syohin4 = {"Kiwi", 0}; //Ziel gelöscht werden
Object[] syohin5 = {"Banane", 15};
syohinList.add(syohin1);
syohinList.add(syohin2);
syohinList.add(syohin3);
syohinList.add(syohin4);
syohinList.add(syohin5);
//Untersuche von hinten
for ( int i = syohinList.size() - 1; i >= 0; --i ) {
//Aus dem Array entfernen, wenn der Produktbestand 0 ist
if ((int)syohinList.get(i)[1] == 0) {
syohinList.remove(i);
}
}
//Überprüfen Sie die Restbestandsmenge des Produkts
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println("Array" + i + " " + syohinList.get(i)[0] + " " + "Restbestand:" + syohinList.get(i)[1]);
}
Bis jetzt habe ich von der Vorderseite der Sequenz aus gesucht (aufsteigende Reihenfolge), aber diesmal habe ich sie in ** geändert, von der Rückseite der Sequenz aus gesehen (absteigende Reihenfolge) **.
Array 0 Äpfel Restbestand:5
Array 1 Traubenrestbestand:20
Array 2 Bananen Restbestand:15
Ja, es sieht so aus, als wäre es weg. Betrachtet man die Bewegung noch einmal Schleife für Schleife,
//Erste Schleife: Array[4]Herausfinden
Array[0]Apple Restbestand:5 //Ich habe es noch nicht überprüft
Array[1]Restlicher Traubenbestand:20 //Ich habe es noch nicht überprüft
Array[2]Mikan Restbestand:0 //Ich habe es noch nicht überprüft
Array[3]Kiwi Restbestand:0 //Ich habe es noch nicht überprüft
Array[4]Bananenreste:15 //Da der Restbestand nicht 0 ist, löschen Sie ihn nicht
//Zweite Schleife: Array[3]Herausfinden
Array[0]Apple Restbestand:5 //Ich habe es noch nicht überprüft
Array[1]Restlicher Traubenbestand:20 //Ich habe es noch nicht überprüft
Array[2]Mikan Restbestand:0 //Ich habe es noch nicht überprüft
Array[3]Kiwi Restbestand:0 //Gelöscht, da der Restbestand 0 ist
Array[4]Bananenreste:15 //Untersucht
Das Element (Kiwi) des Arrays [3] wird gelöscht und das Element (Banane) des Arrays [4] wird neu in das Array [3] eingefügt, es gibt jedoch kein Problem, da es in absteigender Reihenfolge vorliegt.
//Dritte Schleife: Array[2]Herausfinden
Array[0]Apple Restbestand:5 //Ich habe es noch nicht überprüft
Array[1]Restlicher Traubenbestand:20 //Ich habe es noch nicht überprüft
Array[2]Mikan Restbestand:0 //Gelöscht, da der Restbestand 0 ist
Array[3]Bananenreste:15 //Untersucht
Das Element (mikan) des Arrays [2] wird gelöscht und das Element (Banane) des Arrays [3] wird neu in das Array [2] eingefügt, aber es gibt kein Problem, da es bereits untersucht wurde.
//Vierte Schleife: Array[1]Herausfinden
Array[0]Apple Restbestand:5 //Ich habe es noch nicht überprüft
Array[1]Restlicher Traubenbestand:20 //Da der Restbestand nicht 0 ist, löschen Sie ihn nicht
Array[2]Bananenreste:15 //Untersucht
//5. Schleife: Array[0]Herausfinden
Array[0]Apple Restbestand:5 //Da der Restbestand nicht 0 ist, löschen Sie ihn nicht
Array[1]Restlicher Traubenbestand:20 //Untersucht
Array[2]Bananenreste:15 //Untersucht
Es ist so. Ich denke, es ist alles in Ordnung in Bezug auf den Betrieb. (Vielleicht)
Vielleicht ist es eine ziemlich grundlegende Idee des Algorithmus. Ich habe das Gefühl, ich habe es schon vor langer Zeit gehört. In letzter Zeit habe ich jedoch Dinge wie Ruby gemacht und mich auf bequeme Methoden verlassen, daher hielt ich es für wichtig, diese Denkweise zu trainieren.
https://www.javadrive.jp/start/for/index2.html http://d.hatena.ne.jp/nattou_curry_2/20090726/1248600833