Thread: Struggling with an Array of Arrays

Originally Posted by bhenry1790

...it would be impossible to enter manually....

Of course it would.

How did you come up with the sequence of arrays to put into your position array?

Here's how I see it. I'll look at the arays as a set of digits, and I'll do it with three digits instead of eight

The smallest value of each digit is 1. I'll call it minDigit. The largest value of each digit is 8. I'll call it maxDigit.
Start the "counter" with a value of 111 (That is, create a array named "digits" and initialize it with the value minDigit in each position)

How's how I would increment the counter:

Increment the least significant digit (the LSD)
The count is now 112. Increment again. Count is 113. Do it some more until the count gets to 118.

Well---I have been having lots of fun just incrementing the LSD, but now I have a problem: When I increment the LSD, the digit value is greater than maxDigit. So what do I do? Easy, right? Set that digit to minDigit and increment the next digit up from there. So, the count goes from 118 to 121.

Increment the LSD a bunch more times until I get to a count of 128. Now incrementing LSD causes me to have to reset to minDigit again and increment the next one up. So the count goes from 128 to 131, right?

Do this a bunch more times, and the count gets to 188. Now when I increment the LSD, it's too big, so I reset it to minDigit and increment the next one up. But now that one is too big so I reset that one to minDigit and increment the next one up. So the count goes from 188 to 211.

See how it goes?

Here's a possible description of algorithm that can be converted directly to Java code:

We have an array of bytes named digits that holds the count value. It was initialized to all 1s.

Here's how to increment the count represented in the digits array:

Increment:
    Make a loop that starts at the LSD (at the end of the array) and works back to the beginning of the array:
    for (int i = digits.length-1; i >= 0; i--)
    LOOP
        Increment digits[i]
        IF digits[i] IS GREATER THAN maxDigit
        THEN
            Set digits[i] EQUAL TO minDigit
            // That's all for this time through the loop.
            // As it continues through the loop, it will increment
            // the next digit up from here.
        ELSE
             We are done for this incrementation: Break out of the loop
        END IF
    } // End of loop

So, your loop to populate the position array goes like this:

     Declare the position array to your appropriate size.
     Make a loop that can go like this:
     for (int i = 0; i < position.length; i++)
    {
        Create an array of bytes, named c, equal to the current digits array.
 
        Copy the contents of c to position[i].
 
        Execute code to increment the count value in the digits array so
        that next time through the loop will store the next count value in
        the next position.
 
    } // End of loop

(You don't necessarily need a separate array, c, in the middle of the loop, but having it broken out may make debugging easier, since you can print out the array and make sure the count is counting properly. Stuff like that.

Note: I would use arrays of bytes instead of arrays of ints. I mean you are going to have 8 to the ninth power elements, and I definitely would not use larger array elements than necessary. Sometimes size matters.

You can do things in-line in main(), or you can create a Counter class that takes care of initializing the digits array. The Counter class would need a method to return the current contents of the digits[] array and a method that increments the digits[] array according to our radix counting scheme above.

Start with the way that seems "obvious" to you. Test it thoroughly with counters of three or four digits. Then, go for the biggie: Eight-digits and the corresponding array of 16,777,216 eight-byte arrays.

Cheers!

Z

Really struggling with creating a for loop to fill an array of arrays.

Why do you need such a big array?

What I'm thinking is that it's a lot ints. At 4 bytes per element Google says its 67Mb. Not enough to break the computer's bank, but if you don't intend changing more than a smallish number of elements perhaps some sort of sparse array would be a better data structure. A Map<Integer,Integer> would do, for instance.

[Edit] Or if you don't intend changing any elements at all but, instead, intend iterating over the beast, write an Iterator that yields the right values in the right order.

[Edit 2] Or is my maths off? If each of the 8^8 elements is going to hold a sequence of 8 four byte ints then we're at c500Mb for an array that - initially at least - holds next to zero information.

Originally Posted by Voodoo

bhenry1790,
what you did is syntactically wrong

No, it is not. It is valid Java and works just fine as written by the Original Poster.

Originally Posted by Voodoo

Correct is, for example:

Your example is also correct, and many Java programmers prefer its elegance. I mean if you think it adds value to the discussion to present your stylistic preference, I have no problem with that, but I see no value in confusing the issue by pronouncing something "wrong" that is, in fact, not "wrong."

Originally Posted by Voodoo

Nested {{{...}}} like you usually program with some nested loops

Maybe that's what you "usually" do.

As for me: Sometimes yes; sometimes no. It "usually" depends on how the data are being generated (algorithmically or ad-hoc). For me, there is no "usual" way of initializing multi-dimensional arrays.


Cheers!

Z