JS一般算法

回文算法（去除标点和空格，看字符串是否正反相同）
function palindrome(str) {
  var strno = str.replace(/[\ |\~|\`|\!|\@|\#|\$|\%|\^|\&|\*|\(|\)|\-|\_|\+|\=|\||\\|\[|\]|\{|\}|\;|\:|\"|\'|\,|\<|\.|\>|\/|\?]|\s+/g,"");
  strlow = strno.toLowerCase();
  for(var i=0,j=strlow.length-1;i<j;i++,j--){
    if(strlow.charAt(i) !== strlow.charAt(j)){
      return false;
    }
  }
  return true;
}

阶乘算法
function factorialize(num) {
  // 请把你的代码写在这里
  if(num < 0){
    return -1;
  }else if(num === 0 || num ===1){
    return 1;
  }else {
    for(var i = num - 1; i >= 1; i--){
      num *=i;
    }
  }
  
  return num;
}

字符串中每个单词首字母大写
function titleCase(str) {
  // 请把你的代码写在这里
  str = str.toLowerCase().split(" ");  //将所有字母小写
  for(var i=0;i<str.length;i++){
    var char = str[i].charAt(0);   //获取每个单词的首字母
    str[i] = str[i].replace(char,function replace(char){
      return char.toUpperCase();   //将首字母换成大写字母
    });
  }
  str = str.join(' ');
  return str;
}


返回数组中每个数组最大的数字，组成一个新的数组
function largestOfFour(arr) {
	  // 请把你的代码写在这里
	  var newArr = [];
	  for(var i = 0;i<arr.length;i++){
	  	var temp =0;
	    for(var j = 0;j<arr[i].length;j++){
	      if(temp < arr[i][j]) {
	        temp = arr[i][j];
	      }
	    }
	     newArr[i] = temp;
	  }
	  return newArr;
	}

数组分段
function chunk(arr, size) {
  	var newArr = [];
  for(var i=0;i<arr.length;i+=size){
    newArr.push(arr.slice(i,i+size));
  }
  	return newArr;
}

检测第二个字符串的所有字母是否都在第一个字符串内
function mutation(arr) {
  var newArr = [];
  for(var i = 0; i<arr.length;i++){
    newArr.push(arr[i].toLowerCase());
  }  
  for(var i = 0;i<newArr[1].length;i++){
    if(newArr[0].indexOf(newArr[1][i])==-1){
      return false;
    }
  }
  return true;
}

过滤数组中的假值，假值有false、null、0、""、undefined 和 NaN。
function bouncer(arr) {
  var newArr = arr.filter(function(value){
    return !(!value || value === "");
  });
  return newArr;
}


实现一个摧毁(destroyer)函数，第一个参数是待摧毁的数组，其余的参数是待摧毁的值。
1，function destroyer(arr) {
  var args = arguments;
  var newArr = arr.filter(function(val){
        var a = true;
        for(var i = 0; i < args.length; i++){
            if(val === args[i]){
            a = false;
            }
        }
        return a;
  });
  return newArr;
}

2，function destroyer(arr) {  
  var arr_arg = arguments;  
  for(var i = 1; i < arr_arg.length; i++){  
    arr = arr.filter(function(val){  
      return arr_arg[i] !== val;     
    });  
    }  
  return arr;  
}


一个常见的案例就是ROT13密码，字母会移位13个位置。由'A' ↔ 'N', 'B' ↔ 'O'，以此类推。
function rot13(str) { // LBH QVQ VG!
  // 请把你的代码写在这里
  var newArr = [];
  for(var i =0; i < str.length; i++){
    if(str.charCodeAt(i) < 65 || str.charCodeAt(i) >90){
      newArr.push(str.charAt(i));
    }else if(str.charCodeAt(i) >77){
      newArr.push(String.fromCharCode(str.charCodeAt(i) - 13));
    }else{
       newArr.push(String.fromCharCode(str.charCodeAt(i) + 13));
    }
  }
  return newArr.join("");
}


将数字转化为罗马数字
function convert(num) {
  var nums = [1000,900,500,400,100,90,50,40,10,9,5,4,1]; 
  var romans = ["m","cm","d","cd","c","xc","l","xl","x","ix","v","iv","i"];
  
  var str = '';  
  nums.forEach(function(item,index,array){  //对于nums数组的每个数字
    while(num >= item){  //item是当前的数组的数字，index是当前的索引
      str += romans[index];  
      num -= item;  
    }  
  });  
    
 return str.toUpperCase();
}


遍历一个对象数组（第一个参数）并返回一个包含相匹配的属性-值对（第二个参数）的所有对象的数组。如果返回的数组中包含 source 对象的属性-值对，那么此对象的每一个属性-值对都必须存在于 collection 的对象中。
function where(collection, source) {
  var arr = [];
  var keys = Object.keys(source); //source中的属性值数组
  
  for(var j=0;j<collection.length;j++){  //对于collection对象中的每一个数组

      var count=0;  

      for(var i=0;i<keys.length;i++){  
           if(collection[j].hasOwnProperty(keys[i])){  
                if(collection[j][keys[i]]==source[keys[i]]){  
                  count++;  
                }   
           }  
      } 

      if(count==keys.length){  //collection[j]完全包含source才将其加入数组
          arr.push(collection[j]);  
      } 
  }
 
  // What's in a name?
  alert(arr);
}


查找和替换，首字母大小写一致
function myReplace(str, before, after) {
  var newstr="";
  if(before[0] === before[0].toUpperCase()){
    after = after[0].toUpperCase() + after.slice(1);
  }
  
  newstr = str.replace(before,after);
  
  return newstr;
}

把指定的字符串翻译成 pig latin
function translate(str) {
  var vowel = ["a","e","i","o","u"];
  if(vowel.indexOf(str[0]) != -1){
    return str + "way";
  }
  
  while(vowel.indexOf(str[0]) == -1){
    str = str.substr(1) + str.substr(0,1);
  }
  return str + "ay";
}

从传递进来的字母序列中找到缺失的字母并返回它
function fearNotLetter(str) {
  var min = str.charCodeAt(0);
  var max = str.charCodeAt(str.length-1);
  var newArr=[];
  var newstr="";
  for(var i = min; i< max;i++){
     if(str.indexOf(String.fromCharCode(i)) == -1){
       newArr.push(i);
   	}   
  }
  newstr = String.fromCharCode.apply(null, newArr);
  if(newstr === ""){
    return undefined;
  }else{
    return newstr;
  }
  
}

写一个 function，传入两个或两个以上的数组，返回一个以给定的原始数组排序的不包含重复值的新数组。
function unite(arr1, arr2, arr3) {
  var arr = [];
  for(i=0;i<arguments.length;i++){
    for(var j=0;j<arguments[i].length;j++){
      if(arguments[0].indexOf(arguments[i][j]) == -1){
        arr.push(arguments[i][j]);
      }
    }   
  }
  arr=arguments[0].concat(arr);

  return arr;
}

将字符串转换为 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 这种形式的，也就是以连字符连接所有小写单词。
function spinalCase(str) {
  str=str.replace(/([A-Z]+)/g,' $1');   //在大写字母前面加个空格。用$1表示第一个括号的大写字母
  str=str.replace(/\s+|_+/g,'-');    //空格和下划线全部替换为-
  
  if(str[0]=='-'){
    str=str.substring(1); //首字母大写的话，也会加一个空格，即“-”，需要删除
  }
  str=str.replace(/--/g,'-');   //大写字母之前会加一个空格，原来有下划线的话，就会有两个“-”
  str=str.toLowerCase();
  return str;
}

给一个正整数num，返回小于或等于num的斐波纳契奇数之和
function sumFibs(num) {
  var arr = [];
  var i = 2;
  do{
    arr[0] = 1;
    arr[1] = 1;
    arr[i] = arr[i-2] + arr[i-1];
    i++;
  }while(arr[i-1]<=num);
  
  arr.pop();
  
  var sum = 0;
  for(var j = 0; j < arr.length; j++) {
    if(arr[j] % 2 !== 0) {
      sum += arr[j];
    }
  }
  return sum;
}

求小于等于给定数值的质数之和（筛法）
function sumPrimes(num) {
  var arr=[2];
  var total =0;
  for(var i = 2; i<= num; i++){
    var vcheck = true;
    for(var j =0;j < arr.length;j++){
      if(i%arr[j] === 0){
        vcheck = false;
        break;
      }
    }
    if(vcheck){
      arr.push(i);
    }
  }
  
  for(var k=0;k<arr.length;k++){
    total+=arr[k];
  }
  return total;
}

对嵌套的数组进行扁平化处理。你必须考虑到不同层级的嵌套。
function steamroller(arr) {
  var result=[];
  getElement(arr,result);
  return  result;
}
 function getElement(arr,result){    //嵌套函数
      for(var i=0;i<arr.length;i++){
       if(Array.isArray(arr[i])){
         getElement(arr[i],result);
       }else{
         result.push(arr[i]);
       }
      }
   return result;
  }

创建一个函数，接受两个或多个数组，返回所给数组的 对等差分(symmetric difference)(△ or ⊕)数组.
function sym(args) {
  var total = [];
  for(var i=0;i<arguments.length;i++){
    total.push(arguments[i]);
  }
  //使用reduce方法迭代，将不重复出现在下一个参数的数字取出来组成新数组再和后面的数组对比迭代。
  var temp = total.reduce(function(prev,cur,index,array){
    var a = prev.filter(function(item){
      return cur.indexOf(item)<0;
    });
    var b = cur.filter(function(item){
      return prev.indexOf(item)<0;
    });
    return a.concat(b);
  });
  //最后把得到的数组去重，利用fifter方法，函数出现的位置和索引相同时保留达到剔除重复数字的作用
  return temp.filter(function(item,index,array){
    return array.indexOf(item) == index;  /ndex是第一次出现的位置，不等于时说明不是第一次出现
  });


}