Merge pull request #605 from Chalarangelo/add-permuteAll

Add permuteAll

snippets/isAnagram.md

@@ -0,0 +1,16 @@
+### isAnagram
+
+Checks if a string is an anagram of another string (case-insensitive, ignores spaces, punctuation and special characters).
+
+Use `String.toLowerCase()`, `String.replace()` with an appropriate regular expression to remove unnecessary characters, `String.split('')`, `Array.sort()` and `Array.join('')` on both strings to normalize them, then check if their normalized forms are equal.
+
+```js
+const isAnagram = (str1, str2) => {
+  const normalize = str => str.toLowerCase().replace(/[^a-z0-9]/gi, '').split('').sort().join('');
+  return normalize(str1) === normalize(str2);
+};
+```
+
+```js
+isAnagram('iceman', 'cinema'); // true
+```

snippets/permutations.md

@@ -0,0 +1,30 @@
+### permutations
+
+⚠️ **WARNING**: This function's execution time increases exponentially with each array element. Anything more than 8 to 10 entries will cause your browser to hang as it tries to solve all the different combinations.
+
+Generates all permutations of an array's elements (contains duplicates).
+
+Use recursion.
+For each element in the given array, create all the partial permutations for the rest of its elements.
+Use `Array.map()` to combine the element with each partial permutation, then `Array.reduce()` to combine all permutations in one array.
+Base cases are for array `length` equal to `2` or `1`.
+
+```js
+const permutations = arr => {
+  if (arr.length <= 2) return arr.length === 2 ? [arr, [arr[1], arr[0]]] : arr;
+  return arr.reduce(
+    (acc, item, i) =>
+      acc.concat(
+        permutations([...arr.slice(0, i), ...arr.slice(i + 1)]).map(val => [
+          item,
+          ...val,
+        ])
+      ),
+    []
+  );
+};
+```
+
+```js
+permutations([1, 33, 5]) // [ [ 1, 33, 5 ], [ 1, 5, 33 ], [ 33, 1, 5 ], [ 33, 5, 1 ], [ 5, 1, 33 ], [ 5, 33, 1 ] ]
+```

snippets/stringPermutations.md

@@ -0,0 +1,27 @@
+### stringPermutations
+
+⚠️ **WARNING**: This function's execution time increases exponentially with each character. Anything more than 8 to 10 characters will cause your browser to hang as it tries to solve all the different combinations.
+
+Generates all permutations of a string (contains duplicates).
+
+Use recursion.
+For each letter in the given string, create all the partial permutations for the rest of its letters.
+Use `Array.map()` to combine the letter with each partial permutation, then `Array.reduce()` to combine all permutations in one array.
+Base cases are for string `length` equal to `2` or `1`.
+
+```js
+const stringPermutations = str => {
+  if (str.length <= 2) return str.length === 2 ? [str, str[1] + str[0]] : [str];
+  return str
+    .split('')
+    .reduce(
+      (acc, letter, i) =>
+        acc.concat(stringPermutations(str.slice(0, i) + str.slice(i + 1)).map(val => letter + val)),
+      []
+    );
+};
+```
+
+```js
+stringPermutations('abc'); // ['abc','acb','bac','bca','cab','cba']
+```

tag_database

@@ -1,5 +1,4 @@
 all:array,function
-anagrams:string,recursion
 any:array,function
 approximatelyEqual:math
 arrayToHtmlList:browser,array
@@ -117,6 +116,7 @@ intersectionWith:array,function
 invertKeyValues:object,function
 is:type,array,regexp
 isAbsoluteURL:string,utility,browser,url
+isAnagram:string,regexp
 isArrayLike:type,array
 isBoolean:type
 isDivisible:math
@@ -183,6 +183,7 @@ partial:function
 partialRight:function
 partition:array,object,function
 percentile:math
+permutations:array,recursion
 pick:object,array
 pickBy:object,array,function
 pipeAsyncFunctions:adapter,function,promise
@@ -235,6 +236,7 @@ splitLines:string
 spreadOver:adapter
 stableSort:array,sort,advanced
 standardDeviation:math,array
+stringPermutations:string,recursion
 stripHTMLTags:string,utility,regexp
 sum:math,array
 sumBy:math,array,function

test/isAnagram/isAnagram.js

@@ -0,0 +1,5 @@
+const isAnagram = (str1, str2) => {
+const normalize = str => str.toLowerCase().replace(/[^a-z0-9]/gi, '').split('').sort().join('');
+return normalize(str1) === normalize(str2);
+};
+module.exports = isAnagram;

test/isAnagram/isAnagram.test.js

@@ -0,0 +1,17 @@
+const test = require('tape');
+const isAnagram = require('./isAnagram.js');
+
+test('Testing isAnagram', (t) => {
+  //For more information on all the methods supported by tape
+  //Please go to https://github.com/substack/tape
+  t.true(typeof isAnagram === 'function', 'isAnagram is a Function');
+  t.true(isAnagram('iceman', 'cinema'), 'Checks valid anagram');
+  t.true(isAnagram('rail safety', 'fairy tales'), 'Works with spaces');
+  t.true(isAnagram('roast beef', 'eat for BSE'), 'Ignores case');
+  t.true(isAnagram('Regera Dowdy', 'E. G. Deadworry'), 'Ignores special characters');
+  //t.deepEqual(isAnagram(args..), 'Expected');
+  //t.equal(isAnagram(args..), 'Expected');
+  //t.false(isAnagram(args..), 'Expected');
+  //t.throws(isAnagram(args..), 'Expected');
+  t.end();
+});

test/permutations/permutations.js

@@ -0,0 +1,14 @@
+const permutations = arr => {
+if (arr.length <= 2) return arr.length === 2 ? [arr, [arr[1], arr[0]]] : arr;
+return arr.reduce(
+(acc, item, i) =>
+acc.concat(
+permutations([...arr.slice(0, i), ...arr.slice(i + 1)]).map(val => [
+item,
+...val,
+])
+),
+[]
+);
+};
+module.exports = permutations;

test/permutations/permutations.test.js

@@ -0,0 +1,14 @@
+const test = require('tape');
+const permutations = require('./permutations.js');
+
+test('Testing permutations', (t) => {
+  //For more information on all the methods supported by tape
+  //Please go to https://github.com/substack/tape
+  t.true(typeof permutations === 'function', 'permutations is a Function');
+  t.deepEqual(permutations([1, 33, 5]), [ [ 1, 33, 5 ], [ 1, 5, 33 ], [ 33, 1, 5 ], [ 33, 5, 1 ], [ 5, 1, 33 ], [ 5, 33, 1 ] ], 'Generates all permutations of an array');
+  //t.deepEqual(permuteAll(args..), 'Expected');
+  //t.equal(permuteAll(args..), 'Expected');
+  //t.false(permuteAll(args..), 'Expected');
+  //t.throws(permuteAll(args..), 'Expected');
+  t.end();
+});

test/stringPermutations/stringPermutations.js

@@ -0,0 +1,11 @@
+const stringPermutations = str => {
+if (str.length <= 2) return str.length === 2 ? [str, str[1] + str[0]] : [str];
+return str
+.split('')
+.reduce(
+(acc, letter, i) =>
+acc.concat(stringPermutations(str.slice(0, i) + str.slice(i + 1)).map(val => letter + val)),
+[]
+);
+};
+module.exports = stringPermutations;

test/stringPermutations/stringPermutations.test.js

@@ -0,0 +1,16 @@
+const test = require('tape');
+const stringPermutations = require('./stringPermutations.js');
+
+test('Testing stringPermutations', (t) => {
+  //For more information on all the methods supported by tape
+  //Please go to https://github.com/substack/tape
+  t.true(typeof stringPermutations === 'function', 'stringPermutations is a Function');
+  t.deepEqual(stringPermutations('abc'), ['abc','acb','bac','bca','cab','cba'], "Generates all stringPermutations of a string");
+  t.deepEqual(stringPermutations('a'), ['a'], "Works for single-letter strings");
+  t.deepEqual(stringPermutations(''), [''], "Works for empty strings");
+  //t.deepEqual(anagrams(args..), 'Expected');
+  //t.equal(anagrams(args..), 'Expected');
+  //t.false(anagrams(args..), 'Expected');
+  //t.throws(anagrams(args..), 'Expected');
+  t.end();
+});