Il produit les choses algorithmiques apprises lors de la réparation du système en entreprise au lieu de mémos. À l'origine, c'était C #, mais comme je n'ai pas d'environnement C # à la maison, je l'écris en Java.
À l'origine, ce n'était pas un tableau, c'était un peu plus compliqué comme un tableau, et il y avait de nombreux éléments à l'intérieur, mais pour le dire simplement, ** données produit ** (nom, prix, etc.) et son ** inventaire produit * Il y avait un tableau qui contenait beaucoup de fichiers *.
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Nom du produit Quantité en stock
Object[] syohin1 = {"pomme", 5};
Object[] syohin2 = {"Grain de raisin", 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);
//Vérifiez la quantité de stock restante du produit
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println(syohinList.get(i)[0] + "Stock résiduel:" + syohinList.get(i)[1]);
}
//Résultat de sortie
Stock restant de pomme:5
Stock de raisin résiduel:20
Stock résiduel de Mikan:0
Stock restant de kiwi:10
Stock restant de banane:15
Ainsi, l'une de mes tâches était d'implémenter une ** fonction pour supprimer les produits avec 0 inventaire restant du tableau **.
J'ai écrit le code en toute sécurité en répétant l'instruction for pour le nombre de fois du tableau et en le supprimant du tableau si le stock restant est de 0.
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Nom du produit Quantité en stock
Object[] syohin1 = {"pomme", 5};
Object[] syohin2 = {"Grain de raisin", 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 ) {
//Supprimer de la baie si l'inventaire du produit est 0
if ((int)syohinList.get(i)[1] == 0) {
syohinList.remove(i);
}
}
//Vérifiez la quantité de stock restante du produit
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println(syohinList.get(i)[0] + "Stock résiduel:" + syohinList.get(i)[1]);
}
//Résultat de sortie
Stock restant de pomme:5
Stock de raisin résiduel:20
Stock restant de kiwi:10
Stock restant de banane:15
Ouais, c'est parti. Mais en fait, il y a un problème.
Cette méthode consiste à vérifier l'élément à partir du 0 et à le supprimer de l'élément si la condition est remplie (si le stock est à 0), mais ** Sous certaines conditions, une omission de suppression se produit. ** Plus précisément ** Lorsque les éléments qui satisfont aux conditions de suppression se succèdent. ** **
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Nom du produit Quantité en stock
Object[] syohin1 = {"pomme", 5};
Object[] syohin2 = {"Grain de raisin", 20};
Object[] syohin3 = {"Mandarine", 0}; //Cible à supprimer
Object[] syohin4 = {"kiwi", 0}; //Cible à supprimer
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 ) {
//Supprimer de la baie si l'inventaire du produit est 0
if ((int)syohinList.get(i)[1] == 0) {
syohinList.remove(i);
}
}
//Vérifiez la quantité de stock restante du produit
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println(syohinList.get(i)[0] + "Stock résiduel:" + syohinList.get(i)[1]);
}
//Résultat de sortie
Stock restant de pomme:5
Stock de raisin résiduel:20
Stock restant de kiwi:0 //Il n'a pas disparu pour une raison quelconque
Stock restant de banane:15
Le mikan a disparu, mais pas le kiwi.
** La cause était que l'élément a été supprimé et les éléments suivants ont été déplacés vers l'avant. ** **
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Nom du produit Quantité en stock
Object[] syohin1 = {"pomme", 5};
Object[] syohin2 = {"Grain de raisin", 20};
Object[] syohin3 = {"Mandarine", 0}; //Cible à supprimer
Object[] syohin4 = {"kiwi", 0}; //Cible à supprimer
Object[] syohin5 = {"banane", 15};
syohinList.add(syohin1);
syohinList.add(syohin2);
syohinList.add(syohin3);
syohinList.add(syohin4);
syohinList.add(syohin5);
//Vérifiez la quantité de stock restante du produit
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println("Tableau" + i + " " + syohinList.get(i)[0] + " " + "Stock résiduel:" + syohinList.get(i)[1]);
}
System.out.println("------------------------"); //Séparateur (pour faciliter la vue)
for ( int i = 0; i < syohinList.size(); ++i ) {
//Supprimer de la baie si l'inventaire du produit est 0
if ((int)syohinList.get(i)[1] == 0) {
syohinList.remove(i);
}
}
//Reconfirmez la quantité de stock restante du produit
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println("Tableau" + i + " " + syohinList.get(i)[0] + " " + "Stock résiduel:" + syohinList.get(i)[1]);
}
//Résultat de sortie
Array 0 pommes Stock restant:5
Array 1 Raisin restant stock:20
Stock restant de la baie 2 Mikan:0
Array 3 Kiwi Stock restant:0
Stock restant de bananes du tableau 4:15
------------------------
Array 0 pommes Stock restant:5
Array 1 Raisin restant stock:20
Array 2 Kiwi Stock restant:0 //Le mikan a disparu et a glissé
Stock restant de bananes du tableau 3:15 //Le mikan a disparu et a glissé
Si vous regardez de plus près chaque boucle,
//Première boucle: tableau[0]Découvrir
Tableau[0]Stock restant de pomme:5 //Puisque le stock restant n'est pas 0, ne le supprimez pas
Tableau[1]Stock de raisin résiduel:20 //Je ne l'ai pas encore vérifié
Tableau[2]Stock résiduel de Mikan:0 //Je ne l'ai pas encore vérifié
Tableau[3]Stock restant de kiwi:0 //Je ne l'ai pas encore vérifié
Tableau[4]Bouillon de banane restant:15 //Je ne l'ai pas encore vérifié
//Deuxième boucle: tableau[1]Découvrir
Tableau[0]Stock restant de pomme:5 //Examiné
Tableau[1]Stock de raisin résiduel:20 //Puisque le stock restant n'est pas 0, ne le supprimez pas
Tableau[2]Stock résiduel de Mikan:0 //Je ne l'ai pas encore vérifié
Tableau[3]Stock restant de kiwi:0 //Je ne l'ai pas encore vérifié
Tableau[4]Stock restant de banane:15 //Je ne l'ai pas encore vérifié
Le problème commence ici.
//Troisième boucle: tableau[2]Découvrir
Tableau[0]Stock restant de pomme:5 //Examiné
Tableau[1]Stock de raisin résiduel:20 //Examiné
Tableau[2]Stock résiduel de Mikan:0 //Puisque le stock restant est 0, supprimez-le
Tableau[3]Stock restant de kiwi:0 //Je ne l'ai pas encore vérifié
Tableau[4]Bouillon de banane restant:15 //Je ne l'ai pas encore vérifié
Avec cela, les éléments du tableau [2] sont supprimés, et les éléments du tableau 3 sont déplacés vers le tableau [2], et les éléments du tableau 4 sont déplacés vers le tableau [3].
//Troisième boucle: tableau[2]Enquêté
Tableau[0]Stock restant de pomme:5 //Examiné
Tableau[1]Stock de raisin résiduel:20 //Examiné
Tableau[2]Stock restant de kiwi:0 //Je ne l'ai pas encore vérifié
Tableau[3]Stock restant de banane:15 //Je ne l'ai pas encore vérifié
C'est vrai, comme pour la situation actuelle, j'ai cherché le tableau [2], mais ** ce tableau [2] contient des éléments que je n'ai pas encore vérifiés. ** **
//Quatrième boucle: tableau[3]Découvrir
Tableau[0]Stock restant de pomme:5 //Examiné
Tableau[1]Stock de raisin résiduel:20 //Examiné
Tableau[2]Stock restant de kiwi:0 //Je ne l'ai pas vérifié, mais il a été ignoré en conséquence
Tableau[3]Stock restant de banane:15 //Le stock restant n'étant pas égal à 0, ne le supprimez pas
On a l'impression que ça s'est bien passé entre les boucles. Quand je me demandais ce qui s'était passé, mon aîné m'a conseillé de déduire de la valeur maximale et d'enquêter dans la direction opposée. Je vois. C'est comme je l'ai fait en classe il y a longtemps. Cependant, après cela, en raison d'un changement de conception, il est devenu inutile de l'utiliser, donc je ne l'ai pas implémenté. Cependant, j'étais curieux, alors j'ai pensé au mouvement à la maison.
J'ai écrit ce code.
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Nom du produit Quantité en stock
Object[] syohin1 = {"pomme", 5};
Object[] syohin2 = {"Grain de raisin", 20};
Object[] syohin3 = {"Mandarine", 0}; //Cible à supprimer
Object[] syohin4 = {"kiwi", 0}; //Cible à supprimer
Object[] syohin5 = {"banane", 15};
syohinList.add(syohin1);
syohinList.add(syohin2);
syohinList.add(syohin3);
syohinList.add(syohin4);
syohinList.add(syohin5);
//Examiner par derrière
for ( int i = syohinList.size() - 1; i >= 0; --i ) {
//Supprimer de la baie si l'inventaire du produit est 0
if ((int)syohinList.get(i)[1] == 0) {
syohinList.remove(i);
}
}
//Vérifiez la quantité de stock restante du produit
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println("Tableau" + i + " " + syohinList.get(i)[0] + " " + "Stock résiduel:" + syohinList.get(i)[1]);
}
Jusqu'à présent, j'ai cherché à partir du début de la séquence (ordre croissant), mais cette fois je l'ai changé en ** regardant de l'arrière de la séquence (ordre décroissant) **.
Array 0 pommes Stock restant:5
Array 1 Raisin restant stock:20
Stock restant de bananes du tableau 2:15
Ouais, on dirait que c'est parti. En regardant à nouveau le mouvement boucle par boucle,
//Première boucle: tableau[4]Découvrir
Tableau[0]Stock restant de pomme:5 //Je ne l'ai pas encore vérifié
Tableau[1]Stock de raisin résiduel:20 //Je ne l'ai pas encore vérifié
Tableau[2]Stock résiduel de Mikan:0 //Je ne l'ai pas encore vérifié
Tableau[3]Stock restant de kiwi:0 //Je ne l'ai pas encore vérifié
Tableau[4]Bouillon de banane restant:15 //Le stock restant n'étant pas égal à 0, ne le supprimez pas
//Deuxième boucle: tableau[3]Découvrir
Tableau[0]Stock restant de pomme:5 //Je ne l'ai pas encore vérifié
Tableau[1]Stock de raisin résiduel:20 //Je ne l'ai pas encore vérifié
Tableau[2]Stock résiduel de Mikan:0 //Je ne l'ai pas encore vérifié
Tableau[3]Stock restant de kiwi:0 //Supprimé car le stock restant est 0
Tableau[4]Stock restant de banane:15 //Examiné
L'élément (kiwi) du tableau [3] est supprimé et l'élément (banane) du tableau [4] est nouvellement mis dans le tableau [3], mais il n'y a pas de problème car il est dans l'ordre décroissant.
//Troisième boucle: tableau[2]Découvrir
Tableau[0]Stock restant de pomme:5 //Je ne l'ai pas encore vérifié
Tableau[1]Stock de raisin résiduel:20 //Je ne l'ai pas encore vérifié
Tableau[2]Stock résiduel de Mikan:0 //Supprimé car le stock restant est 0
Tableau[3]Stock restant de banane:15 //Examiné
L'élément (mikan) du tableau [2] est supprimé et l'élément (banane) du tableau [3] est nouvellement mis dans le tableau [2], mais il n'y a pas de problème car il a déjà été étudié.
//Quatrième boucle: tableau[1]Découvrir
Tableau[0]Stock restant de pomme:5 //Je ne l'ai pas encore vérifié
Tableau[1]Stock de raisin résiduel:20 //Puisque le stock restant n'est pas 0, ne le supprimez pas
Tableau[2]Stock restant de banane:15 //Examiné
//5ème boucle: tableau[0]Découvrir
Tableau[0]Stock restant de pomme:5 //Le stock restant n'étant pas égal à 0, ne le supprimez pas
Tableau[1]Stock de raisin résiduel:20 //Examiné
Tableau[2]Stock restant de banane:15 //Examiné
C'est comme ça. Je pense que tout va bien en termes de fonctionnement. (Peut-être)
C'est peut-être une idée assez basique de l'algorithme. J'ai l'impression de l'avoir entendu il y a longtemps. Cependant, récemment, j'ai fait des choses comme Ruby et je me suis appuyé sur des méthodes pratiques, alors j'ai pensé qu'il était important de former cette façon de penser.
https://www.javadrive.jp/start/for/index2.html http://d.hatena.ne.jp/nattou_curry_2/20090726/1248600833
Recommended Posts