``````let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 2, 3, 4, 5, 7, 7];

// better SWITCH method
var value = 'otherValue';
const result = {
someValue: 'something',
otherValue: 'another'
}[value] || 'default';
result; // 'another'

// Random number (returns number between a & b or between 0 and a)
function randomNum(a, b) {
if (b === undefined) return Math.random() * a;
return a + Math.random() * (b - a);
}
randomNum(3, 6); // between 3 - 6

// Clamp number (if lower make it min, if hihger make max)
function clampNum(num, min, max) {
return num < min ? min : num > max ? max : num;
}
clampNum(37, 1, 36); // 36

// Comma large numbers
function commasNum(num) {
const parts = String(num).split('.');
parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ',');
return parts.join('.');
}
commasNum(123456789); // '123,456,789'

// Does number divide by a and b?
function isDivideBy(number, a, b) {
return [a, b].every(i => number % i === 0)
}
isDivideBy(9, 1, 3); // true

// Below we will define an n-interesting polygon. Your task is to find the area of a polygon for a given n.
function shapeArea(n) {
if(n === 1) return 1;
return 4 * (n-1) + shapeArea(n-1);
}
shapeArea(3); // 13

// Is palindrome
function checkPalindrome(inputString) {
for(var i=0; i < inputString.length/2; i++){
if(inputString[i] !== inputString[inputString.length - i - 1]) return false;
}

return true;
}
checkPalindrome('rotor'); // true

// Century from year
function centuryFromYear(year) {
return Math.floor((year-1) / 100)+1;
}
centuryFromYear(2020); // 21

// Given a decimal integer n, find an integer k ≥ 2 such that the representation of n in base k
// has the maximum possible number of zeros. If there are several answers, output the smallest one.
function maxZeros(n) {
var base = 2;
var maxZeros = 0;
var result = 2;
while(base < 16){
var x = n.toString(base);
var zeroes = x.split('').filter(i => i==='0').length;
if(zeroes > maxZeros){
maxZeros = zeroes;
result = base;
}
base++;
}
return result;
}
maxZeros(33); // 2

// xor
function xor(a, b) {
var res = a;
for(var i=a+1; i<=b; i++){
res ^= i;
}
return res;
}
xor(9, 18); // 27

// NAND operation
function shefferStroke(a, b) {
return !a || !b;
}
shefferStroke(false, false); // true

// Sum of factors until n is different
function factorSum(n) {
allPrimes = (n) => {
var arr = [];
var div = 2;
while(n !== 1){
while(n % div === 0){
arr.push(div);
n /= div;
}
div++
}
return arr;
}

isPrime = (n) => {
for(var i=2; i<n; i++){
if(n % i === 0) return false;
}
return true;
}

var last = 0;
while(!isPrime(n) && last!==n){
last = n;
n = allPrimes(n).reduce((acc, item) => acc+=item, 0);
}
return n;
}
factorSum(32); //7

// Given an array of integers, find the rightmost round number in it and output its position in the array (0-based).
// If there are no round numbers in the given array, output -1.
function rightmostRoundNumber(inputArray) {
for(var i=inputArray.length-1; i>=0; i--){
if(inputArray[i] % 10 === 0) return i;
}
return -1;
}
rightmostRoundNumber(arr); // 9

// Given an array of integers, find the pair of adjacent elements that has the largest product and return that product.
var max = -9999999;
for(var i=0; i<inputArray.length-1; i++){
var curr = inputArray[i] * inputArray[i+1];
if(curr > max) max = curr;
}
return max;
}

// Given a set of complex values, find their product.
function arrayComplexElementsProduct(real, imag) {
var x = [real[0], imag[0]];
for(var i=1; i<real.length; i++){
var temp = x;
x = [x[0] * real[i] - x[1] * imag[i], x[0] * imag[i] + x[1] * real[i]];
}
return x;
}

// Given a square matrix, your task is to reverse the order of elements on both of its longest diagonals.
function reverseOnDiagonals(matrix) {
for(var i=0; i<matrix.length; i++){
for(var j=0; j<matrix.length / 2; j++){
if(i === j){
var temp = matrix[i][j];
matrix[i][j] = matrix[matrix.length - i - 1][matrix.length - i - 1];
matrix[matrix.length - i - 1][matrix.length - i - 1] = temp;
}
if(i + j === matrix.length - 1){
var temp = matrix[i][j];
matrix[i][j] = matrix[j][i];
matrix[j][i] = temp;
}
}
}

return matrix;
}

// Given an integer, check if it is an increasing digits sequence.
function isIncreasingDigitsSequence(n) {
n = n.toString().split('').map(Number);
for(var i=0; i<n.length -1; i++){
if(n[i+1] <= n[i]) return false;
}
return true;
}
isIncreasingDigitsSequence(321); // false

// Perfect array is an array in which each element is equal to the length of this array. Check if a given array is perfect.
function perfectArray(A) {
var len = A.length;
return A.every(i => i===len);
}

// Digits from Math.abs(a[i+1] - a[i])
function digitDistanceNumber(n) {
var res = [];
n = n.toString().split('').map(Number);
for(var i=0; i<n.length-1; i++){
res.push(Math.abs(n[i+1] - n[i]));
}
return parseInt(res.join(''), 10);
}

// Given a string, find out if its characters can be rearranged to form a palindrome.
function palindromeRearranging(inputString) {
var count = {};
inputString.split('').forEach(cr => {
count[cr] = (count[cr] || 0) + 1;
})

var numberOfOdds = 0;
for(key in count){
if(count[key] % 2 === 1) numberOfOdds++;
}

return numberOfOdds < 2;
}
palindromeRearranging('toror'); // true

// Given an integer n, find the value of phi(n), where phi is Euler's totient function
function eulersTotientFunction(n) {

// Greatest common divisor
gcd = (a,b) => {
if(!a) return b;
return gcd(b%a, a);
}

var count = 0;
for(var i=1; i<=n; i++){
if(gcd(i, n) === 1) count++;
}
return count;
}

// Cool strings
// Let's call a string cool if it is formed only by Latin letters and no
// two lowercase and no two uppercase letters are in adjacent positions. Given a string, check if it is cool.
function coolString(inputString) {
isLower = (c) => {
return c === c.toLowerCase();
}

isUpper = (c) => {
return c === c.toUpperCase();
}

if(/[\W\d]/.test(inputString)) return false;
for(var i=0; i<inputString.length - 1; i++){
var curr = inputString[i];
var next = inputString[i+1];
if(isLower(curr) && isLower(next) || isUpper(curr) && isUpper(next)) return false;
}
return true;
}

// Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7.
function isLuckyNumber(n) {
return n.toString().split('').every(i => i==='4' || i==='7');
}

// Determine if a number is prime
isPrime = (n) => {
for(var i=2; i<n; i++){
if(n % i === 0) return false;
}
return true;
}

// Given a ciphered string, return the initial one if it is known that it consists only of lowercase letters.
function decipher(cipher) {
var len = 1;
var i = 0;
var res = [];
cipher = cipher.split('');
while(cipher.length > 0){
var curr = '';
while(curr < 97){
len++;
curr = parseInt(cipher.slice(0, len).join(''),10);
}
cipher.splice(0, len);
len = 0;
res.push(String.fromCharCode(curr));
}
return res.join('');
}

// Two arrays are called similar if one can be obtained from another
// by swapping at most one pair of elements in one of the arrays.
function areSimilar(A, B) {
var pairs = 0;
var falseA = [];
var falseB = [];
for(var i=0; i<A.length; i++){
if(A[i] !== B[i]){
pairs++;
falseA.push(A[i]);
falseB.push(B[i]);
}
if(pairs > 2) return false;
}
return falseA.sort((a,b) => a-b).join('') === falseB.sort((a,b) => a-b).join('');
}

// Given a positive integer number and a certain length, we need to modify the given number to have a specified length.
// We are allowed to do that either by cutting out leading digits
// (if the number needs to be shortened) or by adding 0s in front of the original number.
function integerToStringOfFixedWidth(number, width) {
number = '00000' + number;
return number.substr(-width);
}

var count = 0;
if(vote + k > max) count++;
});
return k === 0 ? votes.indexOf(max) === votes.lastIndexOf(max) ? 1 : 0 : count;
}

// Timed reading. Boy reading box if word length is less than or equal to maxLenght
var res = text.match(/[a-zA-Z]+/g);
return res === null ? 0 : res.filter(i => i.length <= maxLength).length;
}

// Switch lights if candle is lit
function switchLights(a) {
a = a.map(i => i===1);
for(var i=0; i<a.length; i++){
if(a[i]){
for(var j=0; j<=i; j++){
a[j] = !a[j];
}
}
}
return a.map(i => i ? 1 : 0);

// OR
for(var i=0; i<a.length; i++){
if(a[i]){
for(var j=0; j<=i; j++){
a[j] = a[j] === 1 ? 0 : 1;
}
}
}
return a;
}

// Add border of * to a given array of strings
return [
new Array(picture[0].length + 2).fill('*').join(''),
...picture.map(img => '*'+img+'*'),
new Array(picture[0].length + 2).fill('*').join('')
]
}

// Banana land buying bananas with coins
function minimalNumberOfCoins(coins, price) {
var count = 0;
var i = coins.length - 1;
while(price > 0 && i > -1){
if(price - coins[i] >= 0) {
price -= coins[i];
count++;
} else {
i--;
}
console.log(price, coins[i])
}
return count;
}

// Check whether the given string is a subsequence of the plaintext alphabet.
function alphabetSubsequence(s) {
for(var i=0; i<s.length - 1; i++){
if(s.charCodeAt(i) >= s.charCodeAt(i+1)) return false;
}
return true;
}

// There are some people and cats in a house. You are given the number of legs they have all together.
// Your task is to return an array containing every possible number of people that could be in the house sorted in ascending order.
function houseOfCats(legs) {
var res = [];
var subtract = 0;
while(subtract <= legs){
res.push((legs - subtract) / 2);
subtract += 4;
}
return res.reverse();
}

// Given an array of strings, return another array containing all of its longest strings.
function allLongestStrings(inputArray) {
var max = Math.max(...inputArray.map(i => i.length));
return inputArray.filter(i => i.length === max);
}

// How many strings equal to A can be constructed using letters from the string B?
// Each letter can be used only once and in one string only.
function stringsConstruction(A, B) {
B = B.split('').sort();
A = A.split('').sort();
var times = Math.floor(B.length / A.length);
var full = 0;

for(var q=0; q<times; q++){
var count = 0;

for(var i=0; i<A.length; i++){
if(B.indexOf(A[i]) > -1){
count++;

B.splice(B.indexOf(A[i]), 1);
} else {
break;
}
}

if(count === A.length){
full++;
}
}

return full;
}

var res = inputString.split('-')

return res.length === 6 && res.every(part => /^[0-9A-F]{2}\$/.test(part));
}

// Given a sequence of non-negative integers, find its median.
function arrayMedian(sequence) {
sequence.sort((a,b) => a-b);

if(sequence.length % 2 === 0){
return (sequence[sequence.length / 2] +sequence[sequence.length / 2 - 1]) / 2
}

return sequence[Math.floor(sequence.length / 2)]
}

// Replace each digits with #
function replaceAllDigitsRegExp(input) {
return input.replace(/[0-9]/g,'#');
}

// Number of even digits of an integer
function numberOfEvenDigits(n) {
return n.toString().split('').map(Number).filter(i => i%2==0).length;
}

// Coffee at a vending machine
function coffeeVendingMachine(number){
var coffee = ['French Roast', 'Colombian', 'Kona'];
return cofee(number-1);
}

// Tennis game scores
function tennisSet(score1, score2) {
if(score1 === 6 && score2 < 5 || score2 === 6 && score1 < 5) return true;
if(score1 === 7 && (score2 === 6 || score2 === 5)) return true;
if(score2 === 7 && (score1 === 6 || score1 === 5)) return true;
return false
}

// Special numbers from l to r
function specialNumbers(l, r) {
var count = 0;
for(var i=l; i<=r; i++){
if(specialNumber(i)) count++;
}
return count;
}

// A number is considered special, if it remains the same (and continues being a valid number) when rotated by 180°.
isSpecial = (n) => {
var arr = n.toString().split('').filter(i => i!= '');
for(var i=0; i<arr.length / 2; i++){
if(arr[i] === '9' || arr[i] === '8' || arr[i] === '6' || arr[i] === '0'){
if(arr[i] === '9' && arr[arr.length-i-1] !== '6') return false;
if(arr[i] === '6' && arr[arr.length-i-1] !== '9') return false;
if(arr[i] === '8' && arr[arr.length-i-1] !== '8') return false;
if(arr[i] === '0' && arr[arr.length-i-1] !== '0') return false;
} else {
return false;
}
}
return true;
}

// Correct variable name using regex
function variableName(name) {
return name.match(/^[a-zA-Z_]+[a-zA-Z0-9_]*/) === null ? false : name.match(/^[a-zA-Z_]+[a-zA-Z0-9_]*/)[0].length === name.length;
}

// Given an array of integers, find the number of inversions it contains.
function countInversionsNaive(inputArray) {
var count = 0
for(var i=0; i<inputArray.length; i++){
for(var j=i+1; j<inputArray.length; j++){
if(inputArray[i] > inputArray[j]) count++;
}
}

return count;
}

// Mixed fraction from reduced improper fraction
function improperFractionToMixed(a) {
return [Math.floor(a[0] / a[1]), a[0] % a[1], a[1]];
}

// Magical well, marble a, b
function magicalWell(a, b, n) {
var sum = 0;
var i = 0;
while(i < n){
sum += a * b;
a++;
b++;
i++;
}

return sum;
}

// Decipher Mad Coder evil genius. Check bit if it is 1 and change to 0
function killKthBit(n, k) {
n = n.toString(2).split('').reverse();
if(n[k-1] === '1') n[k-1] ='0';
return parseInt(n.reverse().join(''), 2)
}

// Hamming distance
function hammingDistance(string1, string2) {
var count = 0;
for(var i=0; i<string1.length; i++){
if(string1[i] !== string2[i]) count++;
}
return count;
}

// Compare 2 given fractions
function fractionComparison(A, B) {
var a = A[0] / A[1];
var b = B[0] / B[1];

return a > b ? '>' : a < b ? '<' : '=';
}

//Given an array A of integers construct an array B of the same length as A such that
function suffixSums(A) {
var B = [];
for(var i=0; i<A.length; i++){
var sum = 0;
for(var j=i; j<A.length; j++){
sum += A[j];
}
B.push(sum);
}
return B;
}

// If left or right or left+right divisible by 3, remove. Until s.length > 0 or operation can't be done.
function truncateString(s) {
s = s.split('');

while(s.length > 0){
var left = parseInt(s[0],10);
var right = parseInt(s[s.length-1],10);

if(left % 3 === 0) s.shift();
else if(right % 3 === 0) s.pop();

else if((left + right) % 3 === 0){
s.shift();
s.pop();
}
else {
break;
}
}

return s.join('')
}

// different pairs of numbers summing to n from l to r
function pairsLR(n, l ,r){
var count = 0;
for(var i=l i<=r; i++){
for(var j=i; j<=r; j++){
if(i + j === r) count++;
}
}
return count;
}

// Sequence of different numbers after squaring the digits:
function squareDigitsSequence(a0) {
var arr = [a0];
while(arr.indexOf(sumDigSquared(a0)) === -1){
a0 = sumDigSquared(a0)
arr.push(a0)
}
return arr.length + 1;
}

sumDigSquared = (n) => {
return n.toString().split('').map(Number).reduce((acc, item) => acc+=item*item, 0);
}

// Find the number of ways to express n as sum of some (at least two) consecutive positive integers.
function isSumOfConsecutive2(n) {
var count = 0;
for(var i=n-1; i>=1; i--){
if(n - i > 0){
var j = i;
var m = n;
while(m - j >= 0 && j > 0){
m-=j;
j--;
}
if(m === 0) count++;
}
}

return count;
}

// Candles
function candles(candlesNumber, makeNew) {
var total = candlesNumber;
var left = 0;
while(true){
left += candlesNumber;
candlesNumber = Math.floor(left / makeNew);
left %= makeNew;
total += candlesNumber;
if(left + candlesNumber < makeNew) break;
}

}

// Rounders -> We want to turn the given integer into a number that has only one non-zero digit using a tail rounding approach
function rounders(value) {
var arr = value.toString().split('').map(Number).reverse();

for(var i=0; i<arr.length-1; i++){
if(arr[i] >= 5){
arr[i+1]++;
}
arr[i] = 0;
}

return parseInt(arr.reverse().join(''), 10);
}

// Increase number roundness
function increaseNumberRoundness(n) {
while(n % 10 === 0){
n /= 10;
}

return n.toString().split('').some(i => i === '0');
}

// Boxes with red an yellow apples
function appleBoxes(k) {
var yellow = 0;
var red = 0;

for(var i=1; i<=k; i++){
if(i % 2 === 1){
yellow += i*i;
} else {
red += i*i;
}
}

return red - yellow;
}

var res = [];
while(param1 > 0 || param2 > 0){
res.push((param1 + param2) % 10);
param1 = Math.floor(param1 / 10);
param2 = Math.floor(param2 / 10);
}
return parseInt(res.reverse().join(''),10) || 0 // in case we have an empty array;
}

// It is guaranteed that two integers are equal which is the 3rd?
function extraNumber(a, b, c) {
return a^b^c;
}

// Count the number of different edges in a given undirected graph with no loops and multiple edges.
function graphEdges(matrix) {
var count = 0;
for(var i=0; i<matrix.length; i++){
for(var j=0; j<matrix[0].length; j++){
if(matrix[i][j] && matrix[i][j] === matrix[j][i]){
count++;
}
}
}
return count/2;
}

// Swap neightbor digis pairs
function swapNeighbouringDigits(n) {
var arr =  n.toString().split('');
for(var i=0; i<arr.length; i+=2){
var tmp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = tmp;
}
return parseInt(arr.join(''),10);
}

// Longest word in a string
function longestWord(text) {
var mat = text.match(/[a-zA-Z]+/g)
var len = mat.map(i => i.length);
return mat[len.indexOf(Math.max(...len))];
}

// Given a string inputString and an integer distance,
// find the number of pairs of equal characters in the inputString delimited by exactly distance characters.
function countDistantPairs(inputString, distance) {
var count = 0;
for(var i=0; i<inputString.length-1-distance; i++){
if(inputString[i] === inputString[i+1+distance]){
count++;
}
}
return count;
}

// Subtracting by hand
function subtractionByRegrouping(minuend, subtrahend) {
var res =[];
while(minuend > 0){
var x = minuend % 10;
var y = subtrahend % 10;
if(x < y){
x += 10;
minuend -= 10
}
res.push(x);

minuend = Math.floor(minuend/10);
subtrahend = Math.floor(subtrahend/10);
}
return res
}

// Matrix transpose
function matrixTransposition(matrix) {
var m = [];
for(var i=0; i<matrix[0].length; i++){
m[i] = [];
for(var j=0; j<matrix.length; j++){
m[i][j] = matrix[j][i];
}
}
return m
}

// Given a position of a knight on the standard chessboard, find the number of different moves the knight can perform.
function chessKnightMoves(cell) {
var x = cell.charCodeAt(0) - 'a'.charCodeAt(0);
var y = cell.charCodeAt(1) - '1'.charCodeAt(0);

var count = 0;
var dir = [[-2, 1],[-1, 2],[1, 2],[2, 1],[1, -2],[2, -1],[-2, -1],[-1, -2]];
var table = [];

for(var i=0; i<8; i++){
table[i] = [];
for(var j=0; j<8; j++){
if(i === x && j === y){
table[i][j] = 'k'
} else {
table[i][j] = '.';
}
}
}

for(var i=0; i<dir.length; i++){
if(table[dir[i][0] + x]){
if(table[dir[i][0] + x][dir[i][1] + y]){
table[dir[i][0] + x][dir[i][1] + y] = 'x'
count++;
}
}
}

return count;
}

// n-th Fibonacci number
function fibonacciNumber(n) {
var fib = [0, 1];
var f1 = fib[0];
var f2 = fib[1];

while(fib.length <= n){
var temp = f2;
f2 += f1;
f1 = temp;
fib.push(f2);
}

return fib[n];
}
fibonacciNumber(666); // 6.859356963880477e+138

// Given a certain array, find out if it's a permutation of numbers from 1 to a given integer.
function isPermutation(n, inputArray) {
return inputArray.sort((a, b)=> a-b).filter((item, idx) => item === (idx+1)).length === n;
}

// Regular Brackets with only ()
function regularBrackets(brackets){
var equal = 0;
for(var i=0; i<brackets.length; i++){
brackets[i] === '(' ? equal += 1 : equal -= 1;
if( equal === -1) return false;
}
return equal === 0 ? true : false;
}

// All distinct primes of a number
function primeFactors2(n) {
var primes = [];
var div = 2;
while(n !== 1){
if(n % div === 0){
while(n % div === 0){
n /= div;
}
primes.push(div);

}
div++;
}
return primes
}

// Christmas mobile app gift safety by swapping 3 letters
var count = 0;
count++;
}
}
return count;
}

// White bishop black pawn
function bishopAndPawn(bishop, pawn) {
var x1 = bishop.charCodeAt(0) - 'a'.charCodeAt(0);
var x2 = pawn.charCodeAt(0) - 'a'.charCodeAt(0);
var y1 = bishop.charCodeAt(1) - '1'.charCodeAt(0);
var y2 = pawn.charCodeAt(1) - '1'.charCodeAt(0);

return Math.abs(x2 - x1) === Math.abs(y2 - y1)
}

// Check for regular Brackets () [] and {}
function regularBracketSequence2(b) {
var stack = [];
b = b.split('');
for(var i=0; i<b.length; i++){
if(b[i] === '(' || b[i] === '[' || b[i] === '{') {
stack.push(b[i])
} else {
if(stack.length === 0) {
stack.push(b[i])
break;
} else if (b[i] === ')' && stack[stack.length - 1] === '('
|| b[i] === ']' && stack[stack.length - 1] === '['
|| b[i] === '}' && stack[stack.length - 1] === '{'){
stack.pop();
}
}
}

return stack.length === 0;
}

// Most frequent Digit sum
function mostFrequentDigitSum(n) {
var obj = {}
while(n > 0){
var x = sumDig(n)
obj[x] = (obj[x] || 0) + 1;
n -= x;
}

var max = 0;
var nr = 0;
for(key in obj){
if(obj[key] >= max){
max = obj[key];
nr = key;
}
}

return parseInt(nr,10);
}

// Sum of the digis of n
sumDig = (n) => {
return n.toString().split('').map(Number).reduce((acc, item) => acc+=item, 0);
}

// Sum of digits squared
sumDigSquared = (n) => {
return n.toString().split('').map(Number).reduce((acc, item) => acc+=item*item, 0);
}

// Product of the digis of n
productDig = (n) => {
return n.toString().split('').map(Number).reduce((acc, item) => acc*=item, 1);
}

var x = inputString.split('.').filter(i => i!== '' && i>=0 && i<=255);
if(x.length !== 4) return false;

return true;
}

// Given array of integers, find the number of sorted pairs formed by its (different)
// elements such that the second element in the pair is divisible by the first one.
function divisorsPairs(sequence) {
var pairs = [];
for(var i=0; i<sequence.length; i++){
for(var j=i+1; j<sequence.length; j++){
if(sequence[j] % sequence[i] === 0){
pairs.push([sequence[i] , sequence[j]]);
}
}
}
return pairs.length;

// OR
var count = 0;
for(var i=0; i<sequence.length; i++){
for(var j=i+1; j<sequence.length; j++){
if(sequence[j] % sequence[i] === 0){
count++;
}
}
}
return count;
}

// Different multiplication table values
function differentValuesInMultiplicationTable(n, m) {
var mat = [];
for(var i=1; i<=n; i++){
for(var j=1; j<=m; j++){
mat.push(i*j);
}
}

return mat.filter((item, idx, arr) => arr.indexOf(item) === idx).length;
}

// Return only different items from the string
function differentItemsFromString() {
return str.split('').filter((item, idx, arr) => arr.indexOf(item) !== idx).join('');
}

// Message from binary code
function messageBinary(code){
return code.match(/[0-1]{8}/g).map(i => String.fromCharCode(parseInt(i,2))).join('');
}

// Different matrix of length 2x2
function difMatrix(matrix){
var res = []
for(var i=0; i<matrix.length-1; i++){
for(var j=0; j<matrix[0].length-1; j++){
var x = ''+matrix[i][j]+matrix[i+1][j]+matrix[i][j+1]+matrix[i+1][j+1];
res.push(x);
}
}
return res.filter((item, idx, arr) => arr.indexOf(item)===idx).length;
}

return degrees / 180 * Math.PI;
}

return radians / Math.PI * 180;
}

// TIME AGO
function ago(val) {
val = 0 | (Date.now() - val) / 1000;
var unit, length = { second: 60, minute: 60, hour: 24, day: 7, week: 4.35,
month: 12, year: 10000 }, result;

for (unit in length) {
result = val % length[unit];
if (!(val = 0 | val / length[unit]))
return result + ' ' + (result-1 ? unit + 's' : unit);
}
}
ago(new Date('2019-10-11T01:46:25.251Z')); // '1 day'

// Random HEX Color
const randomHexColorCode = () => {
const n = (Math.random() * 0xfffff * 1000000).toString(16);
return '#' + n.slice(0, 6);
};
console.log('Your hex color code is:', randomHexColorCode());

// Pyramid
function pyramid(level){
for(let i=1;i<=level; i+=1){
let emptySpace = ' '.repeat(level - i);
let charcterSpace = '#'.repeat(i * 2 - 1);

console.log(emptyspace + characterSpace + emptySpace);
}
}

// Quick Sort
function quick_sort(array, left, right)
{
if(left < right)
{
var middle=left;
for(var i = left+1; i <=right; ++i)
if(array[i]<array[left])
{
var temp = array[++middle];
array[middle]=array[i];
array[i]=temp;
}
var temp = array[left];
array[left]=array[middle];
array[middle]=temp;
quick_sort(array,left,middle-1);
quick_sort(array,middle+1,right);
}
}
var array=[1,5,2,7,9,2,3,4,5];
console.log("unsorted: ", array);
quick_sort(array,0,array.length-1);
console.log("sorted: ", array);

// ``````