string – JSAlgorithm

Fizz Buzz

Ronald — Wed, 20 May 2020 02:49:51 +0000

let fizzBuzz = function(n) {

    let result = [];
    for (let i = 1; i <= n; i++) {
        if (i % 3 === 0 && i % 5 === 0) {
            result.push("FizzBuzz");
        }
        else if (i % 3 === 0) {
            result.push("Fizz");
        }
        else if (i % 5 === 0) {
            result.push("Buzz");
        }
        else {
            result.push('' + i);
        }
    }

    return result;
};

Longest Common Prefix

Ronald — Wed, 20 May 2020 02:44:25 +0000

let longestCommonPrefix = function(strs) {

    if (!strs.length) return '';

    let index = 0, curr = '';
    for (;;)
    {
        for (let i = 0; i < strs.length; i++) {
            if (strs[i].length <= index) {
                return strs[0].substring(0, index); //?
            }
            if (curr === '') curr = strs[i][index];
            if (curr !== strs[i][index]) {
                return strs[0].substring(0, index);
            }
            if (i === strs.length - 1) {
                curr = '';
                index++
            }
        }
    }

    return '';
};

Palindrome

Ronald — Wed, 20 May 2020 01:55:55 +0000

let isPalindrome = function(s) {
    let start = 0, end = s.length - 1, regex = /\w/i;
    while (start < end) {
        if (!s[start].match(regex)) {
            start++;
        }
        else if (!s[end].match(regex)) {
            end--;
        }
        else {
            if (s[start].toLowerCase() !== s[end].toLowerCase()) return false;
            start++;
            end--;
        }
    }
    return true;
}

Roman To Int

Ronald — Wed, 20 May 2020 01:43:13 +0000

let romanToInt = function(s) {
    if (!s) return 0;

    let mapping = {
        'I': 1,
        'V': 5,
        'X': 10,
        'L': 50,
        'C': 100,
        'D': 500,
        'M': 1000
    }

    let result = 0;
    for (let i = s.length - 1; i >= 0;) {
        if (mapping[s[i]] > mapping[s[i - 1]]) {
            result += mapping[s[i]] - mapping[s[i - 1]];
            i -= 2;
        }
        else {
            result += mapping[s[i]];
            i -= 1;
        }
    }

    return result;
}

Reorganize String

Ron — Fri, 15 May 2020 23:41:34 +0000

let reorganizeString = function(S) {
    let chars = {}, max = 0;
    for(let i = 0; i < S.length;i++) {
        if (chars[S[i]]) {
            chars[S[i]] = chars[S[i]] + 1;
            max = Math.max(chars[S[i]], max);
        }
        else {
            chars[S[i]] = 1;
        }
    }

    console.log(max, Math.floor((S.length + 1) / 2));
    if (max > (S.length + 1) / 2) {
        return "";
    }

    let result = [], index = 0;
    const keys = Object.keys(chars).sort((a, b) => chars[b] - chars[a]); //?
    while (keys.length) { //?
        const key = keys.shift(); //?
        result[index] = key;

        if (chars[key] - 1 > 0) {
            chars[key] = chars[key] - 1;
            keys.unshift(key); //?
        }

        index += 2; //?
        if (index >= S.length) {
            index = 1;
        }
    }

    return result.join('');
};

Top K Frequent Words

Ronald — Thu, 14 May 2020 00:30:55 +0000

let topKFrequent = function(words, k) {
    let map = new Map();
    words.forEach(word => {
        if(map.has(word)) {
            map.set(word, map.get(word) + 1);
        }
        else {
            map.set(word, 1);
        }
    });

    return [...map].sort((x, y) => {
        const f1 = x[1], f2 = y[1]
        if (f1 < f2) return 1;
        if (f1 > f2) return -1;
        return x[0].localeCompare(y[0]);
    }).map(x => x[0]).slice(0, k);
};

Most Common Word

Ronald — Thu, 14 May 2020 00:15:20 +0000

let mostCommonWord = function(paragraph, banned) {
    let wordMap = paragraph.toLowerCase()
        .replace(/\W+/g, ' ')
        .trim()
        .split(' ')
        .filter(word => banned.indexOf(word) < 0)
        .reduce((map, y) => {
            if (map.has(y)) {
                map.set(y, map.get(y) + 1);
            }
            else {
                map.set(y, 1);
            }
            return map;
        }, new Map()); //?


    let word = null, count = 0;
    for (let [key, val] of wordMap) {
        if (val > count) {
            count = val;
            word = key;
        }
    }

    return word;
};

Reorder Log Files

Ronald — Wed, 13 May 2020 14:31:23 +0000

let reorderLogFiles = function(logs) {

    let alpha = [],
        numbers = [];

    const isNumber = (str) => {
        const [, content] = str.split(' ');
        return content.match(/\d+/);
    }

    const getBody = (str) => {
        return str.substring(str.indexOf(' ') + 1);
    }

    // separate alpha from numbers
    logs.forEach(log => {
        if (isNumber(log)) {
            numbers.push(log);
        }
        else {
            alpha.push(log);
        }
    });

    let comparator = (x, y) => {
        let compareResult = getBody(x).localeCompare(getBody(y));
        if (compareResult === 0) {
           return x.localeCompare(y);
        }
        return compareResult;
    }

    return [...alpha.sort(comparator), ...numbers];
};

Decode String

Ronald — Tue, 12 May 2020 19:55:11 +0000

let decodeString = function(str) {

    if (str.indexOf("[") < 0) {
        return str;
    }

    let openingIndex = [];
    let newStr = "";
    for (let i = 0; i < str.length; i++) {
        if (str[i] === "[") {
            openingIndex.push(i);
            newStr += str[i];
        }
        else if (str[i] === "]") {
            let opening = openingIndex.pop();
            let allMultipliers = str.substring(0, opening).match(/\d+/g);
            let multiplier = allMultipliers[allMultipliers.length - 1];
            let data = str.substring(opening + 1, i);
            if (data.indexOf("[") < 0) {
                newStr = newStr.substring(0, newStr.lastIndexOf("[") - multiplier.length) + data.repeat(multiplier);
                console.log({opening, multiplier, data, newStr});
            }
            else {
                newStr += str[i];
            }
        }
        else {
            newStr += str[i];
        }
    }

    return decodeString(newStr);
};

Int to Roman

Ron — Tue, 12 May 2020 11:50:45 +0000

let intToRoman = function(num) {

    const mapping = {
        1000: 'M',
        900:  'CM',
        500:  'D',
        400:  'CD',
        100:  'C',
        90:   'XC',
        50:   'L',
        40:   'XL',
        10:   'X',
        9:    'IX',
        5:    'V',
        4:    'IV',
        1:    'I'
    }

    let result = "";
    for(let divisor of [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]) {
        if (num >= divisor) {
            let quotient = Math.floor(num / divisor);
            result = result + mapping[divisor].repeat(quotient);
            num = num % divisor;
        }
    }

    return result;
}