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");

1-字符串翻转

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

 factorialize(5);

2-阶乘

 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");

3-回文算法

 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");

4-寻找最长单词

 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");

5-首字母大写

 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]]);

6-数组中的最大值

 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");

7-确认末尾字符串

 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);

8-重复操作算法

 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);

9-字符串截取

 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);

10-数组分割

 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);

11-数组截断

 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"]);

12-数组查询

 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]);

13-删除数组中特定值

 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);

14-去除数组任意多个值

 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);

15-数组排序并插入值

 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");

16-位移密码