freecodecamp_JavaScript解题集

freecodecamp_JavaScript解题集.md

基础算法

• Reverse a String

function reverseString(str) {
  //分割成列表
  var strArr = str.split("");
  //翻转列表
  var reversedArr = strArr.reverse();
  //返回合并的字符串
  return reversedArr.join("");
}

reverseString("hello");

• Factorialize a Number

function factorialize(num) {
  //计数器
  var counter = 1;
  //乘积
  var product = 1;
  while (counter <= num) {
    product *= counter;
    counter++;
  }
  return product;
}

factorialize(5);

• Check for Palindromes

function palindrome(str) {
  //删除空格并转换成小写
  str = str.replace(" ","").toLowerCase();
  //正则匹配，只处理字母或数字
  var expression = /[a-z0-9]/gi;
  var strArr = str.match(expression);
  //处理后的原始字符串
  str = strArr.join("");
  //反转，然后转换成成字符串
  var newStr = strArr.reverse().join("");
  //比较原始字符串和新字符串是否一致
  return newStr === str;
}

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

• Find the Longest Word in a String

function findLongestWord(str) {
  //分割成数组
  var strArr = str.split(" ");
  //使用sort方法，根据数组项的length来排序
  strArr.sort(function(a,b) {
    return a.length < b.length;
  });
  //排序后的首位就是长度最大的单词，直接返回长度即可
  return strArr[0].length;
}

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

• Title Case a Sentence

function titleCase(str) {
  //把传入的字符串统一转换成小写并且用空格分割成数组
  var strArr = str.toLowerCase().split(" ");
  //遍历数组
  for (var i = 0; i < strArr.length; i++) {
    //将strArr中的单词分割成字母
    var tempArr = strArr[i].split("");
    //首字母转换成大写
    tempArr[0] = tempArr[0].toUpperCase();
    //覆盖掉原来的字符串
    strArr[i] = tempArr.join("");
  }
  //返回合并的字符串
  return strArr.join(" ");
}

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

• Return Largest Numbers in Arrays

function largestOfFour(arr) {
  //存放四个数组中的最大数
  var maxNum = [];
  //用来排序的回调函数
  function sortNum(a, b) {
    return a < b;
  }
  //遍历二维数组
  for (var i = 0; i < arr.length; i++) {
    //将小数组进行排序
    var sortedList = arr[i].sort(sortNum);
    //push出最大数
    maxNum.push(sortedList[0]);
  }
  //返回新数组
  return maxNum;
}

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

• Confirm the Ending

function confirmEnding(str, target) {
  //substr方法有两个参数，第一个参数是提取字符串的位置，第二个参数是提取字符数(可选)
  var word = str.substr(-target.length);
  //判断是否匹配
  return word === target;
}

confirmEnding("Bastian", "n");

• Repeat a string repeat a string

function repeat(str, num) {
  //JavaScript的字符串不可修改，这里用一个空数组作为容器
  var strArr = [];
  for (var i = 0;i < num; i++) {
    strArr.push(str);
  }
  return strArr.join("");
}

repeat("abc", 3);

• Truncate a string

function truncate(str, num) {
  //不需要截断就直接返回原字符串
  if (num >= str.length) {
    return str;
  }
  //如果给定的长度大于3，插入到字符串尾部的三个点号也会计入字符串的长度，那就减去3来抵消掉。
  else if (num > 3) {
    return str.slice(0,num - 3) + "...";
  }
  //字符串太短就不能再计算三个点的长度了，不然太欺负人家了
  else {
    return str.slice(0,num) + "...";
  }
}

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

• Chunky Monkey

function chunk(arr, size) {
  //容器
  var newArr = [];
  //遍历数组，步长为size
  for (var i = 0; i < arr.length; i += size) {
    //slice方法可接受两个参数(均是可选参数)，一个是开始提取的索引位置，一个是结束提取的索引位置
    //所以这里可以利用size参数来提取需要的部分
    var tempArr = arr.slice(i,i + size);
    newArr.push(tempArr);
  }
  return newArr;
}

chunk([0, 1, 2, 3, 4, 5], 3);

• Slasher Flick

function slasher(arr, howMany) {
  //从索引0修改，删除数量为howMany
  arr.splice(0,howMany);
  return arr;
}

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

• Mutations

function mutation(arr) {
  //统一转换成小写
  var firstStr = arr[0].toLowerCase();
  var secondStr = arr[1].toLowerCase();
  //遍历第二个字符串
  for (var i = 0; i < secondStr.length; i++) {
    //如果第一个字符串不包含第二个字符串的某个字母，直接返回false
    if (firstStr.indexOf(secondStr[i]) < 0) {
      return false;
    }
  }
  //没有返回false说明全部包含，返回true
  return true;
}

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

• Falsy Bouncer

function bouncer(arr) {
  //直接用filter筛选
  var newArr = arr.filter(function(val) {
    //假值会被自动过滤，只保留真值
    return val;
  });
  //返回筛选后的数组
  return newArr;
}

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

• Seek and Destroy

function destroyer(arr) {
  //遍历出需要摧毁的值
  var target = [];
  for (var i = 1; i < arguments.length; i++) {
    target.push(arguments[i]);
  }
  //filter函数的回调函数
  function isTarget(val) {
    return val !== target[j];
  }
  //有几个待摧毁的值，就遍历几次数组筛选
  for (var j = 0; j < target.length; j++) {
    arr = arr.filter(isTarget);
  }
  return arr;
}

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

• Where do I belong

function where(arr, num) {
  //先把指定的值插入数组
  arr.push(num);
  //由大到小排序
  arr = arr.sort(function(a,b) {
    return a > b;
  });
  //返回指定数值的索引值
  return arr.indexOf(num);
}

where([40, 60], 50);

• Caesars Cipher

function rot13(str) { // LBH QVQ VG!
  //匹配所有大写字母的正则表达式
  var expression = /[A-Z]/g;
  //分割成列表
  var strArr = str.split(" ");
  //遍历列表
  for (var i = 0; i < strArr.length; i++) {
    //初始化一个临时变量，存放处理后的字符串
    var tempStr = "";
    //遍历列表中的所有字符
    for (var j = 0; j < strArr[i].length; j++) {
      //判断是否是大写字母
      if (strArr[i][j].match(expression)) {
        /*
        "A"的charCode 是 65，"Z"的charCode 是 90
        如果一个字母移位13个位置后(charCode+13)，超出了字母表的范围(charCode > 90)
        那么就需要移位到字母表的开头，然后继续进行位移
        */
        if (strArr[i][j].charCodeAt() + 13 > 90) {
          tempStr += String.fromCharCode(strArr[i][j].charCodeAt() + 13 - 91 + 65);
        }
        //没有超出范围，就直接移位
        else {
          tempStr += String.fromCharCode(strArr[i][j].charCodeAt() + 13);
        }
      }
      //不是大写字母不用处理，直接追加
      else {
        tempStr += strArr[i][j];
      }
    }
    //将处理后的字符串覆盖列表中原来的字符串
    strArr[i] = tempStr;
  }
  //返回合并的字符串
  return strArr.join(" ");
}

rot13("SERR PBQR PNZC");  // 你可以修改这一行来测试你的代码