R

E

A

C

T

O

xamples 

epeat

ode

pproach

ptimize

est

{String Permutations}

The Challenge

Given a string, return an array of all the permutations of that string.

All permutations must be the same length as the original string but do not need to be real words.

stringPermutations('one') //should return  [ 'eon', 'eno' 'neo', 'noe', 'one', 'oen']
stringPermutations('app') //should return  [ 'app','pap','ppa']
stringPermutations('nn') //should return  [ 'nn' ]

Notes

• The  returned array should contain only unique values
• The returned array should be alphabetically sorted

Approach

A string of one character has one permutation

'a'   ->   [ 'a' ]

For each additional letter, add it to each possible space in the current results

stringPermutations('abc')

insert 'a'

[ 'a' ]

Approach

A string of one character has one permutation

'a'   ->   [ 'a' ]

For each additional letter, add it to each possible space in the current results

stringPermutations('abc')

insert 'b'

'b'

Approach

For each additional letter, add it to each possible space in the current results

stringPermutations('abc')

'c'

 [        'ba',            'ab'        ]

insert 'c'

[  'cba', 'bca', 'bac'

      'cab', 'acb', 'abc  ]

Possible ITERATIVE Solution

function stringPermutations(str) {
  let permutations = [];
  const letters = str.split('');

  permutations.push([letters.shift()]) // Adds first letter (as a subarray) to `permutations`

  while (letters.length) {
    const nextLetter = letters.shift(); // Takes the next potential letter off the `letters` array
    const tempermutations = []; // Temporary list of permutated results

    permutations.forEach(currentPerm => { // For each permutation in progress

      for (let i = 0; i <= currentPerm.length; ++i) { // As long as the letters already processed
        const currentCopy = Array.from(currentPerm); // Copy `currentPerm` to prep for mutation

        // Add `nextLetter` at each possible position during each iteration of the `for` loop
        currentCopy.splice(i, 0, nextLetter)

        // Add the mutated copy to the temporary list of permutations
        tempermutations.push(currentCopy);
      }
    });

    // Overwrite previous permutations which are now one letter short
    permutations = tempermutations;
  }

  // Turn each permutated subarray back into a string
  permutations = permutations.map(wordArr => wordArr.join(''));

  // Filter out non-unique permutations, sort the array into alphabetical order, then return
  return permutations.filter((el, idx) => permutations.indexOf(el) === idx).sort();
}

repl

Possible  Recursive Solution

// Adapted from: http://www.thatjsdude.com/interview/js1.html#permutation

function permutations(str){
  // Convert `str` to an array
  const arr = str.split(''),
    len = arr.length, 
    perms = [];
  let rest,
    picked,
    restPerms,
    next;
  
  // BASE CASE: If there are no 'rest' characters left, return `['']`
  if (len === 0) return [str];

  for (let i = 0; i < len; ++i) {

    // Create an array copy of all letters in current order
    rest = Object.create(arr);  // Other options include `.slice` and `Array.from` methods
    // Remove & reserve the 1st letter whilst we permute the rest
    picked = rest.splice(i, 1);

    // Create the permuted string variations recursively
    restPerms = permutations(rest.join(''));

    for (let k = 0, kLen = restPerms.length; k < kLen; ++k) {
      // Concatenate each variation of the 'rest' letters to the reserved letter
      next = picked.concat(restPerms[k]);
      // Push each variation into the permutations list
      perms.push(next.join(''));
    }
  }
  
  // Filter out non-unique permutations, sort the array into alphabetical order, then return
  return perms.filter((el, idx) => perms.indexOf(el) === idx).sort();
}

repl

Possible  Recursive Solution Variation

// Adapted from Galen Corey's 1610GHA Solution

function getPerms(lettArray){
  let perms = [];

  // BASE CASE: If we're on the last letter return the letter
  if (lettArray.length === 1) return lettArray;

  lettArray.forEach((char, idx) => {
    // Make a copy of the current array;
    const rest = lettArray.slice();

    // Remove the idx-th character (`char`) in the array
    rest.splice(idx, 1);

    // Recursively concatenate the 'rest' variations to the current character
    const subPerms = getPerms(rest).map(subPerm => char + subPerm);

    // Concatenate all the new permutations into the `perms` array
    perms = [...perms, ...subPerms];
  })

  return perms
}

function getPermsWrapper(str){
    // Turn the input string into an array and call `getPerms` on it
    const allPerms = getPerms(str.split(''));

    // Filter out repeats and sort into alphabetical order
    return allPerms.filter((word, idx) => allPerms.indexOf(word) === idx).sort();
}

repl

Possible  Recursive Solution Variation 2

// Adapted from Griffin Telljohann's Code Wars solution

function permutations(str) {
  if (!str.length) { return ['']; }
  
  // Split the input string and map over each character
  const initial =  str.split('').map((char, idx, arr) => {
    // Recursively create permutations of each string minus the selected `char`acter
    const subPermutations = permutations(remove(arr, char).join(''))
    
    // Map over each subPermutation and return that with the selected `char`acter appended to it
    return subPermutations.map(str => char + str);
  }).reduce((prev, curr) => prev.concat(curr), [])  // Concatenate each new array of permutations to the previous one
  return removeDuplicates(initial);  // Filter out the dupes, sort, and return
}


// Takes an array and a `char`acter and returns it without said `char`acter
function remove(arr, char) {
  const idx = arr.indexOf(char);
  return [...arr.slice(0, idx), ...arr.slice(idx + 1)];
}


// Filters out dupes and sorts in alphabetical order
function removeDuplicates(arr) {
  return arr.filter((el, idx) => arr.indexOf(el) === idx).sort();
}

repl

Conclusion

Know your string and array methods.

Consider breaking a problem into smaller pieces.