Newsgroup: it.comp.java
Titolo: combinazioni di boolean

Salve!!!!
Il mio problema e' il seguente:
ho un array di N boolean, e vorrei avere tutte le possibili combinazioni
di true e false per tutti gli elementi dell'array.
Cioe', se per es ho N=2
vorrei poter elencare
bool[0] bool[1]
true true
true false
false true
false false
e cosi' via al crescere di N.
Qual'e' un modo semplice di realizzare la cosa in java???
Scusatemi per la domanda sciocca ma sono ancora un newbie x il Java!!!
Grazie anticipatamente!
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 Qual'e' un modo semplice di realizzare la cosa in java???
Sai contare in binario?

 e cosi' via al crescere di N.
mica tanto banale!
io farei cosi', con l'utilizzo di una funzione ricorsiva:
public class BooleanTable{
	private String[][] table;
	private int nRows;
	private int nCols;
	public BooleanTable(int dim)
	{
		nCols = dim;
		Double initLines = new Double(Math.pow(2,dim));
		nRows = initLines.intValue();
		table = new String[nRows][dim];
	}
	public String[][] getTable()
	{
		return table;
	}
	public int getNRows()
	{
		return nRows;
	}
	public int getNCols()
	{
		return nCols;
	}
	private void fillTable(int dim, int cIndex, int rStartIndex)
	{
		if(dim < 1)
		{
			System.out.println("error");
			return;
		}
		Double dLines = new Double(Math.pow(2,dim));
		int iLines = dLines.intValue();
		for(int idx = rStartIndex; idx < rStartIndex + iLines/2; idx++)
		{
			table[idx][cIndex] = " true ";
		}
		for(int idx = rStartIndex + iLines/2; idx < rStartIndex + iLines;
idx++)
		{
			table[idx][cIndex] = " false ";
		}
		if(dim > 1)
		{
			fillTable(dim - 1, cIndex + 1, rStartIndex);
			fillTable(dim - 1, cIndex + 1, rStartIndex + iLines/2);
		}
	}
	public static void main(String[] argv){
               // N = 4
		BooleanTable bt = new BooleanTable(4);
		bt.fillTable(4, 0, 0);
		String[][] myTable = bt.getTable();
		for(int idx = 0; idx < bt.getNRows(); idx++)
		{
			for(int idy = 0; idy < bt.getNCols(); idy++)
			{
				System.out.print(myTable[idx][idy]);
			}
			System.out.println();
		}
	}
}
ma puoi evitare il calcolo della meta' sotto perche' e' la negazione
della meta' sopra. Almeno credo.
TREMALNAIK

 io farei cosi', con l'utilizzo di una funzione ricorsiva:
ma anche, seguendo il suggerimento di Manuel T, con una soluzione
iterativa, più lenta ma meno esosa di risorse:
import java.util.Arrays;
public class BooleanTable
{
        public void fillTable(int dim)
        {
                Double dRows = new Double(Math.pow(2, dim));
                int iRows = dRows.intValue();
                for(int idx = 0; idx < iRows; idx++)
                {
                        writeRow(Integer.toBinaryString(idx), dim);
                }
        }
        private void writeRow(String binary, int dim)
        {
               for(int idx = binary.length(); idx < dim; idx++)
               {
                         System.out.print(" false ");
               }
                for(int idx = 0; idx < binary.length(); idx++)
                {
                        if(binary.charAt(idx) == '0')
                        {
                                System.out.print(" false ");
                        }
                        if(binary.charAt(idx) == '1')
                        {
                                System.out.print(" true ");
                        }
                }
                System.out.println();
        }
        public static void main(String[] argv)
        {
                if(argv.length < 1)
                {
                        System.out.println("Missing an argument");
                        return;
                }
                BooleanTable bt = new BooleanTable();
                bt.fillTable(Integer.parseInt(argv[0]));
        }
}
TREMALNAIK