Génération de toutes les combinaisons vrai/faux possibles

Question

Je veux créer un tableau de toutes les combinaisons possibles de trois variables qui peuvent être soit vraies soit fausses (c'est-à-dire 8 combinaisons possibles).

J'essaie de créer le cube dans le coin supérieur gauche de cette image.

La sortie devrait donc être quelque chose comme

points = [
  // first square
  {
    id: '000',
    truths: [false, false, false]
    position: [0, 0]
  },
  {
    id: '100',
    truths: [true, false, false]
    position: [5, 0]
  },
  {
    id: '010',
    truths: [false, true, false]
    position: [0, 5]
  },
  {
    id: '110',
    truths: [true, true, false]
    position: [5, 5]
  },
  // second square
  {
    id: '001',
    truths: [false, false, true]
    position: [2.5, 2.5]
  },
  {
    id: '101',
    truths: [true, false, true]
    position: [7.5, 2.5]
  },
  {
    id: '011',
    truths: [false, true, true]
    position: [2.5, 7.5]
  },
  {
    id: '111',
    truths: [true, true, true]
    position: [7.5, 7.5]
  },
];

lines = [
  { from: '000', to: '100' },
  { from: '000', to: '010' },
  { from: '000', to: '001' },

  { from: '100', to: '101' },
  { from: '100', to: '110' },

  { from: '001', to: '101' },
  { from: '001', to: '011' },

  { from: '101', to: '001' },
  { from: '101', to: '111' },

  ...
]

Je ne sais pas comment passer en revue toutes les valeurs de vérité possibles et créer ces points.

Une approche pourrait consister à utiliser une boucle for

for (var i=0; i<Math.pow(2, 3); i++) {
  ...
}

mais ça ne m'aide pas à attribuer les valeurs de vérité possibles.

Answer 1

Tout dans un ordinateur est déjà binaire. Vous n'avez pas besoin de fantaisie Math.pow ou similaire.

for (let i = 0; i < 1 << 3; i++) {
  console.log([!!(i & (1<<2)), !!(i & (1<<1)), !!(i & 1)]);
}

Même si ça a l'air sympa et court, je ne suis pas vraiment fan de !! ou des chiffres magiques. Je me laisse toujours avoir par ces astuces lorsque j'écris des extraits. Je vais donc essayer de donner une version un peu plus propre :

const AMOUNT_OF_VARIABLES = 3;

for (let i = 0; i < (1 << AMOUNT_OF_VARIABLES); i++) {
  let boolArr = [];

  //Increasing or decreasing depending on which direction
  //you want your array to represent the binary number
  for (let j = AMOUNT_OF_VARIABLES - 1; j >= 0; j--) {
    boolArr.push(Boolean(i & (1 << j)));
  }

  console.log(boolArr);
}

Answer 2

C'est facile, il suffit de convertir tous les entiers de 0 à 2**n-1 en binaire :

var n = 3,
    m = 1 << n;
for (var i = 0; i < m; i++) {
    var s = i.toString(2); // convert to binary
    s = new Array(n + 1 - s.length).join('0') + s; // pad with zeroes
    console.log(s);
}

Le code ci-dessus est général ; vous pouvez modifier n au nombre de bits que vous voulez.

Answer 3

Il y a pow(2, n) valeurs possibles.

Dans le système numérique binaire, les nombres peuvent être considérés comme des "tableaux" de bits : 0= [0,0,0] , 1= [0,0,1] , 2= [0,1,0] , 3= [0,1,1] , 4= [1,0,0] , 5= [1,0,1] , 6= [1,1,0] , 7= [1,1,1] .

En suivant cette idée, l'approche la plus simple est d'extraire les bits des entiers [0, pow(2, n) - 1] . Voici le code qui est une mise en œuvre directe de l'idée ci-dessus :

function test()
{
   var n = 3;
   var k = (1 << n); // bit trick for pow(2, n)

   var truths = [];

   for (var i = 0; i < k; ++i)
   {
      truths[i] = [];

      for (var j = 0; j < n; ++j)
      {
         var value = (i >> j) & 1; // extract the j-th bit of i
         truths[i][j] = value;
      }

      console.log(truths[i]);
   }
}

Answer 4

const boolCombo = size => {
  const buf = Array(1 << size)
  for (let i = buf.length; i--;) {
    buf[ i ] = Array(size)
    for (let j = size; j--;)
      buf[ i ][ j ] = +!!(i & 1 << j)
  }
  return buf
}

console.log(boolCombo(3))