[FreeCodeCamp-JavaScript]Basic Algorithm

最近在freecodecamp上学习js基本知识，在这里做个记载，方便后面复习查看。
1.Reverse a String
翻转字符串，先把字符串转化成数组，再借助数组的reverse方法翻转数组顺序，最后把数组转化成字符串。你的结果必须得是一个字符串
注意：

-
- str.split(’ ‘)用空格分隔str；
- str.reverse()倒置str；
- str.join(’ ‘)用空格连接str；

function reverseString(str) {
  return str.split('').reverse().join('');
}

reverseString("hello");

2.Factorialize a Number
计算一个整数的阶乘,如果用字母n来代表一个整数，阶乘代表着所有小于或等于n的整数的乘积。阶乘通常简写成 n!

function factorialize(num) {
  var result=1;
  while(num>0)
  {
    result*=num;
    num--;
  }
  return result;
}

factorialize(5);

3.Check for Palindromes
如果给定的字符串是回文，返回true，反之，返回false。
如果一个字符串忽略标点符号、大小写和空格，正着读和反着读一模一样，那么这个字符串就是palindrome(回文)。
注意你需要去掉字符串多余的标点符号和空格，然后把字符串转化成小写来验证此字符串是否为回文。
注意：

str.replace(str1,str2)

• 在str中，用str2替换str1中涉及到的字符；
• str1可以是正则表达式或字符串等
• 正则表达式中 \s+ 表示匹配任意多个空白字符，包括空格、换页符、制表符等，等价于\f\n\r\t\v
• /pattern/是正则表达式的界定符，里面的内容(pattern)是要匹配的内容
• g是全局标志global的意思

function palindrome(str) {
  // Good luck!
  var newStr=str.replace(/[\ |\~|\`|\!|\@|\#|\$|\%|\^|\&|\*|\(|\)|\-|\_|\+|\=|\||\\|\[|\]|\{|\}|\;|\:|\"|\'|\,|\<|\.|\>|\/|\?]/g,"").replace(/\s+/g,"").toLowerCase();
  var i=0;
  var j=newStr.length;
  while(i<j-i-1){
    if(newStr[i]==newStr[j-1-i])
      i++;
    else
    continue;
  }
  if(i>=j-i-1)
  return true;
  else
    return false;
}


palindrome("eye");

4.Find the Longest Word in a String
找到提供的句子中最长的单词，并计算它的长度。函数的返回值应该是一个数字。

function findLongestWord(str) {
  var word=str.split(" ");
  var length=0;
  for(var i=0;i< word.length;i++){
    if(word[i].length>length)
    length=word[i].length;
  }
  return length;
}

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

5.Title Case a Sentence
确保字符串的每个单词首字母都大写，其余部分小写。像’the’和’of’这样的连接符同理。

function titleCase(str) {
  var word =str.toLowerCase().split(' ');
  var i=0;
  while(i<word.length){
    word[i]=word[i].replace(word[i].charAt(0),word[i].charAt(0).toUpperCase());
    //word[i].replace(word[i][0],word[i][0].toUpperCase());
    //word[i]=word[i][0].toUpperCase()+word[i].slice(1);
    i++;
  }
  return word.join(' ');
}

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

6.Return Largest Numbers in Arrays
右边大数组中包含了4个小数组，分别找到每个小数组中的最大值，然后把它们串联起来，形成一个新数组。
提示：你可以用for循环来迭代数组，并通过arr[i]的方式来访问数组的每个元素。
注意：

-
- arr.push(s),将s放到数组arr的末尾；
- arr.pop(s),将s从数组arr末尾取出并返回；
- arr.shift(s),将s从数组arr首部取出并返回；
- arr.unshift(s),将s插入arr首部。

function largestOfFour(arr) {
  // You can do this!
  var len1=arr.length;
  var maxs=[];
  for(var i=0;i<len1;i++){
    var max=0;
    for(var j=0;j<arr[i].length;j++){
      if(arr[i][j]>max)
        max=arr[i][j];
    }
    maxs.push(max);
  }
  return maxs;
}

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

7.Confirm the Ending
检查一个字符串(str)是否以指定的字符串(target)结尾。
如果是，返回true;如果不是，返回false。
注意：

str.substr(start[,length])

• 获取str中从start索引位置开始长度为length的子字符串
• start：开始提取子串的起始索引位置（从0开始）
• length：可选参数，表示从start位置开始提取的长度
• 如果length<=0,返回空字符串；
• 如果start>0,且start>length,返回空字符串；
• 如果start<0,获取从str尾部向首部的长度为length的子字符串；
• 如果start<0,且abs（start）>length,此时默认start=0。

function confirmEnding(str, target) {
  // "Never give up and good luck will find you."
  var len_str=str.length;
  var len_target=target.length;
  if(str.substr(-len_target)==target)
  return true;
  else
    return false;
}

confirmEnding("Bastian", "n");

8.Repeat a string repeat a string
重复一个指定的字符串 num次，如果num是一个负数则返回一个空字符串。
注意：

str.concat(str1,[str2,……，str3])

• 将str和str1、str2等多个字符串连接起来并返回
• 其中str2、str3等参数可选
• 该方法并不影响原字符串（str）的值
• 所以这里需要重新赋值str=str.concat(oldstr)

function repeat(str, num) {
  // repeat after me
  if(num<0)
    return "";
  else
    {
      var oldstr=str;
      while(num-1>0){
    str=str.concat(oldstr);
        num--;
    }
      return str;      
    } 
}

repeat("abc", 3);

9.Truncate a string
截断一个字符串！
如果字符串的长度比指定的参数num长，则把多余的部分用…来表示。
切记，插入到字符串尾部的三个点号也会计入字符串的长度。
但是，如果指定的参数num小于或等于3，则添加的三个点号不会计入字符串的长度。
注意：

str.slice(begin[,end])

• end参数可选
• 在str中截取从索引begin（从0开始）到索引end前一位的所有字符；
• 如果start为负数，会当成（str.length+start）处理
• 如果end为负数，同理，也会被当成（str.length+end）处理
• 举例说明：str.slice(1,4),只会截取第2、3、4个字符（即索引为1-3的字符），不包含索引为4的字符，这里很容易搞错！
• slice从原字符串中提取字符串，返回新字符串，但不影响原字符串

function truncate(str, num) {
  // Clear out that junk in your trunk
  var len=str.length; 
  if(len>num){
    if(num<=3){
     str=str.slice(0,num)+"..."; 
    }
    else
    {
      str=str.slice(0,num-3)+"...";
    }
  }              
  return str;
}

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

10. Chunky Monkey
把一个数组arr按照指定的数组大小size分割成若干个数组块。
例如:chunk([1,2,3,4],2)=[[1,2],[3,4]];
chunk([1,2,3,4,5],2)=[[1,2],[3,4],[5]];
注意：
声明一个空数组:
var arr=new Array();
或var arr=[];

function chunk(arr, size) {
  // Break it up.
  //new a empty array
  var newarr=new Array();
  for(var i=0;i<arr.length;i=i+size){
    newarr.push(arr.slice(i,size+i));   
  }
  return newarr;
}

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

11.Slasher Flick
返回一个数组被截断n个元素后还剩余的元素，截断从索引0开始。
注意：

str.splice(start,deletecountt[, item1[, item2[, …]]])

• 表示在str中从索引start（从0开始）开始，删除start之后deletecount个字符，并将后面item1、item2等（item参数可选，不强制要求必须向数组中添加内容）添加进数组
• 如果start>str,length,则从数组末尾添加内容
• 如果start<0,用（start+str.length）代替start即可
• 如果deletecount=0，则至少要添加一个新元素
• 如果deletecount>start之后的总元素个数，则start及start之后的都要删除
• splice和slice方法大不相同，splice可以直接操作原字符串str，而slice不影响原字符串str
• splice返回被删除字符组成的数组

function slasher(arr, howMany) {
  // it doesn't always pay to be first
  arr.splice(0,howMany);
  return arr;
}

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

12.Mutations
如果数组第一个字符串元素包含了第二个字符串元素的所有字符，函数返回true。
举例，[“hello”, “Hello”]应该返回true，因为在忽略大小写的情况下，第二个字符串的所有字符都可以在第一个字符串找到。
[“hello”, “hey”]应该返回false，因为字符串”hello”并不包含字符”y”。
[“Alien”, “ane”]应该返回true，因为”ane”中所有字符都可以在”Alien”找到。
注意：

str.indexOf(searchValue[,fromIndex])

• fromIndex参数可选，指开始查找的索引位置，如果不写，默认为0
• 在str中从索引fromIndex（从0开始）处查找searchValue
• 返回首次匹配到的索引位置；如果不存在，则返回-1

• 匹配区分大小写，即”Abc”.indexOf(“abc”)会返回-1

  str.charAt(index)，返回str中索引index处的字符

function mutation(arr) {
  //标记第二个字符串中数组是否在第一个字符串都能找到
  var flag=true;  
    for(var j=0;j<arr[1].length;j++){
      //在arr数组中第一个字符串中遍历arr中第二个字符串中的字符
      //indexOf()区分大小写，遍历前统一改成小写toLowerCase()
      //str.indexOf()返回字符串首次出现的位置，不出现则返回-1
      if(arr[0].toLowerCase().indexOf(arr[1].charAt(j).toLowerCase())==-1)
        flag=false;
    }  
  if(flag==true)
    return true;
  else
    return false;   
}

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

13.Falsy Bouncer
删除数组中的所有假值。
在JavaScript中，假值有false、null、0、”“、undefined 和 NaN（not a number）。
注意：

arr.filter(function)

• 最终返回一个新建的数组，原数组并不受影响
• function是个测试函数，对arr中每个字符用function方法测试；如果function测试通过，即返回true，则将该元素加入新建的数组中
• 对Boolean（element），当element=false、0、“”、undefined、NAN时均返回false

function bouncer(arr) {
  // Don't show a false ID to this bouncer.
  //检测element如果是false、null、0、""、undefined、NAN（not a number），则返回false；否则返回true
  function isTrue(element){
    return Boolean(element);
  }
  //用在arr中通过isTrue函数测试返回true的字符串组成新数组，并返回
 arr=arr.filter(isTrue);
  return arr;
}

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

14.Seek and Destroy
实现一个摧毁(destroyer)函数，第一个参数是待摧毁的数组，其余的参数是待摧毁的值。
例如：destroyer([1, 2, 3, 1, 2, 3], 2, 3) 应该返回 [1, 1].
注意：

arguments

• 函数的隐含对象
• 无需明确指明参数名，就能直接访问它
• arguments 对象并不是一个真正的Array,它类似于数组，但没有数组所特有的属性和方法。除了 length,即可以调用arguments.length
• 这里我还不是很清楚该隐含对象的用法，后面要注意！

function destroyer(arr) {
  // Remove all the values
  //arguments能捕捉到数组arr,这里类似于arr
  //创建空数组
  var newarr=[];
  //用待摧毁的值组成一个新数组newarr
  for(var i=1;i<arguments.length;i++)
    newarr.push(arguments[i]);
 //返回newarr中不存在的字符，即最后要保留的字符
  function notDestory(element){
  //如果newarr中不存在element，则indexOf返回-1
    return newarr.indexOf(element)<0;
  }
  var temp=arr.filter(notDestory);     
  return temp;
}

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

15.Where do I belong
先给数组排序，然后找到指定的值在数组的位置，最后返回位置对应的索引。
举例：where([1,2,3,4], 1.5) 应该返回 1。因为1.5插入到数组[1,2,3,4]后变成[1,1.5,2,3,4]，而1.5对应的索引值就是1。
同理，where([10,3,5], 9) 应该返回 2。因为数组会先排序为 [3,5,10]，9插入到数组[3,5,10]后变成[3,5,9,10]，而9对应的索引值就是2。
注意：

arr.sort([compareFunction])

• 将arr按照给定的compareFunction方法进行排序
• 参数compareFunction比较方法可选

//以数字升序排列，默认按照字符的Unicode位点进行排序
function compareFunction(a,b){
  return a-b;
}

• 如果 compareFunction(a, b) < 0 ，则 a 会被排列在 b 之前；
• 如果compareFunction（a,b）>0，则a会被排列在b之后；
• 如果compareFunction（a,b）=0，则a、b相对位置不变。
• 举例说明：arr=[2,5,1,4],
• 若排序函数为：compareFunction(a,b){ return a-b;}
• 则第一次compareFunction（2,5）,a-b=2-5=-3<0,则2（a）排在5（b）前面，即按照升序排列；
• 若排序函数为：compareFunction(a,b){ return b-a;}
• 则第一次compareFunction（2,5），b-a=5-2=3>0,则2（a）排在5（b）后面，即按照降序排列。

function where(arr, num) {
  // Find my place in this sorted array.
  //将待插入的值push插入到数组中
  arr.push(num);
  //进行数字排序，而不是默认的字符排序
  function compareNumbers(a,b){
    return a-b;
  }
  //按照升序排序
  arr.sort(compareNumbers);  
  //返回指定的值在数组中的索引位置
  return arr.indexOf(num);
}

where([40, 100], 50);

16.Caesars Cipher
移位密码也就是密码中的字母会按照指定的数量来做移位。
一个常见的案例就是ROT13密码，字母会移位13个位置。由’A’ ↔ ‘N’, ‘B’ ↔ ‘O’，以此类推。
写一个ROT13函数，实现输入加密字符串，输出解密字符串。
所有的字母都是大写，不要转化任何非字母形式的字符(例如：空格，标点符号)，遇到这些特殊字符，跳过它们。
注意：

str.charCodeAt(index)

• 返回str中索引index处的字符的Unicode编码
• 例如：”ABC”.charCodeAt(0) // returns 65（A）

String.fromCharCode(num1, …, numN)

• num1、……numN表示Unicode中的编码值
• 返回一个以num1……numN中编码对应的字符组成的字符串
• 例如：String.fromCharCode(65,66,67)//返回字符串 “ABC”

function rot13(str) { // LBH QVQ VG!
  var newstr=[];
  for(var i=0;i<str.length;i++){
    //如果大写字母从A-M,charCodeAt(i)+13
    if(str.charAt(i)>='A'&&str.charAt(i)<='M')          
     {
       newstr.push(String.fromCharCode(str.charCodeAt(i)+13));
     } 
    //如果大写字母从N-Z，charCodeAt(i)-13,因为仅在26个大写字母间变换
    else if(str.charAt(i)>='N'&&str.charAt(i)<='Z')
    {
      newstr.push(String.fromCharCode(str.charCodeAt(i)-26+13));     
    } 
    //除了大写字母之外的字符保持不变，push进数组
    else{
      newstr.push(str.charAt(i));  
    }  
  } 
  //用空格连接输出解密字符串
  return newstr.join("");
}

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