Fill Array with all possible combinations of 0/1

Question

Hi,
i'm looking for a fast way to fill an array, respectively an int[8], with all possible combinations of 0 and 1 (or -1 and 1, shouldn't make a difference).
I kind of know how to do it using multiple loops but I assume there is a more elegant or at leaster "better" practice.
Thanks,
nikolaus
        static int cnt = 0;
     public static void main(String[] args) {
          int[] element = new int[]{1,1,1,1,1,1,1,1};
          Integer[] x = new Integer[2];
          x[0] = 1;
          x[1] = -1;
          for(int i7:x){
               element[7] = i7;
               for(int i6:x){
                    element[6] = i6;
                    for(int i5:x){
                         element[5] = i5;
                         for(int i4:x){
                              element[4] = i4;
                              for(int i3:x){
                                   element[3] = i3;
                                   for(int i2:x){
                                        element[2] = i2;
                                        for(int i1:x){
                                             element[1] = i1;
                                             for(int i0:x){
                                                  element[0] = i0;
                                                  cnt++;
          }Edited by: NikolausO on Oct 30, 2008 4:21 AM
Edited by: NikolausO on Oct 30, 2008 4:22 AM

Answer 1

pm_kirkham wrote:
No I replied to message number 5. as the ' (In reply to #5 )' above my post indicates, which was in reply to (a reply) to Sabre150's post which wasn't using enhanced loops, nor has any obvious place where you could use that approach to fill the array.
Though you could pass in an array of the values to fill the array with, and loop over those, instead of using 0 or 1, at which point Sabre's approach becomes the same as your OP, but without the manual unrolling:
import java.util.Arrays;
public class NaryCombinations {
public interface CombinationHandler {
void apply (int[] combination) ;
public static void main(String[] args) {
calculateCombinations(new int[]{-1, 0, 1}, 4, new CombinationHandler () {
public void apply (int[] combination) {
System.out.println(Arrays.toString(combination));
public static void calculateCombinations (int[] values, int depth, CombinationHandler handler) {
recursivelyCalculateCombinations(values, 0, depth, handler, new int[depth]);
private static void recursivelyCalculateCombinations (int[] values, int index, int depth,
CombinationHandler handler, int[] combination) {
if (index == depth) {
handler.apply(combination);
} else {
for (int value : values) {
combination[index] = value;
recursivelyCalculateCombinations(values, index + 1, depth, handler, combination);
Which looks to use the same basic approach to the generalization I created shortly after posting the original.
public class Scratch1
     * A 'callback' to be invoked with every combination
     * of the result.
    public interface Callback
         * Invoked for each combination.
         * <br>
         * Each call is passed an new instance of the array.
         * @param array the array containing a combination.
        void processArray(int[] array);
    public Scratch1(final int[] array, final Callback callback, final int... values)
        if (callback == null)
            throw new IllegalArgumentException("The 'callback' cannot be 'null'");
        if (array.length < 1)
            throw new IllegalArgumentException("The array length must be >= 1");
        if ((values == null) || (values.length < 1))
            throw new IllegalArgumentException("The 'values' must have be at least of length 2");
        callback_ = callback;
        values_ = values.clone();
        array_ = array;
    public Scratch1(final int order, final Callback callback, final int... values)
        this(new int[order], callback, values);
     * Generates every possible value and invokes the callback for each one.
    public void process()
        process(0);
     * Internal method with no logical external use.
    private void process(int n)
        if (n == array_.length)
            callback_.processArray(array_.clone());
        else
            for (int v : values_)
                array_[n] = v;
                process(n + 1);
    private final Callback callback_;
    private final int[] values_;
    private final int[] array_;
    public static void main(String[] args) throws Exception
        final Callback callback = new Callback()
            public void processArray(int[] array)
                System.out.println(java.util.Arrays.toString(array));
        new Scratch1(6, callback, 2, 1, 0).process();