前端Freecode camp

Day07 JavaScript（Algorithm）

2016-10-13  本文已影响69人  有个水友

Free Code Camp的JavaScript算法

翻转字符串（Reverse a String）

实现：先把字符串转化成数组，再借助数组的reverse方法翻转数组顺序，最后把数组转化成字符串。

function reverseString(str) {
  newStr = str.split("");    //将字符串分割为单个字符，并且每个字符作均作为数组的一个元素
  newStrReverse = newStr.reverse();      //翻转数组元素顺序
  strUnordered = newStrReverse.join("");    //连接数组的每个元素，没有分隔符，组成一个字符串
  return strUnordered;
}
reverseString("hello");

计算一个整数的阶乘（Factorialize a Number）

使用n表示一个整数，阶乘代表所有小于或等于n的整数的乘积，阶乘写成n!。
n! = 1 * 2 * 3 * ... * (n-1) * n。

function factorialize(num) {
  if(num <= 1) {
    return 1;            //处理num为0和1的情况，0！等于1。
  } else {
     return num * factorialize(num - 1);     //递归调用factorialize()函数
  }
}
factorialize(5);

字符串回文（Check for Palindromes）

01、捣鼓了一下午，终于把回文数弄出来了。之前一直卡在怎么匹配出不带标点和空白的字符串上，finally还是找到了，就是个枚举的正则表达式...顺带看了点正则表达式的知识，明、后天好好看看正则表达式的内容。
02、就是找到了效率高一点的判断回文数的方法

function palindrome(str) {
    //匹配所有标点符号（英文的），并且匹配所有空白符（/s）
    var expression = /[\ |\~|\`|\!|\@|\#|\$|\%|\^|\&|\*|\(|\)|\-|\_|\+|\=|\||\\|\[|\]|\{|\}|\;|\:|\"|\'|\,|<|\.|>|\/|\?|\s]+/g; 

    //使用replace()方法将所有标点和空白替换为空，相当于将所有文本字符连接在一起；并且将所有字符转化为小写（不会改变原字符串）
    var allChar = str.replace(expression, "").toLowerCase(); 

    //将字符串分割为单子字符数组，反转数组，再合并数组成一个字符串
    var allLowerChar = allChar.split("").reverse().join("");  、

    //比较原字符串与反转后字符串是否相同，相同返回true，不同返回false
    if(allLowerChar === allChar) {
      return true;
    } else {
      return false;
    }
}
palindrome("woca");     //调用

注：使用正则表达式expression = /[\~|\|!|@|#|$|%|^|&|*|(|)|-|_|+|=|||\|[|]|{|}|;|:|"|'|,|<|.|>|/|?]+/g`可以匹配字符串中的所有标点符号。

去掉开头的\ |，用于匹配空格，使用后面的\s来匹配所有的空白符。

function isPalindrome(str) {
    var expression = /[\ |\~|\`|\!|\@|\#|\$|\%|\^|\&|\*|\(|\)|\-|\_|\+|\=|\||\\|\[|\]|\{|\}|\;|\:|\"|\'|\,|<|\.|>|\/|\?|\s]*/g; 
    var allChar = str.replace(expression, "").toLowerCase(); 
  
    for(var i = 0, j = allChar.length - 1; i < j; i++, j--) {
      if(allChar.charAt(i) !== allChar.charAt(j)) {
        return false;
      }       //.charAt(i)返回字符串索引为i位置的字符
    } 
    return true;    //如果执行完循环没有退出，`str`为回文字符串
}
isPalindrome("ooaaoo");

找到句子中最长的单词（Find the longest world in a string）

function findLongestWord(str) {
    var strArray = str.split(" ");   //转化为以单词为元素的数组，以空格为分隔符
    var strSort = strArray.sort(function(a, b) {
      return b.length - a.length;      //递减排序（如果a-b则是递增排序），看看`sort(a, b)`的文档
   });
  
    var lenMax = strSort[0].length;
  
    return lenMax;
}
findLongestWord("The quick brown fox jumped over the lazy dog");

function titleCase(str) {
    return str.toLowerCase().split(' ').map(function(word) {
      return word.charAt(0).toUpperCase() + word.slice(1);
    }).join(' ');     //先将字符串全部转化为小写，再以空格分割为以单词为元素的数组，然后将每个单词的首字母大写，最后以空格连接每个元素，重新组合为字符串。
}
titleCase("I'm a little tea pot");

返回数组中的最大值（Return Largest Numbers in Arrays）

//返回一个数组中的最大值
function largeOne(arr) {
    var max = 0;
    for(var i = 0; i < arr.length; i++) {
      if(arr[i] > max) {
        max = arr[i];
      }
    }
    return max;
}
//分别迭代每个数组，把最大值添加到新的数组中
function largestOfFour(arr) {
    var newArr = [];
    for(var i = 0; i < arr.length; i++) {
      newArr.push(largeOne(arr[i]));       //选出最大的值并添加到新的数组中
    }
    return newArr;
}
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

检查一个字符串的结尾（Confirm the Ending）

function confirmEnding(str, target) {
    if(str.slice(str.length - target.length, str.length) === target) {   //忽略slice()的第二个参数，默认提取到字符串的末尾
      return true;
    } else {
    return false;
    }
}
confirmEnding("Bastian", "n");

function confirmEnding(str, target) {
    if(str.substr(str.length - target.length) === target) {
      return true;
    } else {
      return false;
    }
}
confirmEnding("Bastian", "n");

重复一个字符串（Repeat a String）

  function repeat(str, num) {
    var newStr = "";
    if(num <= 0) {
      return "";
    } else {
        for(var i = 0; i < num; i++) {
          newStr += str;
        }
      }  
    return newStr;
}
repeat("abc", 3);

截断字符串（Truncate a String）

function truncate(str, num) {
    //如果字符串长度大于指定参数num
    if(str.length > num) {
      //如果参数num > 3
      if(num > 3) {
        return str.slice(0, num - 3) + "...";    //-3是三个.会计入字符串的长度
      } else {
        return str.slice(0, num) + "...";      //三个.不计入字符串长度
      }
    } else {
      return str;
    }
}
truncate("A-tisket a-tasket A green and yellow basket", 11);

将数组分割为若干块（Chunky Monkey）

function chunk(arr, size) {
  var newStr = [];
  var temp = [];
  var len = arr.length;
  
  if(len < size || size <= 0) {
    return arr;
    } else {
    for(var i = 0; i < len; i += size) {
      temp = arr.slice(i, i + size);
      newStr.push(temp);
      }
    return newStr;
    }
}
chunk(["a", "b", "c", "d"], 2);

注意：参考资料

Slasher Flick

function slasher(arr, howMany) {
    if(arr.length < howMany) {
      return [];
    } else {
      var newArr = arr.slice(-(arr.length-howMany));  //采用负索引，访问数组的倒数元素
      return newArr;
    }
  }
slasher([1, 2, 3], 2);

注：采用.splice()方法，可以删除原数组中的前n个元素。.splice()会直接修改原数组。

function slasher(arr, howMany) {
    if(arr.length < howMany) {
      return [];
    } else {
      arr.splice(0, howMany);   //参考MDNjs的文档
      return arr;
    }
}
slasher([1, 2, 3], 2);

Mutations

function mutation(arr) {
    var str1 = arr[0].toLowerCase();
    var str2 = arr[1].toLowerCase();
    var len = str2.length;
  
    //遍历str2的每个字符，如果有一个字符不在str1中，则返回false，如果全部通过，则返回true
    for(var i = 0; i < len; i++){
      if(str1.indexOf(str2[i]) === -1) {
        return false;
      }
    }
    return true;
}
mutation(["hello", "hey"]);

Falsy Bouncer

function isFake(element) {
   if(element) {
     return true;
   } else {
     return false;
   }
}
function bouncer(arr) {
   var newArr = arr.filter(isFake);  
   return newArr;        //filter()方法不会改变原数组
}
bouncer([7, "ate", "", false, 9]);

Seek and Destroy

function destroyer(arr) {
    var tempArr = [];
    var newArr = [];
    var len = arguments.length;
    //构建其余参数数组
    for(var i = 1; i < len; i++) {
      tempArr.push(arguments[i]);       //使用arguments.length可以获得传入的参数数量
    }
  
    //遍历第一个数组参数，如果数组元素在tempArr中，则淘汰；如果不在，则增加到newArr中，最后得到淘汰后的数组
    for(var j = 0; j < arguments[0].length; j++) {
      if(!tempArr.includes(arguments[0][j])) {
         newArr.push(arguments[0][j]);
         }
    }
    return newArr;               //使用arguments.length可以获得传入的参数个数
}
destroyer([1, 2, 3, 1, 2, 3], 2, 3);

注：.filter()方法没有想出怎么实现。。。

Where Do I Belong

function where(arr, num) {
  // Find my place in this sorted array.
    arr.push(num);
    arr.sort(function(a, b) {
      return a - b;
    });
  
    for(var i = 0; i < arr.length; i++) {
      if(arr[i] === num) {
        return i;   //返回第一个值得索引
      }
    }
}
where([5, 3, 20, 3], 5);

Caesars Cipher

function rot13(str) { // LBH QVQ VG!
    var newArr = str.split("");
    var arr = [];
  
    //大写字母的Unicode码从65到90
    //如果在78-90之间，Unicode值减去13,；在65-77之间，Unicode值加上13
    //最后转化为字符。
    for(var i = 0; i < newArr.length; i++) {
      if(newArr[i].charCodeAt() <= 90 && newArr[i].charCodeAt() >= 78) {
        arr[i] = String.fromCharCode(newArr[i].charCodeAt() - 13);
      } else if(newArr[i].charCodeAt() <= 77 && newArr[i].charCodeAt() >= 65) {
        arr[i] = String.fromCharCode(newArr[i].charCodeAt() + 13);
      } else {
        arr[i] = newArr[i];      //不在65-90之间的不处理，略去空格和标点
      }
    } 
    return arr.join("");      //组合回字符串
}
// Change the inputs below to test
rot13("SERR PBQR PNZC");

居然做完了

哈哈，花了也不知道几天的空余时间，终于刷完了这点儿题，其中大部分都是自己完成，有些参考了网上的代码，不过都是亲手敲出来的码，哈哈哈哈，自己居然能想出来！

上一篇下一篇

猜你喜欢

热点阅读