Intermediate Algorithm Scripting (50 hours)中级算法脚本练习

1.Sum All Numbers in a Range，两个数之间所有数加起来

sumAll([1, 4]) 应该返回一个数字。
sumAll([1, 4]) 应该返回 10。
sumAll([4, 1]) 应该返回 10。

function sumAll(arr) {
  arr.sort(function(a,b){
    return a-b;
  });
  var max=arr[1];
  var min=arr[0];
  var num=max-min+1;
  return (min+max)*num/2;
}
sumAll([1, 4]);

---

2.Diff Two Arrays,比较，返回差异值组成的数组。

[1, 2, 3, 5], [1, 2, 3, 4, 5] 应该返回 [4]。
(做复杂了…)

  var newArr = [];
  var num1=arr1.length;
  var num2=arr2.length;
  var sameArr=[];
  for(i=0;i<num1;i++){
    for(j=0;j<num2;j++){
      if(arr1[i]==arr2[j]){
        sameArr.push(arr1[i]);
      }
    }
  }
  上面找出了相同的~
  下面找不同的~

  for(i=0;i<num1;i++){
    if(arr2.indexOf(arr1[i])==-1){
      newArr.push(arr1[i]);
    }
  }
  for(i=0;i<num2;i++){
    if(arr1.indexOf(arr2[i])==-1){
      newArr.push(arr2[i]);
    }
  }
  return newArr;
}

---

3.Roman Numeral Converter随机数字转化为罗马数字

(数字和字符串不能相乘，else if,前面判断了==4,后面直接<9,不要4< x<9要出错）
convert(1006) 应该返回 “MVI”。
convert(1023) 应该返回 “MXXIII”。
convert(2014) 应该返回 “MMXIV”。
convert(3999) 应该返回 “MMMCMXCIX”。

  var a=0;
  var b=0;
  var c=0;
  var d=0;

  var y=num.toString();   
var newN=y.split("");//数字分开成数组['3','6']
  var num1=newN.length;
   if(num1==1){
    d=num;
  }else if(num1==2){
    c=parseInt(newN[0]);
    d=parseInt(newN[1]);
  }else if(num1==3){
    b=parseInt(newN[0]);
    c=parseInt(newN[1]);
    d=parseInt(newN[2]);
  }else if(num1==4){
    a=parseInt(newN[0]);
    b=parseInt(newN[1]);
    c=parseInt(newN[2]);
    d=parseInt(newN[3]);
  }
  var rea="";
  var reb="";
  var rec="";
  var red="";
  for(i=1;i<=a;i++){
    rea=rea+"M";
  }

  if(b<4){
 for(i=1;i<=b;i++){
    reb=reb+"C";
  }
  }else if(b==4){
    reb="CD";
  }else if(b<9){
    reb="D";
    for(i=1;i<=b-5;i++){
    reb=reb+"C";
  }
  }else if(b==9){
    reb="CM";
  }

    if(c<4){
    for(i=1;i<=c;i++){
    rec=rec+"X";
  }
  }else if(c==4){
    rec="XL";
  }else if(c<9){
    rec="L";
    for(i=1;i<=c-5;i++){
      rec=rec+"X";
    }
  }else if(c==9){
    rec="XC";
  }
    if(d<4){
    for(i=1;i<=d;i++){
    red=red+"I";
  }
  }else if(d==4){
    red="IV";
  }else if(d<9){
        red="V";
    for(i=1;i<=d-5;i++){
      red=red+"I";}
  }else if(d==9){
    red="IX";
  } 
 var result=rea+reb+rec+red;
 return result;
}

---

4.Where art thou

写一个 function，它遍历一个对象数组（第一个参数）并返回一个包含相匹配的属性-值对（第二个参数）的所有对象的数组。如果返回的数组中包含 source 对象的属性-值对，那么此对象的每一个属性-值对都必须存在于 collection 的对象中。
- where([{ first: “Romeo”, last: “Montague” }, { first: “Mercutio”, last: null }, { first: “Tybalt”, last: “Capulet” }], { last: “Capulet” }) 应该返回 [{ first: “Tybalt”, last: “Capulet” }]。
- where([{ “a”: 1 }, { “a”: 1 }, { “a”: 1, “b”: 2 }], { “a”: 1 }) 应该返回 [{ “a”: 1 }, { “a”: 1 }, { “a”: 1, “b”: 2 }]。

function where(collection, source) {
  var arr = [];
  var count=0;
  // What's in a name?
  var keys=Object.keys(source);//返回source的属性key组成的数组
  for(i=0;i<collection.length;i++){
    for(j=0;j<keys.length;j++){
      if(collection[i].hasOwnProperty(keys[j])===true){
        if(collection[i][keys[j]] == source[keys[j]]){ //后来更正的地方1
          count++;
        }
      }
    }
    if(count==keys.length){
      arr.push(collection[i]);
    }
    count=0;  //后来更正的地方2
  }
  return arr;
}

---

5.Search and Replace

使用给定的参数对句子执行一次查找和替换，然后返回新句子。
第一个参数是将要对其执行查找和替换的句子。
第二个参数是将被替换掉的单词（替换前的单词）。
第三个参数用于替换第二个参数（替换后的单词）。
注意：替换时保持原单词的大小写。例如，如果你想用单词 “dog” 替换单词 “Book” ，你应该替换成 “Dog”。

function myReplace(str, before, after) {
  str=str.split(" ");
  var re=/[A-Z]/;
  var x=before.split("");//before首字母
  var y=after.split("");
  if(x[0].match(re)!==null){//before是大写的，则
    y[0]=y[0].toUpperCase();//after首字母大写
    after=y.join("");
  }
  for(i=0;i<str.length;i++){
    if(str[i]==before){
      str[i]=after;
    }
  }
  str=str.join(" ");
  return str;
}

6.Pig Latin

Pig Latin 把一个英文单词的第一个辅音或辅音丛（consonant cluster）移到词尾，然后加上后缀 “ay”。
如果单词以元音开始，你只需要在词尾添加 “way” 就可以了。
translate(“glove”) 应该返回 “oveglay”。
translate(“algorithm”) 应该返回 “algorithmway”。

  var newstr=str.split("");
  var yuan=["a","e","i","o","u"];//元音组
  var fu="";//辅音组
  var remain="";//剩下的
  for(i=0;i<str.length;i++){
    if(yuan.indexOf(newstr[i])!==-1){
      fu=str.substr(0,i);
      remain=str.substr(i);
      break;
    }
  }
  if(fu===""){
    str=str+"way";
  }else{
    str=remain+fu+"ay";
  }
  return str;
}

---

7.DNA Pairing

DNA 链缺少配对的碱基。依据每一个碱基，为其找到配对的碱基，然后将结果作为第二个数组返回。
Base pairs（碱基对） 是一对 AT 和 CG，为给定的字母匹配缺失的碱基。
在每一个数组中将给定的字母作为第一个碱基返回。
例如，对于输入的 GCG，相应地返回 [[“G”, “C”], [“C”,”G”],[“G”, “C”]]

function pair(str) {
  var pairs=[];
  var newStr=str.split("");
  for(i=0;i<newStr.length;i++){
    if(newStr[i]=="G"){
      pairs.push(["G","C"]);
    }
    if(newStr[i]=="C"){
      pairs.push(["C","G"]);
    }
    if(newStr[i]=="A"){
      pairs.push(["A","T"]);
    }
    if(newStr[i]=="T"){
      pairs.push(["T","A"]);
    }
  }
  return pairs;
}

---

8.Missing letters

从传递进来的字母序列中找到缺失的字母并返回它。
如果所有字母都在序列中，返回 undefined。

function fearNotLetter(str) {
  var newStr=str.split("");
  var results=[];
  var missingLetter=undefined;
  for(i=0;i<newStr.length;i++){
    var x=str.charCodeAt(i);//挨着挨着返回数字
    results.push(x);
  }
  for(i=0;i<results.length-1;i++){
    if(results[i+1]-results[i]!==1){
      missingLetter=String.fromCharCode(results[i]+1);
      break;
    }
  }
  return missingLetter;
}

---

9.Sorted Union

unite([1, 3, 2], [5, 2, 1, 4], [2, 1]) 应该返回 [1, 3, 2, 5, 4]。
unite([1, 3, 2], [1, [5]], [2, [4]]) 应该返回 [1, 3, 2, [5], [4]]。

function unite(arr) {
  //因为arr的数量不定，所以要用到arguments
  var arr1=arguments[0];
  for(i=0;i<arguments.length-1;i++){
    for(j=0;j<arguments[i+1].length;j++){
      if(arr1.indexOf(arguments[i+1][j])==-1){
        arr1.push(arguments[i+1][j]);
      }
    }
  } 
  return arr1;
}

---

10.Spinal Tap Case

将字符串转换为 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 这种形式的，也就是以连字符连接所有小写单词。
spinalCase(“thisIsSpinalTap”) 应该返回 “this-is-spinal-tap”。
spinalCase(“The_Andy_Griffith_Show”) 应该返回 “the-andy-griffith-show”。

function spinalCase(str) {
  // "It's such a fine line between stupid, and clever."
  // --David St. Hubbins
  //通过大写字母或者空格区分单词
  //找到了后转小写再连起来；
  var newstr=str.split("");
  var re=/[A-Za-z]/g;//通过判断空格或其他符号，将其变成"-"
  var rex=/[A-Z]/g;
  var count=1;
  for(i=0;i<newstr.length;i++){
    if(newstr[i].match(re)===null){
      newstr[i]="-";
      count++;
    } 
  }
  if(count===1){
    for(j=0;j<newstr.length;j++){
      if(newstr[j].match(rex)!==null){
        newstr.splice(j,0,"-");//这一句为什么bao无限循环？
        j++;//这一句贼关键！因为splice会增加或者减少数组的长度，所有j应该跟着变才对
      }
    }
  }
  str=newstr.join("").toLowerCase();
  return str;
}

---

11.Sum All Odd Fibonacci Numbers

给一个正整数num，返回小于或等于num的斐波纳契奇数之和。
斐波纳契数列中的前几个数字是 1、1、2、3、5 和 8，随后的每一个数字都是前两个数字之和。
例如，sumFibs(4)应该返回 5，因为斐波纳契数列中所有小于4的奇数是 1、1、3。

function sumFibs(num) {
  var arr=[];
  if(num==1){
   arr=[1];}
   else if(num>=2){
   arr=[1,1];
   for(i=2;i<num;i++){//得到小于或等于num的斐波纳契数组
       arr[i]=arr[i-1]+arr[i-2];
       if(arr[i]>num){//陷入崩溃，因为数组太大，内存不够，加入break，判断最大的值小于num
         arr.pop();
         break;
       }
     }
   }
  //得到他们的奇数：
  function Evennum(x){//过滤函数
    if(x%2!==0){
      return x;
    }
  }
  for(i=0;i<arr.length;i++){
    arr=arr.filter(Evennum);
  }

   arr=arr.reduce(function(a,b){//奇数之和
     return a+b;
   });
  return arr;
}

---

12.Sum All Primes

求小于等于给定数值的质数之和。
只有 1 和它本身两个约数的数叫质数。例如，2 是质数，因为它只能被 1 和 2 整除。1 不是质数，因为它只能被自身整除。
给定的数不一定是质数。
sumPrimes(977) 应该返回 73156。

function sumPrimes(num) {
  //首先是如何判断质数：不能被质数整除即为质数
  //然后把质数用数组包起来，再用reduce加起来就行了
  var arr=[2];
  var count=0;
  for(i=3;i<=num;i++){
    for(j=0;j<arr.length;j++){
          if(i%arr[j]===0){
            count++;
    }
  }
    if(count===0){
      arr.push(i);
    }
    count=0;//没算一次，count要清零
  }
  arr=arr.reduce(function(a,b){//和加起来
                 return a+b;
                 });
  return arr;
}

---

13.Smallest Common Multiple

找出能被两个给定参数和它们之间的连续数字整除的最小公倍数。
范围是两个数字构成的数组，两个数字不一定按数字顺序排序。
例如对 1 和 3 —— 找出能被 1 和 3 和它们之间所有数字整除的最小公倍数。
smallestCommons([5, 1]) 应该返回 60。
smallestCommons([1, 13]) 应该返回 360360。

function smallestCommons(arr) {
  //两个数字间的所有数都必须被整除，因此第一步是排序,然后把所有整数表达出来；
  //然后挨着判断就行了..不过会infinite loop,内存占用太大了这样
  //改进：求质数之积，再用挨着判断剩下的。然后再最后相乘。
 arr.sort(function(a,b){//排序
   return a-b;
 });
 //所有整数：
  var maxnum=arr[1];
  var minnum=arr[0];
  var result1=[];//中间存放
  var result=[];//结果
  var result2=[];//质数
  var result3=0;
  var count1=0;
  //所有整数arrPrimes[]
  for(i=1;i<maxnum-minnum;i++){
    arr.splice(i,0,minnum+i);
  }
  //其中的质数
  var arrPrimes=[2];
  var count2=0;
  for(i=3;i<=maxnum;i++){
    for(j=0;j<arrPrimes.length;j++){
      if(i%arrPrimes[j]===0){
        count2++;
      }
    }
    if(count2===0){
      arrPrimes.push(i);
    }
    count2=0;
  }
  result2=arrPrimes;
   //剩下的非素数数组
  for(i=0;i<arr.length;i++){
     if(arrPrimes.indexOf(arr[i])!==-1){
       arr.splice(i,1);
       //删除了一个总长度-1
       i--;
     }
   }//得到arr=[1,4,6,8...]非素数 result2=arrPrimes=[2,3,5,7...]素数组
  //除去非素数中的素数因数
  for(i=0;i<arrPrimes.length;i++){
    for(j=0;j<arr.length;j++){
      if(arr[j] % arrPrimes[i]===0){//取余
        arr[j]=arr[j]/arrPrimes[i];
       // result1.push(arrPrimes[i]);//加入一个因式
      }
    }
  } //过后arr=[1,2,1,4,3,1,2] 

  //非素数组挨着判断
    var Sum=arr.reduce(function(a,b){
    return a*b;
  });
  for(i=1;i<=Sum;i++){
    for(j=0;j<arr.length;j++){
      if(i%arr[j]!==0){//如果arr中有数无法被i整除
        count1++;
      }
    }
    if(count1===0){
      result3=i;
      break;
    }
    count1=0;
  } 
  result2.push(result3);
  result=result2.reduce(function(a,b){
    return a*b;
  });
  return result;
}

---

14.Drop it

让我们来丢弃数组(arr)的元素，从左边开始，直到回调函数return true就停止。
第二个参数，func，是一个函数。用来测试数组的第一个元素，如果返回fasle，就从数组中抛出该元素(注意：此时数组已被改变)，继续测试数组的第一个元素，如果返回fasle，继续抛出，直到返回true。
最后返回数组的剩余部分，如果没有剩余，就返回一个空数组。
drop([1, 2, 3, 9, 2], function(n) {return n > 2;}) 应该返回 [3, 9, 2]。
drop([0, 1, 0, 1], function(n) {return n === 1;}) 应该返回 [1, 0, 1]。

function drop(arr, func) {
  // Drop them elements
  var newArr=[];
  var test=0;

  for(i=0;i<arr.length;i++){
    newArr[0]=arr[i];//成功了的
    //console.log(newArr[0]);
    if(newArr.filter(func)[0] ===undefined){//"" 和null都不行？
      arr.shift(); //shift会改变arr的总长度
      i--;//这个刚开始忘了
      console.log(arr);//如果不满足func，则从arr删去
    }else{
      break;
    }
  }
return arr;
}

---

15.Steamroller

对嵌套的数组进行扁平化处理。你必须考虑到不同层级的嵌套。
Array.isArray()用到
steamroller([1, [], [3, [[4]]]]) 应该返回 [1, 3, 4]。
steamroller([1, {}, [3, [[4]]]]) 应该返回 [1, {}, 3, 4]。

function steamroller(arr) {
  var length=0;
  var newArr=[];
  for(i=0;i<arr.length;i++){
    if(Array.isArray(arr[i])===false){//不是array
      newArr.push(arr[i]);
    }else{//如果是arr
      if(arr[i]!=="[]"){//且不是空[];
         length=arr[i].length;//i的增加值,放在for之前，防着因为i++而改变。
        for(j=0;j<length;j++){
        arr.splice(i,0,arr[i][j]);//去掉一层[];，但解决不了[]中有两个及多个的元素问题
        i++;//里面元素按顺序加到arr中
      }
        i=i-length;
        arr.splice(i+length,1);//把[]中的多个元素拿出来加入到arr中，并删除原array[]。
     }
      if(Array.isArray(arr[i])===true){//如果去掉一层[]还是array，再进行一次这样的运算，让i--;
        i--;
      }
    }
  }
  return arr;
}

---

16.Binary Agents

传入二进制字符串，翻译成英语句子并返回。
二进制字符串是以空格分隔的。binaryAgent(“01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111”) 应该返回 “Aren’t bonfires fun!?”

function binaryAgent(str) {
  //二进制转十进制parseInt()
  //然后String.fromCharCode(65,66,67);"ABC".charCodeAt(0) // returns 65这样
  str=str.split(" ");
  for(i=0;i<str.length;i++){
    str[i]=parseInt(str[i],2);
  }
  for(i=0;i<str.length;i++){
    str[i]=String.fromCharCode(str[i]);
  }
  str=str.join("");
  return str;
}

---

17.Everything Be True

完善编辑器中的every函数，如果集合(collection)中的所有对象都存在对应的属性(pre)，并且属性(pre)对应的值为真。函数返回ture。反之，返回false。
every([{“user”: “Tinky-Winky”, “sex”: “male”}, {“user”: “Dipsy”, “sex”: “male”}, {“user”: “Laa-Laa”, “sex”: “female”}, {“user”: “Po”, “sex”: “female”}], “sex”) 应该返回 true。
every([{“user”: “Tinky-Winky”, “sex”: “male”}, {“user”: “Dipsy”}, {“user”: “Laa-Laa”, “sex”: “female”}, {“user”: “Po”, “sex”: “female”}], “sex”) 应该返回 false。

function every(collection, pre) {
  // Is everyone being true?
  //把collectioin的所有属性找出来成为一个array,然后再判断pre是否存在，值是否为false；
  var count=0;//计数用
  for(i=0;i<collection.length;i++){
    var keys=Object.keys(collection[i]);//每一项中的属性数组
    if(keys.indexOf(pre)!==-1){//如果属性存在并且值不为Boolean的false
      if(Boolean(collection[i][pre])){
        count++;
      }
    }
}
  if(count==collection.length){//数组的每一个元素都有pre属性
    return true;
  }else{
    return false;
  }
}

---

18.Arguments Optional :用到闭包

创建一个计算两个参数之和的 function。如果只有一个参数，则返回一个 function，该 function 请求一个参数然后返回求和的结果。
例如，add(2, 3) 应该返回 5，而 add(2) 应该返回一个 function。
调用这个有一个参数的返回的 function，返回求和的结果：
var sumTwoAnd = add(2);
sumTwoAnd(3) 返回 5。
如果两个参数都不是有效的数字，则返回 undefined。

function isNumber(x){//判断是否是数字
  return typeof x === 'number';
}
function add() {
  if(arguments.length==2 && isNumber(arguments[0]) && isNumber(arguments[1])){//如果有两个参数，且都是数字
    return arguments[0]+arguments[1];
  }else if(arguments.length==1 && isNumber(arguments[0])){//如果只有一个参数且为数字
    var add1=arguments[0];//add1为只存在一个的参数
    return function(){//闭包
      if(isNumber(arguments[0])){  //如果是数字    
      return add1+arguments[0];  //在不同的function里面arguments会改变，此处变成了第二个括号里的东西()
   }
  };
 }
}