From 47e3f8ee0ae675125a411ea045974cbf5d178a4c Mon Sep 17 00:00:00 2001 From: Kok Chee Kean Date: Tue, 27 Feb 2018 16:08:11 +0800 Subject: [PATCH 1/3] All solutions uploaded except numSquare.js (what's that?). Masterfile in allSolutions.js --- js/allSolutions.js | 223 +++++++++++++++++++++++++++++++++++++++++++++ js/isPrime.js | 10 ++ js/letterCount.js | 14 +++ js/merge.js | 3 + js/primes.js | 19 ++++ js/sillySum.js | 3 + 6 files changed, 272 insertions(+) create mode 100644 js/allSolutions.js diff --git a/js/allSolutions.js b/js/allSolutions.js new file mode 100644 index 0000000..452d70d --- /dev/null +++ b/js/allSolutions.js @@ -0,0 +1,223 @@ +function maxOfThree(num1, num2, num3) { + let result = num1; + if (num2 > result) { + result = num2; + }; + if (num3 > result) { + result = num3; + }; + // Note: A if-else would result in maxOfThree(1,3,5) returning 3. + return result; +} + +function isCharacterAVowel(char) { + let vowels = ["a", "e", "i", "o", "u"]; + if (char.length != 1) { + console.error("Not a character") + return false; + }; + let result = false; + vowels.forEach((c) => {if (c = char) {result = true}}); + return result; +} + +function sumArray(arr) { + return arr.reduce((accumulator, current) => accumulator + current) +} + +function multiplyArray(arr) { + return arr.reduce((accumulator, current) => accumulator * current) +} + +function sillySum(arr) { + return arr.map((currentValue, index) => currentValue * index).reduce((accumulator, currentValue) => accumulator + currentValue) +} + +function reverseString(num) { + // Iteratively concatenate a result string with the character popped off at the end of the given string + let result = ""; + let tmp = num.split(''); + while (tmp.length) { + result += tmp.pop(); + } + return result; +} + +function findLongestWord(arr) { + // Sort the array by word length in ascending order and return the first element + // The sort function should return true if the 2nd parameter has a length greater than the 1st, i.e. make the swap if the 2nd parameter has a longer word + return arr.sort((a,b) => {return b.length - a.length})[0] +} + +function filterLongWords(arr, maxLength) { + if (typeof(maxLength) != "number" || parseInt(maxLength) != maxLength || maxLength < 0) {console.error("Need a positive number for max length!"); return}; + let result = []; + arr.map((currentWord) => {if (currentWord.length < maxLength) {result.push(currentWord)}}); + console.log(maxLength); + return result; +} + +function grade(testScore) { + if (typeof(testScore) != "number" || testScore < 0 || testScore > 100) {console.error("Need a valid test score between 0 and 100!"); return} + let result = "A"; + switch (true) { + case (testScore < 45): {result = "F"; break}; + case (testScore < 50): {result = "E"; break}; + case (testScore < 55): {result = "D"; break}; + case (testScore < 60): {result = "C"; break}; + case (testScore < 70): {result = "B"; break}; + default: break; + } + return result; +} + +// I was originally thinking of using this blunderbuss of a function, but I don't think it exists? It looks like it should be a utility, so I'm writing it here for future use. The required task doesn't actually require its use since it's a 1 time look up. +function phoneBookReverse (phonebook) { + var reversedPhoneBook = {}; + for (var number in phonebook) { + if (phonebook.hasOwnProperty(number)) { + if (!(reversedPhoneBook.hasOwnProperty(phonebook[number]))) { + reversedPhoneBook[phonebook[number]] = []; + } + reversedPhoneBook[phonebook[number]].push(number); + }; + } + return reversedPhoneBook; +} + +function phoneBookLookUp (phonebook, number) { + for (let name in phonebook) { + if (phonebook[name] == number) { + console.log(name) + } + } +} + +function letterCount(word) { + // Use the unicode of a character as its index in a translated array + let tmp = word.toLowerCase().split(''); + let result = new Array(26).fill(0); + for (char in tmp) { + result[tmp[char].charCodeAt(0) - 97]++; + } + for (let i = 0; i<26; i++) { + if (result[i]) { + console.log(String.fromCharCode(i+97) + " - " + result[i]) + } + } +} + +function isPrime(n) { + if (typeof(n) != "number" || parseInt(n) != n) {console.error("Need an integer!"); return}; + if (n == 2 || n == 3) {return true}; + let upperLimit = Math.floor(Math.sqrt(n)); + let result = true; + for (let i = 2; i <= upperLimit; i++) { + if (!(n % i)) {result = false; break} + } + return result; +} + +function primes(max) { + if (max < 2 || parseInt(max) != max) {console.error("Need an integer larger than 2!"); return}; + let result = []; + for (let i = 2; i <= max; i++) { + if (isPrime(i)) {result.push(i)} + } + return result; +} + +function merge(arr1, arr2) { + return arr1.concat(arr2); +} + + +// The concept of this solution is that the residues of integers +// modulo 15 are periodic (with period 15). The implementation can +// be done in a few ways, but since machine language deals with binary +// numbers, it's possible that the fastest implementation uses +// binary numbers as a filter (because division is expensive!). +// Nevertheless, I'll write here (in 15 min?) +// both the binary and the human-readable version. + +// Note: 810092018 in binary is 110000010010010000011000010000 +// Split into pairs, 11 00 00 01 00 10 01 00 00 01 10 00 01 00 00 +// Notice that there are 15 pairs of bits, which represent: +// 11 - divisible by 15 +// 01 - divisible by 3 +// 10 - divisible by 5 + +// To effectively use that large binary string as a filter, we use bitwise +// comparison operators, e.g. the & comparison operator, and bitshift operators +// e.g. the >> and << shift operators. + +// The reason why that binary string is written like this "in reverse" is that +// the digits with smaller values are on the right, e.g. in decimal, the digit 7 +// has the smallest value in the number 1234127. + +const end = 100; +const start = 1; + +function bitFizzBuzz(start, end) { + var bFilter = 810092048; + let counter = bFilter & 3; + + for (let i = 1; i < start; i++) { + bFilter = bFilter >> 2 | counter << 28; + } + + for (let num = start; num <= end; num++){ + let counter = bFilter & 3; + let result = 'FizzBuzz'; + // if the binary string returns 0 when bitwise compared to 3 (11), then it's neither + // divisible by 3 (represented by 01) nor 5 (represented by 10). + // if the binary string returns 1 when bitwise compared to 3 (11), then it's divisible by 3 (01). + // if the binary string returns 2 when bitwise compared to 3 (11), then it's divisible by 5 + // (remember, 10 indicates divisibility by 5). + + if (counter === 0) { + result = num; + } else if (counter === 1) { + result = 'Fizz'; + } else if (counter === 2) { + result = 'Buzz'; + } + + // Sadly this algorithm relies on its own iterative nature to seek the correct position in the + // binary filter, and so doing bitFizzBuzz(15) in the console will not work. + // We will need to do something like "for (let i=1;i> 2 | counter << 28; + + console.log(result); + } +} + + +// And now for the normal implementations... +function normalFizzBuzz(start, end) { + let nFilter = [false, false, 'Fizz', false, 'Buzz', 'Fizz', false, false, 'Fizz', 'Buzz', false, 'Fizz', false, false, 'FizzBuzz']; + for (let i = start; i <= end; i++) { + let result = nFilter[(i - 1) % 15]; //This is an expensive operation, but how much more expensive is it in JS compared to lower level languages, and is it expensive enough to merit the bit comparison implementation above?? If we wanted to cheat like in the bit comparison implementation, we wouldn't do this and just increment the index each time, subtracting 15 each time we hit 16 for the fastest possible runtime :D + console.log(((result) ? result : i)); + } +} + +function nFizzBuzz(start, end) { //This is the cheaty implementation described above :D + let nFilter = [false, false, 'Fizz', false, 'Buzz', 'Fizz', false, false, 'Fizz', 'Buzz', false, 'Fizz', false, false, 'FizzBuzz']; + var r = (start % 16) - 1; + for (let i = start; i <= end; i++){ + if (r > 14) {r-=15}; + console.log((nFilter[r]) ? nFilter[r] : i); + r++; + } +} + +// Pick your poison! :D +//bitFizzBuzz(start, end); +//normalFizzBuzz(start, end); +//nFizzBuzz(start, end); \ No newline at end of file diff --git a/js/isPrime.js b/js/isPrime.js index e69de29..2d7c103 100644 --- a/js/isPrime.js +++ b/js/isPrime.js @@ -0,0 +1,10 @@ +function isPrime(n) { + if (typeof(n) != "number" || parseInt(n) != n) {console.error("Need an integer!"); return}; + if (n == 2 || n == 3) {return true}; + let upperLimit = Math.floor(Math.sqrt(n)); + let result = true; + for (let i = 2; i <= upperLimit; i++) { + if (!(n % i)) {result = false; break} + } + return result; +} \ No newline at end of file diff --git a/js/letterCount.js b/js/letterCount.js index e69de29..67ebe2b 100644 --- a/js/letterCount.js +++ b/js/letterCount.js @@ -0,0 +1,14 @@ +function letterCount(word) { + if (typeof(word) != "string") {console.error("Need a string!"); return}; + // Use the unicode of a character as its index in a translated array + let tmp = word.toLowerCase().split(''); + let result = new Array(26).fill(0); + for (char in tmp) { + result[tmp[char].charCodeAt(0) - 97]++; + } + for (let i = 0; i<26; i++) { + if (result[i]) { + console.log(String.fromCharCode(i+97) + " - " + result[i]) + } + } +} \ No newline at end of file diff --git a/js/merge.js b/js/merge.js index e69de29..27549f7 100644 --- a/js/merge.js +++ b/js/merge.js @@ -0,0 +1,3 @@ +function merge(arr1, arr2) { + return arr1.concat(arr2); +} \ No newline at end of file diff --git a/js/primes.js b/js/primes.js index e69de29..3fc0652 100644 --- a/js/primes.js +++ b/js/primes.js @@ -0,0 +1,19 @@ +function isPrime(n) { + if (typeof(n) != "number" || parseInt(n) != n) {console.error("Need an integer!"); return}; + if (n == 2 || n == 3) {return true}; + let upperLimit = Math.floor(Math.sqrt(n)); + let result = true; + for (let i = 2; i <= upperLimit; i++) { + if (!(n % i)) {result = false; break} + } + return result; +} + +function primes(max) { + if (max < 2 || parseInt(max) != max) {console.error("Need an integer larger than 2!"); return}; + let result = []; + for (let i = 2; i <= max; i++) { + if (isPrime(i)) {result.push(i)} + } + return result; +} \ No newline at end of file diff --git a/js/sillySum.js b/js/sillySum.js index e69de29..f7f07d4 100644 --- a/js/sillySum.js +++ b/js/sillySum.js @@ -0,0 +1,3 @@ +function sillySum(arr) { + return arr.map((currentValue, index) => currentValue * index).reduce((accumulator, currentValue) => accumulator + currentValue) +} \ No newline at end of file From f1af552a5fa071a8c713f3cfe7eff30e3ae169a4 Mon Sep 17 00:00:00 2001 From: CK Date: Wed, 28 Feb 2018 00:12:54 +0800 Subject: [PATCH 2/3] oops missed out the sorting part of the merge.js problem. fixed. --- js/merge.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/js/merge.js b/js/merge.js index 27549f7..50f2645 100644 --- a/js/merge.js +++ b/js/merge.js @@ -1,3 +1,3 @@ function merge(arr1, arr2) { - return arr1.concat(arr2); + return arr1.concat(arr2).sort((a,b)=>{return a-b}); } \ No newline at end of file From a6eae8fd113212ccbe842c86b02188049c975a6f Mon Sep 17 00:00:00 2001 From: CK Date: Wed, 28 Feb 2018 00:29:11 +0800 Subject: [PATCH 3/3] slight optimization of isPrime function --- js/allSolutions.js | 1 + 1 file changed, 1 insertion(+) diff --git a/js/allSolutions.js b/js/allSolutions.js index 452d70d..9b360e7 100644 --- a/js/allSolutions.js +++ b/js/allSolutions.js @@ -110,6 +110,7 @@ function letterCount(word) { function isPrime(n) { if (typeof(n) != "number" || parseInt(n) != n) {console.error("Need an integer!"); return}; if (n == 2 || n == 3) {return true}; + if (!(n & 1)) {return false}; let upperLimit = Math.floor(Math.sqrt(n)); let result = true; for (let i = 2; i <= upperLimit; i++) {