├── README.md
├── 初级算法
    ├── 11-Slasher Flick.js
    ├── 1-Reverse a String.js
    ├── 2-Factorialize a Number.js
    ├── 3-Check for Palindromes.js
    ├── 8-Repeat a string repeat a string.js
    ├── 14-Seek and Destroy.js
    ├── 7-Confirm the Ending.js
    ├── 12-Mutations.js
    ├── 9-Truncate a string.js
    ├── 10-Chunky Monkey.js
    ├── 15-Where do I belong.js
    ├── 13-Falsy Bouncer.js
    ├── 16-Caesars Cipher.js
    ├── 6-Return Largest Numbers in Arrays.js
    ├── 4-Find the Longest Word in a String.js
    └── 5-Title Case a Sentence.js
├── 中级算法
    ├── 16-Finders Keepers.js
    ├── 9-Boo who.js
    ├── 17-Drop it.js
    ├── 5-Search and Replace.js
    ├── 13-Sum All Odd Fibonacci Numbers.js
    ├── 7-DNA Pairing.js
    ├── 2-Diff Two Arrays.js
    ├── 20-Everything Be True.js
    ├── 6-Pig Latin.js
    ├── 8-Missing letters.js
    ├── 1-Sum All Numbers in a Range.js
    ├── 10-Sorted Union.js
    ├── 12-Spinal Tap Case.js
    ├── 19-Binary Agents.js
    ├── 21-Arguments Optional.js
    ├── 18-Steamroller.js
    ├── 14-Sum All Primes.js
    ├── 4-Where are you.js
    ├── 15-Smallest Common Multiple.js
    ├── 11-Convert HTML Entities.js
    └── 3-Roman Numeral Converter.js
├── 附件
    ├── 直接插入排序.js
    ├── 冒泡排序.js
    ├── 简单选择排序.js
    ├── 希尔排序.js
    ├── 归并排序.js
    ├── 最小公倍数和最大公约数.js
    ├── 二分查找.js
    ├── 快速排序.js
    └── 全排列.js
└── 高级算法
    ├── 8-Map the Debris.js
    ├── 1-Validate US Telephone Numbers.js
    ├── 2-Symmetric Difference.js
    ├── 7-Make a Person.js
    ├── 9-Pairwise.js
    ├── 5-No repeats please.js
    ├── 4-Inventory Update.js
    ├── 3-Exact Change.js
    └── 6-Friendly Date Ranges.js


/README.md:
--------------------------------------------------------------------------------
1 | # FreeCodeCamp
2 | freecodecamp前端训练项目解答
3 | #### 2016-6-26：算法部分更新完毕
4 | 所有解答都通过了测试，无一例外
5 | 
6 | 


--------------------------------------------------------------------------------
/初级算法/11-Slasher Flick.js:
--------------------------------------------------------------------------------
1 | //数组截头存尾
2 | /*2016-6-19 By沐浴星光*/
3 | function slasher(arr, howMany) {
4 |   arr.splice(0,howMany);
5 |   return arr;
6 | }
7 | slasher([1, 2, 3], 2);


--------------------------------------------------------------------------------
/初级算法/1-Reverse a String.js:
--------------------------------------------------------------------------------
1 | // 反转字符串
2 | /*2016-6-18 By沐浴星光*/
3 | function reverseString(str) {
4 |  
5 | return str.split("").reverse().join("");//将字符串转化成数组，反转后在转化成字符串
6 | }
7 | reverseString("hello");
8 | 


--------------------------------------------------------------------------------
/初级算法/2-Factorialize a Number.js:
--------------------------------------------------------------------------------
 1 | //数字阶乘
 2 | /*2016-6-19 By沐浴星光*/
 3 | function factorialize(num) {
 4 | 	if (num<=1) {
 5 | 		return 1;//0的阶乘为0,同时也是递归出口
 6 | 	}
 7 |   return num*factorialize(num-1);//使用递归
 8 | }
 9 | 
10 | factorialize(5);
11 | 


--------------------------------------------------------------------------------
/中级算法/16-Finders Keepers.js:
--------------------------------------------------------------------------------
1 | //查找数组中符合条件的元素
2 | function findElement(arr, func) {
3 |   var num=arr.filter(function(item,index,arr){
4 |   	return func(item);
5 |   });
6 |   return num[0];
7 | }
8 | 
9 | findElement([1, 2, 3, 4], function(num){ return num % 2 === 0; });


--------------------------------------------------------------------------------
/中级算法/9-Boo who.js:
--------------------------------------------------------------------------------
 1 | //判断一个值是否为布尔原始值
 2 | 
 3 | function booWho(bool) {
 4 |   // What is the new fad diet for ghost developers? The Boolean.
 5 |   if(bool===false || bool===true){//使用恒等
 6 |   	return true;
 7 |   }else{
 8 |   	return false;
 9 |   }
10 | }
11 | 
12 | booWho(null);


--------------------------------------------------------------------------------
/初级算法/3-Check for Palindromes.js:
--------------------------------------------------------------------------------
1 | //回文字符串
2 | /*2016-6-19 By沐浴星光*/
3 | function palindrome(str) {
4 |   
5 |   var newStr=str.replace(/[^a-zA-Z0-9]/g,"").toLowerCase();//将非数字字母替换掉
6 |   return newStr.split("").reverse().join("")===newStr;//比较反转前后是否相等
7 | }
8 | palindrome("race car");
9 | 


--------------------------------------------------------------------------------
/初级算法/8-Repeat a string repeat a string.js:
--------------------------------------------------------------------------------
 1 | //重复字符串
 2 | /*2016-6-19 By沐浴星光*/
 3 | function repeatStringNumTimes(str, num) {
 4 | 	var newStr="";
 5 | 
 6 | 	for (var i = num; i >0; i--) {
 7 | 		newStr+=str;
 8 | 	}
 9 | 	return newStr;
10 | 	
11 | }
12 | 
13 | console.log(repeatStringNumTimes("abc", 3));


--------------------------------------------------------------------------------
/中级算法/17-Drop it.js:
--------------------------------------------------------------------------------
 1 | //从数组开头删除数组中不符合要求的元素直到遇到一个符合要求的元素，
 2 | //返回这个符合要求的元素及后面的所有元素组成的数组
 3 | 
 4 | function dropElements(arr, func) {
 5 |   // Drop them elements.
 6 |   while(func(arr[0])==false){
 7 |   	arr.shift();
 8 |   }
 9 |   return arr;
10 | }
11 | 
12 | dropElements([1, 2, 3], function(n) {return n < 3; });


--------------------------------------------------------------------------------
/初级算法/14-Seek and Destroy.js:
--------------------------------------------------------------------------------
 1 | //查找并删除数组中特定值
 2 | /*2016-6-19 By沐浴星光*/
 3 | function destroyer(arr) {
 4 | 	var arg=Array.prototype.slice.call(arguments,1);
 5 | 	var newArr=arr.filter(function(item,index,arr){
 6 | 		return arg.indexOf(item)==-1;
 7 | 	});
 8 |   return newArr;
 9 | }
10 | 
11 | destroyer([1, 2, 3, 1, 2, 3], 2, 3);


--------------------------------------------------------------------------------
/初级算法/7-Confirm the Ending.js:
--------------------------------------------------------------------------------
 1 | //确认字符串以特定子串结尾
 2 | /*2016-6-19By沐浴星光*/
 3 | function confirmEnding(str, target) {
 4 |   var targetLength=target.length;
 5 |   var strLength=str.length;
 6 |   var substr=str.substr(strLength-targetLength,targetLength);
 7 |   return substr===target;
 8 | }
 9 | 
10 | confirmEnding("Bastian", "n");


--------------------------------------------------------------------------------
/中级算法/5-Search and Replace.js:
--------------------------------------------------------------------------------
1 | //查找和替换
2 | function myReplace(str, before, after) {
3 | 	if (before.charCodeAt(0)<=90) {//如果首字母是大写的
4 | 		after=after.charAt(0).toUpperCase()+after.substring(1);
5 | 	} 
6 |   return str.replace(before,after);
7 | }
8 | 
9 | console.log(myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped"));


--------------------------------------------------------------------------------
/中级算法/13-Sum All Odd Fibonacci Numbers.js:
--------------------------------------------------------------------------------
 1 | //求所有斐波那契数列中奇数的和
 2 | function sumFibs(num) {
 3 | 	var fib1=1,fib2=1;
 4 | 	var sum=fib1+fib2;
 5 | 	var next=fib1+fib2;
 6 | 	while(next<=num){
 7 | 		if(next%2==1){
 8 | 			sum+=next;
 9 | 		}
10 | 		fib1=fib2;
11 | 		fib2=next;
12 | 		next=fib1+fib2;
13 | 	}
14 | 	return sum;
15 | }
16 | sumFibs(4);


--------------------------------------------------------------------------------
/初级算法/12-Mutations.js:
--------------------------------------------------------------------------------
 1 | //转变
 2 | /*2016-6-19 By沐浴星光*/
 3 | function mutation(arr) {
 4 | 	var first=arr[0].toLowerCase();
 5 | 	var second=arr[1].toLowerCase();
 6 |   for (var i = 0; i < second.length; i++) {
 7 |   	if(first.indexOf(second[i])===-1)
 8 |   		return false;
 9 |   }
10 |   return true;
11 | }
12 | 
13 | mutation(["hello", "hey"]);


--------------------------------------------------------------------------------
/初级算法/9-Truncate a string.js:
--------------------------------------------------------------------------------
 1 | //截断字符串
 2 | /*2016-6-19 By沐浴星光*/
 3 | 
 4 | function truncateString(str, num) {
 5 | 
 6 | 	if(str.length<=num){
 7 | 		return str;
 8 | 	}
 9 | 	else{
10 | 		return (num<=3)?(str.slice(0,num)+"..."):(str.slice(0,num-3)+"...");
11 | 	}
12 | 
13 | }
14 | truncateString("A-tisket a-tasket A green and yellow basket", 11);


--------------------------------------------------------------------------------
/初级算法/10-Chunky Monkey.js:
--------------------------------------------------------------------------------
 1 | //数组分块
 2 | /*2016-6-19 By沐浴星光*/
 3 | function chunkArrayInGroups(arr, size) {
 4 |   // Break it up.
 5 |   var newArr=[];
 6 |   var index=0;
 7 |   while(index<arr.length){
 8 |   	newArr.push(arr.slice(index,index+=size));
 9 |   }
10 |   return newArr;
11 | }
12 | 
13 | console.log(chunkArrayInGroups(["a", "b", "c", "d"], 2));


--------------------------------------------------------------------------------
/中级算法/7-DNA Pairing.js:
--------------------------------------------------------------------------------
 1 | //DNA配对
 2 | /*A-T,C-G*/
 3 | function pairElement(str) {
 4 |   var arr=str.split("");
 5 |   var pairArr=arr.map(function(item,index,arr){
 6 |   	var pair=[];
 7 |   	var rules={"A":"T","T":"A","C":"G","G":"C"};
 8 |   	 pair.push(item,rules[item]);
 9 |   	 return pair;
10 |   });
11 |   return pairArr;
12 | }
13 | 
14 | pairElement("GCG");


--------------------------------------------------------------------------------
/中级算法/2-Diff Two Arrays.js:
--------------------------------------------------------------------------------
 1 | // 合并两个数组的不重复元素组成新的数组
 2 | function diffArray(arr1, arr2) {
 3 | 
 4 | 	var diff1=arr1.filter(function(item,index,arr){
 5 | 		return arr2.indexOf(item)==-1;
 6 | 	});
 7 | 	var diff2=arr2.filter(function(item,index,arr){
 8 | 		return arr1.indexOf(item)==-1;
 9 | 	});
10 | 	return diff1.concat(diff2);
11 | }
12 | diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]);


--------------------------------------------------------------------------------
/中级算法/20-Everything Be True.js:
--------------------------------------------------------------------------------
1 | //检查一组对象集合中每个对象的某个属性是否为有效值
2 | function truthCheck(collection, pre) {
3 |   return collection.every(function(item,index,arr){
4 |   	return Boolean(item[pre])!==false;
5 |   });
6 | }
7 | 
8 | truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"},
9 |  {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");


--------------------------------------------------------------------------------
/中级算法/6-Pig Latin.js:
--------------------------------------------------------------------------------
 1 | //儿童黑话
 2 | /*辅音是单词中第一个元音字母前面所有的字母构成*/
 3 | 
 4 | function translatePigLatin(str) {
 5 |   var pattern=/^[^aeiou]+/;//正则表达式匹配开头
 6 |   if (pattern.test(str)) {
 7 |   	 str+=(RegExp.lastMatch+"ay");
 8 |   	 str=str.slice(RegExp.lastMatch.length);
 9 |   }else{
10 |   	str+="way";
11 |   }
12 |   return str;
13 | }
14 | 
15 | console.log(translatePigLatin("consonant"));


--------------------------------------------------------------------------------
/初级算法/15-Where do I belong.js:
--------------------------------------------------------------------------------
 1 | //定位数据插入的位置
 2 | /*2016-6-19 By沐浴星光*/
 3 | function getIndexToIns(arr, num) {
 4 |   // Find my place in this sorted array.
 5 |   var index=0;
 6 |   arr.sort(function(value1,value2){
 7 |   	return value1-value2;
 8 |   });
 9 |   console.log(arr);
10 |   while(num>arr[index++]){
11 |   }
12 |   return index-1;
13 | }
14 | 
15 | getIndexToIns([40, 60], 50);
16 | 


--------------------------------------------------------------------------------
/中级算法/8-Missing letters.js:
--------------------------------------------------------------------------------
 1 | //查找丢失的字母
 2 | 
 3 | function fearNotLetter(str) {
 4 |   var missing;
 5 |   for (var i = 0; i < str.length-1; i++) {
 6 |   	if (str.charCodeAt(i+1)==parseInt(str.charCodeAt(i),10)+1) {
 7 |   		continue;
 8 |   	}else{
 9 |   		missing="";
10 |   		missing+=String.fromCharCode(parseInt(str.charCodeAt(i),10)+1);
11 |   	}
12 |   }
13 |   return missing;
14 | }
15 | 
16 | fearNotLetter("abce");


--------------------------------------------------------------------------------
/附件/直接插入排序.js:
--------------------------------------------------------------------------------
 1 | var insertionSort=function (arr) {
 2 | 	var length=arr.length;
 3 | 	for (var i = 1; i < length; i++) {
 4 | 		var temp=arr[i];//待插入元素
 5 | 		var j=i;
 6 | 		while (j>0&&temp<arr[j-1]) {//从已有序的序列最后一个元素开始往前比较
 7 | 			arr[j]=arr[j-1];//如果不符合插入要求，那么与之比较的元素就要后移
 8 | 			j--;
 9 | 		}
10 | 		arr[j]=temp;//插入元素到合适位置		
11 | 	}
12 | 	return arr;
13 | }
14 | var arr=[85,24,63,45,17,31,96,50];
15 | console.log(insertionSort(arr));
16 | 


--------------------------------------------------------------------------------
/中级算法/1-Sum All Numbers in a Range.js:
--------------------------------------------------------------------------------
 1 | //累加一段范围内的数字
 2 | function sumAll(arr) {
 3 |   var max=Math.max.apply(null,arr);
 4 |   var min=Math.min.apply(null,arr);
 5 |   var newArr=[];
 6 |   var sum;
 7 |   for (var i = min; i <= max; i++) {
 8 |   	 newArr.push(i);
 9 | 
10 |   }
11 |    sum=newArr.reduce(function(prev,cur,index,array){
12 |    		return prev+cur;
13 |    });
14 |    
15 |    return sum;
16 | }
17 | console.log(sumAll([1, 4]));


--------------------------------------------------------------------------------
/中级算法/10-Sorted Union.js:
--------------------------------------------------------------------------------
 1 | //返回一组数组集合中的唯一项组成的新数组
 2 | function uniteUnique(arr) {
 3 | 	var result=[];
 4 | 	arg=Array.prototype.slice.call(arguments);
 5 | 	result=arg.reduce(function(prev,cur,index,arg){
 6 | 		for (var i = 0; i < cur.length; i++) {
 7 | 			if (prev.indexOf(cur[i])==-1) {
 8 | 				prev.push(cur[i]);
 9 | 			}
10 | 		}
11 | 		return prev;
12 | 	});
13 |   return result;
14 | }
15 | 
16 | uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]);


--------------------------------------------------------------------------------
/附件/冒泡排序.js:
--------------------------------------------------------------------------------
 1 | var bubbleSort=function (arr) {
 2 | 	var length=arr.length;
 3 | 	for (var i = 0; i < length; i++) {
 4 | 		/*因为每冒泡一次就会将本次最大值放在最后，所以后面的就不需要再比较了，
 5 | 		所以可以从内循环减去外循环已经跑过的轮数*/
 6 | 		for (var j = 0; j <length-1-i; j++) {
 7 | 			if (arr[j]>arr[j+1]) {
 8 | 				var temp=arr[j];
 9 | 				arr[j]=arr[j+1];
10 | 				arr[j+1]=temp;
11 | 			}
12 | 		}
13 | 		
14 | 	}
15 | 	return arr;
16 | }
17 | var arr=[85,24,63,45,17,31,96,50];
18 | console.log(bubbleSort(arr));
19 | 
20 | 


--------------------------------------------------------------------------------
/高级算法/8-Map the Debris.js:
--------------------------------------------------------------------------------
 1 | //求轨道运行周期
 2 | /*2016-6-26 By沐浴星光*/
 3 | function orbitalPeriod(arr) {
 4 |   var GM = 398600.4418;
 5 |   var earthRadius = 6367.4447;
 6 | 
 7 | 	for (var i = 0; i < arr.length; i++) {
 8 | 		var orbitalPeriod=2*Math.PI*Math.pow(Math.pow(earthRadius+arr[i].avgAlt,3)/GM,0.5);
 9 | 		delete arr[i].avgAlt;
10 | 		arr[i].orbitalPeriod=Math.round(orbitalPeriod);
11 | 	}
12 |   
13 |   return arr;
14 | }
15 | 
16 | orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}]);


--------------------------------------------------------------------------------
/中级算法/12-Spinal Tap Case.js:
--------------------------------------------------------------------------------
 1 | function spinalCase(str) {
 2 |   // "It's such a fine line between stupid, and clever."
 3 |   // --David St. Hubbins
 4 |   var pattern=/[A-Z\_]/g;
 5 |  return  str.replace(pattern,function(match){
 6 |   	if (match==="_") {//将所有的下划线替换成空格
 7 |   		return " ";
 8 |   	}else{
 9 |   		return	" "+match;//在所有大写字母前面添加空格
10 |   	}
11 |   }).trim().replace(/\s+/g,'-').toLowerCase();//去掉字符串首尾空格，将空格替换成“-”,并小写
12 | 
13 | 
14 | 
15 | }
16 | 
17 | spinalCase('This Is Spinal Tap');


--------------------------------------------------------------------------------
/中级算法/19-Binary Agents.js:
--------------------------------------------------------------------------------
 1 | //二进制转字符串
 2 | function binaryAgent(str) {
 3 |   var arr=str.split(" ");
 4 |   var output="";
 5 |   for (var i = 0; i < arr.length; i++) {
 6 |   	var char=String.fromCharCode(parseInt(arr[i],2));
 7 |   	output+=char;
 8 |   }
 9 | 
10 |   return output;
11 | }
12 | 
13 | binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");


--------------------------------------------------------------------------------
/中级算法/21-Arguments Optional.js:
--------------------------------------------------------------------------------
 1 | function addTogether() {
 2 | 	var len=arguments.length;
 3 | 	if(len===1&&typeof arguments[0]=="number"){
 4 | 		var para1=arguments[0];
 5 | 		return function(num){
 6 | 			if (typeof num!=="number") {
 7 | 				return undefined;
 8 | 			}
 9 | 			return num+para1;
10 | 		};
11 | 	}else if(len===2 && typeof arguments[0]=="number"&& typeof arguments[1]=="number"){
12 | 		return arguments[0]+arguments[1];
13 | 	}else{
14 | 		return undefined;
15 | 	}
16 | }
17 | 
18 | console.log(addTogether(2));


--------------------------------------------------------------------------------
/附件/简单选择排序.js:
--------------------------------------------------------------------------------
 1 | var selectionSort=function (arr) {
 2 | 	var length=arr.length;
 3 | 	for (var i = 0; i < length; i++) {
 4 | 		var min=i;//用一个变量存储最小值下标，初始值为仍未排序的第一个元素的下标
 5 | 		for (var j = i+1; j <length; j++) {
 6 | 			//与当前最小值比较，如果小于当前最小值，最小值下标就要移动了
 7 | 			if (arr[j]<arr[min]) {
 8 | 				min=j;
 9 | 			}
10 | 		}
11 | 		if(min!=i){//如果最小值下标移动了，就交换元素
12 | 			var temp=arr[i];
13 | 			arr[i]=arr[min];
14 | 			arr[min]=temp;
15 | 		}
16 | 	}
17 | 	return arr;
18 | }
19 | 
20 | var arr=[85,24,63,45,17,31,96,50];
21 | console.log(selectionSort(arr));
22 | 


--------------------------------------------------------------------------------
/初级算法/13-Falsy Bouncer.js:
--------------------------------------------------------------------------------
 1 | //移除数组中的假值
 2 | /*2016-6-19 By沐浴星光*/
 3 | /*
 4 | console.log(new Boolean(false)==false);
 5 | console.log(new Boolean(null)==false);
 6 | console.log(new Boolean(0)==false);
 7 | console.log(new Boolean("")==false);
 8 | console.log(new Boolean(undefined)==false);
 9 | console.log(new Boolean(NaN)==false);
10 | //以上表达式都返回true
11 | */
12 | function bouncer(arr) {
13 | 	var newArr=arr.filter(function(item,index,arr){
14 | 		return new Boolean(item)!=false;
15 | 	});
16 | 	
17 | 	return newArr;
18 | }
19 | 
20 | bouncer([7, "ate", "", false, 9]);
21 | 
22 | 
23 | 


--------------------------------------------------------------------------------
/附件/希尔排序.js:
--------------------------------------------------------------------------------
 1 | var shellSort=function (arr) {
 2 | 	var length=arr.length;
 3 | 	var gap=Math.floor(length/2);
 4 | 	while(gap>=1){
 5 | 		for (var i = gap; i < length; i++) {
 6 | 			var j=i;
 7 | 			var temp=arr[i];
 8 | 			/*对距离为gap的元素组内进行直接插入排序
 9 | 			下面这段是不是似曾相识，和直接排序算法如出一辙。
10 | 			这不过直接排序算法的gap为1*/
11 | 			while(j >=0&&temp<arr[j-gap]) {
12 | 				arr[j]=arr[j-gap];//元素在本组内后移
13 | 				j-=gap;
14 | 			}
15 | 			arr[j]=temp;
16 | 		}
17 | 
18 | 		gap=Math.floor(gap/2);
19 | 	}
20 | 
21 | 	return arr;	
22 | 
23 | }
24 | 
25 | var arr=[85,24,63,45,17,31,96,50,23];
26 | console.log(shellSort(arr));
27 | 


--------------------------------------------------------------------------------
/初级算法/16-Caesars Cipher.js:
--------------------------------------------------------------------------------
 1 | //凯撒密码
 2 | /*2016-6-19 By沐浴星光*/
 3 | function rot13(str) { // LBH QVQ VG!
 4 |   var newStr;
 5 |   var charCodeArr=[];//存储所有转换后的字符编码
 6 |   var charCode;
 7 |   for (var i = 0; i < str.length; i++) {
 8 |   	charCode=str.charCodeAt(i);
 9 |   	if(charCode>=65&&charCode<=90){
10 |       charCodeArr.push((charCode-13)>=65?(charCode-13):(90-65-13+charCode+1));//90-[13-(charCode-65)]+1
11 |   	}else{
12 |   		charCodeArr.push(charCode);
13 |   	}
14 |   }
15 |   
16 |   return String.fromCharCode.apply(null,charCodeArr);
17 | }
18 | 
19 | // Change the inputs below to test
20 | rot13("SERR PBQR PNZC");


--------------------------------------------------------------------------------
/高级算法/1-Validate US Telephone Numbers.js:
--------------------------------------------------------------------------------
 1 | //验证北美电话号码的有效性
 2 | /*2016-6-22 By沐浴星光*/
 3 | function telephoneCheck(str) { 
 4 | 	var pattern=/^1?\s?(\()?\d{3}(\))?[\s-]?\d{3}[\s-]?\d{4}$/;
 5 | 	//由于JavaScript不支持条件匹配，所以，上面的正则表达式无法剔除只有单括号的情况
 6 | 	//，这里使用了一个很巧妙的方法，在两个括号处使用了两个子表达式，下面检测只有当这两个表达式
 7 | 	//同时匹配到或者同时没匹配到时才返回true,这样就不会出现单括号的情况了
 8 | 
 9 | 	if(pattern.test(str)){
10 | 		if(RegExp.$1&&RegExp.$2){
11 | 
12 | 			return true;
13 | 		}else if(!RegExp.$1&&!RegExp.$2){
14 | 			return true;
15 | 		}
16 | 		else{
17 | 
18 | 			return false;
19 | 		}
20 | 
21 | 	}
22 | 
23 | 	return false;
24 | 
25 | }
26 | 
27 | 
28 | telephoneCheck("555-555-5555");


--------------------------------------------------------------------------------
/中级算法/18-Steamroller.js:
--------------------------------------------------------------------------------
 1 | // 将多维数组展平为一位数组
 2 | // 下面的代码参考了undercscore库的源代码http://www.css88.com/doc/underscore/docs/underscore.html
 3 | function steamrollArray(arr) {
 4 | 	var output=[],idx=0;
 5 | 	for (var i = 0; i < arr.length; i++) {//遍历数组
 6 | 		var item=arr[i];
 7 | 		if(Array.isArray(item)){//如果数组元素还是元素就递归
 8 | 			item=steamrollArray(item);	//递归过后的返回值还是数组
 9 | 			var j=0,len=item.length;
10 | 			output.length+=len;
11 | 			while(j<len){//将结果填进output数组
12 | 				output[idx++]=item[j++];
13 | 			}
14 | 		}else{//如果数组元素不是数组，则直接填进结果数组
15 | 			output[idx++]=item;
16 | 		}
17 | 	}
18 | 		return output;
19 | }
20 | 
21 | 
22 | steamrollArray([[1], [2]]);


--------------------------------------------------------------------------------
/中级算法/14-Sum All Primes.js:
--------------------------------------------------------------------------------
 1 | //计算素数之和
 2 | function sumPrimes(num) {
 3 | 	
 4 | 	var sum=0;
 5 |     var isPrime=function(n){//判断一个数是否是质数
 6 |     	if (n===2) {
 7 |     		return true;
 8 |     	}else{
 9 |     		//实际上不用检查n开二次方根以上的数,试想一下，
10 |     		//如果有一个大于根号n的整数p能被n整除，则结果q必然小于根号n,
11 |     		//那么n也能被q整除，结果是p,因为q<p,所以在下面的循环中i=q会先不符合要求返回false,后面也就不用检查了
12 |     		for (var i = 2; i*i <= n; i++) {
13 |     			if (n%i===0) {
14 |     				return false;
15 |     			}
16 |     		}
17 |     	}
18 |     	return true;
19 |     };
20 | 
21 |     for (var j = 2; j <=num; j++) {
22 |     	if (isPrime(j)) {
23 |     		sum+=j;
24 |     	}
25 |     }
26 |     return sum;
27 | }
28 | 
29 | sumPrimes(10);


--------------------------------------------------------------------------------
/中级算法/4-Where are you.js:
--------------------------------------------------------------------------------
 1 | //从对象数组中查找拥有特殊键值的对象
 2 | function whereAreYou(collection, source) {
 3 |   // What's in a name?
 4 |   var arr = [];
 5 |   // Only change code below this line
 6 |   arr=collection.filter(function(obj){//过滤出符合条件的项
 7 |   	var keys=Object.keys(source);//提取所有要查找的键
 8 |   	var match=keys.every(function(item){//对于所有的键在collection的某一项是否都存在且值相等
 9 |   		return obj.hasOwnPropety(item)&&source[item]===obj[item]					
10 |   	});
11 | 
12 |   	return match;
13 |   });
14 |  
15 |   // Only change code above this line
16 |   return arr;
17 | }
18 | 
19 | whereAreYou([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });
20 | 


--------------------------------------------------------------------------------
/初级算法/6-Return Largest Numbers in Arrays.js:
--------------------------------------------------------------------------------
 1 | //查找数组集合里每一个数组的最大值组成的数组
 2 | /*2016-6-19 By沐浴星光*/
 3 | 
 4 | Array.prototype.myMap = function (fn) {//ES5之前不支持数组迭代方法，自定义一个迭代方法
 5 |   var ary = [];
 6 |   if (Array.prototype.map) {//如果有原生迭代map方法就直接调用
 7 |     ary = this.map(fn);
 8 |   } else {
 9 |     for (var i = 0; i < this.length; i++) {
10 |       ary[i] = fn.apply(null, [this[i], i, this]);
11 |     }
12 |   }
13 |   return ary;
14 | }
15 | 
16 | 
17 | function largestOfFour(arr) {
18 |   var largestArr=arr.myMap(function(item,index,arr){
19 |   	return Math.max.apply(null,item);
20 |   });
21 |   return largestArr;
22 | }
23 | 
24 | largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);


--------------------------------------------------------------------------------
/附件/归并排序.js:
--------------------------------------------------------------------------------
 1 | var mergeSort=function (arr) {
 2 | 	if (arr.length<=1) {
 3 | 		return arr;
 4 | 	}
 5 | 	var mid=Math.floor(arr.length/2),
 6 | 	left=arr.slice(0,mid),
 7 | 	right=arr.slice(mid,arr.length);
 8 | 	return merge(mergeSort(left),mergeSort(right));
 9 | }
10 | var merge=function(left,right){
11 | 	var result=[],i=0,j=0;
12 | 	while(i<left.length&&j<right.length){
13 | 		if (left[i]<right[j]) {
14 | 			result.push(left[i++]);
15 | 		}else{
16 | 			result.push(right[j++]);
17 | 		}
18 | 	}
19 | 	while(i<left.length){
20 | 		result.push(left[i++]);
21 | 	}
22 | 	while(j<right.length){
23 | 		result.push(right[j++]);
24 | 	}
25 | 	return result;
26 | }
27 | 
28 | var arr=[85,24,63,45,17,31,96,50];
29 | console.log(mergeSort(arr));
30 | 


--------------------------------------------------------------------------------
/初级算法/4-Find the Longest Word in a String.js:
--------------------------------------------------------------------------------
 1 | // 计算句子中最长单词的长度
 2 | /*2016-6-19 By沐浴星光*/
 3 | Array.prototype.myMap = function (fn) {//ES5之前不支持数组迭代方法，自定义一个迭代方法
 4 |   var ary = [];
 5 |   if (Array.prototype.map) {//如果有原生迭代map方法就直接调用
 6 |     ary = this.map(fn);
 7 |   } else {
 8 |     for (var i = 0; i < this.length; i++) {
 9 |       ary[i] = fn.apply(null, [this[i], i, this]);
10 |     }
11 |   }
12 |   return ary;
13 | }
14 | 
15 | function findLongestWord(str) {
16 |   var arr=str.split(" ");//将句子分割成数组
17 |   var lenArr=arr.myMap(function(item,index,array){//使用map方法返回数组每项长度
18 |   	return item.length;
19 |   });
20 |   return Math.max.apply(null,lenArr);//借用apply求最大值
21 | }
22 | findLongestWord("The quick brown fox jumped over the lazy dog");


--------------------------------------------------------------------------------
/高级算法/2-Symmetric Difference.js:
--------------------------------------------------------------------------------
 1 | //求数组集对称差分数组
 2 | ///*2016-6-22 By沐浴星光*/
 3 | function sym(args) {
 4 | 	var arrays=Array.prototype.slice.call(arguments);
 5 | 
 6 | 	//首先对数组进行去重
 7 | 	for (var i = 0; i < arrays.length; i++) {		
 8 | 		var temp=[];
 9 | 		for (var j = 0; j < arrays[i].length; j++) {
10 | 			if (temp.indexOf(arrays[i][j])===-1) {
11 | 				temp.push(arrays[i][j])
12 | 			}
13 | 		}
14 | 		arrays[i]=temp;
15 | 	}
16 | 
17 | 	return arrays.reduce(function(prev,cur,index,args){
18 | 		for (var i = 0; i < cur.length; i++) {
19 | 			var idx=prev.indexOf(cur[i]);
20 | 			if(idx===-1){
21 | 				prev.push(cur[i]);
22 | 			}else{
23 | 				prev.splice(idx,1);
24 | 			}	 
25 | 		}
26 | 		return prev; 
27 | 	});
28 | 	
29 | }
30 | 
31 | sym([1,3],[3,4,5,5]);


--------------------------------------------------------------------------------
/中级算法/15-Smallest Common Multiple.js:
--------------------------------------------------------------------------------
 1 | //求数组元素的最小公倍数
 2 | /*依次求出前两个数的最小公倍数，并将求出的最小公倍数放入数组，重复前面的过程*/
 3 | function smallestCommons(arr) {
 4 |     var max=Math.max.apply(null,arr),min=Math.min.apply(null,arr);
 5 |     var newArr=[];
 6 |     for (var i = min; i <=max; i++) {
 7 |     	newArr.push(i);
 8 |     }
 9 |     //循环法求最小公倍数
10 |     var scm=function(m,n){
11 |     	var min=Math.min(m,n),max=Math.max(m,n);
12 |     	var i=1;
13 |     	while(i<=max){
14 |     		var temp=min*i;
15 |     		if(temp%max===0){
16 |     			return temp;
17 |     		}
18 |     		i++;
19 |     	}
20 |     };
21 |     
22 |     var scms=newArr.reduce(function(prev,cur,index,arr){
23 |     	return scm(prev,cur);
24 |     });
25 |     return scms;
26 |    
27 | }
28 | 
29 | 
30 | console.log(smallestCommons([1,5]));


--------------------------------------------------------------------------------
/初级算法/5-Title Case a Sentence.js:
--------------------------------------------------------------------------------
 1 | //句子单词首字母大写化
 2 | /*2016-6-18 By沐浴星光*/
 3 | 
 4 | Array.prototype.myMap = function (fn) {//ES5之前不支持数组迭代方法，自定义一个迭代方法
 5 |   var ary = [];
 6 |   if (Array.prototype.map) {//如果有原生迭代map方法就直接调用
 7 |     ary = this.map(fn);
 8 |   } else {
 9 |     for (var i = 0; i < this.length; i++) {
10 |       ary[i] = fn.apply(null, [this[i], i, this]);
11 |     }
12 |   }
13 |   return ary;
14 | }
15 | 
16 | function titleCase(str) {
17 |     var newStr=str.toLowerCase();//将句子转化成小写
18 |     var wordArr=newStr.split(" ");//将句子分割成数组
19 |     var newWorldArr=wordArr.map(function(item,index,arr){
20 |     	return item.charAt(0).toUpperCase()+item.substring(1);//新的数组项由每一项的第一个字母大写+后面的字符拼接而成
21 |     });
22 | return newWorldArr.join(" ");
23 | }
24 | 
25 | titleCase("I'm a little tea pot");


--------------------------------------------------------------------------------
/高级算法/7-Make a Person.js:
--------------------------------------------------------------------------------
 1 | //创建对象
 2 | /*2016-6-25 By沐浴星光*/
 3 | var Person = function(firstAndLast) {
 4 | 	var fullName=firstAndLast;
 5 | 	var object={};
 6 | 	this.getFirstName=function(){
 7 | 		return fullName.split(" ")[0];
 8 | 	};
 9 | 	this.getLastName=function(){
10 |     	return fullName.split(" ")[1];
11 |     };
12 |     this.getFullName=function(){
13 |     	return fullName;
14 |     };
15 |     this.setFirstName=function(first){
16 |     	fullName=first+" "+fullName.split(" ")[1];
17 |     	return;
18 |     };
19 |     this.setLastName=function(last){
20 |     	fullName=fullName.split(" ")[0]+" "+last;
21 |     	return;
22 |     };
23 |     this.setFullName=function(firstAndLast){
24 |     	fullName=firstAndLast;
25 |     };
26 | };
27 | 
28 | var bob = new Person('Bob Ross');
29 | bob.getFullName();


--------------------------------------------------------------------------------
/高级算法/9-Pairwise.js:
--------------------------------------------------------------------------------
 1 | //数组配对
 2 | /*2016-6-26 By沐浴星光*/
 3 | /*这一题题目要求好像有点问题
 4 | If multiple pairs are possible that have the same numeric elements but different indices,
 5 |  return the smallest sum of indices.但是后面的测试用例中pairwise([0, 0, 0, 0, 1, 1], 1) should return 10.
 6 |  按照上面的要求银应该返回4
 7 | */
 8 | function pairwise(arr, arg) {
 9 |   var indices=[];
10 |   if (arr.length===0) {
11 |   	return 0;
12 |   }
13 |   for (var i = 0; i < arr.length-1; i++) {
14 |   	for (var j = i+1; j < arr.length; j++) {
15 |   		if (arr[i]+arr[j]==arg&&indices.indexOf(i)==-1&&indices.indexOf(j)==-1) {
16 |   			indices.push(i,j);
17 |   		}
18 |   	}
19 |   }
20 | 
21 | 
22 | 
23 |   var sum=indices.reduce(function(prev,cur,index,arr){
24 |   	return prev+cur;
25 |   });
26 |    return sum;
27 | }
28 | 
29 | pairwise([1,4,2,3,0,5], 7);


--------------------------------------------------------------------------------
/附件/最小公倍数和最大公约数.js:
--------------------------------------------------------------------------------
 1 | /*求最大公约数和最小公倍数*/
 2 | 
 3 | //递归法求最大公约数
 4 | function mcd1(m,n) {
 5 | 	var min=Math.min(m,n),max=Math.max(m,n);
 6 | 	if (max%min===0) {
 7 | 		return  min;
 8 | 	}else{
 9 | 		return mcd1(min,max%min);
10 | 	}
11 | }
12 | 
13 | //循环法求最大公约数
14 | function mcd2(m,n) {
15 | 	var min=Math.min(m,n),max=Math.max(m,n);
16 | 	while(max%min!=0){
17 | 		var temp=max%min;
18 | 		max=min;
19 | 		min=temp;
20 | 	}
21 | 	return min;
22 | }
23 | 
24 | //利用最大公约数求最小公倍数,a，b的最大公约数记为（a，b）,整数a，b的最小公倍数记为[a，b]
25 | //(a,b)[a,b]=ab(a,b均为整数)则最小公倍数=两数的乘积/最大公约数
26 | function scm1(m,n){
27 | 	return m*n/mcd1(m,n);
28 | }
29 | 
30 | //循环法求最小公倍数
31 | function scm2(m,n){
32 | 	var min=Math.min(m,n),max=Math.max(m,n);
33 | 	var i=1;
34 | 	while(i<=max){
35 | 		var temp=min*i;
36 | 		if(temp%max===0){
37 | 			return temp;
38 | 		}
39 | 		i++;
40 | 	}
41 | }
42 | 
43 | 


--------------------------------------------------------------------------------
/中级算法/11-Convert HTML Entities.js:
--------------------------------------------------------------------------------
 1 | //方法一
 2 | // function convertHTML(str) {
 3 | //   // &colon;&rpar;
 4 | //   var pattern=/[&<>"']/g;
 5 | //   rules={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&apos;"};
 6 | 
 7 | 
 8 | //  return str.replace(pattern,function(match){
 9 | //   	return	rules[match];
10 | //   });
11 | // }
12 | // console.log(convertHTML("<Tom & Jerry>"));
13 | 
14 | //方法二
15 | function convertHTML(str) {
16 |   // &colon;&rpar;
17 |   var pattern=/[&<>"']/g;
18 |   return str.replace(pattern,function(match){
19 |   	switch(match){
20 |   		case "<":
21 |   		return "&lt;";
22 |   		case ">":
23 |   		return "&gt;";
24 |   		case "&":
25 |   		return "&amp;";
26 |   		case "\"":
27 |   		return "&quot;";
28 |   		case "\'":
29 |   		return "&apos;"; 
30 |   	}
31 |   });
32 | }
33 | console.log(convertHTML("<Tom & Jerry>"));
34 | 


--------------------------------------------------------------------------------
/高级算法/5-No repeats please.js:
--------------------------------------------------------------------------------
 1 | //同一个字母不相邻的排列组合
 2 | /*2016-6-23 By沐浴星光*/
 3 | /*先组合出所有的情况，再使用正则表达式过滤掉不符合的情况*/
 4 | 
 5 | function permAlone(str) {
 6 | 
 7 | 
 8 | 	var regex = /(.)\1+/g;
 9 | 
10 | 	var permutate=function(str) {
11 | 
12 | 		var result=[];
13 | 		if(str.length==1){
14 | 			return [str];  	
15 | 		}else{
16 | 			
17 | 				var preResult=permutate(str.slice(1));
18 | 				for (var j = 0; j < preResult.length; j++) {
19 | 					for (var k = 0; k < preResult[j].length+1; k++) {
20 | 						var temp=preResult[j].slice(0,k)+str[0]+preResult[j].slice(k);					
21 | 						result.push(temp);
22 | 
23 | 					}
24 | 				}
25 | 
26 | 			return result;
27 | 		}  
28 | 	};
29 | 
30 | 	var permutations= permutate(str);
31 | 
32 | 
33 | 	var filtered = permutations.filter(function(string) {
34 | 		return !string.match(regex);
35 | 	});
36 | 
37 | 
38 | 	return filtered.length;
39 | }
40 | 
41 | console.log(permAlone('aab'));


--------------------------------------------------------------------------------
/附件/二分查找.js:
--------------------------------------------------------------------------------
 1 | //二分查找
 2 | 
 3 | 
 4 | //快速排序
 5 | var quickSort=function(arr){
 6 | 	if(arr.length<=1){
 7 | 		return arr;
 8 | 	}
 9 | 	var pivotIndex=Math.floor((arr.length/2));
10 | 	var pivot=arr.splice(pivotIndex,1)[0];
11 | 	var left=[],right=[];
12 | 	for (var i = 0; i < arr.length; i++) {
13 | 		if(arr[i]<pivot){
14 | 			left.push(arr[i]);
15 | 		}else{
16 | 			right.push(arr[i]);		
17 | 		}
18 | 	}
19 | 	return quickSort(left).concat([pivot],quickSort(right));
20 | }
21 | 
22 | 
23 | var binarySearch=function(arr,item){
24 | 	arr=quickSort(arr);//先对序列排序
25 | 	var low=0,
26 | 	high=arr.length-1,
27 | 	mid;
28 | 	while(low<=high){
29 | 		mid=Math.floor((high+low)/2);
30 | 		if (arr[mid]<item) {
31 | 			low=mid+1;
32 | 		}else if (arr[mid]>item) {
33 | 			high=mid-1;
34 | 		}else{
35 | 			return mid;
36 | 		}
37 | 	}
38 | 	return -1;//没有找到就返回-1
39 | };
40 | var arr=[85,24,63,45,17,31,96,50,23];
41 | console.log(binarySearch(arr,45));
42 | 


--------------------------------------------------------------------------------
/高级算法/4-Inventory Update.js:
--------------------------------------------------------------------------------
 1 | //管理库存
 2 | /*2016-6-23 By沐浴星光*/
 3 | function updateInventory(arr1, arr2) {
 4 | 
 5 |     var remain=[];
 6 |     for (var i = 0; i < arr2.length; i++) {
 7 |         for (var j = 0; j < arr1.length; j++) {
 8 |            if (arr1[j][1]==arr2[i][1]) {//如果在arr1找到了相同项目，则直接增加数量
 9 |             arr1[j][0]+=arr2[i][0];
10 |             break;
11 |             }                     
12 |         }
13 |         if (j==arr1.length) {//如果j的值最终等于arr1的长度,说明内部循环并没有找到该项目
14 |              remain.push(arr2[i]);//将新增的项目暂时存在remain数组中;
15 |         }   
16 |     }
17 |  
18 |     if (remain.length===0) {//如果没有新增项目
19 |         return arr1;
20 |     }else{
21 |        arr1=arr1.concat(remain);//合并重排序
22 |        arr1.sort(function(var1,var2){
23 |             if(var1[1]>var2[1]){
24 |                 return 1;
25 |             }else if (var1[1]<var2[1]) {
26 |                 return -1;
27 |             }else{
28 |                 return 0;
29 |             }
30 |        });
31 |        return arr1;
32 |     }
33 |    
34 | }
35 | 
36 | // Example inventory lists
37 | var curInv = [
38 | [21, "Bowling Ball"],
39 | [2, "Dirty Sock"],
40 | [1, "Hair Pin"],
41 | [5, "Microphone"]
42 | ];
43 | 
44 | var newInv = [
45 | [2, "Hair Pin"],
46 | [3, "Half-Eaten Apple"],
47 | [67, "Bowling Ball"],
48 | [7, "Toothpaste"]
49 | ];
50 | 
51 | updateInventory(curInv, newInv);


--------------------------------------------------------------------------------
/附件/快速排序.js:
--------------------------------------------------------------------------------
 1 | //方法一
 2 | var quickSort=function(arr){
 3 | 	if(arr.length<=1){
 4 | 		return arr;
 5 | 	}
 6 | 	var pivotIndex=~~(arr.length/2);
 7 | 	var pivot=arr.splice(pivotIndex,1)[0];
 8 | 	var left=[],right=[];
 9 | 	for (var i = 0; i < arr.length; i++) {
10 | 		if(arr[i]<pivot){
11 | 			left.push(arr[i]);
12 | 		}else{
13 | 			right.push(arr[i]);		
14 | 		}
15 | 	}
16 | 
17 | 	return quickSort(left).concat([pivot],quickSort(right));
18 | 
19 | }
20 | 
21 | var arr=[85,24,63,45,17,31,96,50];
22 | console.log(quickSort(arr));
23 | 
24 | 
25 | //方法二
26 | var quickSort=function (arr) {
27 | 	quick(arr,0,arr.length-1);
28 | 	return arr;
29 | }
30 | 
31 | var quick=function(arr,left,right){
32 | 	var index;
33 | 	if (arr.length>1) {
34 | 		index=partition(arr,left,right);//返回枢轴所在位置
35 | 		if (left<index-1) {
36 | 			quick(arr,left,index-1);
37 | 		}
38 | 		if (index<right) {
39 | 			quick(arr,index,right);
40 | 		}
41 | 	}
42 | }
43 | var partition=function(arr,left,right){
44 | 	var pivot=arr[Math.floor((right+left)/2)],
45 | 	i=left,j=right;
46 | 	while(i<j){
47 | 		while(arr[i]<pivot){
48 | 			i++;
49 | 		}
50 | 		while(arr[j]>pivot){
51 | 			j--;
52 | 		}
53 | 		if(i<=j){
54 | 			swapQuickSort(arr,i,j);
55 | 			i++;j--;
56 | 		}
57 | 	}
58 | 	return i;
59 | }
60 | 
61 | var swapQuickSort=function(array,index1,index2){
62 | 	var temp=array[index1];
63 | 	array[index1]=array[index2];
64 | 	array[index2]=temp;
65 | };
66 | 


--------------------------------------------------------------------------------
/高级算法/3-Exact Change.js:
--------------------------------------------------------------------------------
 1 | //收银机找零(浮点数运算存在误差)
 2 | /*2016-6-23 By沐浴星光*/
 3 | function checkCashRegister(price, cash, cid) {
 4 | 	var diff=cash-price;//找零的金额
 5 | 	var change=[];//找零方案数组
 6 | 	var sum=0;
 7 | 	var currency=[["PENNY", 0.01], ["NICKEL", 0.05], ["DIME", 0.10], ["QUARTER", 0.25],
 8 | 	["ONE", 1.00], ["FIVE", 5.00], ["TEN", 10.00], ["TWENTY", 20.00], ["ONE HUNDRED", 100.00]];
 9 | 	
10 | 	for (var i = currency.length-1; i>=0; i--) {
11 | 		var count=parseInt(diff/currency[i][1],10);//从最大额货币开始除
12 | 		if (count>0) {
13 | 			currency[i][1]=count*currency[i][1];//需要某个金额的货币的总数
14 | 			if (currency[i][1]<=cid[i][1]) {//如果需要的货币总额小于收银台余额
15 | 				
16 | 				cid[i][1]=cid[i][1]-currency[i][1];//收银台余额扣除相应的部分
17 | 				currency[i][1]=parseFloat(currency[i][1].toFixed(2));//注意结果要求保留两位小数
18 | 				change.push(currency[i]);//将这种某种货币的找零方式推入数组
19 | 				diff=(diff-currency[i][1]).toFixed(2);//剩余还要找给顾客的钱
20 | 			}
21 | 			if(currency[i][1]>cid[i][1]&&cid[i][1]>0){//如果需要的货币总额小于收银台余额
22 | 				
23 | 				currency[i][1]=parseFloat(cid[i][1].toFixed(2));//此时将这种货币的所有余额都用来找零
24 | 				change.push(currency[i]);
25 | 				diff=(diff-cid[i][1]).toFixed(2);
26 | 				cid[i][1]=0.00;
27 | 			}					
28 | 		}
29 | 	}
30 | 
31 | 	for (var j = 0; j < cid.length; j++) {
32 | 		 sum+=cid[j][1];//统计收银台余额	
33 | 		}
34 | 
35 | 	if (change.length===0 ||diff>0) {//如果未形成找零方案或者还有钱没有找给顾客
36 | 			return "Insufficient Funds";
37 | 	}else if (sum===0) {
38 | 		return "Closed";
39 | 	}else{
40 | 		return change;
41 | 	}
42 | }
43 | 
44 | 
45 | checkCashRegister(19.50, 20.00, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0],
46 |  ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]);


--------------------------------------------------------------------------------
/附件/全排列.js:
--------------------------------------------------------------------------------
 1 | 
 2 | //求给定数组元素的全排列
 3 | // function permutate(arr) {
 4 | 
 5 | //     var result=[];
 6 | //     if(arr.length==1){
 7 | //     	return [arr]  	
 8 | //     }else{
 9 |     
10 | //     		var preResult=permutate(arr.slice(1));
11 | //     		for (var j = 0; j < preResult.length; j++) {
12 | //     			for (var k = 0; k < preResult[j].length+1; k++) {
13 | //     				var temp=preResult[j].slice();
14 | //     				temp.splice(k,0,arr[0]); 				
15 | //     				result.push(temp);    			
16 | //     			}
17 | //     		}
18 |     		
19 | //     	return result;
20 | 
21 | //     }  
22 | // }
23 | 
24 | // console.log(permutate(['a','b','c']));
25 | 
26 | 
27 | //求给定字符串字符的全排列
28 | function permutate(str) {
29 | 
30 |     var result=[];
31 |     if(str.length==1){
32 |     	return [str]  	
33 |     }else{   
34 |     		var preResult=permutate(str.slice(1));
35 |     		console.log(preResult);
36 |     		for (var j = 0; j < preResult.length; j++) {
37 |     			for (var k = 0; k < preResult[j].length+1; k++) {
38 |     				var temp=preResult[j].slice(0,k)+str[0]+preResult[j].slice(k);				
39 |     				result.push(temp);   			
40 |     			}
41 |     		}
42 |     	return result;
43 | 
44 |     }  
45 | }
46 | 
47 | console.log(permutate("abc"));
48 | 
49 | 
50 | //求给定数组元素的全排列 
51 | function permutate(input) {
52 |   var permArr = [],
53 |   usedChars = [];
54 |   function main(input){
55 |     var i, ch;
56 |     for (i = 0; i < input.length; i++) {
57 |       ch = input.splice(i, 1)[0];
58 |       usedChars.push(ch);
59 |       if (input.length == 0) {
60 |         permArr.push(usedChars.slice());
61 |       }
62 |       main(input);
63 |       input.splice(i, 0, ch);
64 |       usedChars.pop();
65 |     }
66 |     return permArr
67 |   }
68 |   return main(input);
69 | };
70 | console.log(permutate(['a','b','c']));


--------------------------------------------------------------------------------
/中级算法/3-Roman Numeral Converter.js:
--------------------------------------------------------------------------------
 1 | //转换成罗马数字
 2 | /*方法一*/
 3 | function convertToRoman1(num) {
 4 | 	var symbols=['I','V','X','L','C','D','M'];
 5 | 	var roman="";
 6 | 	var index=0;
 7 | 	while(num>0){
 8 | 		var temp=num%10;
 9 | 		switch(temp){//注意后面case取值的顺序很巧妙，并且注意哪些该加break,哪些不该加
10 | 			case 3:
11 | 			{
12 | 				roman+=symbols[index];
13 | 				temp--;
14 | 			}
15 | 			case 2:
16 | 			{
17 | 				roman+=symbols[index];
18 | 				temp--;
19 | 			}
20 | 			case 1:
21 | 			{
22 | 				roman+=symbols[index];
23 | 				temp--;
24 | 				break;
25 | 			}
26 | 			case 4:
27 | 			{
28 | 				roman+=symbols[index+1];
29 | 				roman+=symbols[index];
30 | 				break;
31 | 			}
32 | 			case 8:
33 | 			{
34 | 				roman+=symbols[index];
35 | 				temp--;
36 | 			}
37 | 			case 7:
38 | 			{
39 | 				roman+=symbols[index];
40 | 				temp--;
41 | 			}
42 | 			case 6:
43 | 			{
44 | 				roman+=symbols[index];
45 | 				temp--;
46 | 			}
47 | 			case 5:
48 | 			{
49 | 				roman+=symbols[index+1];
50 | 				break;
51 | 			}
52 | 			case 9:
53 | 			{
54 | 				roman+=symbols[index+2];
55 | 				roman+=symbols[index];
56 | 				break;
57 | 			}
58 | 			default:
59 | 			{
60 | 				break;
61 | 			}
62 | 
63 | 		}
64 | 		index+=2;
65 | 		num=Math.floor(num/10);
66 | 	}
67 | 	return roman.split("").reverse().join("");
68 | }
69 | 
70 | /*方法二*/
71 | function convertToRoman2(num) {
72 |    var symbols=[["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"],
73 |    [ "", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"],
74 |    ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"],
75 |    ["", "M", "MM", "MMM", "", "", "", "", "", "", ""]];
76 |    var roman=symbols[3][Math.floor(num/1000)]
77 |    +symbols[2][Math.floor(num%1000/100)]
78 |    +symbols[1][Math.floor(num%100/10)]
79 |    +symbols[0][Math.floor(num%10)];
80 |    return roman;
81 | }
82 | 
83 | 
84 | convertToRoman1(36);


--------------------------------------------------------------------------------
/高级算法/6-Friendly Date Ranges.js:
--------------------------------------------------------------------------------
 1 |  //日期格式化成风格友好格式
 2 |  ///*2016-6-23 By沐浴星光*/ 
 3 | function makeFriendlyDates(arr) {
 4 | 	var result=[];
 5 | 	var Months=['January','February','March','April','May','June','July','August','September','October','November','December'];
 6 | 	var Days=['1st','2nd','3rd','4th','5th','6th','7th','8th','9th',
 7 | 	'10th','11th','12th','13th','14th','15th','16th','17th','18th','19th',
 8 | 	'20th','21st','22nd','23rd','24th','25th','26th','27th','28th','29th','30th',
 9 | 	'31st'];	
10 | 	var start=arr[0].split("-");
11 | 	var end=arr[1].split("-");
12 | 	var startYear=parseInt(start[0],10), startMonth=parseInt(start[1],10),startDay=parseInt(start[2],10);
13 | 	var endYear=parseInt(end[0],10), endMonth=parseInt(end[1],10),endDay=parseInt(end[2],10);
14 | 	var diffYear=endYear-startYear;
15 | 	var friendlyStart='',friendlyEnd='';
16 | 	var currentYear=new Date().getFullYear();
17 | 	if ((diffYear==1&&startMonth<endMonth)||(diffYear==1&&startMonth==endMonth&&startDay<=endDay)||diffYear>1) {
18 |   		//如果起止时间超过一年,所有的信息都要显示
19 |   		friendlyStart=Months[startMonth-1]+" "+Days[startDay-1]+", "+startYear;
20 |   		friendlyEnd=Months[endMonth-1]+" "+Days[endDay-1]+', '+endYear;
21 |   	}else{//如果时间没超过一年
22 |   			
23 |   			friendlyStart=Months[startMonth-1]+" "+Days[startDay-1];
24 |   			if (startYear!=currentYear) {//如果起始时间不是今年
25 |   				friendlyStart=friendlyStart+", "+startYear;
26 |   			}
27 |   			if (startYear==endYear&&startMonth==endMonth) {//如果起止年份和月份相同
28 |   				if (startDay!=endDay) {//如果起止日期不是同一天
29 |   					friendlyEnd=Days[endDay-1];
30 |   				}
31 |   			}else{//如果起止月份不同 				
32 |   				friendlyEnd=Months[endMonth-1]+" "+Days[endDay-1];
33 |   			}		
34 |   	}
35 |   	result.push(friendlyStart);
36 |   	if (friendlyEnd!=='') {
37 |   		result.push(friendlyEnd);
38 |   	}
39 |   	return result;
40 |   }
41 | 
42 |   console.log(makeFriendlyDates(["2022-09-05", "2023-09-04"]));


--------------------------------------------------------------------------------