有人可以解释一下下面的代码如何工作吗

Question

Could somebody please explain me how the following code actually works.

Problem: You have 64 doors in a row that are all initially closed. You make 64 passes by the doors. The first time through, you visit every door and toggle the door (if the door is closed, you open it; if it is open, you close it). The second time you only visit every 2nd door (door #2, #4, #6, ...). The third time, every 3rd door (door #3, #6, #9, ...), etc, until you only visit the 64th door.

The following code I found works, but I'd like to know what exactly is happening. I don't understand the loop.

public class doors {
public static void main(String args[]) {
    // assume true=open, false=closed. Doors will all default to closed.
    boolean[] doors = new boolean[64];
    for (int i=0; i<64; i++) {
        for (int j=i; j<64; j=j+i+1) {
            doors[j] = !doors[j];
        }
    }
    // at the end, print out all the doors that are closed
    System.out.println("These doors are opened:");
    for (int i=0;i<64;i++){
        if (doors[i]) {
            // printing out i+1 to negate the zero-indexing
            System.out.println(i+1);
        }
    }
}
}

Answer 1

Assuming that you know how for loops works, still, lets take a look at the following example:

First assume that all of the doors are closed and close means false f , open means true t . For a simpler understanding we are also assuming that, total number of doors = 4 .

index       :     0       1       2       3
              +-----+ +-----+ +-----+ +-----+
begin       : |  f  | |  f  | |  f  | |  f  | // say all doors closed
              +-----+ +-----+ +-----+ +-----+
door number :    1       2       3       4

Now

 for (int i=0; i<4; i++) { // our example has 4 doors instead of 64
        // first iteration of outer loop, i = 0
        for (int j=i; j<4; j=j+i+1) {
            // as i = 0, j = 0 too
            // and j = j+i+1 = j + 0 + 1 = j +1 
            // so j will increment by 1
            // hence, j < 4 means the loop will rotate 4 (j = 0 to 3) times 
            doors[j] = !doors[j]; // this line do the trick, See bellow for details.
        }
    }

The doors[j] = !doors[j]; toggles the current state. How? suppose the doors[j] contains false means door is closed, then !doors[j] change the value false to true means closed to open! Ta da, that's what we want!

   index(value of j) :    0       1       2       3
                       +-----+ +-----+ +-----+ +-----+
after 1st iteration  : |  t  | |  t  | |  t  | |  t  |
                       +-----+ +-----+ +-----+ +-----+
         door number :    1       2       3       4

All four doors opens!

Now, for the 2nd iteration of outer loop,

 for (int i=0; i<4; i++) { // our example has 4 doors instead of 64
        // 2nd iteration of outer loop, i = 1
        for (int j=i; j<4; j=j+i+1) {
            // as i = 1, j = 1 too
            // and j = j+i+1 = j + 1 + 1 = j + 2 
            // so j will increment by 2
            // hence, j < 4 means the loop will rotate 2 (j = 1 and j = 3) times 
            doors[j] = !doors[j]; 
        }
    }

So,

   index(value of j) :    0       1       2       3
                       +-----+ +-----+ +-----+ +-----+
after 2nd iteration  : |  t  | |  f  | |  t  | |  f  |
                       +-----+ +-----+ +-----+ +-----+
         door number :    1       2       3       4

Only 2 and 4 number doors are closed! Yes, we are on right track!

Now you clearly understand that in the third iteration of outer loop, j will start with value 2 and increment by 3 , means only door 3 will be toggled!

   index(value of j) :    0       1       2       3
                       +-----+ +-----+ +-----+ +-----+
after 3rd iteration  : |  t  | |  f  | |  f  | |  f  |
                       +-----+ +-----+ +-----+ +-----+
         door number :    1       2       3       4

Hope this will help you to understand how the problem is solved by this code for 64 doors!

The final (4th) iteration will makes all the door, looks like:

   index(value of j)   :    0       1       2       3
                         +-----+ +-----+ +-----+ +-----+
after final iteration  : |  t  | |  f  | |  f  | |  t  |
                         +-----+ +-----+ +-----+ +-----+
         door number   :    1       2       3       4

Answer 2

First job: number the doors 1 - 64. Having them zero based messes up the mathematics.

A door will remain open if, and only if, the number of factors in its number is odd.

That is only true for perfect squares, as any other number has an even number of factors. (For example, 10 has 1, 10, 2, and 5. But 25 has 1, 25, and 5).

So the doors that remain open are 1, 4, 9, 16, 25, 36, 49, and 64.

So all you need to do to get the answer is to iterate through the perfect squares, and that's O(N).

The way your code will figure this out is abysmally inefficient as it's O(N * N). Your code works by repeatedly traversing the door set. The key expression is j=j+i+1 which bypasses an increasingly large number of doors. doors[j] = !doors[j]; changes the door state.

Try to recode in O(N) using the perfect squares approach. That will impress your professor.

Answer 3

if you mean you don't understand this loop:

 for (int i=0; i<64; i++) {
    for (int j=i; j<64; j=j+i+1) {
        doors[j] = !doors[j];
    }
}

This is the most straightforward solution. In the outer loop, i represents the step (so you have 64 steps altogether), i also represents number of door to skip (how many door you jump) to toggle. So in the loop 0, you skip no door to toggle, in the loop 1, you skip 1 door, in the loop number 2, you skip 2 door each time,...and so on. The inner loop will find the actual doors to toggle and store in index j. Since you will skip i doors in step number i so you will start from i up to 64 and each time increase the index by i+1 (equivalent to skip i doors). Hope you understand.