diff --git a/docs/archive.html b/docs/archive.html index 8a79d9ecd..694b28123 100644 --- a/docs/archive.html +++ b/docs/archive.html @@ -97,24 +97,297 @@ -

undefined

-

undefined

-

undefined

-

undefined

-

undefined

-

undefined

-

undefined

-

undefined

-

undefined

-

undefined

-

undefined

-

undefined

-

undefined

-

undefined

-

undefined

-

undefined

-

undefined

-

undefined

+

binarySearch

+

Use recursion. Similar to Array.indexOf() that finds the index of a value within an array. +The difference being this operation only works with sorted arrays which offers a major performance boost due to it's logarithmic nature when compared to a linear search or Array.indexOf().

+

Search a sorted array by repeatedly dividing the search interval in half. +Begin with an interval covering the whole array. +If the value of the search is less than the item in the middle of the interval, recurse into the lower half. Otherwise recurse into the upper half. +Repeatedly recurse until the value is found which is the mid or you've recursed to a point that is greater than the length which means the value doesn't exist and return -1.

+
const binarySearch = (arr, val, start = 0, end = arr.length - 1) => {
+  if (start > end) return -1;
+  const mid = Math.floor((start + end) / 2);
+  if (arr[mid] > val) return binarySearch(arr, val, start, mid - 1);
+  if (arr[mid] < val) return binarySearch(arr, val, mid + 1, end);
+  return mid;
+};
+
binarySearch([1, 4, 6, 7, 12, 13, 15, 18, 19, 20, 22, 24], 6); // 2
+binarySearch([1, 4, 6, 7, 12, 13, 15, 18, 19, 20, 22, 24], 21); // -1
+
+

cleanObj

+

Removes any properties except the ones specified from a JSON object.

+

Use Object.keys() method to loop over given JSON object and deleting keys that are not included in given array. +If you pass a special key,childIndicator, it will search deeply apply the function to inner objects, too.

+
const cleanObj = (obj, keysToKeep = [], childIndicator) => {
+  Object.keys(obj).forEach(key => {
+    if (key === childIndicator) {
+      cleanObj(obj[key], keysToKeep, childIndicator);
+    } else if (!keysToKeep.includes(key)) {
+      delete obj[key];
+    }
+  });
+  return obj;
+};
+
const testObj = { a: 1, b: 2, children: { a: 1, b: 2 } };
+cleanObj(testObj, ['a'], 'children'); // { a: 1, children : { a: 1}}
+
+

collatz

+

Applies the Collatz algorithm.

+

If n is even, return n/2. Otherwise, return 3n+1.

+
const collatz = n => (n % 2 === 0 ? n / 2 : 3 * n + 1);
+
collatz(8); // 4
+
+

countVowels

+

Retuns number of vowels in provided string.

+

Use a regular expression to count the number of vowels (A, E, I, O, U) in a string.

+
const countVowels = str => (str.match(/[aeiou]/gi) || []).length;
+
countVowels('foobar'); // 3
+countVowels('gym'); // 0
+
+

factors

+

Returns the array of factors of the given num. +If the second argument is set to true returns only the prime factors of num. +If num is 1 or 0 returns an empty array. +If num is less than 0 returns all the factors of -int together with their additive inverses.

+

Use Array.from(), Array.map() and Array.filter() to find all the factors of num. +If given num is negative, use Array.reduce() to add the additive inverses to the array. +Return all results if primes is false, else determine and return only the prime factors using isPrime and Array.filter(). +Omit the second argument, primes, to return prime and non-prime factors by default.

+

Note:- Negative numbers are not considered prime.

+
const factors = (num, primes = false) => {
+  const isPrime = num => {
+    const boundary = Math.floor(Math.sqrt(num));
+    for (var i = 2; i <= boundary; i++) if (num % i === 0) return false;
+    return num >= 2;
+  };
+  const isNeg = num < 0;
+  num = isNeg ? -num : num;
+  let array = Array.from({ length: num - 1 })
+    .map((val, i) => (num % (i + 2) === 0 ? i + 2 : false))
+    .filter(val => val);
+  if (isNeg)
+    array = array.reduce((acc, val) => {
+      acc.push(val);
+      acc.push(-val);
+      return acc;
+    }, []);
+  return primes ? array.filter(isPrime) : array;
+};
+
factors(12); // [2,3,4,6,12]
+factors(12, true); // [2,3]
+factors(-12); // [2, -2, 3, -3, 4, -4, 6, -6, 12, -12]
+factors(-12, true); // [2,3]
+
+

fibonacciCountUntilNum

+

Returns the number of fibonnacci numbers up to num(0 and num inclusive).

+

Use a mathematical formula to calculate the number of fibonacci numbers until num.

+
const fibonacciCountUntilNum = num =>
+  Math.ceil(Math.log(num * Math.sqrt(5) + 1 / 2) / Math.log((Math.sqrt(5) + 1) / 2));
+
fibonacciCountUntilNum(10); // 7
+
+

fibonacciUntilNum

+

Generates an array, containing the Fibonacci sequence, up until the nth term.

+

Create an empty array of the specific length, initializing the first two values (0 and 1). +Use Array.reduce() to add values into the array, using the sum of the last two values, except for the first two. +Uses a mathematical formula to calculate the length of the array required.

+
const fibonacciUntilNum = num => {
+  let n = Math.ceil(Math.log(num * Math.sqrt(5) + 1 / 2) / Math.log((Math.sqrt(5) + 1) / 2));
+  return Array.from({ length: n }).reduce(
+    (acc, val, i) => acc.concat(i > 1 ? acc[i - 1] + acc[i - 2] : i),
+    []
+  );
+};
+
fibonacciUntilNum(10); // [ 0, 1, 1, 2, 3, 5, 8 ]
+
+

howManyTimes

+

Returns the number of times num can be divided by divisor (integer or fractional) without getting a fractional answer. +Works for both negative and positive integers.

+

If divisor is -1 or 1 return Infinity. +If divisor is -0 or 0 return 0. +Otherwise, keep dividing num with divisor and incrementing i, while the result is an integer. +Return the number of times the loop was executed, i.

+
const howManyTimes = (num, divisor) => {
+  if (divisor === 1 || divisor === -1) return Infinity;
+  if (divisor === 0) return 0;
+  let i = 0;
+  while (Number.isInteger(num / divisor)) {
+    i++;
+    num = num / divisor;
+  }
+  return i;
+};
+
howManyTimes(100, 2); // 2
+howManyTimes(100, 2.5); // 2
+howManyTimes(100, 0); // 0
+howManyTimes(100, -1); // Infinity
+
+

httpDelete

+

Makes a DELETE request to the passed URL.

+

Use XMLHttpRequest web api to make a delete request to the given url. +Handle the onload event, by running the provided callback function. +Handle the onerror event, by running the provided err function. +Omit the third argument, err to log the request to the console's error stream by default.

+
const httpDelete = (url, callback, err = console.error) => {
+  const request = new XMLHttpRequest();
+  request.open("DELETE", url, true);
+  request.onload = () => callback(request);
+  request.onerror = () => err(request);
+  request.send();
+};
+
httpDelete('https://website.com/users/123', request => {
+  console.log(request.responseText);
+}); // 'Deletes a user from the database'
+
+

httpPut

+

Makes a PUT request to the passed URL.

+

Use XMLHttpRequest web api to make a put request to the given url. +Set the value of an HTTP request header with setRequestHeader method. +Handle the onload event, by running the provided callback function. +Handle the onerror event, by running the provided err function. +Omit the last argument, err to log the request to the console's error stream by default.

+
const httpPut = (url, data, callback, err = console.error) => {
+    const request = new XMLHttpRequest();
+    request.open("PUT", url, true);
+    request.setRequestHeader('Content-type','application/json; charset=utf-8');
+    request.onload = () => callback(request);
+    request.onerror = () => err(request);
+    request.send(data);
+};
+
const password = "fooBaz";
+const data = JSON.stringify(password);
+httpPut('https://website.com/users/123', data, request => {
+  console.log(request.responseText);
+}); // 'Updates a user's password in database'
+
+

isArmstrongNumber

+

Checks if the given number is an Armstrong number or not.

+

Convert the given number into an array of digits. Use the exponent operator (**) to get the appropriate power for each digit and sum them up. If the sum is equal to the number itself, return true otherwise false.

+
const isArmstrongNumber = digits =>
+  (arr => arr.reduce((a, d) => a + parseInt(d) ** arr.length, 0) == digits)(
+    (digits + '').split('')
+  );
+
isArmstrongNumber(1634); // true
+isArmstrongNumber(56); // false
+
+

isSimilar

+

Determines if the pattern matches with str.

+

Use String.toLowerCase() to convert both strings to lowercase, then loop through str and determine if it contains all characters of pattern and in the correct order. +Adapted from here.

+
const isSimilar = (pattern, str) =>
+	[...str].reduce(
+		(matchIndex, char) => char.toLowerCase() === (pattern[matchIndex]  || '').toLowerCase() ? matchIndex + 1 : matchIndex, 0
+	) === pattern.length ? true : false;
+
isSimilar('rt','Rohit'); // true
+isSimilar('tr','Rohit'); // false
+
+

JSONToDate

+

Converts a JSON object to a date.

+

Use Date(), to convert dates in JSON format to readable format (dd/mm/yyyy).

+
const JSONToDate = arr => {
+  const dt = new Date(parseInt(arr.toString().substr(6)));
+  return `${dt.getDate()}/${dt.getMonth() + 1}/${dt.getFullYear()}`;
+};
+
JSONToDate(/Date(1489525200000)/); // "14/3/2017"
+
+

levenshteinDistance

+

Calculates the Levenshtein distance between two strings.

+

Calculates the number of changes (substitutions, deletions or additions) required to convert string1 to string2. +Can also be used to compare two strings as shown in the second example.

+
const levenshteinDistance  = (string1, string2) => {
+    if(string1.length === 0) return string2.length;
+    if(string2.length === 0) return string1.length;
+    let matrix = Array(string2.length + 1).fill(0).map((x,i) => [i]);
+    matrix[0] = Array(string1.length + 1).fill(0).map((x,i) => i);
+    for(let i = 1; i <= string2.length; i++){
+        for(let j = 1; j<=string1.length; j++){
+            if(string2[i-1] === string1[j-1]){
+                matrix[i][j] = matrix[i-1][j-1];
+            }
+            else{
+                matrix[i][j] = Math.min(matrix[i-1][j-1]+1, matrix[i][j-1]+1, matrix[i-1][j]+1);
+            }
+        }
+    }
+    return matrix[string2.length][string1.length];
+};
+
levenshteinDistance('30-seconds-of-code','30-seconds-of-python-code'); // 7
+const compareStrings = (string1,string2) => (100 - levenshteinDistance(string1,string2) / Math.max(string1.length,string2.length));
+compareStrings('30-seconds-of-code', '30-seconds-of-python-code'); // 99.72 (%)
+
+

quickSort

+

QuickSort an Array (ascending sort by default).

+

Use recursion. +Use Array.filter and spread operator (...) to create an array that all elements with values less than the pivot come before the pivot, and all elements with values greater than the pivot come after it. +If the parameter desc is truthy, return array sorts in descending order.

+
const quickSort = ([n, ...nums], desc) =>
+  isNaN(n)
+    ? []
+    : [
+        ...quickSort(nums.filter(v => (desc ? v > n : v <= n)), desc),
+        n,
+        ...quickSort(nums.filter(v => (!desc ? v > n : v <= n)), desc)
+      ];
+
quickSort([4, 1, 3, 2]); // [1,2,3,4]
+quickSort([4, 1, 3, 2], true); // [4,3,2,1]
+
+

removeVowels

+

Returns all the vowels in a str replaced by repl.

+

Use String.replace() with a regexp to replace all vowels in str. +Omot repl to use a default value of ''.

+
const removeVowels = (str, repl = '') => str.replace(/[aeiou]/gi,repl);
+
removeVowels("foobAr"); // "fbr"
+removeVowels("foobAr","*"); // "f**b*r"
+
+

solveRPN

+

Solves the given mathematical expression in reverse polish notation. +Throws appropriate errors if there are unrecognized symbols or the expression is wrong. The valid operators are :- +,-,*,/,^,** (^&** are the exponential symbols and are same). This snippet does not supports any unary operators.

+

Use a dictionary, OPERATORS to specify each operator's matching mathematical operation. +Use String.replace() with a regular expression to replace ^ with **, String.split() to tokenize the string and Array.filter() to remove empty tokens. +Use Array.forEach() to parse each symbol, evaluate it as a numeric value or operator and solve the mathematical expression. +Numeric values are converted to floating point numbers and pushed to a stack, while operators are evaluated using the OPERATORS dictionary and pop elements from the stack to apply operations.

+
const solveRPN = rpn => {
+  const OPERATORS = {
+    '*': (a, b) => a * b,
+    '+': (a, b) => a + b,
+    '-': (a, b) => a - b,
+    '/': (a, b) => a / b,
+    '**': (a, b) => a ** b
+  };
+  const [stack, solve] = [
+    [],
+    rpn
+      .replace(/\^/g, '**')
+      .split(/\s+/g)
+      .filter(el => !/\s+/.test(el) && el !== '')
+  ];
+  solve.forEach(symbol => {
+    if (!isNaN(parseFloat(symbol)) && isFinite(symbol)) {
+      stack.push(symbol);
+    } else if (Object.keys(OPERATORS).includes(symbol)) {
+      const [a, b] = [stack.pop(), stack.pop()];
+      stack.push(OPERATORS[symbol](parseFloat(b), parseFloat(a)));
+    } else {
+      throw `${symbol} is not a recognized symbol`;
+    }
+  });
+  if (stack.length === 1) return stack.pop();
+  else throw `${rpn} is not a proper RPN. Please check it and try again`;
+};
+
solveRPN('15 7 1 1 + - / 3 * 2 1 1 + + -'); // 5
+solveRPN('2 3 ^'); // 8
+
+

speechSynthesis

+

Performs speech synthesis (experimental).

+

Use SpeechSynthesisUtterance.voice and window.speechSynthesis.getVoices() to convert a message to speech. +Use window.speechSynthesis.speak() to play the message.

+

Learn more about the SpeechSynthesisUtterance interface of the Web Speech API.

+
const speechSynthesis = message => {
+  const msg = new SpeechSynthesisUtterance(message);
+  msg.voice = window.speechSynthesis.getVoices()[0];
+  window.speechSynthesis.speak(msg);
+};
+
speechSynthesis('Hello, World'); // // plays the message
+
diff --git a/docs/index.html b/docs/index.html index b3bdc1b95..22c9b9683 100644 --- a/docs/index.html +++ b/docs/index.html @@ -46,7 +46,7 @@
-

19462
stars

+

19461
stars

@@ -76,38 +76,38 @@
-

byteSize

-

Returns the length of a string in bytes.

-

Convert a given string to a Blob Object and find its size.

-
const byteSize = str => new Blob([str]).size;
-
byteSize('😀'); // 4
-byteSize('Hello World'); // 11
+      
reduceWhich

+
Returns the minimum/maximum value of an array, after applying the provided function to set comparing rule.

+
Use Array.reduce() in combination with the comparator function to get the appropriate element in the array.
+You can omit the second parameter, comparator, to use the default one that returns the minimum element in the array.

+
const reduceWhich = (arr, comparator = (a, b) => a - b) =>
+  arr.reduce((a, b) => (comparator(a, b) >= 0 ? b : a));
+
reduceWhich([1, 3, 2]); // 1
+reduceWhich([1, 3, 2], (a, b) => b - a); // 3
+reduceWhich(
+  [{ name: 'Tom', age: 12 }, { name: 'Jack', age: 18 }, { name: 'Lucy', age: 9 }],
+  (a, b) => a.age - b.age
+); // {name: "Lucy", age: 9}
 

-
hashNode

-
Creates a hash for a value using the SHA-256 algorithm. Returns a promise.

-
Use crypto API to create a hash for the given value.

-
const crypto = require('crypto');
-const hashNode = val =>
-  new Promise(resolve =>
-    setTimeout(
-      () =>
-        resolve(
-          crypto
-            .createHash('sha256')
-            .update(val)
-            .digest('hex')
-        ),
-      0
-    )
+
uniqueElements

+
Returns all unique values of an array.

+
Use ES6 Set and the ...rest operator to discard all duplicated values.

+
const uniqueElements = arr => [...new Set(arr)];
+
uniqueElements([1, 2, 2, 3, 4, 4, 5]); // [1,2,3,4,5]
+

+
unzip

+
Creates an array of arrays, ungrouping the elements in an array produced by zip.

+
Use Math.max.apply() to get the longest subarray in the array, Array.map() to make each element an array.
+Use Array.reduce() and Array.forEach() to map grouped values to individual arrays.

+
const unzip = arr =>
+  arr.reduce(
+    (acc, val) => (val.forEach((v, i) => acc[i].push(v)), acc),
+    Array.from({
+      length: Math.max(...arr.map(x => x.length))
+    }).map(x => [])
   );
-
hashNode(JSON.stringify({ a: 'a', b: [1, 2, 3, 4], foo: { c: 'bar' } })).then(console.log); // '04aa106279f5977f59f9067fa9712afc4aedc6f5862a8defc34552d8c7206393'
-

-
take

-
Returns an array with n elements removed from the beginning.

-
Use Array.slice() to create a slice of the array with n elements taken from the beginning.

-
const take = (arr, n = 1) => arr.slice(0, n);
-
take([1, 2, 3], 5); // [1, 2, 3]
-take([1, 2, 3], 0); // []
+
unzip([['a', 1, true], ['b', 2, false]]); //[['a', 'b'], [1, 2], [true, false]]
+unzip([['a', 1, true], ['b', 2]]); //[['a', 'b'], [1, 2], [true]]
 

 

       

diff --git a/scripts/web.js b/scripts/web.js
index 384212d9d..93f3c0406 100644
--- a/scripts/web.js
+++ b/scripts/web.js
@@ -282,28 +282,30 @@ try {
   process.exit(1);
 }
 
-// Create the output for the beginner.html file
+// Create the output for the archive.html file
 try {
   // Add the static part
-  beginnerOutput += `${beginnerStartPart + '\n'}`;
+  archivedOutput += `${archivedStartPart + '\n'}`;
 
-  // Filter begginer snippets
-  const filteredBeginnerSnippets = Object.keys(snippets)
-    .filter(key => beginnerSnippetNames.map(name => name+'.md').includes(key))
+  // Filter README.md from folder
+  const excludeFiles = ['README.md'];
+
+  const filteredArchivedSnippets = Object.keys(archivedSnippets)
+    .filter(key => !excludeFiles.includes(key))
     .reduce((obj, key) => {
-      obj[key] = snippets[key];
+      obj[key] = archivedSnippets[key];
     return obj;
   }, {});
 
-  for (let snippet of Object.entries(filteredBeginnerSnippets))
-        beginnerOutput +=
+  // Generate archived snippets from md files
+  for (let snippet of Object.entries(filteredArchivedSnippets))
+        archivedOutput +=
         '
' +
         '
' +
           '
' +
           md
-            .render(`\n${snippets[snippet[0]]}`)
+            .render(`\n${filteredArchivedSnippets[snippet[0]]}`)
             .replace(/
/g, `${snippet[1].includes('advanced')?'advanced':''}
`)
             .replace(/<\/h3>/g, '
')
             .replace(/
([^\0]*?)<\/code><\/pre>/gm, (match, p1) => `
${Prism.highlight(unescapeHTML(p1), Prism.languages.javascript)}
`)
             .replace(/<\/pre>\s+
';
 
         // Optimize punctuation nodes
-        beginnerOutput = util.optimizeNodes(beginnerOutput, /([^\0<]*?)<\/span>([\n\r\s]*)([^\0]*?)<\/span>/gm, (match, p1, p2, p3)  => `${p1}${p2}${p3}`);
+        archivedOutput = util.optimizeNodes(archivedOutput, /([^\0<]*?)<\/span>([\n\r\s]*)([^\0]*?)<\/span>/gm, (match, p1, p2, p3)  => `${p1}${p2}${p3}`);
         // Optimize operator nodes
-        beginnerOutput = util.optimizeNodes(beginnerOutput, /([^\0<]*?)<\/span>([\n\r\s]*)([^\0]*?)<\/span>/gm, (match, p1, p2, p3)  => `${p1}${p2}${p3}`);
+        archivedOutput = util.optimizeNodes(archivedOutput, /([^\0<]*?)<\/span>([\n\r\s]*)([^\0]*?)<\/span>/gm, (match, p1, p2, p3)  => `${p1}${p2}${p3}`);
         // Optimize keyword nodes
-        beginnerOutput = util.optimizeNodes(beginnerOutput, /([^\0<]*?)<\/span>([\n\r\s]*)([^\0]*?)<\/span>/gm, (match, p1, p2, p3)  => `${p1}${p2}${p3}`);
+        archivedOutput = util.optimizeNodes(archivedOutput, /([^\0<]*?)<\/span>([\n\r\s]*)([^\0]*?)<\/span>/gm, (match, p1, p2, p3)  => `${p1}${p2}${p3}`);
 
 
-  beginnerOutput += `${beginnerEndPart}`;
+        archivedOutput += `${archivedEndPart}`;
 
   // Generate 'beginner.html' file
-  fs.writeFileSync(path.join(docsPath, 'beginner.html'), beginnerOutput);
-  console.log(`${chalk.green('SUCCESS!')} beginner.html file generated!`);
+  fs.writeFileSync(path.join(docsPath, 'archive.html'), archivedOutput);
+  console.log(`${chalk.green('SUCCESS!')} archive.html file generated!`);
 
 } catch (err) {
-  console.log(`${chalk.red('ERROR!')} During beginner.html generation: ${err}`);
+  console.log(`${chalk.red('ERROR!')} During archive.html generation: ${err}`);
   process.exit(1);
 }