Otdfbt

I'm trying to find every permutations of 2 arrays like this:

// input
lowerWords = ['one', 'two', 'three' ] 
upperWords = [ 'ONE', 'TWO', 'THREE' ]

// output
keywords = 
 'one two three': true,
 'ONE two three': true,
 'ONE TWO three': true,
 'ONE TWO THREE': true,
 'ONE two THREE': true,
 'one TWO three': true,
 'one two THREE': true,
 'one TWO THREE': true,

It should function with more than 3 items, both arrays will always be same length. This is my code:

const keywords = 
const lowerWords = ['one', 'two', 'three' ] 
const upperWords = [ 'ONE', 'TWO', 'THREE' ]
const wordCount = lowerWords.length

let currentWord = 0
let currentWords = [...upperWords]
while (currentWord < wordCount) 
 currentWords[currentWord] = lowerWords[currentWord]
 let keyword = currentWords.join(' ')
 keywords[keyword] = true
 currentWord++


currentWord = 0
currentWords = [...lowerWords]
while (currentWord < wordCount) 
 currentWords[currentWord] = upperWords[currentWord]
 let keyword = currentWords.join(' ')
 keywords[keyword] = true
 currentWord++

result is missing some

ONE TWO THREE: true
ONE TWO three: true
ONE two three: true
one TWO THREE: true
one two THREE: true
one two three: true

You could transpose the arrays for getting an array of pairs and then get all combinations of the pairs.

const
 transpose = array => array.reduce((r, a) => a.map((v, i) => [...(r[i] || []), v]), []),
 combinations = array => array.reduce((a, b) => a.reduce((r, v) => r.concat(b.map(w => [].concat(v, w))), []));

var lowerWords = ['one', 'two', 'three'],
 upperWords = ['ONE', 'TWO', 'THREE'],
 pairs = transpose([lowerWords, upperWords]),
 result = combinations(pairs);
 
console.log(result);

.as-console-wrapper max-height: 100% !important; top: 0; 

Thought I'd give it a try. I used binary to get the possible combinations, as this problem needed a base 2 solution:

const low = ["one", "two", "three"];
const up = ["ONE", "TWO", "THREE"];

const words = [low, up]
const len = words[0].length


function getCombinations(noOfArrays, len) 
 var temp, newCombo, combos = [];
 for (var i = 0; i < (noOfArrays ** len); i++) 
 temp = new Array(len).fill(0)
 newCombo = i.toString(noOfArrays).split('');
 newCombo.forEach((el, i) => temp[temp.length - newCombo.length + i] = +el);
 combos.push(temp);
 
 return combos;


function setCombinations(combos) 
 return combos.map(combo => combo.map((el, i) => words[el][i]))



var combos = getCombinations(words.length, len)
combos = setCombinations(combos)


console.log(combos)

Explanation of loop:

1. temp = new Array(len).fill(0)
2. newCombo = i.toString(2).split("");
3. newCombo.forEach((el, i) => temp[temp.length - newCombo.length + i] = +el);

1. Creates temp array [0,0,0]
   


2. Grabs loop number (i) and converts it to binary e.g:

1 -> 1
2 -> 10
3 -> 11
4 -> 100
etc...

Then split the binary into an array 100 -> [1,0,0].

3. Then for each element push it in that new array. This gave a problem with pushing the 1 and 2 element arrays (10 -> [1,0]) into the back of the array. I used temp.length - newCombo.length + i to fix that.

That function then returns:

[ 0, 0, 0 ]
[ 0, 0, 1 ]
[ 0, 1, 0 ]
[ 0, 1, 1 ]
[ 1, 0, 0 ]
[ 1, 0, 1 ]
[ 1, 1, 0 ]
[ 1, 1, 1 ]

Then, I can map over each combination, and grab each array depending on the value, and get the words ('one' or 'ONE') via loop index.

Note this code works with more than one array, as long as the arrays are all the same length.

We can enumerate these directly. And this may be a good opportunity for you to learn more about recursion. The algorithm is very simple:

If we've reached the end of
the list, return the combination
the current recursion branch is
building.

Otherwise, create a new branch
that picks the next item from B,
while the current branch picks
the next item from A.

JavaScript code:

function f(A, B, i=0, comb=[])
 return i == A.length
 ? [comb]
 : f(A, B, i + 1, comb.concat(A[i])).concat(
 f(A, B, i + 1, comb.slice().concat(B[i])))


console.log(JSON.stringify(f(['one','two','three'], ['ONE','TWO','THREE'])))

You need to get a total of 2 ^ 3 combinations. If you create a 2D matrix from the 2 arrays, the below table represents the row number from which of the item should be taken.

0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1

If you analyze indexes of the combinations, each of this a binary number from 0 to 2 ^ 3 with leading zeros.

So, you could

• loop from 0 to 8


• create binary number using toString(2)
  


• Add leading zero using padStart
  


• 
  split each digit to get an array


• Get each item from matrix[digit-from-binary][position-of-each-split]
  


• 
  join the array of items with a ' ' separator to get the key
  


• Add the key to the output object

function getAllCombinations(matrix) 
 const combinations = 2 ** 3,
 output = ;
 
 for(let i = 0; i < combinations; i++) 
 const key = i.toString(2)
 .padStart(3, 0)
 .split('')
 .map((n, j) => matrix[n][j])
 .join(" ")
 
 output[key] = true;
 
 
 return output


console.log(getAllCombinations([['one', 'two', 'three' ],[ 'ONE', 'TWO', 'THREE' ]]))

You can generalize this for m x n matrix. Instead of converting each to a binary number, you need to convert it to base-m and padStart to length n

function getAllCombinations(matrix) 
 const rows = matrix.length,
 columns = matrix[0].length,
 combinations = rows ** columns,
 output = 
 
 for(let i = 0; i < combinations; i++) 
 const key = i.toString(rows)
 .padStart(columns, 0)
 .split('')
 .map((n, j) => matrix[n][j])
 .join(" ")
 
 output[key] = true;
 
 
 return output


console.log(getAllCombinations([[1, 2, 3 ],[ 4, 5, 6], [ 7, 8, 9]])) // 3 x 3 matrix
console.log(getAllCombinations([[1, 2], [3, 4], [5, 6], [7, 8]])) // 4 x 2 matrix

.as-console-wrapper max-height: 100% !important; top: 0;