初级 JavaScript 算法

初级 JavaScript 算法，题目来源 W3Cschool 编程实战。

• 1、翻转字符串
• 2、阶乘
• 3、回文
• 4、寻找最长单词
• 5、设置首字母大写
• 6、寻找数组中的最大值
• 7、确认末尾字符
• 8、重复操作
• 9、字符串截取
• 10、数组分割
• 11、数组截断
• 12、数组查询
• 13、删除数组中的所有的假值
• 14、去除数组中任意多个值
• 15、数组排序并插入值
• 16、位移密码
• 相关链接

1、翻转字符串

function reverseString(str) {
    var array = str.split("");
    var reverseArray = array.reverse();
    return reverseArray.join("");
}

console.log(reverseString("hello")); // "olleh"

2、阶乘

function factorialize(num) {
    var result = 1;
    for (var i = num; i > 0; i--) {
        result *= i;
    }
    return result;
}

console.log(factorialize(10)); // 3628800

3、回文

palindrome (回文) 是指一个字符串忽略标点符号、大小写和空格，正着读和反着读一模一样。

function palindrome(str) {
    var newStr = str.toLowerCase();
    newStr = newStr.replace(/[,.:()/\-_ ]/g, "");
    var reverseStr = reverseString(newStr);
    if (newStr == reverseStr) {
        return true;
    }
    return false;
}

function reverseString(str) {
    var array = str.split("");
    var reverseArray = array.reverse();
    return reverseArray.join("");
}

console.log(palindrome("eye")); // true
console.log(palindrome("A man, a plan, a canal. Panama")); // true
console.log(palindrome("nope")); // false
console.log(palindrome("0_0 (: /-\ :) 0-0")); // true

4、寻找最长单词

返回最长单词的长度。

function findLongestWord(str) {
    var words = str.split(" ");
    var length = 1;
    words.map(function(word) {
        length = Math.max(length, word.length);
    });
    return length;
}

console.log(findLongestWord("The quick brown fox jumped over the lazy dog")); // 6
console.log(findLongestWord("What is the average airspeed velocity of an unladen swallow")); // 8
console.log(findLongestWord("What if we try a super-long word such as otorhinolaryngology")); // 19

5、设置首字母大写

返回一个字符串, 确保字符串的每个单词首字母都大写，其余部分小写。

function titleCase(str) {
    var words = str.split(" ");
    words = words.map(function(word) {
        var newWord = word.toLowerCase();
        newWord = newWord.replace(newWord.charAt(0), newWord.charAt(0).toUpperCase());
        return newWord;
    });
    return words.join(" ");
}

console.log(titleCase("I'm a little tea pot")); // I'm A Little Tea Pot
console.log(titleCase("sHoRt AnD sToUt")); // Short And Stout
console.log(titleCase("HERE IS MY HANDLE HERE IS MY SPOUT")); // Here Is My Handle Here Is My Spout

6、寻找数组中的最大值

在大数组中包含了 4 个小数组，请分别找到每个小数组中的最大值，然后把它们串联起来，形成一个新的数组。

function largestOfFour(arr) {
    return arr.map(array => Math.max(...array));
}

console.log(largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])); // [ 27, 5, 39, 1001 ]
console.log(largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])); // [ 9, 35, 97, 1000000 ]

7、确认末尾字符

检查一个字符串 (str) 是否以指定的字符串 (target) 结尾。

function confirmEnding(str, target) {
    return str.endsWith(target);
}

console.log(confirmEnding("Bastian", "n")); // true
console.log(confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification")); // false
console.log(confirmEnding("He has to give me a new name", "name")); // true
console.log(confirmEnding("He has to give me a new name", "na")); // false

8、重复操作

循环拼接一个指定的字符串 num 次，如果 num 是一个负数, 则返回一个空字符串。

function repeat(str, num) {
    return num < 0 ? "" : str.repeat(num);
}

console.log(repeat("*", 3)); // "***"
console.log(repeat("abc", 1)); // "abc"
console.log(repeat("abc", -2)); // ""

9、字符串截取

如果字符串的长度比给定的参数 num 长，则把多余的部分用 ... 来表示。
切记，插入到字符串尾部的三个点号也会计入字符串的长度。
然而，如果指定的参数 num 小于或等于 3，则添加的三个点号不会计入字符串的长度。

function truncate(str, num) {
    if (str.length > num) {
        if (num > 3) {
            return str.slice(0, num - 3) + "...";
        } else {
            return str.slice(0, num) + "...";
        }
    } else {
        return str;
    }
}

console.log(truncate("A-tisket a-tasket A green and yellow basket", 11)); // "A-tisket...""
console.log(truncate("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)); // "A-tisket a-tasket A green and yellow basket"
console.log(truncate("A-", 1)); // "A..."

10、数组分割

编写一个函数, 把一个数组 arr 按照指定的数组大小 size 分割成若干个数组块。

function chunk(arr, size) {
    var array = [];
    for (var i = 0; i < arr.length / size; ++i) {
        array.push(arr.slice(i * size, i * size + size));
    }
    return array;
}

console.log(chunk(["a", "b", "c", "d"], 2)); // [ [ 'a', 'b' ], [ 'c', 'd' ] ]
console.log(chunk([0, 1, 2, 3, 4, 5], 4)); // [ [ 0, 1, 2, 3 ], [ 4, 5 ] ]
console.log(chunk([0, 1, 2, 3, 4, 5, 6], 3)); // [ [ 0, 1, 2 ], [ 3, 4, 5 ], [ 6 ] ]

11、数组截断

返回一个数组被截断 n 个元素后还剩余的元素，从索引 0 开始截断。

function slasher(arr, howMany) {
    arr.splice(0, howMany);
    return arr;
}

console.log(slasher([1, 2, 3], 2)); // [ 3 ]
console.log(slasher([1, 2, 3], 0)); // [ 1, 2, 3 ]
console.log(slasher([1, 2, "chicken", 3, "potatoes", "cheese", 4], 5)); // [ 'cheese', 4 ]

12、数组查询

如果数组第一个字符串元素包含了第二个字符串元素的所有字符，则函数返回 true。

function mutation(arr) {
    return arr[1].toLowerCase().split("").every(function(char) {
        return arr[0].toLowerCase().indexOf(char) >= 0;
    });
}

console.log(mutation(["hello", "hey"])); // false
console.log(mutation(["hello", "Hello"])); // true
console.log(mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"])); // true
console.log(mutation(["hello", "neo"])); // false

13、删除数组中的所有的假值

function bouncer(arr) {
    var newArray = [];
    arr.map(function(elem) {
        if (elem) {
            newArray.push(elem);
        }
    });
    return newArray;
}

console.log(bouncer([7, "ate", "", false, 9])); // [ 7, 'ate', 9 ]
console.log(bouncer([false, null, 0, NaN, undefined, ""])); // []

14、去除数组中任意多个值

实现一个 destroyer 函数，第一个参数是初始数组，后跟一个或多个参数。从初始数组中删除与这些参数具有相同值的所有元素。

function destroyer(arr, ...args) {
    var newArr = [];
    arr.filter(function(elem) {
        if (args.indexOf(elem) == -1) {
            newArr.push(elem);
        }
    });
    return newArr;
}

console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3)); // [ 1, 1 ]
console.log(destroyer(["tree", "hamburger", 53], "tree", 53)); // [ 'hamburger' ]

15、数组排序并插入值

先给数组排序，然后找到指定的值在数组的位置，最后返回位置对应的索引。

function where(arr, num) {
    arr.sort(function(a, b) {
        return a > b;
    });
    for (var i = 0; i < arr.length; ++i) {
        if (num <= arr[i]) {
            return i
        }
    }
    return arr.length;
}

console.log(where([10, 20, 30, 40, 50], 35)); // 3
console.log(where([3, 10, 5], 3)); // 0
console.log(where([1,2,3,4], 1.5)); // 1

16、位移密码

凯撒密码 Caesar cipher，又叫移位密码。移位密码也就是密码中的字母会按照指定的数量来做移位。一个常见的案例就是 ROT13 密码，字母会移位 13 个位置。由 ‘A’ -> ‘N’, ‘B’ -> ‘O’，以此类推。

写一个 ROT13 函数，实现输入加密字符串，输出解密字符串。所有的字母都是大写，不要转化任何非字母形式的字符 (例如：空格，标点符号)，遇到这些特殊字符，就跳过它们。

function rot13(str) {
    var newStr = "";
    for (var i = 0; i < str.length; ++i) {
        if (str.charCodeAt(i) > 90 || str.charCodeAt(i) < 65) {
            newStr += str.charAt(i);
            continue;
        }
        var code = str.charCodeAt(i) + 13;
        if (code < 65) {
            code = 91 - (65 - code);
        } else if (code > 90) {
            code = 64 + (code - 90);
        }
        newStr += String.fromCharCode(code);
    }
    return newStr;
}

console.log(rot13("SERR PBQR PNZC")); // "FREE CODE CAMP"
console.log(rot13("GUR DHVPX OEBJA QBT WHZCRQ BIRE GUR YNML SBK.")); // "THE QUICK BROWN DOG JUMPED OVER THE LAZY FOX."

相关链接

• W3CSchool
• https://developer.mozilla.org/zh-CN/docs/Web/JavaScript