Массив таблицы истинности

Я застрял в том, как начать кодировать это. Я хочу иметь возможность сделать следующее. Это классическая проблема с подбрасыванием монеты. Если я подброшу монету дважды, выйдут:
T T
T F
F T
F F
Я хочу иметь возможность создавать массив с одним результатом за раз . Чтобы лучше это проиллюстрировать, это должно выглядеть примерно так (кстати, я использую Java):
boolean[] case = new boolean[numberOfFlips]

первый случай будет иметь: T T.
После того, как я закончу другие вычисления с этим результатом, я хочу двигаться дальше и теперь создаю случаи: T F и продолжаю выполнять другие вычисления.
Может ли кто-нибудь направить меня в правильном направлении, пожалуйста? Я буду очень признателен. Алгоритм на любом языке меня устраивает. Спасибо за ваше время! (:


java truthtable
person Ceelos    schedule 08.12.2012    source источник
comment
Если я подброшу дважды, выпадет: T T T F F T F F Что это за монета, это? Когда я дважды подбрасываю монету, я получаю только два результата... ;-) Редактировать: О, вы имеете в виду возможные результаты.   -  person T.J. Crowder    schedule 08.12.2012
comment
извините, забыл добавить туда некоторые возвраты разрыва, чтобы он читался в одну строку   -  person Ceelos    schedule 08.12.2012
comment
Совершенно непонятно, о чем вы спрашиваете. Вы спрашиваете, как постепенно записывать результаты фактических бросков (или псевдослучайных бросков) или пройтись по всем возможным результатам по мере увеличения количества бросков?   -  person T.J. Crowder    schedule 08.12.2012
comment
мой массив должен содержать один возможный результат за раз. затем пусть это будет следующий результат и так далее. В первом случае мой массив будет содержать [T, T], затем он будет содержать [T, F], затем [F, T] и, наконец, [F, F]   -  person Ceelos    schedule 08.12.2012

Ответы (4)


arrow_upward
4
arrow_downward

Есть много способов хранить бинарные данные в Java и неясно, что вы хотите хранить. Если вы хотите хранить ВСЕ возможные комбинации N перелистываний, то вам нужен и массив new boolean[2^N][N]

Помните, что в Java есть другой синтаксис для возведения в степень.

ОБНОВЛЕНИЕ

Ниже приведен код для хранения всех комбинаций N флипов.

Из него вы получите представление о том, как сгенерировать и одну комбинацию: из двоичного представления порядкового номера комбинации. Смотрите комментарии.

    // number of flips
    // limit it by 31
    int N = 3;

    // number of combinations
    // using bitshift to power 2
    int NN = 1<<N;

    // array to store combinations
    boolean flips[][] = new boolean[NN][N];

    // generating an array
    // enumerating combinations
    for(int nn=0; nn<NN; ++nn) {

        // enumerating flips
        for( int n=0; n<N; ++n) {

            // using the fact that binary nn number representation
            // is what we need
            // using bitwise functions to get appropriate bit
            // and converting it to boolean with ==
            flips[nn][N-n-1] = (((nn>>n) & 1)==1);

            // this is simpler bu reversed
            //flips[nn][n] = (((nn>>n) & 1)==1);

        }

    }

    // printing an array
    for(int nn=0; nn<NN; ++nn) {

        System.out.print("" + nn + ": ");

        for( int n=0; n<N; ++n) {
            System.out.print(flips[nn][n]?"T ":"F ");
        }
        System.out.println("");
    }
person Dims    schedule 08.12.2012
comment
да, делать все возможные комбинации довольно просто, я хочу делать только один результат в своем массиве за раз. поэтому размер моего массива равен только количеству переворотов, а не 2 ^ N - person Ceelos; 08.12.2012
comment
Размер массива из вашего примера должен быть [4][2], где 4 равно 2^N, т.е. актуально для 2 бросков. - person Dims; 08.12.2012

arrow_upward
1
arrow_downward

Обратите внимание на сходство между желаемым результатом и двоичным представлением целого числа. Вот пример:

for(int i = 0; i < 4; ++i) {
    boolean first = (i & 1) == 0;
    boolean second = (i & 2) == 0;
    System.out.println(first + "\t" + second);
}

Отпечатки:

true    true
false   true
true    false
false   false
person Tomasz Nurkiewicz    schedule 08.12.2012

arrow_upward
1
arrow_downward

Вот общее решение, которое работает для любого количества переворотов (в пределах разумного):

public class Flips {

    static void generate(boolean[] res, int start) {
        if (start == res.length) {
            System.out.println(Arrays.toString(res));
        } else {
            generate(res, start + 1);
            res[start] = true;
            generate(res, start + 1);
            res[start] = false;
        }
    }

    static void generate(int n) {
        boolean res[] = new boolean[n];
        generate(res, 0);
    }

    public static void main(String args[]) {
        generate(4);
    }
}

Он создает комбинации в другом порядке, чем в вашем вопросе, но тривиально изменить его, чтобы он соответствовал вашему порядку, если это важно.

person NPE    schedule 08.12.2012

arrow_upward
1
arrow_downward

Использование рекурсии:

public static void main(String args[]) {
int size = 3;
generateTable(0, size, new int[size]);
}

private static void generateTable(int index, int size, int[] current) {
if(index == size) { 
    for(int i = 0; i < size; i++) {
        System.out.print(current[i] + " ");
    }
    System.out.println();
} else {
    for(int i = 0; i < 2; i++) {
        current[index] = i;
        generateTable(index + 1, size, current);
    }
}
}
person Abhishek_Mishra    schedule 08.12.2012