JavaScript Coding Challenges
##### 01. Creates a function that takes two numbers as arguments and return their sum.
```js
function addition(a, b) {
//Write Your solution Here
};
console.log(addition(10, 20)); // 30
console.log(addition(30, 20)); // 50
console.log(addition(10, 90)); // 100
```
Solution
```js
function addition(a, b) {
let add = a + b;
return (add)
};
```
Solution
```js
function howManySeconds(hours) {
let hoursToSeconds = (hours*3600);
return(hoursToSeconds)
};
```
Solution
```js
function convert(minutes) {
let seconds = minutes*60;
return (seconds)
};
```
Solution
```js
function footballPoints(wins, draws, losses) {
let points = (wins*3) + (draws*1) + (losses*0)
return(points)
};
```
Solution
```js
function bitwiseAND(n1, n2) {
let answer = n1 & n2;
return (answer);
};
function bitwiseOR(n1, n2) {
let answer = n1 | n2;
return (answer);
};
function bitwiseXOR(n1, n2) {
let answer = n1 ^ n2;
return (answer);
};
```
Solution
```js
function getFirstValue(arr) {
return arr[0];
};
```
Solution
```js
function addition(num) {
let numPlusOne = num + 1;
return(numPlusOne)
};
```
Solution
```js
function lessThan100(a, b) {
if (a + b < 100) {
return true;
}
else {
return false;
}
};
```
Solution
```js
function isSameNum(num1, num2) {
if (num1 === num2){
return true;
}
else {
return false;
}
};
```
```js
function matchHouses(step){
//Write Your solution Here
};
console.log(matchHouses(5)); // 26
console.log(matchHouses(0)); // 0
console.log(matchHouses(10)); // 51
```
Solution
```js
function matchHouses(step){
if (step > 0) {
let matchSticks = ((step*6) - (step -1));
return(matchSticks)
}
else {
let matchSticks = 0;
return (matchSticks)
}
};
```
Solution
```js
function squared(a) {
return (a*a);
};
```
Solution
```js
function findPerimeter(height, width){
let perimeter = 2*(height + width);
return (perimeter)
};
```
Solution
```js
function addUp(num) {
let sum = 0;
for (i = 0; i <= num; i++){
sum += i;
}
return(sum)
};
```
Solution
```js
function profitableGamble(prob, prize, pay){
if (prob*prize > pay) {
return (true)
}
else {
return (false)
}
};
```
Solution
```js
function minMax(arr){
arr.sort(function(a, b){return(a - b)})
return [arr[0], arr[arr.length - 1]]
};
```
Solution
```js
function canNest(arr1, arr2) {
arr1.sort(function(a,b){return(a - b)});
arr2.sort(function(a,b){return(a - b)});
let arr1MinMax = [arr1[0], arr1[arr1.length -1]];
let arr2MinMax = [arr2[0], arr2[arr2.length -1]];
if (arr1MinMax[0] > arr2MinMax[0] && arr1MinMax[1] < arr2MinMax[1]){
return true
}
else{
return false
}
};
```
```js
function numberSquares(n){
//Write Your solution Here
};
console.log(numberSquares(4)); // 30
console.log(numberSquares(5)); // 55
console.log(numberSquares(6)); // 91
```
Solution
```js
function numberSquares(n){
let num = n*(2*n + 1)*(n + 1)/6
return (num)
};
```
Solution
```js
function whichIsLarger(f, g){
if (f() > g()) {
return ('f')
}
else if (g() > f()) {
return ('g')
}
else if (f() === g()) {
return ('neither')
}
};
```
Solution
```js
function timeForMilkAndCookies(date){
return date.getMonth() === 11 && date.getDate() === 24;
};
```
Solution
```js
function largestSwap(num){
let num1 = num + "";
let num2 = num1.split("").reverse().join("");
if (num1 >= num2) {
return true;
}
if (num1 < num2) {
return false;
}
};
function largestSwap(num) {
let c = num.toString();
let a = [];
let b = 0;
for (let i = 0; i < c.length; i++) {
a.push(c[c.length - 1 - i]);
b += a[i];
}
let d = parseInt(b);
if (d > num) {
return false;
} else return true;
};
```
Solution
```js
function charCount(myChar, str){
let a = 0;
for (let i = 0; i < str.length; i++) {
if (myChar.toLowerCase() === str.toLowerCase()[i]) {
a += 1;
}
}
return a
};
```
Solution
```js
function repetition(txt, n){
let reptxt = ""
while (n > 0) {
reptxt += txt
n--;
}
return reptxt
};
```
Solution
```js
function filterArray(arr){
let filteredArray = arr.filter(item => typeof item === "number");
return filteredArray
};
function filterArray(arr) {
let filteredArr = [];
for (let i = 0; i < arr.length; i++) {
if ( typeof arr[i] !== "string") {
filteredArr.push(arr[i])
}
} return filteredArr
};
```
Solution
```js
function matchFlag(str){
let REGEXP = /red flag|blue flag/g;
return str.match(REGEXP);
};
```
Solution
```js
function matchEllipsis(str){
let REGEXP = /\.{3,}/g;
return str.match(REGEXP);
};
```
Solution
```js
function flip(y){
let x = y - 1;
return (Math.abs(x))
};
```
Solution
```js
function doubleChar(str) {
let doubleString = '';
for(let i=0; i x.repeat(2));
let doubleString = array2.join("");
return doubleString
};
```
Solution
```js
function factorial(num) {
let fact = 1;
for (let i = 0; i 1) {
num--;
result *= num;
}
return result;
};
function factorial(num){
let fact = num;
if (num === 0 || num === 1) return 1;
for (let i = num - 1; i >= 1; i--) {
fact *= i;
}
return fact;
};
```
Solution
```js
function getAbsSum(arr){
let absSum = 0;
for (var i = 0; i < arr.length; i++) {
absSum += Math.abs(arr[i]);
}
return absSum;
};
```
Solution
```js
function matchAny(str){
const REGEXP = /[^a-z0-9 ]/gi;
return str.match(REGEXP)
};
```
Solution
```js
function countVowels(str){
let count = 0;
let vowlStr = str.toLowerCase().match(/(a|e|i|o|u)/g);
for (let i = 0; i < vowlStr.length; i++) {
count += 1;
}
return count;
};
```
Solution
```js
function isOrthogonal(arr1, arr2){
let ortho = 0;
for (i = 0; i < arr1.length; i++){
ortho += arr1[i]*arr2[i]
}
if (ortho === 0) {
return true
}
return false
};
```
Solution
```js
function inkLevels(inks){
return Math.min(...Object.values(inks));
};
```
Solution
```js
function removeVowels(str){
let newArr = str.match(/[^aeiouAEIOU]/g);
let newString = newArr.join('');
return newString
};
```
Solution
```js
function findLargestNums(arr){
let newArr = []
for (let i = 0; i < arr.length; i++) {
newArr.push(Math.max(...arr[i]));
}
return newArr
};
```
Solution
```js
function maximumScore(tileHand){
let score = 0;
for ( let i = 0; i < tileHand.length; i++) {
score += tileHand[i].score;
}
return score;
};
```
Solution
```js
function isJS(path){
let extension = path.match( /[^.]+$/g)[0]
if(extension === 'js' || extension==='jsx'){
return true;
}
return false;
};
```
Solution
```js
function animals(chickens, cows, goats){
return chickens*2 + cows*4 + goats*4;
};
```
Solution
```js
function frames(minutes, fps){
return minutes*60*fps;
};
```
Solution
```js
function makesTen(a, b){
if (a == 10 || b == 10) {
return true;
} else if (a + b == 10) {
return true;
} else {
return false;
};
};
```
Solution
```js
function comp(str1, str2) {
if (str1.length === str2.length) {
return true;
}
return false;
};
```
Solution
```js
function calculateFuel(n){
let fuel = n * 10;
if (fuel >= 100) {
return fuel;
};
return 100;
};
```
Solution
```js
function sumPolygon(n){
return (n - 2) * 180;
};
```
Solution
```js
function divisibleByFive(n){
if (n % 5 === 0) {
return true;
};
return false;
};
```
Solution
```js
function sumOfCubes(nums){
var cubeSum = 0;
for (i in nums) {
cubeSum += nums[i] * nums[i] * nums[i];
};
return cubeSum;;
};
```
Solution
```js
function societyName(friends){
let nameArr = friends.map((x) => x.split(""));
let letterArr = "";
for (let i = 0; i < nameArr.length; i++) {
letterArr += nameArr[i][0];
};
return letterArr;
};
```
Solution
```js
function isPrefix(word, prefix) {
return word.startsWith(prefix.slice(0, -1));
}
function isSuffix(word, suffix) {
return word.endsWith(suffix.slice(1));
}
function isPrefix(word, prefix) {
let prefixWord = prefix.slice(0, -1);
let mainWord = '';
for(let i = 0; i < prefixWord.length; i++){
mainWord += word[i];
}
if(prefixWord === mainWord){
return true;
}
return false;
}
function isSuffix(word, suffix) {
let suffixWord = suffix.slice(1);
let mainWord = '';
let newString = '';
for(let i = word.length - 1; i > suffixWord.length; i--){
mainWord += word[i];
}
for (let i = mainWord.length - 1; i >= 0; i--) {
newString += mainWord[i];
}
if(suffixWord === newString){
return true;
}
return false;
}
```
Solution
```js
function hashPlusCount(str){
let hash = (str.match(/#/g) || []).length;
let plus = (str.match(/\+/g) || []).length;
return [hash, plus];
};
```
Solution
```js
function formatPhoneNumber(numbers) {
numbers.splice(0, 0, "(");
numbers.splice(4, 0, ")");
numbers.splice(5, 0, " ");
numbers.splice(9, 0, "-");
let str = numbers.join("");
return str;
};
```
Solution
```js
function matchEven(num){
let REGEXP = /[24680]$/;
return num.match(REGEXP)?.[0];
};
```
Solution
```js
function firstVowel(str){
let regex = /[aeiou]/gi;
return str.search(regex);
};
```
Solution
```js
function removesDuplicateItems(arr) {
const setArr = [...new Set(arr)];
return setArr;
};
function removesDuplicateItems(arr) {
let unique = arr.filter((element, index) => {
return arr.indexOf(element) === index;
});
return unique;
};
function removesDuplicateItems(arr) {
let unique = [];
arr.forEach((c) => {
if (!unique.includes(c)) {
unique.push(c);
}});
return unique;
};
function removesDuplicateItems(arr){
let outputArray = [];
let count = 0;
let start = false;
for (j = 0; j < arr.length; j++) {
for (k = 0; k < outputArray.length; k++) {
if (arr[j] == outputArray[k]) {
start = true;
}
}
count++;
if (count == 1 && start == false) {
outputArray.push(arr[j]);
}
start = false;
count = 0;
}
return outputArray;
};
function removesDuplicateItems(arr){
for (let i = 0; i < arr.length; i++) {
for (let j = i + 1; j < arr.length; j++) {
if (arr[i] === arr[j]) {
for (let k = j; k < arr.length; k++) {
arr[k] = arr[k + 1];
}
arr.length--;
j--;
}
}
}
return arr;
};
```
Solution
```js
function sortNumsAscending(arr){
if ((arr === []) | (arr === null)) {
return [];
}
return arr.sort(function (a, b){
return a - b;
});
};
function sortNumsAscending(arr) {
for (let i = 1; i < arr.length; i++)
for (let j = 0; j < i; j++)
if (arr[i] < arr[j]) {
var x = arr[i];
arr[i] = arr[j];
arr[j] = x;
}
return arr;
}
```
Solution
```js
function amplify(num) {
let arr = [];
for ( let i = 1; i <= num; i++) {
if (i % 4 === 0) {
arr.push(i * 10);
} else {
arr.push(i);
}
}
return arr;
}
```
Solution
```js
function maxTotal(nums){
let nums1 = nums.sort(function (a, b){return a-b})
let max = 0
for (i=5; i
---
**[⬆ Back to Top](#header)**
##### 56. Write a regular expression that matches a string if and only if it is a valid zip code.
###### Must only contain numbers (no non-digits allowed).
###### Must not contain any spaces.
###### Must not be greater than 5 digits in length.
```js
function isValidZip(zip){
//Write Your solution Here
};
console.log(isValidZip("393939")); //false
console.log(isValidZip("59001")); //true
console.log(isValidZip("853a7")); //false
```
Solution
```js
function isValidZip(zip) {
const REXEX = /^\d{5}$/;
return REXEX.test(zip);
}
```
Solution
```js
const highestDigit = (number) => {
let arr = (number.toString().split(''))
return Math.max(...arr)
}
```
