Implemented suggesting improvements

snippets/anagrams.md

@@ -1,27 +0,0 @@
-### anagrams
-
-⚠️ **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 anagrams of a string (contains duplicates).
-
-Use recursion.
-For each letter in the given string, create all the partial anagrams for the rest of its letters.
-Use `Array.map()` to combine the letter with each partial anagram, then `Array.reduce()` to combine all anagrams in one array.
-Base cases are for string `length` equal to `2` or `1`.
-
-```js
-const anagrams = str => {
-  if (str.length <= 2) return str.length === 2 ? [str, str[1] + str[0]] : [str];
-  return str
-    .split('')
-    .reduce(
-      (acc, letter, i) =>
-        acc.concat(anagrams(str.slice(0, i) + str.slice(i + 1)).map(val => letter + val)),
-      []
-    );
-};
-```
-
-```js
-anagrams('abc'); // ['abc','acb','bac','bca','cab','cba']
-```

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/permuteAll.md

@@ -1,37 +0,0 @@
-### permuteAll
-
-Uses recursion and `Array.push()` to return all the permutations of the given input in an array.
-
-```js
-const permuteAll = (input) => {
-  const result = [];
-  let inputState = input;
-
-  if (typeof input === 'string') inputState = input.split('');
-  if (typeof input === 'number') inputState = (input).toString().split('');
-
-  const permute = (arr, m = []) => {
-    (arr.length === 0)
-      ? result.push(m)
-      : arr.forEach((_, i) => {
-          let curr = arr.slice();
-          let next = curr.splice(i, 1);
-          permute(curr.slice(), m.concat(next));
-        });
-  };
-
-  permute(inputState);
-
-  return (typeof input === 'string')
-            ? result.map(variant => variant.join(''))
-            : (typeof input === 'number') 
-                ? result.map(variant => parseFloat(variant.join('')))
-                : result;
-};
-```
-
-```js
-permuteAll('sun') // [ 'sun', 'snu', 'usn', 'uns', 'nsu', 'nus' ]
-permuteAll([1, 33, 5]) // [ [ 1, 33, 5 ], [ 1, 5, 33 ], [ 33, 1, 5 ], [ 33, 5, 1 ], [ 5, 1, 33 ], [ 5, 33, 1 ] ]
-permuteAll(345) // [ 345, 354, 435, 453, 534, 543 ]
-```

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,4 +1,3 @@
-anagrams:string,recursion
 arrayToHtmlList:browser,array
 ary:adapter,function
 atob:node,string,utility
@@ -110,6 +109,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
@@ -174,7 +174,7 @@ partial:function
 partialRight:function
 partition:array,object,function
 percentile:math
-permuteAll:utility,advanced,array,string
+permutations:array,recursion
 pick:object,array
 pickBy:object,array,function
 pipeAsyncFunctions:adapter,function,promise
@@ -225,6 +225,7 @@ sortedLastIndexBy:array,math,function
 splitLines:string
 spreadOver:adapter
 standardDeviation:math,array
+stringPermutations:string,recursion
 stripHTMLTags:string,utility,regexp
 sum:math,array
 sumBy:math,array,function

test/anagrams/anagrams.js

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

test/anagrams/anagrams.test.js

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

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/permuteAll/permuteAll.js

@@ -1,26 +0,0 @@
-const permuteAll = (input) => {
-const result = [];
-let inputState = input;
-
-if (typeof input === 'string') inputState = input.split('');
-if (typeof input === 'number') inputState = (input).toString().split('');
-
-const permute = (arr, m = []) => {
-(arr.length === 0)
-? result.push(m)
-: arr.forEach((_, i) => {
-let curr = arr.slice();
-let next = curr.splice(i, 1);
-permute(curr.slice(), m.concat(next));
-});
-};
-
-permute(inputState);
-
-return (typeof input === 'string')
-? result.map(variant => variant.join(''))
-: (typeof input === 'number')
-? result.map(variant => parseFloat(variant.join('')))
-: result;
-};
-module.exports = permuteAll;

test/permuteAll/permuteAll.test.js

@@ -1,13 +0,0 @@
-const test = require('tape');
-const permuteAll = require('./permuteAll.js');
-
-test('Testing permuteAll', (t) => {
-  //For more information on all the methods supported by tape
-  //Please go to https://github.com/substack/tape
-  t.true(typeof permuteAll === 'function', 'permuteAll is a Function');
-  //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();
+});