Surely there has to be a better way to do this

p5.js Coding Questions
1

What i wanted to do was take an array of integers and get all permutations of that array keeping the same length. I was using the array [1,2,3,4,5] after trying for a bit i just decided to do it the hard way. However im sure there is a better way. If you’ve ever done this before I’d love to see how you did it. This is how i did it in an ugly non scalable way.

let nums = [1,2,3,4,5];
let perms = [];

function permutate(arr){

	for(let i = 0; i < arr.length; i++){
		for(let j = 0; j < arr.length; j++){
			for(let k = 0; k < arr.length; k++){
				for(let l = 0; l < arr.length; l++){
					for(let m = 0; m < arr.length; m++){
						if(i != j && i != k && i != l && i != m && j != k && j != l && j != m && k != l && k != m && l != m){
							let newArr = [arr[i],arr[j],arr[k],arr[l],arr[m]];
							perms.push(newArr);
						}
					}
				}
			}
		}
	}
}

permutate(nums);
2

found some info here:

3

Here’s an iterative version of Heap’s algorithm. It’s able to handle large arrays of any data type without stack overflows, it does not alter the original list order, and it calls a user-specified function for each iteration.

const perm = ( list, func ) => {
	const len = list.length
	const indices = []
	const listCopy = list.slice( )
	
	for ( let i = 0; i < len; i++ ) indices.push( 0 )
	
	let idx = 1
	
	func && func( list )
	
	while ( idx < len ) {
		if ( indices[ idx ] < idx ) {
			const swap = idx % 2 * indices[ idx ]
			
			;[ listCopy[ swap ], listCopy[ idx ] ] = [ listCopy[ idx ], listCopy[ swap ] ]
			
			func && func( listCopy )
			
			indices[ idx ]++
			idx = 1
		} else {
			indices[ idx++ ] = 0
		}
	}
}


const nums = [ 1, 2, 3, 4, 5 ]

perm( nums, ( list ) => console.log( list.join( ', ' ) ) )