It outputs the algorithmic things learned while repairing the system at work instead of memos. Originally it was C #, but since I don't have a C # environment at home, I write it in Java.
Originally, it wasn't an array, it was a little more complicated like an array, and there were many elements inside, but to put it simply, ** product data ** (name, price, etc.) and its ** product inventory * There was an array that had a lot of *.
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Product name Stock quantity
Object[] syohin1 = {"Apple", 5};
Object[] syohin2 = {"Grape", 20};
Object[] syohin3 = {"Mandarin orange", 0};
Object[] syohin4 = {"Kiwi", 10};
Object[] syohin5 = {"banana", 15};
syohinList.add(syohin1);
syohinList.add(syohin2);
syohinList.add(syohin3);
syohinList.add(syohin4);
syohinList.add(syohin5);
//Check the remaining stock quantity of the product
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println(syohinList.get(i)[0] + "Residual inventory:" + syohinList.get(i)[1]);
}
//Output result
Residual stock of apples:5
Grape stock:20
Mandarin orange remaining inventory:0
Kiwi residual inventory:10
Banana stock:15
So, one of my tasks was to implement a ** function to delete products with 0 remaining inventory from the array **.
I wrote the code safely by repeating the for statement for the number of times of the array and deleting it from the array if the remaining inventory is 0.
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Product name Stock quantity
Object[] syohin1 = {"Apple", 5};
Object[] syohin2 = {"Grape", 20};
Object[] syohin3 = {"Mandarin orange", 0};
Object[] syohin4 = {"Kiwi", 10};
Object[] syohin5 = {"banana", 15};
syohinList.add(syohin1);
syohinList.add(syohin2);
syohinList.add(syohin3);
syohinList.add(syohin4);
syohinList.add(syohin5);
for ( int i = 0; i < syohinList.size(); ++i ) {
//If the product inventory is 0, delete it from the array
if ((int)syohinList.get(i)[1] == 0) {
syohinList.remove(i);
}
}
//Check the remaining stock quantity of the product
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println(syohinList.get(i)[0] + "Residual inventory:" + syohinList.get(i)[1]);
}
//Output result
Residual stock of apples:5
Grape stock:20
Kiwi residual inventory:10
Banana stock:15
Yeah, it's gone. But actually there is a problem.
This method is to check the element from the 0th and delete it from the element if the condition is met (if the inventory is 0), but ** Under certain conditions, deletion omission occurs. ** Specifically ** When elements that satisfy the deletion conditions come in succession. ** **
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Product name Stock quantity
Object[] syohin1 = {"Apple", 5};
Object[] syohin2 = {"Grape", 20};
Object[] syohin3 = {"Mandarin orange", 0}; //Target to be deleted
Object[] syohin4 = {"Kiwi", 0}; //Target to be deleted
Object[] syohin5 = {"banana", 15};
syohinList.add(syohin1);
syohinList.add(syohin2);
syohinList.add(syohin3);
syohinList.add(syohin4);
syohinList.add(syohin5);
for ( int i = 0; i < syohinList.size(); ++i ) {
//If the product inventory is 0, delete it from the array
if ((int)syohinList.get(i)[1] == 0) {
syohinList.remove(i);
}
}
//Check the remaining stock quantity of the product
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println(syohinList.get(i)[0] + "Residual inventory:" + syohinList.get(i)[1]);
}
//Output result
Residual stock of apples:5
Grape stock:20
Kiwi residual inventory:0 //It hasn't disappeared for some reason
Banana stock:15
The oranges are gone, but the kiwi isn't.
** The cause was that the element was deleted and the subsequent elements were shifted forward. ** **
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Product name Stock quantity
Object[] syohin1 = {"Apple", 5};
Object[] syohin2 = {"Grape", 20};
Object[] syohin3 = {"Mandarin orange", 0}; //Target to be deleted
Object[] syohin4 = {"Kiwi", 0}; //Target to be deleted
Object[] syohin5 = {"banana", 15};
syohinList.add(syohin1);
syohinList.add(syohin2);
syohinList.add(syohin3);
syohinList.add(syohin4);
syohinList.add(syohin5);
//Check the remaining stock quantity of the product
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println("Array" + i + " " + syohinList.get(i)[0] + " " + "Residual inventory:" + syohinList.get(i)[1]);
}
System.out.println("------------------------"); //Separator (to make it easier to see)
for ( int i = 0; i < syohinList.size(); ++i ) {
//If the product inventory is 0, delete it from the array
if ((int)syohinList.get(i)[1] == 0) {
syohinList.remove(i);
}
}
//Reconfirm the number of remaining products in stock
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println("Array" + i + " " + syohinList.get(i)[0] + " " + "Residual inventory:" + syohinList.get(i)[1]);
}
//Output result
Array 0 Apples Remaining inventory:5
Array 1 Grape stock:20
Array 2 mandarin orange remaining inventory:0
Array 3 Kiwi Remaining Inventory:0
Array 4 Banana Remaining Inventory:15
------------------------
Array 0 Apples Remaining inventory:5
Array 1 Grape stock:20
Array 2 Kiwi Remaining Inventory:0 //The oranges disappeared and slipped
Array 3 Banana Remaining Inventory:15 //The oranges disappeared and slipped
If you take a closer look at each loop,
//First loop: array[0]To find out
Array[0]Residual stock of apples:5 //Since the remaining inventory is not 0, do not delete it
Array[1]Grape stock:20 //I haven't checked it yet
Array[2]Mandarin orange remaining inventory:0 //I haven't checked it yet
Array[3]Kiwi residual inventory:0 //I haven't checked it yet
Array[4]Banana stock:15 //I haven't checked it yet
//Second loop: array[1]To find out
Array[0]Residual stock of apples:5 //Examined
Array[1]Grape stock:20 //Since the remaining inventory is not 0, do not delete it
Array[2]Mandarin orange remaining inventory:0 //I haven't checked it yet
Array[3]Kiwi residual inventory:0 //I haven't checked it yet
Array[4]Banana stock:15 //I haven't checked it yet
The problem starts here.
//Third loop: array[2]To find out
Array[0]Residual stock of apples:5 //Examined
Array[1]Grape stock:20 //Examined
Array[2]Mandarin orange remaining inventory:0 //Since the remaining inventory is 0, delete it.
Array[3]Kiwi residual inventory:0 //I haven't checked it yet
Array[4]Banana stock:15 //I haven't checked it yet
This deletes the elements of array [2] and shifts the elements (kiwi) of array [3] to array [2] and the elements of array 4 to array [3].
//Third loop: array[2]Investigated
Array[0]Residual stock of apples:5 //Examined
Array[1]Grape stock:20 //Examined
Array[2]Kiwi residual inventory:0 //I haven't checked it yet
Array[3]Banana stock:15 //I haven't checked it yet
That's right, in the current situation, I searched up to array [2], but ** that array [2] contains elements that I haven't checked yet. ** **
//Fourth loop: array[3]To find out
Array[0]Residual stock of apples:5 //Examined
Array[1]Grape stock:20 //Examined
Array[2]Kiwi residual inventory:0 //I didn't check it, but it was skipped as a result
Array[3]Banana stock:15 //Since the remaining inventory is not 0, do not delete it
It feels like it's gone well between the loops. When I was wondering what happened, my senior advised me to deduct from the maximum value and investigate from the opposite direction. I see. It's like I've done it in class a long time ago. However, after that, due to a design change, it was not necessary to use for after all, so I did not implement it. However, I was curious, so I thought about the movement at home.
I wrote this code.
Launcher.java
ArrayList<Object[]> syohinList = new ArrayList<Object[]>();
//Product name Stock quantity
Object[] syohin1 = {"Apple", 5};
Object[] syohin2 = {"Grape", 20};
Object[] syohin3 = {"Mandarin orange", 0}; //Target to be deleted
Object[] syohin4 = {"Kiwi", 0}; //Target to be deleted
Object[] syohin5 = {"banana", 15};
syohinList.add(syohin1);
syohinList.add(syohin2);
syohinList.add(syohin3);
syohinList.add(syohin4);
syohinList.add(syohin5);
//Examine from behind
for ( int i = syohinList.size() - 1; i >= 0; --i ) {
//If the product inventory is 0, delete it from the array
if ((int)syohinList.get(i)[1] == 0) {
syohinList.remove(i);
}
}
//Check the remaining stock quantity of the product
for ( int i = 0; i < syohinList.size(); ++i ) {
System.out.println("Array" + i + " " + syohinList.get(i)[0] + " " + "Residual inventory:" + syohinList.get(i)[1]);
}
Until now, I searched from the front of the array (ascending order), but this time I changed it to ** looking from the back of the array (descending order) **.
Array 0 Apples Remaining inventory:5
Array 1 Grape stock:20
Array 2 Banana Remaining Inventory:15
Yeah, it looks like it's gone well. Looking at the movement again loop by loop,
//First loop: array[4]To find out
Array[0]Residual stock of apples:5 //I haven't checked it yet
Array[1]Grape stock:20 //I haven't checked it yet
Array[2]Mandarin orange remaining inventory:0 //I haven't checked it yet
Array[3]Kiwi residual inventory:0 //I haven't checked it yet
Array[4]Banana stock:15 //Since the remaining inventory is not 0, do not delete it
//Second loop: array[3]To find out
Array[0]Residual stock of apples:5 //I haven't checked it yet
Array[1]Grape stock:20 //I haven't checked it yet
Array[2]Mandarin orange remaining inventory:0 //I haven't checked it yet
Array[3]Kiwi residual inventory:0 //Deleted because the remaining inventory is 0
Array[4]Banana stock:15 //Examined
The element (kiwi) of the array [3] is deleted and the element (banana) of the array [4] is newly put in the array [3], but there is no problem because it is in descending order.
//Third loop: array[2]To find out
Array[0]Residual stock of apples:5 //I haven't checked it yet
Array[1]Grape stock:20 //I haven't checked it yet
Array[2]Mandarin orange remaining inventory:0 //Deleted because the remaining inventory is 0
Array[3]Banana stock:15 //Examined
The element (mandarin orange) of the array [2] is deleted and the element (banana) of the array [3] is newly put in the array [2], but there is no problem because it has already been investigated.
//Fourth loop: array[1]To find out
Array[0]Residual stock of apples:5 //I haven't checked it yet
Array[1]Grape stock:20 //Since the remaining inventory is not 0, do not delete it
Array[2]Banana stock:15 //Examined
//5th loop: array[0]To find out
Array[0]Residual stock of apples:5 //Since the remaining inventory is not 0, do not delete it
Array[1]Grape stock:20 //Examined
Array[2]Banana stock:15 //Examined
It is like this. I think it's all okay in terms of operation. (Perhaps)
Perhaps it's a fairly basic idea of the algorithm. I feel like I've heard it a long time ago. However, recently I've been doing Ruby and relying on convenient methods, so I thought it was important to train this way of thinking.
https://www.javadrive.jp/start/for/index2.html http://d.hatena.ne.jp/nattou_curry_2/20090726/1248600833
Recommended Posts