freeCodeCamp JavaScript Algorithm and Data Structure Projects Solutions

caesars-cipher.js

var charCodeOfM = "m".charCodeAt(0);

function getDecoded(char) {
var charcode = char.toLowerCase().charCodeAt(0);
var decoded;
if(charcode <= charCodeOfM) {
    decoded = charcode + 13;
} else {
    decoded = charcode - 13;
}

if(char == char.toUpperCase()) {
    return String.fromCharCode(decoded).toUpperCase();
} else {
    return String.fromCharCode(decoded);
}
}

function isLetter(char) {
var re = new RegExp(/[a-z]/, 'i');
return char.match(re) != null;
}

function rot13(str) {
var result = '';
for(let i = 0; i < str.length; i++) {
    if(isLetter(str[i])) {
        result += getDecoded(str[i]);
    } else {
        result += str[i];
    }
}
// console.log(result);
return result;
}

rot13('hello');
rot13('SERR PBQR PNZC');

cash-register.js

var currency = {
    "PENNY": 0.01,
    "NICKEL": 0.05,
    "DIME": 0.1,
    "QUARTER": 0.25,
    "ONE": 1,
    "FIVE": 5,
    "TEN": 10,
    "TWENTY": 20,
    "ONE HUNDRED": 100
};

var cashInDrawer;
var returns = {};

function fixedTo2Decimal(num) {
    return Math.round(num * 100) / 100;
}

function checkDrawerStatus() {
    for(let i = 0; i < cashInDrawer.length; i++) {
        if(cashInDrawer[i][1] > 0) return true;
    }
    return false;
}

function getDenomination(value, currencyType) {
    var currencyValue = currency[currencyType[0]];
    return Math.floor(fixedTo2Decimal(value / currencyValue));
}

function getChange(change, currencyType) {
    if(currency[currencyType[0]] > change) return change;
    var denominations = getDenomination(change, currencyType);
    var total = currency[currencyType[0]] * denominations;
    var change_copy = change;
    if(total <= currencyType[1]) {
        change_copy -= total;
        currencyType[1] -= total;
        returns.change.push([currencyType[0], total]);
        return change_copy;
    } else {
        change_copy -= currencyType[1];
        returns.change.push([...currencyType]);
        currencyType[1] = 0;
        
        return change_copy;
    }
}

function check(change) {
    for(let i = cashInDrawer.length - 1; i >= 0; i--) {
        if(cashInDrawer[i][1] == 0) continue;
        if(change == 0) break;
        change = getChange(change, cashInDrawer[i]);
    }
    if(change > 0) {
        returns.status = "INSUFFICIENT_FUNDS";
        returns.change = [];
    } else if(checkDrawerStatus()) {
        returns.status = 'OPEN';
    } else {
        returns.status = 'CLOSED';
    }
}

function checkCashRegister(price, cash, cid) {
    cashInDrawer = [];
    for(let i = 0; i < cid.length; i++) {
        var arr = [];
        for(let j = 0; j < cid[i].length; j++) {
            arr.push(cid[i][j]); 
        }
        cashInDrawer.push(arr);
    }
    returns = {status: '', change: []};
    check(cash - price);
    console.log(cid);
    if(returns.status == 'CLOSED') {
        returns.change = [...cid];
    }
    console.log(returns);
    return returns;
}

checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]]); 

checkCashRegister(3.26, 100, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]]);

checkCashRegister(19.5, 20, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]);

checkCashRegister(19.5, 20, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 1], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]); 

checkCashRegister(19.5, 20, [["PENNY", 0.5], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]);

palindrome-checker.js

var getSimplifiedStringArray = function(str) {
    var strArr = str.split("");
    var regex = new RegExp(/[a-zA-Z0-9]/);
    return strArr.filter(char => char.match(regex))
    .map(element => element.toLowerCase());
}

var palindrome = function(str) {
    var arr = getSimplifiedStringArray(str);
    for(let i = 0, j = arr.length -  1; i <= j; i++, j--) {
        if(arr[i] != arr[j]) return false;
    }
    return true;
}

console.log(palindrome('0_0 (: /-\ :) 0-0'));

roman-numeral-converter.js

var eqvRoman = {
    1: "I",
    4: "IV",
    5: "V",
    9: "IX",
    10: "X",
    40: "XL",
    50: "L",
    90: "XC",
    100: "C",
    400: "CD",
    500: "D",
    900: "CM",
    1000: "M"
};
var incrementer, roman;

function add(char, times) {
    // console.log('in add');
    times = Math.floor(times);
    // console.log('received: ' + char + ', ' + times);
    let str = '';

    for(let i = 0; i < times; i++) {
        str += char;
        // console.log('current str value: ' + str);
    }

    // console.log('returning ' + str);
    return str;
}

function toRoman(arg, romanOfArg) {
    var num = arg;

    // console.log('in toRoman');
    // console.log('received: ' + num);

    if(num == 0){
        // console.log('returning from toRoman. ret value ' + romanOfArg);
        return romanOfArg;
    }

    if(num >= 1000) {
        romanOfArg += add(eqvRoman[1000], num / 1000);
        num = num % 1000;
    }

    else if(num >= 900) {
        romanOfArg += add(eqvRoman[900], num / 900);
        num = num % 900;
    }

    else if(num >= 500) {
        romanOfArg += add(eqvRoman[500], num / 500);
        num = num % 500;
    }

    else if(num >= 400) {
        romanOfArg += add(eqvRoman[400], num / 400);
        num = num % 400;
    }

    else if(num >= 100) {
        romanOfArg += add(eqvRoman[100], num / 100);
        num = num % 100;
    }

    else if(num >= 90) {
        romanOfArg += add(eqvRoman[90], num / 90);
        num = num % 90;
    }

    else if(num >= 50) {
        romanOfArg += add(eqvRoman[50], num / 50);
        num = num % 50;
    }

    else if(num >= 40) {
        romanOfArg += add(eqvRoman[40], num / 40);
        num = num % 40;
    }

    else if(num >= 10) {
        romanOfArg += add(eqvRoman[10], num / 10);
        num = num % 10;
    }

    else if(num >= 9) {
        romanOfArg += add(eqvRoman[9], num / 9);
        num = num % 9;
    }

    else if(num >= 5) {
        romanOfArg += add(eqvRoman[5], num / 5);
        num = num % 5;
    }

    else if(num >= 4) {
        romanOfArg += add(eqvRoman[4], num / 4);
        num = num % 4;
    }

    else if(num >= 1) {
        romanOfArg += add(eqvRoman[1], num / 1);
        num = num % 1;
    }
    
    // console.log('recursively calling toRoman with value ' + num + ' and ' + romanOfArg);
    return toRoman(num, romanOfArg);
}

function decompose(num) {
    // console.log('current num value: ' + num);
    if(num == 0) return;
    var rem = num % 10;
    rem *= incrementer;
    // console.log('calling toRoman with value: ' + rem);
    roman = toRoman(rem, '') + roman;
    num = Math.floor(num / 10);
    incrementer *= 10;
    // console.log('recursively calling decompose with value: ' + num);
    return decompose(num);
}

function convertToRoman(num) {
    incrementer = 1;
    roman = '';
    decompose(num);
    // console.log(roman);
    return roman;
}

convertToRoman(1984);
convertToRoman(3999);

telephone-number-validator.js

function bracketValidator(str) {
    var opening = false;
    var closing = false;
    for(let i = 0; i < str.length; i++) {
        if(str.charAt(i) == '(' && !opening) {
            opening = true;
        } else if(str.charAt(i) == ')' && opening) {
            closing = true;
        } else if(str.charAt(i) == '(' && closing) {
            return false;
        } else if(str.charAt(i) == ')' && (closing || !opening)) {
            return false;
        }
    }
    return (opening && closing) || (!opening && !closing);
}

function containsSTDCode(str) {
    return str.charAt(0) == '1';
}

function telephoneCheck(str) {
    str = str.trim();
    if(!bracketValidator(str)) return false;
    var regexWithoutSTD = new RegExp(/\(?\d{3}\)?[ -]?\d{3}[ -]?\d{4}/);
    var matched = str.match(regexWithoutSTD);
    if(matched == null) return false;
    matched = matched.join('');
    if(containsSTDCode(str)) {
        if(str.charAt(1) == ' ') {
            console.log(str.substr(2) == matched);
            return str.substr(2) == matched;
        } else if(str.charAt(1) == '(') {
            console.log(str.substr(1) == matched);
            return str.substr(1) == matched;
        } else return false;
    }

    console.log(str == matched);
    return str == matched;
}

telephoneCheck("555-555-5555");
telephoneCheck("1 555-555-5555");
telephoneCheck("1 (555) 555-5555");