andre/30-seconds-of-code
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'deprecate-archive'

Browse Source 
Resolves #1125
This commit is contained in:
Angelos Chalaris
2020-04-16 11:33:27 +03:00
parent f2e55d7ea7 6eb3e19bf7
commit 47270911ff
47 changed files with 27 additions and 796 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
snippets_archive/celsiusToFahrenheit.md → snippets/celsiusToFahrenheit.md
View File

@ -3,7 +3,7 @@ title: celsiusToFahrenheit
tags: math,beginner
---
Celsius to Fahrenheit temperature conversion.
Converts Celsius to Fahrenheit.
Follows the conversion formula `F = 1.8C + 32`.
@ -13,4 +13,4 @@ const celsiusToFahrenheit = degrees => 1.8 * degrees + 32;
```js
celsiusToFahrenheit(33) // 91.4
```
```

4
snippets_archive/fahrenheitToCelsius.md → snippets/fahrenheitToCelsius.md
View File

@ -3,7 +3,7 @@ title: fahrenheitToCelsius
tags: math,beginner
---
Fahrenheit to Celsius temperature conversion.
Converts Fahrenheit to Celsius.
Follows the conversion formula `C = (F - 32) * 5/9`.
@ -13,4 +13,4 @@ const fahrenheitToCelsius = degrees => (degrees - 32) * 5/9;
```js
fahrenheitToCelsius(32); // 0
```
```

10
snippets_archive/httpDelete.md → snippets/httpDelete.md
View File

@ -1,6 +1,6 @@
---
title: httpDelete
tags: browser,intermediate
tags: utility,url,browser,intermediate
---
Makes a `DELETE` request to the passed URL.
@ -21,7 +21,9 @@ const httpDelete = (url, callback, err = console.error) => {
```
```js
httpDelete('https://website.com/users/123', request => {
httpDelete('https://jsonplaceholder.typicode.com/posts/1', request => {
console.log(request.responseText);
}); // 'Deletes a user from the database'
```
}); /*
Logs: {}
*/
```

22
snippets_archive/httpPut.md → snippets/httpPut.md
View File

@ -1,6 +1,6 @@
---
title: httpPut
tags: browser,intermediate
tags: utility,url,browser,intermediate
---
Makes a `PUT` request to the passed URL.
@ -24,8 +24,20 @@ const httpPut = (url, data, callback, err = console.error) => {
```js
const password = "fooBaz";
const data = JSON.stringify(password);
httpPut('https://website.com/users/123', data, request => {
const data = JSON.stringify({
id: 1,
title: 'foo',
body: 'bar',
userId: 1
});
httpPut('https://jsonplaceholder.typicode.com/posts/1', data, request => {
console.log(request.responseText);
}); // 'Updates a user's password in database'
```
}); /*
Logs: {
id: 1,
title: 'foo',
body: 'bar',
userId: 1
}
*/
```

0
snippets_archive/objectToEntries.md → snippets/objectToEntries.md
View File

19
snippets_archive/JSONToDate.md
View File

@ -1,19 +0,0 @@
---
title: JSONToDate
tags: object,date,beginner
---
Converts a JSON object to a date.
Use `Date()`, to convert dates in JSON format to readable format (`dd/mm/yyyy`).
```js
const JSONToDate = arr => {
const dt = new Date(parseInt(arr.toString().substr(6)));
return `${dt.getDate()}/${dt.getMonth() + 1}/${dt.getFullYear()}`;
};
```
```js
JSONToDate(/Date(1489525200000)/); // "14/3/2017"
```

27
snippets_archive/binarySearch.md
View File

@ -1,27 +0,0 @@
---
title: binarySearch
tags: algorithm,beginner
---
Use recursion. Similar to `Array.prototype.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.prototype.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`.
```js
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;
};
```
```js
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
```

27
snippets_archive/cleanObj.md
View File

@ -1,27 +0,0 @@
---
title: cleanObj
tags: object,beginner
---
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.
```js
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;
};
```
```js
const testObj = { a: 1, b: 2, children: { a: 1, b: 2 } };
cleanObj(testObj, ['a'], 'children'); // { a: 1, children : { a: 1}}
```

16
snippets_archive/collatz.md
View File

@ -1,16 +0,0 @@
---
title: collatz
tags: math,beginner
---
Applies the Collatz algorithm.
If `n` is even, return `n/2`. Otherwise, return `3n+1`.
```js
const collatz = n => (n % 2 === 0 ? n / 2 : 3 * n + 1);
```
```js
collatz(8); // 4
```

17
snippets_archive/countVowels.md
View File

@ -1,17 +0,0 @@
---
title: countVowels
tags: string,beginner
---
Returns `number` of vowels in provided string.
Use a regular expression to count the number of vowels `(A, E, I, O, U)` in a `string`.
```js
const countVowels = str => (str.match(/[aeiou]/gi) || []).length;
```
```js
countVowels('foobar'); // 3
countVowels('gym'); // 0
```

45
snippets_archive/factors.md
View File

@ -1,45 +0,0 @@
---
title: factors
tags: math,intermediate
---
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.prototype.map()` and `Array.prototype.filter()` to find all the factors of `num`.
If given `num` is negative, use `Array.prototype.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.prototype.filter()`.
Omit the second argument, `primes`, to return prime and non-prime factors by default.
**Note**:- _Negative numbers are not considered prime._
```js
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;
};
```
```js
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]
```

17
snippets_archive/fibonacciCountUntilNum.md
View File

@ -1,17 +0,0 @@
---
title: fibonacciCountUntilNum
tags: math,beginner
---
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`.
```js
const fibonacciCountUntilNum = num =>
Math.ceil(Math.log(num * Math.sqrt(5) + 1 / 2) / Math.log((Math.sqrt(5) + 1) / 2));
```
```js
fibonacciCountUntilNum(10); // 7
```

24
snippets_archive/fibonacciUntilNum.md
View File

@ -1,24 +0,0 @@
---
title: fibonacciUntilNum
tags: math,intermediate
---
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.prototype.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.
```js
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),
[]
);
};
```
```js
fibonacciUntilNum(10); // [ 0, 1, 1, 2, 3, 5, 8 ]
```

21
snippets_archive/heronArea.md
View File

@ -1,21 +0,0 @@
---
title: heronArea
tags: math,beginner
---
Returns the area of a triangle using only the 3 side lengths, Heron's formula. Assumes that the sides define a valid triangle. Does NOT assume it is a right triangle.
More information on what Heron's formula is and why it works available here: https://en.wikipedia.org/wiki/Heron%27s_formula.
Uses `Math.sqrt()` to find the square root of a value.
```js
const heronArea = (side_a, side_b, side_c) => {
const p = (side_a + side_b + side_c) / 2
return Math.sqrt(p * (p-side_a) * (p-side_b) * (p-side_c))
};
```
```js
heronArea(3, 4, 5); // 6
```

32
snippets_archive/howManyTimes.md
View File

@ -1,32 +0,0 @@
---
title: howManyTimes
tags: math,beginner
---
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`.
```js
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;
};
```
```js
howManyTimes(100, 2); // 2
howManyTimes(100, 2.5); // 2
howManyTimes(100, 0); // 0
howManyTimes(100, -1); // Infinity
```

20
snippets_archive/isArmstrongNumber.md
View File

@ -1,20 +0,0 @@
---
title: isArmstrongNumber
tags: math,beginner
---
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`.
```js
const isArmstrongNumber = digits =>
(arr => arr.reduce((a, d) => a + parseInt(d) ** arr.length, 0) == digits)(
(digits + '').split('')
);
```
```js
isArmstrongNumber(1634); // true
isArmstrongNumber(56); // false
```

25
snippets_archive/isSimilar.md
View File

@ -1,25 +0,0 @@
---
title: isSimilar
tags: string,intermediate
---
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](https://github.com/forrestthewoods/lib_fts/blob/80f3f8c52db53428247e741b9efe2cde9667050c/code/fts_fuzzy_match.js#L18).
```js
const isSimilar = (pattern, str) =>
[...str].reduce(
(matchIndex, char) =>
char.toLowerCase() === (pattern[matchIndex] || '').toLowerCase()
? matchIndex + 1
: matchIndex,
0
) === pattern.length;
```
```js
isSimilar('rt','Rohit'); // true
isSimilar('tr','Rohit'); // false
```

17
snippets_archive/kmphToMph.md
View File

@ -1,17 +0,0 @@
---
title: kmphToMph
tags: math,beginner
---
Convert kilometers/hour to miles/hour.
Multiply the constant of proportionality with the argument.
```js
const kmphToMph = (kmph) => 0.621371192 * kmph;
```
```js
kmphToMph(10); // 16.09344000614692
kmphToMph(345.4); // 138.24264965280207
```

42
snippets_archive/levenshteinDistance.md
View File

@ -1,42 +0,0 @@
---
title: levenshteinDistance
tags: algorithm,advanced
---
Calculates the [Levenshtein distance](https://en.wikipedia.org/wiki/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.
```js
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];
};
```
```js
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 (%)
```

17
snippets_archive/mphToKmph.md
View File

@ -1,17 +0,0 @@
---
title: mphToKmph
tags: math,beginner
---
Convert miles/hour to kilometers/hour.
Multiply the constant of proportionality with the argument.
```js
const mphToKmph = (mph) => 1.6093440006146922 * mph;
```
```js
mphToKmph(10); // 16.09344000614692
mphToKmph(85.9); // 138.24264965280207
```

16
snippets_archive/pipeLog.md
View File

@ -1,16 +0,0 @@
---
title: pipeLog
tags: utility,beginner
---
Logs a value and returns it.
Use `console.log` to log the supplied value, combined with the `||` operator to return it.
```js
const pipeLog = data => console.log(data) || data;
```
```js
pipeLog(1); // logs `1` and returns `1`
```

26
snippets_archive/quickSort.md
View File

@ -1,26 +0,0 @@
---
title: quickSort
tags: algorithm,recursion,beginner
---
QuickSort an Array (ascending sort by default).
Use recursion.
Use `Array.prototype.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.
```js
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)
];
```
```js
quickSort([4, 1, 3, 2]); // [1,2,3,4]
quickSort([4, 1, 3, 2], true); // [4,3,2,1]
```

18
snippets_archive/removeVowels.md
View File

@ -1,18 +0,0 @@
---
title: removeVowels
tags: string,beginner
---
Returns all the vowels in a `str` replaced by `repl`.
Use `String.prototype.replace()` with a regexp to replace all vowels in `str`.
Omot `repl` to use a default value of `''`.
```js
const removeVowels = (str, repl = '') => str.replace(/[aeiou]/gi, repl);
```
```js
removeVowels("foobAr"); // "fbr"
removeVowels("foobAr","*"); // "f**b*r"
```

48
snippets_archive/solveRPN.md
View File

@ -1,48 +0,0 @@
---
title: solveRPN
tags: algorithm,advanced
---
Solves the given mathematical expression in [reverse polish notation](https://en.wikipedia.org/wiki/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.prototype.replace()` with a regular expression to replace `^` with `**`, `String.prototype.split()` to tokenize the string and `Array.prototype.filter()` to remove empty tokens.
Use `Array.prototype.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.
```js
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`;
};
```
```js
solveRPN('15 7 1 1 + - / 3 * 2 1 1 + + -'); // 5
solveRPN('2 3 ^'); // 8
```

23
snippets_archive/speechSynthesis.md
View File

@ -1,23 +0,0 @@
---
title: speechSynthesis
tags: browser,intermediate
---
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](https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesisUtterance).
```js
const speechSynthesis = message => {
const msg = new SpeechSynthesisUtterance(message);
msg.voice = window.speechSynthesis.getVoices()[0];
window.speechSynthesis.speak(msg);
};
```
```js
speechSynthesis('Hello, World'); // // plays the message
```

16
snippets_archive/squareSum.md
View File

@ -1,16 +0,0 @@
---
title: squareSum
tags: math,beginner
---
Squares each number in an array and then sums the results together.
Use `Array.prototype.reduce()` in combination with `Math.pow()` to iterate over numbers and sum their squares into an accumulator.
```js
const squareSum = (...args) => args.reduce((squareSum, number) => squareSum + Math.pow(number, 2), 0);
```
```js
squareSum(1, 2, 2); // 9
```

9
test/JSONToDate.test.js
View File

@ -1,9 +0,0 @@
const {JSONToDate} = require('./_30s.js');
test('JSONToDate is a Function', () => {
expect(JSONToDate).toBeInstanceOf(Function);
});
test('JSONToDate returns the correct date string', () => {
var reg = new RegExp(`Date(${Date.parse('March 14,2017')})`);
expect(JSONToDate(reg)).toBe('14/3/2017');
});

17
test/binarySearch.test.js
View File

@ -1,17 +0,0 @@
const {binarySearch} = require('./_30s.js');
test('binarySearch is a Function', () => {
expect(binarySearch).toBeInstanceOf(Function);
});
test('Finds item in array', () => {
expect(binarySearch([1, 4, 6, 7, 12, 13, 15, 18, 19, 20, 22, 24], 6)).toBe(2);
});
test('Returns -1 when not found', () => {
expect(binarySearch([1, 4, 6, 7, 12, 13, 15, 18, 19, 20, 22, 24], 21)).toBe(-1);
});
test('Works with empty arrays', () => {
expect(binarySearch([], 21)).toBe(-1);
});
test('Works for one element arrays', () => {
expect(binarySearch([1], 1)).toBe(0);
});

9
test/cleanObj.test.js
View File

@ -1,9 +0,0 @@
const {cleanObj} = require('./_30s.js');
test('cleanObj is a Function', () => {
expect(cleanObj).toBeInstanceOf(Function);
});
const testObj = { a: 1, b: 2, children: { a: 1, b: 2 } };
test('Removes any properties except the ones specified from a JSON object', () => {
expect(cleanObj(testObj, ['a'], 'children')).toEqual({ a: 1, children: { a: 1 } });
});

21
test/collatz.test.js
View File

@ -1,21 +0,0 @@
const {collatz} = require('./_30s.js');
test('collatz is a Function', () => {
expect(collatz).toBeInstanceOf(Function);
});
test('When n is even, divide by 2', () => {
expect(collatz(8)).toBe(4);
});
test('When n is odd, times by 3 and add 1', () => {
expect(collatz(9)).toBe(28);
});
test('Eventually reaches 1', () => {
let n = 9;
while (true) {
if (n === 1) {
expect(n).toBe(1);
break;
}
n = collatz(n);
}
});

11
test/countVowels.test.js
View File

@ -1,11 +0,0 @@
const {countVowels} = require('./_30s.js');
test('countVowels is a Function', () => {
expect(countVowels).toBeInstanceOf(Function);
});
test('countVowels returns the correct count', () => {
expect(countVowels('foobar')).toBe(3);
});
test('countVowels returns the correct count', () => {
expect(countVowels('ggg')).toBe(0);
});

17
test/factors.test.js
View File

@ -1,17 +0,0 @@
const {factors} = require('./_30s.js');
test('factors is a Function', () => {
expect(factors).toBeInstanceOf(Function);
});
test('factors returns the correct array', () => {
expect(factors(12)).toEqual([2, 3, 4, 6, 12]);
});
test('factors returns the correct array of primes', () => {
expect(factors(12, true)).toEqual([2, 3]);
});
test('factors returns the correct array for negatives', () => {
expect(factors(-12)).toEqual([2, -2, 3, -3, 4, -4, 6, -6, 12, -12]);
});
test('factors returns the correct array of primes for negatives', () => {
expect(factors(-12, true)).toEqual([2, 3]);
});

8
test/fibonacciCountUntilNum.test.js
View File

@ -1,8 +0,0 @@
const {fibonacciCountUntilNum} = require('./_30s.js');
test('fibonacciCountUntilNum is a Function', () => {
expect(fibonacciCountUntilNum).toBeInstanceOf(Function);
});
test('Returns the correct number', () => {
expect(fibonacciCountUntilNum(10)).toBe(7);
});

8
test/fibonacciUntilNum.test.js
View File

@ -1,8 +0,0 @@
const {fibonacciUntilNum} = require('./_30s.js');
test('fibonacciUntilNum is a Function', () => {
expect(fibonacciUntilNum).toBeInstanceOf(Function);
});
test('Returns the correct sequence', () => {
expect(fibonacciUntilNum(10)).toEqual([0, 1, 1, 2, 3, 5, 8]);
});

8
test/heronArea.test.js
View File

@ -1,8 +0,0 @@
const {heronArea} = require('./_30s.js');
test('heronArea is a Function', () => {
expect(heronArea).toBeInstanceOf(Function);
});
test('howManyTimes returns the correct result', () => {
expect(heronArea(3, 4, 5)).toBe(6);
});

17
test/howManyTimes.test.js
View File

@ -1,17 +0,0 @@
const {howManyTimes} = require('./_30s.js');
test('howManyTimes is a Function', () => {
expect(howManyTimes).toBeInstanceOf(Function);
});
test('howManyTimes returns the correct result', () => {
expect(howManyTimes(100, 2)).toBe(2);
});
test('howManyTimes returns the correct result', () => {
expect(howManyTimes(100, 2.5)).toBe(2);
});
test('howManyTimes returns the correct result', () => {
expect(howManyTimes(100, 0)).toBe(0);
});
test('howManyTimes returns the correct result', () => {
expect(howManyTimes(100, -1)).toBe(Infinity);
});

11
test/isArmstrongNumber.test.js
View File

@ -1,11 +0,0 @@
const {isArmstrongNumber} = require('./_30s.js');
test('isArmstrongNumber is a Function', () => {
expect(isArmstrongNumber).toBeInstanceOf(Function);
});
test('isArmstrongNumber returns true', () => {
expect(isArmstrongNumber(1634)).toBeTruthy();
});
test('isArmstrongNumber returns false', () => {
expect(isArmstrongNumber(56)).toBeFalsy();
});

11
test/isSimilar.test.js
View File

@ -1,11 +0,0 @@
const {isSimilar} = require('./_30s.js');
test('isSimilar is a Function', () => {
expect(isSimilar).toBeInstanceOf(Function);
});
test('isSimilar returns true', () => {
expect(isSimilar('rt', 'Rohit')).toBeTruthy();
});
test('isSimilar returns false', () => {
expect(isSimilar('tr', 'Rohit')).toBeFalsy();
});

8
test/kmphToMph.test.js
View File

@ -1,8 +0,0 @@
const {kmphToMph} = require('./_30s.js');
test('kmphToMph is a Function', () => {
expect(kmphToMph).toBeInstanceOf(Function);
});
test('Returns mph from kph.', () => {
expect(kmphToMph(10)).toBe(6.21371192);
});

14
test/levenshteinDistance.test.js
View File

@ -1,14 +0,0 @@
const {levenshteinDistance} = require('./_30s.js');
test('levenshteinDistance is a Function', () => {
expect(levenshteinDistance).toBeInstanceOf(Function);
});
test('levenshteinDistance returns the correct results', () => {
expect(levenshteinDistance('30-seconds-of-code', '30-seconds-of-python-code')).toBe(7);
});
test('levenshteinDistance returns the correct result for 0-length string as first argument', () => {
expect(levenshteinDistance('', 'foo')).toBe(3);
});
test('levenshteinDistance returns the correct result for 0-length string as second argument', () => {
expect(levenshteinDistance('bar', '')).toBe(3);
});

8
test/mphToKmph.test.js
View File

@ -1,8 +0,0 @@
const {mphToKmph} = require('./_30s.js');
test('mphToKmph is a Function', () => {
expect(mphToKmph).toBeInstanceOf(Function);
});
test('Returns kph from mph.', () => {
expect(mphToKmph(10)).toBe(16.09344000614692);
});

8
test/pipeLog.test.js
View File

@ -1,8 +0,0 @@
const {pipeLog} = require('./_30s.js');
test('pipeLog is a Function', () => {
expect(pipeLog).toBeInstanceOf(Function);
});
test('pipeLog returns the given value', () => {
expect(pipeLog('hi')).toBe('hi');
});

42
test/quickSort.test.js
View File

@ -1,42 +0,0 @@
const {quickSort} = require('./_30s.js');
test('quickSort is a Function', () => {
expect(quickSort).toBeInstanceOf(Function);
});
test('quickSort([5, 6, 4, 3, 1, 2]) returns [1, 2, 3, 4, 5, 6]', () => {
expect(quickSort([5, 6, 4, 3, 1, 2])).toEqual([1, 2, 3, 4, 5, 6]);
});
test('quickSort([-1, 0, -2]) returns [-2, -1, 0]', () => {
expect(quickSort([-1, 0, -2])).toEqual([-2, -1, 0]);
});
test('quickSort() throws an error', () => {
expect(() => {
quickSort();
}).toThrow();
});
test('quickSort(123) throws an error', () => {
expect(() => {
quickSort(123);
}).toThrow();
});
test('quickSort({ 234: string}) throws an error', () => {
expect(() => {
quickSort({ 234: string });
}).toThrow();
});
test('quickSort(null) throws an error', () => {
expect(() => {
quickSort(null);
}).toThrow();
});
test('quickSort(undefined) throws an error', () => {
expect(() => {
quickSort(undefined);
}).toThrow();
});
let start = new Date().getTime();
quickSort([11, 1, 324, 23232, -1, 53, 2, 524, 32, 13, 156, 133, 62, 12, 4]);
let end = new Date().getTime();
test('quickSort([11, 1, 324, 23232, -1, 53, 2, 524, 32, 13, 156, 133, 62, 12, 4]) takes less than 2s to run', () => {
expect(end - start < 2000).toBeTruthy();
});

11
test/removeVowels.test.js
View File

@ -1,11 +0,0 @@
const {removeVowels} = require('./_30s.js');
test('removeVowels is a Function', () => {
expect(removeVowels).toBeInstanceOf(Function);
});
test('Removes vowels.', () => {
expect(removeVowels('foobAr')).toBe('fbr');
});
test('Replaces vowels.', () => {
expect(removeVowels('foobAr', '*')).toBe('f**b*r');
});

11
test/solveRPN.test.js
View File

@ -1,11 +0,0 @@
const {solveRPN} = require('./_30s.js');
test('solveRPN is a Function', () => {
expect(solveRPN).toBeInstanceOf(Function);
});
test('solveRPN returns the correct result', () => {
expect(solveRPN('15 7 1 1 + - / 3 * 2 1 1 + + -')).toBe(5);
});
test('solveRPN returns the correct result', () => {
expect(solveRPN('2 3 ^')).toBe(8);
});

5
test/speechSynthesis.test.js
View File

@ -1,5 +0,0 @@
const {speechSynthesis} = require('./_30s.js');
test('speechSynthesis is a Function', () => {
expect(speechSynthesis).toBeInstanceOf(Function);
});

16
test/squareSum.test.js
View File

@ -1,16 +0,0 @@
const {squareSum} = require('./_30s.js');
test('squareSum is a Function', () => {
expect(squareSum).toBeInstanceOf(Function);
});
test('squareSum returns the proper result', () => {
expect(squareSum(2, 3, 4)).toBe(29);
});
test('works with negative numbers', () => {
expect(squareSum(-2, 3, -4)).toBe(29);
});
test('NaN when parameters have text', () => {
expect(squareSum(-2, 3, -4, 'text')).toBe(NaN);
});