freecodecamp 算法部分刷题笔记

字符串反转

• Array.join
• Array.reverse
• Array.split

function reverseString(str) {
  str = str.split(' ').reverse();
  for(var i = 0;i < str.length;i ++){
    str[i] = str[i].split('').reverse().join('');
  }
  str = str.join(' ');
  return str;
}

reverseString("Greetings from Earth");

---

求阶乘

function factorialize(num) {
     
  var total = 1;
  if(num === 0){
    num = 1;
  }else{
    for(var i = 1;i <= num;i ++){
      total *= i;
    }
    num = total;
  }
  return num;
}

factorialize(5);

简化一下if-else

function factorialize(num) {
     
   return num > 1 ? num * factorialize(num - 1) : 1;
}

factorialize(5);

---

验证回文

String.replace()
String.toLowerCase()

\s替换空格，[^a-zA-Z0-9]/g为全局替换非字母和数字

function palindrome(str) {
     
    var newStr = str.replace(/\s/g,"").replace(/[^a-zA-Z0-9]/g,"").toLowerCase();
    var reverStr = newStr.split("").reverse().join("");
   if(reverStr === newStr){
      return true;
   }
   else{
     return false;
  } 
}

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

---

求最长单词长度

function findLongestWord(str) {
  var arr = str.split(/\s/g);
  console.log(arr);
  var length = 0;
  for(var i = 0;i < arr.length;i ++){
    length = length > arr[i].length ? length : arr[i].length;
    console.log(length);
  }
  return length;
}

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

---

大写所有单词首字母

function titleCase(str) {
     
  var arr = str.toLowerCase().split(/\s/g);
  var newStr;
  for(var i = 0;i < arr.length;i ++){
    arr[i] = arr[i][0].toUpperCase() + arr[i].substring(1, arr[i].length);
  }
  newStr = arr.join(' ');
  return newStr;
}

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

在大写首字母的时候，最开始想用arr[i][0].toUpperCase(),后来发现这样并不行，研究了一下，这个和数据结构有关，具体也不是很懂，大概就是字符串是常量存在堆里面不能修改，而数组是存储在栈里面的可以修改

---

寻找数组中数组中的最大值

function largestOfFour(arr) {
  var max = null;
  var newarr = [];
  for(var i = 0;i < arr.length;i ++){
    max = arr[i][0];
    for(var j = 1;j < arr[i].length;j ++){
      max = max >= arr[i][j] ? max : arr[i][j]; 
    }
    newarr.push(max);
  }
  return newarr;
}

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

---

检查字符串是否以指定字符串结尾

String.substr

function confirmEnding(str, target) {
     
  var tarlen = target.length;
  var subStr = str.substr(-tarlen,tarlen);
  if(subStr == target){
      return true;
  }else{
      return false;
  }
}

confirmEnding("my city Bastian", "tian");

---

重复指定次数的字符串

function repeat(str, num) {
     
  var newstr = '';
  if(num <= 0){
    return newstr;
  }else{
    for(var i = 0;i < num; i ++){
      newstr += str;
    }
  }
  return newstr;
}

repeat("abc", 3);

---

截断字符串

String.slice()

//...也要算3个字符长度
function truncate(str, num) {
  var strLen = str.length;
  if(num >= strLen){
    return str;}
  else if(num > 3){
    str = str.slice(0,num - 3) + '...';
  }else{
    str = str.slice(0,num) + "...";
  }
  return str;
}

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

---

Array.push():push可以直接push一个数组，形成二维数组，也可以通过apply把一个数组push进另一个数组，达到合并的目的。MDN上有解释
Array.slice():

方法一：通过push（），单独取出每一个数push进新数组

function chunk(arr, size) {
     
  if(arr.length <= size){
    return arr;
  }else{
    //len存储新的二维数组的一维长度
    var len = 0;
    //定义一维数组
    var newArr = new Array();
    //newSize作为子数组的长度，原因是当arr.length % size > 0时，最后一个子数组的长度是不定的，此时需要更改size的长度，而在取arr中的元素push进新数组的时候需要用到原本的size，所以创建一个size的复制的值来避免冲突。
    var newSize = size;
    //根据arr.length % size是否有余数来生成新数组的长度
    if(arr.length % size > 0){
      len = parseInt(arr.length / size) + 1;
    }else{
      len = parseInt(arr.length / size);
    }
    //三目运算符的简化：len = (arr.length % size > 0) ? len + 1 : len; 
    for(var i = 0;i < len;i ++){
      //定义二维数组
        newArr[i] = new Array();
      //这里就是当arr.length % size > 0，在生成最后一个子数组的时候，改变子数组的长度。
        if(i == parseInt(arr.length / size)){
            newSize = arr.length % size;
        }
      //给新的二维数组赋值
        for(var j = 0;j < newSize;j ++){
            newArr[i].push(arr[i * size + j]);
        }
    }
  }
  return newArr;
}  
chunk([0, 1, 2, 3, 4], 2);

方法二：通过slice（）取出新的子数组，push（）进新数组中

function chunk(arr, size) {
     
  if(arr.length <= size){
    return arr;
  }else{
    var len = parseInt(arr.length / size);
    var newArr = new Array();
    len =(arr.length % size > 0) ? len + 1 : len;   
    for(var i = 0;i < len;i ++){
        var start = i * size;
      //在生成最后一个子数组的时候，因为只有当arr.length % size > 0时，才会出现i == len的情况
        var end = (i == len) ? ((i + 1 )* size + (arr.length % size)) : (i+1) * size;
        newArr.push(arr.slice(start,end));
    }
  }
  return newArr;
}  
chunk(["a", "b", "c", "d","e"], 2);

---

返回数组被截断n个元素后剩余的元素

Array.slice()

function slasher(arr, howMany) {
     
  var newArr = [];
  if(arr.length <= howMany){
    return newArr;
  }else{
    //slice会截取从start-end的数返回新数组，但是不包括end，所以当end=arr.length时，截取到arr[7]但是不包括arr[7],并且arr[7]也不存在。或者可以省略end，就会直接截取到数组末尾了。
    newArr = arr.slice(howMany,arr.length);    
    //newArr = arr.slice(howMany);

  }
  // it doesn't always pay to be first
  return newArr;
}

slasher(["burgers", "fries", "shake"], 1);

---

判断一个字符串是否包含了第二个字符串元素的所有字符（不区分大小写）

String.indexOf()

function mutation(arr) {
     
  var target = arr[0].toLowerCase();  
  var test = arr[1].toLowerCase();
  for(var i = 0;i < test.length;i ++){
    if(target.indexOf(test[i]) ==-1){
      return false;
    }
  }
  return true;
}

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

---

去掉数组中的假值

Array.filter()
Boolean Objects

function bouncer(arr) {
     
//filter()会测试数组的每个元素，返回符合filter条件，也就是满足isBool()的元素。
   var newArr =  arr.filter(isBool);
   return newArr;
}
function isBool(value){
     
  return Boolean(value) > 0;
}

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

---

从数组中删除传入的参数

Arguments object
Array.filter()

function destroyer(arr) {
       
  //这里需要保存传入的参数，因为在匿名函数中传入的arguments发生了变化
  var tempArguments = arguments;  
  var newArr = arr.filter(function(value) {
         
    for(var i = 1; i < tempArguments.length; i++) {      
      if (value == tempArguments[i]) {        
        return false;      
      }   
    }   
    return true;
  });
  return newArr; 
}

---

先排序，再找到元素在数组中的位置

Array.sort()

function where(arr, num) {
     
  arr.push(num);
  arr.sort(function(val1,val2){
     
    return val1 - val2;
  });

  return arr.indexOf(num);
}

where([40, 60], 50);

---

ROT13解码

String.fromCharCode()
String.charCodeAt()
Function.prototype.apply()

function rot13(str) {
     
  //newStr用来转化大小写
  var newStr = str.toUpperCase();
  //由于需要把字符串中的字母转换为编码值，但是不能直接更改字符串中的某个元素，所以需要一个数组来作为中介
  var newArr = new Array();
  for(var i = 0;i < newStr.length;i ++){
    //如果是大写字母则进行解码，解码规则是A-M和N-Z相互对应。如果是其他字符则只是转换为编码值。
    if(newStr[i] >= 'A' && newStr[i] <= 'Z'){
        newArr[i] =  newStr.charCodeAt(i) <= 77 ? newStr.charCodeAt(i) + 13 :  newStr.charCodeAt(i) - 13;
    }else{
        newArr[i] = newStr.charCodeAt(i);
    }
  }
  // newStr = newArr.join(',');
  //formCharCode只能接受字符串参数，所以通过apply()完成传参。
  return String.fromCharCode.apply(this,newArr);
}

rot13("GUR DHVPX OEBJA QBT WHZCRQ BIRE GUR YNML SBK.");

---

总结

• split() → 数组 → join() → 字符串 → split() 以上方法不改变原始数组，返回原始数组被改变后的一个新数组
• splice() 从原始数组中删除/添加元素，返回被删除的元素组成的数组，改变原始数组
• slice() 从原始数组中选择从开始到结束的数组，不包括结束，返回被选择的元素组成的数组，不改变原始数组
• substr(),substring():substring接收的是起始位置和结束位置(不包括结束位置)，而substr接收的则是起始位置和所要返回的字符串长度,两者都用于处理字符串，不能直接用于数组

终于结束了阶段性的刷题，不管还记得多少，至少学会了认真阅读文档，当然还有很多比如apply()这种自己看了一百遍，但是也不知道什么时候该用的问题继续困扰着自己，比如闭包，也是模模糊糊，你说我知道，你让我做，sorry我是猪。所以还要多看书，多实战，fcc这样的刷题练习真的很好呀。开心~~撒花