Confusing redrawing of the lines - java help on CodeGym

The logic of the algorithm is that it takes all of the non full lines and add them to an array. It leaves the full lines in the old array because the old array will be overwritten. Now, in line 25 it says add incomplete lines to the beginning of the list. This line of code doesn't make sense to me. It says add incomplete lines but it add new, empty lines. Shouldn't it add to the beginning of the array the incomplete lines we took earlier from the initial array and, after these lines, add new lines until the height is reached? So, instead of line 26 i believe it should be like this:

for (int i = lines.size() ; i < height; i++){
  lines.add(new int[width]);
}

public void removeFullLines() {
        // For example, like this:
        // Create a list to store the lines
        // Copy all the non-empty lines into a list.
        // Add incomplete lines to the beginning of the list.
        // Convert the list back into a matrix

        // Create a list to store the lines
        ArrayList<int[]> lines = new ArrayList<>();

        // Copy all the non-empty lines into a list.
        for (int i = 0; i < height; i++) {
            // Count the number of occupied cells in the line - simply sum up all its values
            int count = 0;
            for (int j = 0; j < width; j++) {
                count += matrix[i][j];
            }

            // If the line's sum is not equal to its width, then add it to the list
            if (count != width)
                lines.add(matrix[i]);
        }

        // Add incomplete lines to the beginning of the list.
        while (lines.size() < height) {
            lines.add(0, new int[width]);
        }

        // Convert the list back into a matrix
        matrix = lines.toArray(new int[height][width]);
    }

Comments (4)

Popular
New
Old

You must be signed in to leave a comment

Thomas

Level 41 , Bayreuth, Germany

25 June 2021, 06:47

I can't read the task req. but I think you should copy all the partial filled lines to a list and that back to the array eg.: 1empty 2empty 3empty 4full 5full 6partial1 7partial2 8partial3 now you start copying to the list and have as result 6partial1 7partial2 8partial3 next step is to add new lines to the beginning of the list so that the partial lines stay at the bottom 1new empty line 2new empty line 3new empty line 4new empty line 5new empty line 6partial1 7partial2 8partial3 last step, copy back to the array. So the algorithm looks OK

Andrei

Level 41

25 June 2021, 07:05

Which algorithm looks ok to you? The one I provided in the big block (which is the mentor suggested solution) ? Or the one I suggested in the small block (3 lines of code) ?

25 June 2021, 07:11

solution

mentor, you need the empty lines at the beginning (top) of the array. The filled lines are at the bottom. After copying the partial filled lines to the list, the partial filled ones are at the top. Now you add the empty ones at the top as well moving the filled ones to the bottom and copy the list to the array. That's it. No magic. You add the empty lines at the bottom. Then you'd have 6partial1 7partial2 8partial3 emtpy empty ... if a new block appeares at the top now it crashes directly into a partial filled line (that hovers in the air).

25 June 2021, 07:20

Ah... this is where the confusion was occurring for me. See, I thought that what this line

lines.add(0, new int[width]); //line 26 from big block

does it added an empty line at the bottom of the array and it would transform this 6partial1 7partial2 8partial3 to this 6partial1 7partial2 8partial3 emtpy empty ... until the height is reached. So I visualized the array in the opposite way it was being constructed. Thanks!