W3CSchool闯关笔记(初级脚本算法)

W3C后台校验代码bug很多，有的时候跑不过不一定是自己代码写得有问题，也许是网页后台的bug,可以自己把代码放到本地的html文件中跑一下看看

function reverseString(str) {
       
     /*
     *******学过java的朋友特别注意******
     ***JS中数组处理方法默认行为与java中的数组处理方法默认行为有差异,跑不出来的话请学习W3C官方教程中JS的对应内容了解详情
     */
     //  var arr = str.split();
     //这是把整个hello字符串作为数组的一个元素转化成数组,即便翻转数组元素只会翻转多个元素之间的位置,不会翻转元素内容
     //例如["hello"],使用reverse之后结果仍然是["hello"]
     //正确的思路应该是:吧字符串---逐个字母---存进数组,然后翻转数组输出
     
     var arr = str.split("");   //括号内加引号是逐个字符存进数组
     
     var temp = arr.reverse();  //Java中reverse方法可以直接翻转字符串,JS中不行,必须先转化成数组
     
     str = temp.join('');   //括号内加引号是规定数组元素之间以空字符连接,即元素之间直接连接
     //若括号内什么都不加,则默认数组元素之间是以逗号连接
    return str;
}

reverseString("hello");

function factorialize(num) {
    var result = 1; //这里引入了新变量result用于存放结果,对于初学者推荐使用这种方式,逻辑较为清晰
    for (var i = num; i >= 1; i--) {
        result *= i;
    }
    return result;  //注意return出来的值
}

factorialize(5);

function palindrome(str) {

    for( var i = 0; i < 50; i++){
        //将所有字符串中多余的标点符号和空格删除
        str = str.replace( /[^a-zA-Z0-1]/i ,"" );
    }
    str = str.toLowerCase();            //将清除过后的字符串中的大写字母全部换成小写
    var arr = str.split("");             //将得到的小写化的字符串逐个字符转为数组
    var reArr = arr.reverse();           //将数组元素位置翻转
    
    
    arr = str.split("");    //把数组arr的值恢复到翻转前的状态
    str = arr.join("");     //把数组arr拼接成字符串,这里注意,将数组arr拼接形成的字符串和str不同
    
    
    var reStr = reArr.join("");          //将翻转的数组拼接成字符串
    return str === reStr;

}

palindrome("A man, a plan, a canal. Panama");

function findLongestWord(str) {
    var arr = str.split(" ");   
    //引号中间不加空格时将逐个字符的转化成数组
    //引号中间加上空格,将以空格为划分界限,将相邻空格之间的所有字符作为一个数组元素
    //可以自己返回arr测试,进行比较
    var len = 0;
    for (var i = 0; i <= arr.length - 1 ; i++) {
        if (len < arr[i].length) {  //数组中单词长度比较
            len = arr[i].length;    //遇到更长的就把长度赋值给len
        }
    }
    
return len;
}

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

function titleCase(str) {
    var arr = str.toLowerCase().split(" ");     
    //把输入的字符串全部转为小写字母,再转化成数组,注意:::::会把字符串外面的引号消去
    for(var i =0; i < arr.length ; i++){
        //每个单词首字母取出转为大写后与剩余字母拼接
        arr[i] = arr[i].substring(0,1).toUpperCase() + arr[i].substring(1);
    }
    str = arr.join(" ");    //把转换完成的数组拼接成字符串
    
/*    str = "\"" + str + "\"";  因为系统bug加上这句编译反而出错,实际上加上这句输出才与题目要求一致         */

    return  str ;      //经过一系列的转换,字符串中的引号被消除了,最后要把引号加回来.
}

titleCase("sHoRt AnD sToUt");

function largestOfFour(arr) {
// You can do this!
    var newArr = [];
    var max = 0;
    for (var i = 0; i < arr.length; i++) {
        for (var j = 0; j < arr[i].length ; j++) {
            //小数组中找最大值赋值给max
            if( arr[i][j] > max){
                max = arr[i][j];
            }
        }
        newArr.push(max);
        max = 0;    //每个小数组中的最大值插入新数组后要将max清零,否则会印象后续小数组最大值的寻找
    }
    return newArr;
}

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

function confirmEnding(str, target) {
// "Never give up and good luck will find you."
// -- Falcor
/*  
    这种方法只适用于单字符,当目标是字符串时不适用
    var n = str.lastIndexOf(target);
    if ( n == str.length-1) {
        return true;
    } else {
        return false;
    }*/
/*    return n;*/

//思路,从字符串末尾处截取与匹配字符串相同长度的字符串,进行匹配
return str.substr(str.length - target.length , target.length) == target;

}

confirmEnding("Bastia3", "3");

function repeat(str, num) {
// repeat after me
/* 
******第一种,能跑过,返回值没有引号*****
    if (num <= 0) {
        return "";
    } else {
        return  str.repeat(num);
    }*/
    
    
/*******第二种,能跑过,返回值没有引号
    if(num<=0){
        return "";
    }else{
        var string="";
        for (var i = 0; i <num; i++) {
            string=string+str;
        }
    }
    return string;*/
    
/***下面为第三种,本人自己写的,网页跑不过,本地html文件中测试能满足题目所有要求,返回值有引号*****/
    if (num <= 0) {
        return outStr;
    } else {
        for (var i = 0; i < num; i++) {
            outStr += str;
        }
        return "\"" + outStr + "\"";
    }

}

var outStr = "";
/*repeat("*", 3);
repeat("abc", 3);
repeat("abc", 4);
repeat("abc", 1);
repeat("*", 8);*/
repeat("abc", 5);

function truncate(str, num) {
// Clear out that junk in your trunk
    if (num <= 3) {
        return str.slice(0,num) + "...";    
    //注意:slice方法两个参数中,前一个参数是起始截取位置,后一个参数是截取的长度,不是截取的终止位置
    } else if( num < str.length){
        return str.slice(0,num-3) + "...";
    }
    else {
        return str;
    }
}

truncate("A-", 1);

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

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

function slasher(arr, howMany) {
// it doesn't always pay to be first

return arr.slice(howMany);//slice只有一个参数n时表示将数组前面的n个元素剔除
}

slasher([1, 2, 3,4,5,6,7,5,9], 2);

function mutation(arr) {
    var str1 = arr[0].toLowerCase();
    var str2 = arr[1].toLowerCase();
    var newArr = str2.split("");
    //使用到很多方法的时候注意每个方法的细节,一点不同可能效果完全不一样,可以逐一检查是哪一步与预想不同
    for (var i = 0; i < newArr.length; i++) {
        if(  str1.indexOf(newArr[i]) < 0){
            return false;
        }
    }
    // var index = str1.indexOf(newArr[2]);
    return true;
    //本题还可以不适用indexOf方法解决,将两个字符串分别逐个字符存进两个数组,将第二个数组的所有元素在数组一中遍历
}
mutation(["hello", "neo"]);

function bouncer(arr) {
// Don't show a false ID to this bouncer.
/*filter方法的作用是将不符合括号内条件的元素删除*/
    return arr.filter(function(val){
        // 内层函数的作用是检测数组中每个元素是否为假值，即将值为false或者不为字符串或空字符串删除
        return !(!val || val === "");
    });
}

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

function destroyer(arr) {
// Remove all the values
var newArr = arguments; //获取所有参数
for (var i = 0; i <= newArr.length ; i++) {
    arr = arr.filter(function(val){
        // 内层函数执行结果为真则删除其余元素，这里逻辑有点绕，得一层层理清楚
       return newArr[i] !== val; 
    });
}
return arr;
}

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

function where(arr, num) {
// Find my place in this sorted array.
    function sortNumber(a,b){   //规定排序按数字大小排序
        return a - b
    }
    arr.push(num);  //将num插入数组
    arr.sort(sortNumber);   //将数组排序
    for (var i = 0; i <= arr.length ; i++) {
        //查找num并返回索引值
        if(arr[i] == num){
            return i;
        }
    }
}

where([40, 70,90,150,30,60], 50);

function rot13(str) { // LBH QVQ VG!
    
    var start = "A".charCodeAt(0);
    var   end = "Z".charCodeAt(0);
    var objstr = "";
    
    var strs = str.split(" ");
    for(var i=0 ; i<strs.length ; i++){
        for(var j=0 ; j<strs[i].length ; j++){
          
            if (strs[i].charCodeAt(j) >= start && strs[i].charCodeAt(j) <= end) {
                if (strs[i].charCodeAt(j)-13 >= start && strs[i].charCodeAt(j)-13 <= end) {
                    objstr += String.fromCharCode(strs[i].charCodeAt(j)-13);
                }else{
                    objstr += String.fromCharCode(strs[i].charCodeAt(j)+13);
                }
            } else {
                objstr += strs[i][j];
            }
        }
        objstr += " ";
    }
    return  objstr.substr(0 , objstr.length-1);
}

// Change the inputs below to test
rot13("SERR PBQR PNZC");