W3Cschool 初级脚本算法

1.翻转字符串算法

可以先把字符串转化成数组，再借助数组的reverse方法翻转数组顺序，然后把数组转化成字符串。

知识点： .split()  .reverse()  .join()  

1)字符串转数组

.split() 将字符串以指定的分隔符分割成数组

var a = 'hello'

a.split('')  // [h, e, l, l, o]

const a = '720_1_6'

a.split('_')  // [720, 1, 6]

2)reverse()

reverse()用于颠倒数组中元素的顺序。

var arr = [1, 2, 3];
arr.reverse(); //3, 2, 1

3)数组转字符串

.join() 将数组中所有元素放到一个字符串中，并用指定的分隔符进行分割

var a = [1, 2, 3]

a.join(',')  // "1,2,3"
a.join('_')  // "1_2_3"
a.join('')   // "123"

本题代码如下：

function reverseString(str) {
    var strArr = str.split(''); // ['h','e','l','l','o']
    strArr.reverse();           // ['o','l','l','e','h']
    str = strArr.join('')       // olleh
    return str;
}

reverseString("hello");

 

2.阶乘算法

计算所提供整数的阶乘。如果使用字母n代表一个整数，则阶乘是所有小于或等于n的整数的乘积。

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

factorialize(5);

 

3.回文算法

如果给定的字符串是回文，返回true，反之，返回false。

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

function palindrome(str) {
    var regex = /[^0-9a-z]/gi;
    str = str.replace(regex, ''); // 只包含数字和字母 无多余的标点符号和空格
    str = str.toLowerCase(); // 将所有字母转为小写
    var arr = str.split("");  // 将字符串转为数组
    arr.reverse();  // 翻转
    arr = arr.join(''); // 将数组转为字符串
    if(str === arr){
        return true;
    }
    return false;
}

palindrome("eye");

4.寻找最长的单词算法

返回提供的句子中最长的单词的长度。返回值应该是一个数字。

function findLongestWord(str) {
    var arr = str.split(" ");
    var res = 0;
    for(var i=0; i<arr.length; i++){
        if( res < arr[i].length ){
            res = arr[i].length;
        }
    }
    return res;
}

findLongestWord("The quick brown fox jumped over the lazy dog");

 5.设置首字母大写算法

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

function titleCase(str) {
    var arr = str.split(" ");
    for(var i =0; i < arr.length; i++){
        // substring(1, arr[i].length)是从1开始 不包含arr[i].length
        arr[i] = arr[i][0].toUpperCase() + arr[i].substring(1, arr[i].length).toLowerCase();
    }
    str = arr.join(" ");
    return str;
}

titleCase("I'm a little tea pot");

6.寻找数组中的最大值算法

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

提示：你可以用for循环来迭代数组，并通过arr[i]的方式来访问数组的每个元素。

function largestOfFour(arr) {
    var res = [];
    for(var i=0; i<arr.length; i++){
        res[i] = arr[i][0];
        for(var j=0; j<arr[i].length; j++){
            if( res[i] < arr[i][j]){
                res[i] = arr[i][j];
            }
        }
    }
    return res;
}

largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

7.确认末尾字符算法

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

如果是，返回true;如果不是，返回false。

这个挑战可以通过在ES2015中引入的.endsWith()方法来解决。但是出于这个挑战的目的，我们希望您使用JavaScript子串方法之一。

function confirmEnding(str, target) {
    var endStr = str.substring(str.length-target.length, str.length)
    if(target === endStr){
        return true;
    }
    return false;
}

confirmEnding("Bastian", "n");

8.重复操作算法

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

function repeat(str, num) {
// repeat after me
    if(num<0){
        return "";
    }
    else{
        return str.repeat(num); // repeat()方法是js自带方法
    }
}

repeat("abc", 3);

9.字符串截取算法

如果字符串的长度比给定的参数num长，则把多余的部分用...来表示。

切记，插入到字符串尾部的三个点号也会计入字符串的长度。然而，如果指定的参数num小于或等于3，则添加的三个点号不会计入字符串的长度。

function truncate(str, num) {
// Clear out that junk in your trunk
    if( 0 < num && num <= 3 ){
        return str.slice(0, num) + "...";
    }
    else if( 3 < num && num < str.length ){
        return str.slice(0, num-3) + "...";
    }
    else{
        return str;
    }
    
}

truncate("A-tisket a-tasket A green and yellow basket", 11);

10.数组分割算法

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

例如:chunk([1,2,3,4],2)=[[1,2],[3,4]];     chunk([1,2,3,4,5],2)=[[1,2],[3,4],[5]];

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

chunk(["a", "b", "c", "d"], 2);

11.数组截断算法

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

提示：Array.prototype.slice()    Array.prototype.splice()

function slasher(arr, howMany) {
    var res = [];
    if(howMany <  arr.length){
        res = arr.slice(howMany);
        return res;
    }
    return res;
}

slasher([1, 2, 3], 2);

12.数组查询算法

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

mutation(["Mary", "Aarmy"]) 应该返回 true.mutation(["hello", "Hello"]) 应该返回 true.

function mutation(arr) {
    var str1 = arr[0].toLowerCase();
    var str2 = arr[1].toLowerCase();
    var res = -1;
    // indexOf 返回字符串出现位置 如果要检索的字符串值没有出现，则该方法返回 -1 
    for(var i=0; i<str2.length; i++){
        res = str1.indexOf(str2[i]);
            if(res < 0){
                return false;
            }	
    }
    return true;
}

mutation(["hello", "hey"]);

以下代码与本题无关，我总觉得应该找到一个删除一个，这样hello和hlllo就不算是匹配，用上面▲算法的话，认为是匹配的。

用▼算法的话，认为是不匹配的。

function mutation(arr) {
	var str1 = arr[0].toLowerCase();
	var str2 = arr[1].toLowerCase();
	var res = -1;
	// indexOf 返回字符串出现位置 如果要检索的字符串值没有出现，则该方法返回 -1 
	for(var i=0; i<str2.length; i++){
		res = str1.indexOf(str2[i]);
		if(res >= 0){
			// 在第一个字符串里删除找第二个字符串的元素 
			str1 = str1.slice(0,res) + str1.slice(res+1, str1.length)
		}
		else
			return false;
	}
	return true;
}

mutation(["hEllo", "lEy"]);

13.删除数组中特定值算法

删除数组中的所有的假值。  在JavaScript中，假值有false、null、0、""、undefined 和 NaN。

function bouncer(arr) {
// Don't show a false ID to this bouncer.
    return arr.filter(function(element){
		return !( !element || element === "")
	});
}

bouncer([7, "ate", "", false, 9]);

14.去除数组中任意多个值算法

实现一个 destroyer 函数，第一个参数是初始数组，后跟一个或多个参数。从初始数组中删除与这些参数具有相同值的所有元素。 //为什么arr里只是1, 2, 3, 1, 2, 3因为destroyer函数用arr接收1, 2, 3, 1, 2, 3 后续的没有接收

function destroyer(arr) {
    // arguments是js提供的存放函数参数的
    arrAgu = arguments;
    for(var i=1; i<arrAgu.length; i++){
        arr = arr.filter(function (val){
            return arrAgu[i] !== val;
        });
    }
    return arr;
}

destroyer([1, 2, 3, 1, 2, 3], 2, 3);

15.数组排序并插入值算法

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

举例：where([1,2,3,4], 1.5) 应该返回 1。因为1.5插入到数组[1,2,3,4]后变成[1,1.5,2,3,4]，而1.5对应的索引值就是1。

function where(arr, num) {
    // 先对数组进行排序 给sort方法传递一个比较函数
    arr.sort(function(a,b){
        return a - b;
    });
    for(var i=0; i<arr.length; i++){
        if(arr[i] >= num){
            return i;
        }
    }
    return arr.length;
}

where([5, 3, 20, 3], 5);

16.位移密码算法

下面我们来介绍著名的凯撒密码Caesar cipher，又叫移位密码。

移位密码也就是密码中的字母会按照指定的数量来做移位。

一个常见的案例就是ROT13密码，字母会移位13个位置。由'A' ↔ 'N', 'B' ↔'O'，以此类推。

写一个ROT13函数，实现输入加密字符串，输出解密字符串。

所有的字母都是大写，不要转化任何非字母形式的字符(例如：空格，标点符号)，遇到这些特殊字符，就跳过它们。

function rot13(str) { 
	var res = "";
    for(var i=0; i<str.length; i++){
    	// 先判断是否是A-Z范围之内的
        if('A' <= str[i] && str[i] <='Z' ){
        	// str.charCodeAt(i)将str中第i个字符转为ACSII值 A->65
            s = str.charCodeAt(i);
            // 如果是字母N或者之后，减13
            if(s >= 78){
            	s = s-13;
            }
            else{
            	s = s+13;
            }
            // String.fromCharCode(s)将ASCII值s转为字符 65->A
            res = res+String.fromCharCode(s);
        }
        else{
        	res = res+str[i];
        }
    }
    return res;
}
rot13("SERR PBQR PNZC");