1、区间求值算法（Sum All Numbers in a Range）
我们会传递给你一个包含两个数字的数组。返回这两个数字和它们之间所有数字的和。
最小的数字并非总在最前面。
对你有帮助的资源:
Math.max() 函数返回一组数中的最大值。
Math.min() 函数返回一组数中的最小值。
//思路：先找出最大值和最小值，循环算和
function sumAll(arr) {
var sum = 0;
var min = Math.min(arr[0],arr[1]);
var max = Math.max(arr[0],arr[1]);
for(var i = min;i<=max;i++){
sum+=i;
}
return sum;
}
sumAll([1, 4]);
2、找出数组间差异算法（Diff Two Arrays）
比较两个数组，然后返回一个新数组，该数组的元素为两个给定数组中所有独有的数组元素。换言之，返回两个数组的差异。
对你有帮助的资源:
Array.indexOf() 方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
Array.concat() 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。
//思路：分别对比两个数组中的元素，不同的加入新数组中，然后将不同的元素连接成一个新数组
function diff(arr1, arr2) {
var newArr = [];
var arr3 = [];
for (var i=0;i<arr1.length;i++) {
if(arr2.indexOf(arr1[i]) === -1) //对比
arr3.push(arr1[i]);
}
var arr4 = [];
for (var j=0;j<arr2.length;j++) {
if(arr1.indexOf(arr2[j]) === -1) //对比
arr4.push(arr2[j]);
}
newArr = arr3.concat(arr4); //连接
// Same, same; but different.
return newArr;
}
diff([1, 2, 3, 5], [1, 2, 3, 4, 5]);
3、数字转罗马数字（Roman Numeral Converter）
所有返回的 罗马数字 都应该是大写形式。
对你有帮助的资源:
Array.prototype.forEach() 方法对数组的每个元素执行一次提供的函数。
//思路：将数字对应的罗马数字建立对应的数组，将数字数组循环跟要转化的数字进行对比，找出对应区间对应的罗马数字
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){ //循环对比要转化的数字
while(num >= item){
str += romans[index]; //转化成对应的罗马数字
num -= item;
}
});
return str.toUpperCase(); //全部转化成大写
}
convert(36);
4、对象搜索算法（Where art thou）
写一个 function，它遍历一个对象数组（第一个参数）并返回一个包含相匹配的属性-值对（第二个参数）的所有对象的数组。如果返回的数组中包含 source 对象的属性-值对，那么此对象的每一个属性-值对都必须存在于 collection 的对象中。
例如，如果第一个参数是[{ first: “Romeo”, last: “Montague” }, { first: “Mercutio”, last: null }, { first: “Tybalt”, last: “Capulet” }]，第二个参数是{ last: “Capulet” }，那么你必须从数组（第一个参数）返回其中的第三个对象，因为它包含了作为第二个参数传递的属性-值对。
对你有帮助的资源:
Object.keys() 方法会返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和使用 for…in 循环遍历该对象时返回的顺序一致 （两者的主要区别是 一个 for-in 循环还会枚举其原型链上的属性）。
语法
function where(collection, source) {
var arr = [];
var arrSource=Object.keys(source);//把source的属性转化为数组
var i='',j=0;
for(i in collection){//循环collection的元素
var count=0;
for(j=0;j<arrSource.length;j++){//针对source的属性进行循环，查找这个collection元素中是否有指定的source的属性
if(collection[i][arrSource[j]]&&source[arrSource[j]]==collection[i][arrSource[j]]){
count++;
}
}
//判断：如果完全包含，这个collection的元素就被允许添加到里边。
if(count==arrSource.length){
arr.push(collection[i]);
}
}
return arr;
}
where([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });
5、查询替换算法(Search and Replace)
使用给定的参数对句子执行一次查找和替换，然后返回新句子。
第一个参数是将要对其执行查找和替换的句子。
第二个参数是将被替换掉的单词（替换前的单词）。
第三个参数用于替换第二个参数（替换后的单词）。
注意：替换时保持原单词的大小写。例如，如果你想用单词 “dog” 替换单词 “Book” ，你应该替换成 “Dog”。
//思路：确定好了要替换的单词和原来的单词之后用replace方法直接替换
function myReplace(str, before, after) {
if(before[0] === before[0].toUpperCase()){ //如果原单词大写，替换的单词也要大写
after = after[0].toUpperCase() + after.slice(1);
}
str = str.replace(before,after);
return str;
}
myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");
6、字符串移动插入算法（Pig Latin）
把指定的字符串翻译成 pig latin。
Pig Latin 把一个英文单词的第一个辅音或辅音丛（consonant cluster）移到词尾，然后加上后缀 “ay”。
如果单词以元音开始，你只需要在词尾添加 “way” 就可以了。
对你有帮助的资源:
String.substr() 方法返回一个字符串中从指定位置开始到指定字符数的字符。
//思路：用indexOf方法判断元素的第一个字母是不是元音，如果是就直接加way，如果不是就用substr方法截取将第一个字母移到最后再加ay
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";
}
translate("consonant");
7、字符配对算法（DNA Pairing）
DNA 链缺少配对的碱基。依据每一个碱基，为其找到配对的碱基，然后将结果作为第二个数组返回。
Base pairs（碱基对） 是一对 AT 和 CG，为给定的字母匹配缺失的碱基。
在每一个数组中将给定的字母作为第一个碱基返回。
例如，对于输入的 GCG，相应地返回 [[“G”, “C”], [“C”,”G”],[“G”, “C”]]
字母和与之配对的字母在一个数组内，然后所有数组再被组织起来封装进一个数组。
对你有帮助的资源:
Array.prototype.map() 方法创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
//思路：将字符串分割成数组，然后将每一个元素进行配对
function pair(str) {
var arr = str.split("");
var pair = '';
var result = arr.map(function(item,index,array){
switch(item){
case 'A':
pair = 'T';
break;
case 'T':
pair = 'A';
break;
case 'C':
pair = 'G';
break;
case 'G':
pair = 'C';
break;
}
return [item,pair];
});
return result;
}
pair("GCG");
8、字符串查询补充算法（）
从传递进来的字母序列中找到缺失的字母并返回它。
如果所有字母都在序列中，返回 undefined。
/*思路：
（1）如果传进来的不是一个按顺序来的字母队列，需要给他转成键码，排序，再转化为字符串。这段是题目之外的要求。
（2）接下来查找字符串排序后在a-z中的索引，然后根据索引用substring切割出来，用以比较（strCompare）
（3）遍历这个数组，找到没有的，*/
function fearNotLetter(str) {
var arrCover=[];
for(var i=0;i<str.length;i++){
arrCover.push(str[i].charCodeAt());
}//转化为键码
arrCover.sort(function(a,b){
return a-b;
});//重新排序
str='';//清空
for(i=0;i<arrCover.length;i++){
str+=(String.fromCharCode(arrCover[i]));
}//把转化出来的数组重新给字符串
//获取索引
var strAll='abcdefghijklmnopqrstuvwxyz';
var indexOver=strAll.indexOf(str.charAt(str.length-1));
var indexStart=strAll.indexOf(str.charAt(0));
//切割出用以比较的字符串
var strCompare=strAll.substring(indexStart,indexOver+1);
var newStr='';
if(strCompare==str){
return undefined;
}
for(i=0;i<strCompare.length;i++){
if(str.indexOf(strCompare[i])==-1){
newStr+=strAll[i];
}
}
console.log(newStr);
return newStr;
}
fearNotLetter("abce");
9、输入检查算法（Boo who）
检查一个值是否是基本布尔类型，并返回 true 或 false。
function boo(bool){
return (typeof bool == 'boolean');
}
boo(null);
10、数组去重算法（Sorted Union）
写一个 function，传入两个或两个以上的数组，返回一个以给定的原始数组排序的不包含重复值的新数组。
换句话说，所有数组中的所有值都应该以原始顺序被包含在内，但是在最终的数组中不包含重复值。
非重复的数字应该以它们原始的顺序排序，但最终的数组不应该以数字顺序排序。
这是一些对你有帮助的资源:
Arguments object
//思路：循环逐个进行对比，符合条件的放入数组中
function unite(arr1, arr2, arr3) {
var newArr=[];
for(var i=1;i<arguments.length;i++){
for(var j=0;j<arguments[i].length;j++){
if(arguments[0].indexOf(arguments[i][j])==-1){
newArr.push(arguments[i][j]);
}
}
}
newArr=arguments[0].concat(newArr);
console.log(newArr);
return newArr;
}
unite([1, 3, 2], [5, 2, 1, 4], [2, 1]);
11、html符号转实体算法（Convert HTML Entities）
将字符串中的字符&、<、>、”（双引号）, 以及’（单引号）转换为它们对应的 HTML 实体。
对你有帮助的资源:
HTML Entities
//思路：将数组分割成数组时候，每个元素进行检查，如果是符号就转化成相应的实体
function convert(str) {
var i=0;
var arr=str.split("");
for(i=0;i<arr.length;i++){
switch(arr[i]){
case '&':
arr.splice(i,1,'&');
break;
case '>':
arr.splice(i,1,'>');
break;
case '<':
arr.splice(i,1,'<');
break;
case "'":
arr.splice(i,1,''');
break;
case '"':
arr.splice(i,1,'"');
break;
}
}
str=arr.join('');
return str;
}
convert("Dolce & Gabbana");
12、字符串连接算法（Spinal Tap Case）
将字符串转换为 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 这种形式的，也就是以连字符连接所有小写单词。
function spinalCase(str) {
str=str.replace(/([A-Z]+)/g,' $1');//在大写字母前面加个空格。用$来选择小括号
str=str.replace(/\s+|_+/g,'-');//空格全部替换为-
if(str[0]=='-'){
str=str.substring(1);
}//去掉可能大写开头前面的-
str=str.replace(/--/g,'-');//把中段的--（两个）替换为一个-。(因为下划线+大写导致生成了两个-)
str=str.toLowerCase();//转换小写
rn str;
}
spinalCase('This Is Spinal Tap')
spinalCase("This Is Spinal Tap") 应该返回 "this-is-spinal-tap"。
spinalCase("thisIsSpinalTap") 应该返回 "this-is-spinal-tap"。
spinalCase("The_Andy_Griffith_Show") 应该返回 "the-andy-griffith-show"。
spinalCase("Teletubbies say Eh-oh") 应该返回 "teletubbies-say-eh-oh"。
13、斐波纳契奇数求和算法(Sum All Odd Fibonacci Numbers)
给一个正整数num，返回小于或等于num的斐波纳契奇数之和。
斐波纳契数列中的前几个数字是 1、1、2、3、5 和 8，随后的每一个数字都是前两个数字之和。
例如，sumFibs(4)应该返回 5，因为斐波纳契数列中所有小于4的奇数是 1、1、3。
提示：此题不能用递归来实现斐波纳契数列。因为当num
较大时，内存会溢出，推荐用数组来实现。
参考文档：博客园，Issue
function sumFibs(num) {
var fibo = [1, 1]; //定义数组，存放奇数1
var oddSum = 2; //定义固定和为2
while(true){
var item = fibo[0] + fibo[1]; //
if(num < item){ //当数字小于2的时候，直接返回2
return oddSum;
}
if(item % 2){ //算奇数，算和
oddSum += item;
}
fibo[0] = fibo[1];
fibo[1] = item;
}
}
sumFibs(4);
15、质素求和算法(Sum All Primes)
求小于等于给定数值的质数之和。
只有 1 和它本身两个约数的数叫质数。例如，2 是质数，因为它只能被 1 和 2 整除。1 不是质数，因为它只能被自身整除。
给定的数不一定是质数。
function sumPrimes(num) {
var arr=[2];
var sum=0;
for(var i=2;i<=num;i++){
var bCheck=true;//假定为真
for(var j=0;j<arr.length;j++){//循环数组
if(i%arr[j]==0){//如果可以被质数整除
bCheck=false;//判定为false
break;//退出循环，用不着继续判断了。
}
}
if(bCheck){
arr.push(i);
}
}
console.log(arr);
for(var k=0;k<arr.length;k++){
sum+=arr[k];
}//求和
return sum;
}
sumPrimes(10);
16、最小公倍数算法（Smallest Common Multiple）
找出能被两个给定参数和它们之间的连续数字整除的最小公倍数。
范围是两个数字构成的数组，两个数字不一定按数字顺序排序。
例如对 1 和 3 —— 找出能被 1 和 3 和它们之间所有数字整除的最小公倍数。
如果你被卡住了，记得开大招 Read-Search-Ask 。尝试与他人结伴编程、编写你自己的代码。
对你有帮助的资源:
Smallest Common Multiple
/*思路：
（1）在此之前要了解欧拉算法求最大公约数。
简单的说，求两个数的最大公约数，用大数对小数求模，如果能被整除，则小数是这两个数的最大公约数。
如果不能整除，就用小数对余数再次求模，循环此过程直到返回能除尽的那个除数。就是最大公约数。
比如20和15，用20除以15余数为5，然后用15除以余数5，能够整除，所以返回出来的除数5为这两个数的最大公约数。
（2）有了最大公约数，就可以求最小公倍数。
最小公倍数的求法是：彼此之间的乘积除以最大公约数。
因为是求几个连续自然数之间的公倍数，所以，求出前两个最小公倍数之后，用这个最小公倍数和下一个值比较。
然后就得出了新的最小公倍数。主要用的是递归的思想。*/
function smallestCommons(arr) {
arr=arr.sort(function(a,b){
return a-b;
});
function fun(m,n){
if(m%n===0) return n;
return fun(n,m%n);
}
var num=arr[0];
for(var i=arr[0]+1;i<=arr[1];i++){
num*=i/fun(num,i);
}
return num;
}
smallestCommons([1,5]);
17、数组验证算法(Finders Keepers)
写一个 function，它遍历数组 arr，并返回数组中第一个满足 func 返回值的元素。
举个例子，如果 arr 为 [1, 2, 3]，func 为 function(num) {return num === 2; }，那么 find 的返回值应为 2。
find([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; }) 应该返回 8。
find([1, 3, 5, 9], function(num) { return num % 2 === 0; }) 应该返回 undefined。
//思路：这题相比前面的简单很多了。注意：用break强制跳出循环。
function find(arr, func) {
var num = 0;
for(var i=0;i<arr.length;i++){
if(func(arr[i])===true){
num=arr[i];
break;
}
}
if(num===0){
return undefined;
}
return num;
}
find([1, 2, 3, 4], function(num){ return num % 2 === 0; });
18、数组取值算法（Drop it）
队友该卖就卖，千万别舍不得。
当你的队伍被敌人包围时，你选择拯救谁、抛弃谁非常重要，如果选择错误就会造成团灭。
如果是AD或AP，优先拯救。
因为AD和AP是队伍输出的核心。
其次应该拯救打野。
因为打野死了对面就可以无所顾虑地打龙。
最后才是辅助或上单。
因为辅助和上单都是肉，死了也不会对团队造成毁灭性影响，该卖就卖。
但真实中的团战远比这要复杂，你的队伍很可能会被敌人分割成2个或3个部分。
当你救了一个重要的人时，很可能其他队友也会因此获救。
举个例子：
辅助和AD经常是在一起的，打野和中单在一起，上单经常一个人。
你救了AD，辅助也经常因此获救。
让我们来丢弃数组(arr)的元素，从左边开始，直到回调函数return true就停止。
第二个参数，func，是一个函数。用来测试数组的第一个元素，如果返回fasle，就从数组中抛出该元素(注意：此时数组已被改变)，继续测试数组的第一个元素，如果返回fasle，继续抛出，直到返回true。
最后返回数组的剩余部分，如果没有剩余，就返回一个空数组。
//思路：遍历这个数组，然后用func判断返回的是布尔值，根据布尔值插入一个占位的字符串‘false’。待循环结束之后用filter过滤掉就行了。
function drop(arr, func) {
// Drop them elements.
for(var i=0;i<arr.length;i++){
if(func(arr[i])===false){
arr.splice(i,1,'false');
}else{
break;
}
}
arr=arr.filter(function(a){
return a!='false';
});
console.log(arr);
return arr;
}
drop([1, 2, 3], function(n) {return n < 3; });
19、数组简化算法（Steamroller）
对嵌套的数组进行扁平化处理。你必须考虑到不同层级的嵌套。
steamroller([[[“a”]], [[“b”]]]) 应该返回 [“a”, “b”]。
steamroller([1, [2], [3, [[4]]]]) 应该返回 [1, 2, 3, 4]。
steamroller([1, [], [3, [[4]]]]) 应该返回 [1, 3, 4]。
steamroller([1, {}, [3, [[4]]]]) 应该返回 [1, {}, 3, 4]。
//思路：还是用递归的办法。判断数组用isArray。算是递归方法的简单实例。
function steamroller(arr) {
// I'm a steamroller, baby
var newArr=[];
function fun(a){
for(var j=0;j<a.length;j++){
if(Array.isArray(a[j])===true){
fun(a[j]);
}else{
newArr.push(a[j]);
}
}
return newArr;
}
fun(arr);
console.log(newArr);
return newArr;
}
steamroller([1, [2], [3, [[4]]]]);
20、二进制转字符算法（Binary Agents）
传入二进制字符串，翻译成英语句子并返回。
二进制字符串是以空格分隔的。
function binaryAgent(str) {
var arr=str.split(' ');
var arr10=[];
var newStr='';
for(var i=0;i<arr.length;i++){
arr10.push(parseInt(arr[i],2));
}
for(var j=0;j<arr10.length;j++){
newStr+=String.fromCharCode(arr10[j]);
}
return newStr;
}
binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");
21、数组元素判断算法(Everything Be True)
所有的东西都是真的！
完善编辑器中的every函数，如果集合(collection)中的所有对象都存在对应的属性(pre)，并且属性(pre)对应的值为真。函数返回ture。反之，返回false。
记住：你只能通过中括号来访问对象的变量属性(pre)。
提示：你可以有多种实现方式，最简洁的方式莫过于Array.prototype.every()。
//思路：这个看起来很复杂，其实只要做个json的for-in循环，就可以实现。
function every(collection, pre) {
var i='';
var bCheck=true;//假设为真
for(i in collection){
if(!collection[i][pre]){
bCheck=false;
}
}
return bCheck;
}
every([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");
22、函数迭代可选参数算法（Arguments Optional）
创建一个计算两个参数之和的 function。如果只有一个参数，则返回一个 function，该 function 请求一个参数然后返回求和的结果。
例如，add(2, 3) 应该返回 5，而 add(2) 应该返回一个 function。
调用这个有一个参数的返回的 function，返回求和的结果：
var sumTwoAnd = add(2);
sumTwoAnd(3) 返回 5。
如果两个参数都不是有效的数字，则返回 undefined。
对你有帮助的资源:
Closures 闭包
/*思路：这个其实就是call()方法。jquery的链式操作就是这样实现的。
函数链式操作原理：返回函数本身。当然也可以返回一个别的函数。
function show(str){
alert(str);
return show;//关键
}
show('abc')('bcd')；
上述代码将弹出两个框，abc，和bcd。只要你想，可以无限地写下去。
你可以返回一个函数，那么下次操作时，得到的就是这个函数。*/
function add(x) {
if (arguments.length === 1 && typeof x === "number") {
return function (y) {
if (typeof y === "number"){
return x + y;
}
};
}else {
if (typeof x !== "number"|| typeof arguments[1] !== "number") {
return undefined;
}
return arguments[0] + arguments[1];
}
}
add(2,3);
