CodeGym/Help with Java Tasks/It's working but still not valid

Level 50

Kraków

07.09.2023
295views
9comments

It's working but still not valid

Question about the task

Tetris (part 14)

Java Collections, Level 2, Lesson 15

Resolved

I'm little tired of this course I dare say. Maybe I don't see something. Please help!

Implement the removeFullLines() method in the Field class.

Here's what we need to do:
a) delete all lines from the matrix that are completely full (consist of only ones);
b) move the remaining lines down;
c) create new lines to replace missing ones.

IMPORTANT!
matrix[y][x] contains the element with coordinates (x, y).
matrix[i] contains the i-th line.
We can:
a) remove a line:
matrix[i] = null;
b) copy a reference to a line:
matrix[i+1] = matrix[i];
c) create a new line:
matrix[i] = new int[width];

Requirements:

After the removeFullLines() method is run, no lines consisting of only ones should be left in the matrix array.
The remaining lines should be correctly shifted, and new lines should be added to replace the lines that are removed.

package com.codegym.task.task22.task2213; import java.awt.event.KeyEvent; /** * The Tetris class contains the basic functionality of the game. */ public class Tetris { private Field field; // Game field private GamePiece gamePiece; // Game piece private boolean isGameOver; // Indicates whether the game is over public Tetris(int width, int height) { field = new Field(width, height); gamePiece = null; } /** * Getter for the field variable. */ public Field getField() { return field; } /** * Getter for the gamePiece variable. */ public GamePiece getGamePiece() { return gamePiece; } /** * The program's main loop. * This is where all the important actions happen */ public void run() throws Exception { // Create a KeyboardObserver object and start it. KeyboardObserver keyboardObserver = new KeyboardObserver(); keyboardObserver.start(); // Set the initial value of isGameOver to false isGameOver = false; // Create the first game piece in the middle at the top: x = half of the width, y = 0. gamePiece = GamePieceFactory.createRandomGamePiece(field.getWidth()/2, 0); // The game is not over yet while (!isGameOver) { // Does the observer have any key events? if (keyboardObserver.hasKeyEvents()) { // Get the first event from the queue KeyEvent event = keyboardObserver.getEventFromTop(); // If 'q', then exit the game. if (event.getKeyChar() == 'q') return; // If "left arrow", then move the game piece to the left if (event.getKeyCode() == KeyEvent.VK_LEFT) gamePiece.left(); // If "right arrow", then move the game piece to the right else if (event.getKeyCode() == KeyEvent.VK_RIGHT) gamePiece.right(); // If the key code is 12 ("5 on the numeric keypad), rotate the game piece else if (event.getKeyCode() == 12) gamePiece.rotate(); // If it's a space, then drop the game piece at top speed else if (event.getKeyCode() == KeyEvent.VK_SPACE) gamePiece.downMaximum(); } step(); // Take a step field.print(); // Display the field Thread.sleep(300); // Pause for 300 milliseconds (about 1/3 of a second) } // Display "Game Over" System.out.println("Game Over"); } /** * One step of the game */ public void step() { // Drop the game piece lower // If the game piece can't be placed in the current location: // Put it back // Land it // If the game piece lands at the very top, then the game is over // Remove the completed lines // Create a new game piece } /** * Setter for gamePiece */ public void setGamePiece(GamePiece gamePiece) { this.gamePiece = gamePiece; } /** * Setter for field */ public void setField(Field field) { this.field = field; } public static Tetris game; public static void main(String[] args) throws Exception { game = new Tetris(10, 20); game.run(); } }

Comments (9)

Popular
New
Old

You must be signed in to leave a comment

Guadalupe Gagnon

Level 37 , Tampa, United States

7 September 2023, 14:29

The problem is that this code is unable to remove lines that appear consecutively, such as if lines 2 and 3 need to be removed. When the code reaches, and subsequently removes, line 2 that means the rest of the lines are moved down one. Line 3 would become line 2, line 4 would become line 3, line 5 to 4 etc. The 'i' for loop does not account for this and increments by 1 after the shift. In this scenario line 3 (which is moved to line 2 after the shift) would effectively be skipped. TIP: Have you learned about labels yet? They were originally used with goto statements (I learned about goto statements when I was studying BASIC), however Java never implemented goto statements because they can very easily lead to spaghetti code that is very difficult to debug/maintain. Labels, however, are still in Java and can be useful in certain situations, such as nested loops with conditions that should break an outer loop. Your removeFullLines() method can be rewritten as this:

outer:
for (int i = 0; i < matrix.length; i++) {
   for (int j = 0; j < matrix[0].length; j++)
      if (matrix[i][j] == 0) continue outer;
   removeLine(i);
}

This will speed up the code as it doesn't use the boolean check if(j == matrix[0].length - 1) every single cycle of the inner loop.

matemate123

Level 50 , Kraków, Poland

8 September 2023, 04:48

My mistake, when I testing I don't try remove two line in row :( Like I think, I was a little tried. Now I rewrite it. Yes I know about labels have had the pleasure of using them :) Please tell me whether sentence above is correct? Because gpt correct this line but I don't understand structure "have had". I want write clean english too beside clean code :D

matemate123

Level 50 , Kraków, Poland

8 September 2023, 05:13

However turn out I yesterday testing for remove lines consequetively and It's worked. Or maybe I don't understand something.

private int[][] matrix =
                             {{1, 1, 1, 0},
                              {1, 1, 1, 1},
                              {1, 1, 1, 1},
                              {0, 0, 1, 0},
                              {1, 1, 1, 1},
                              {1, 0, 1, 0}};

result:

matemate123

Level 50 , Kraków, Poland

8 September 2023, 05:26

I rebuild like you said because you right that your solution is much better, but still same result and still not validate. But I try change something like new line initiation

matrix[0] = new int[width];

Maybe here validator wants something else

Thomas

Level 41 , Bayreuth, Germany

8 September 2023, 07:41

solution

Guys, call me stupid but I don't see the problem. Why should matemate's original code don't remove consecutive full lines? It starts at line zero, if it is full, it got removed. Then it advances to the next line and continues with the same process. It would be different if we begin at line matrix.length. If you remove that, then the next line will be the current line and if we now proceed to the upper line we would get the second next. But here that's not the case (nevertheless I'd start at the bottom or matrix.length as this would allow nice exploding lines effects :) ). So I could post how I'd do it but I doubt that'll validate as imho your both approaches are correct and therefore the problem probably is something different (or some weird requirement)? Oh, the array definition is new int[width]; is correct. No need to think about that one. If you would start from 0 to matrix.length you could remove the else row-- (similar to your approach) and just have a row++

public void removeFullLines() {
    int row = matrix.length - 1;
    while (row >= 0) {
        if (isFullLine(matrix[row]))
            removeLine(row);
        else
            row--;
    }
}

private boolean isFullLine(int[] row) {
    for (int cell : row) {
        if (cell == 0)
            return false;
    }
    return true;
}

private void removeLine(int row) {
    while (row > 0) {
        matrix[row] = matrix[--row];
    }
    matrix[0] = new int[width];
}

Guadalupe Gagnon

Level 37 , Tampa, United States

8 September 2023, 13:32

solution

Thomas is right, I was wrong in my initial post. Because he starts from the top and works his way down it should work just fine. Also, after a little reconsideration, I think that the validator doesn't like how MateMate's code just overwrites the values in each array as the mechanism to move lines down instead of just shifting the position of each array in the matrix, the way in which Thomas's example does.

matemate123

Level 50 , Kraków, Poland

8 September 2023, 16:46

Uff you scared me Lupe :D I think you may be right, in example in conditions is shifting position of each array. I saw that but I think I do it each value after each value I don't know why. That was it, and it's good that my way is not valid because I did undermentioned test:

for (int i = 0; i < 10; i++) { // 10 performance testing loop
      long startTime = System.currentTimeMillis();
      for (int x = 0; x < 1_000_000; x++) {
          Test2 test2 = new Test2();
          test2.removeFullLines();
      }
      long endTime = System.currentTimeMillis();
      long differenceTime = endTime - startTime;
      System.out.println(differenceTime);
  }

Result is that overwrites whole array is above two times faster: Output for:

private void removeLine(int i) {
        while (i > 0) {
            matrix[i] = matrix[i - 1];
            i--;
        }
        matrix[0] = new int[matrix[0].length];
    }

is:

And output for for

private void removeLine(int i) {
    while (i > 0) {
        for (int j = 0; j < matrix[0].length; j++) {
            matrix[i][j] = matrix[i - 1][j];
        }
        i--;
    }
    matrix[0] = new int[matrix[0].length];
}

Why every first performance testing loop is about 30 % slower than nine another? It's something about program uses some data or caches of something like that from memory patches from first loop?

Guadalupe Gagnon

Level 37 , Tampa, United States

8 September 2023, 16:55

😋 I like your testing!

Thomas

Level 41 , Bayreuth, Germany

8 September 2023, 17:08

useful

Probably cause of the class loader having to load the Test class in the first run only. Create a constant in Test and print it before the run then the class is pre loaded.