地址：https://www.w3cschool.cn/codecamp/list?pename=intermediate_algorithm_scripting_camp
区间求值算法挑战 ：
我们会传递给你一个包含两个数字的数组。返回这两个数字和它们之间所有数字的和。
最小的数字并非总在最前面。
function sumAll(arr) { var left = arr[0]>arr[1]?arr[1]:arr[0]; var right = arr[0]+arr[1]-left; var sum = 0; for(;left<=right;left++) { sum+=left; } return sum; } sumAll([1, 4]); function sumAll(arr) { let min = Math.min(arr[0],arr[1]); let max = Math.max(arr[0],arr[1]); let result = []; for(;min<=max;min++) { result.push(min); } return result.reduce(function (accumulator, currentValue) { return accumulator + currentValue;}); } sumAll([1, 4]);
找出数组间差异算法挑战
比较两个数组，然后返回一个新数组，该数组的元素为两个给定数组中所有独有的数组元素。换言之，返回两个数组的差异。
function diff(arr1, arr2) { return arr1.filter(a=> arr2.indexOf(a)<0).concat(arr2.filter(a=> arr1.indexOf(a)<0)); } diff([1, 2, 3, 5], [1, 2, 3, 4, 5]);
数字转罗马数字挑战：
将给定的数字转换成罗马数字。
function convert(num) { let result = ""; let k = Math.floor(num / 1000); let h = Math.floor((num % 1000) / 100); let t = Math.floor((num % 100) / 10); let o = num % 10; let one = ['I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX']; let ten = ['X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC']; let hundred = ['C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM'] let thousand = 'M'; for (let i = 0; i < k; i++) { result += thousand; } if (h) result += hundred[h - 1]; if (t) result += ten[t - 1]; if (o) result += one[o - 1]; return result; } convert(36);
对象搜索算法挑战
写一个 function方法，它遍历一个对象数组（第一个参数）并返回一个包含相匹配的属性-值对（第二个参数）的所有对象的数组。如果返回的数组中包含 source 对象的属性-值对，那么此对象的每一个属性-值对都必须存在于 collection 的对象中。
例如，如果第一个参数是 [{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }]，第二个参数是 { last: "Capulet" }，那么你必须从数组（第一个参数）返回其中的第三个对象，因为它包含了作为第二个参数传递的属性-值对。
function where(collection, source) { var result = []; for(let i = 0,j=collection.length;i<j;i++) { let obj = collection[i]; let flag = true; for(let key in source) { if(obj[key] != source[key]) { flag = !flag; break; } } if(flag) { result.push(obj); } } return result; } where([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });
字符串查询替换算法挑战：
使用给定的参数对字符串执行一次查找和替换，然后返回新字符串。
第一个参数是将要对其执行查找和替换的字符串。
第二个参数是将被替换掉的单词（替换前的单词）。
第三个参数用于替换第二个参数（替换后的单词）。
注意：替换时保持原单词的大小写。例如，如果你想用单词 "dog" 替换单词 "Book" ，你应该替换成 "Dog"。
function myReplace(str, before, after) { if(before.slice(0,1).toUpperCase() == before.slice(0,1)) { after = after.slice(0,1).toUpperCase() + after.slice(1); } else { after = after.slice(0,1).toLowerCase() + after.slice(1); } return str.replace(new RegExp(before,"gm"),after); } myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");
字符串移动插入算法挑战：
把指定的字符串翻译成 pig latin。
Pig Latin 把一个英文单词的第一个辅音或辅音丛（consonant cluster）移到词尾，然后加上后缀 "ay"。
如果单词以元音开始，你只需要在词尾添加 "way" 就可以了。
输入字符串保证是英文单词全部小写。
function translate(str) { let y=['a','e','i','o','u']; //定义元音 let i=0; //保存辅音丛的长度 while(i<str.length){ if(y.indexOf(str[i])=== -1){ // indexOf 比较结果为 -1时，则说明不存在，即当前比较的字母不为元音； i++; // 记录辅音丛长度 } else{ break; } } if(i===0){ return str+"way"; //元音开头 } else{ return str.substr(i)+str.substr(0,i)+"ay"; //辅音丛开头 } return ""; } translate("consonant");
字符配对算法挑战：
DNA 链缺少配对的碱基。依据每一个碱基，为其找到配对的碱基，然后将结果作为第二个数组返回。
Base pairs（碱基对） 是一对 AT 和 CG，为给定的字母匹配缺失的碱基。
在每一个数组中将给定的字母作为第一个碱基返回。
例如，对于输入的 GCG，相应地返回 [["G", "C"], ["C","G"],["G", "C"]]
字母和与之配对的字母在一个数组内，然后所有数组再被组织起来封装进一个数组。
function pair(str) { let result = []; for(let i =0,j=str.length;i<j;i++) { let arr = [str[i]]; switch (str[i]) { case 'G': arr.push("C"); break; case 'C': arr.push("G"); break; case 'A': arr.push("T"); break; case 'T': arr.push("A"); break; default: break; } result.push(arr); } return result; } pair("GCG");
字符串查询补充算法挑战：
从传递进来的字母序列中找到缺失的字母并返回它。
如果所有字母都在序列中，返回 undefined。
function fearNotLetter(str) { let result = ""; let a = str[0].charCodeAt(); for(let i=1,j=str.length;i<j;i++) { if(++a != str[i].charCodeAt()) { result += String.fromCharCode(a); a = str[i].charCodeAt() } } return result==""?undefined:result; } fearNotLetter("abce");
输入检查算法挑战：
检查一个值是否是基本布尔类型，并返回 true 或 false。
基本布尔类型即 true 和 false。
function boo(bool) { return typeof(bool)=="boolean"; } boo(null);
数组去重算法挑战：
写一个 function，传入两个或两个以上的数组，返回一个以给定的原始数组排序的不包含重复值的新数组。
换句话说，所有数组中的所有值都应该以原始顺序被包含在内，但是在最终的数组中不包含重复值。
非重复的数字应该以它们原始的顺序排序，但最终的数组不应该以数字顺序排序。
function unite(arr1,... arrs) { var result = arr1.concat(); for(let i=0,j=arrs.length;i<j;i++) { let array = arrs[i].filter( a=> result.indexOf(a) < 0 ); for(let i=0,j=array.length;i<j;i++) { result.push(array[i]); } } return result; } unite([1, 3, 2], [5, 2, 1, 4], [2, 1]);
html符号转实体算法挑战：
将字符串中的字符 &、<、>、" （双引号）, 以及 ' （单引号）转换为它们对应的 HTML 实体。
function convert(str) { // :) return str.replace(/&/g,"&").replace(/</g,"<").replace(/>/g,">").replace(/"/g,""").replace(/'/g,"'"); } convert("Dolce & Gabbana");
字符串连接算法挑战：
将字符串转换为 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 这种形式的，也就是以连字符连接所有小写单词。
function spinalCase(str) { return str.replace(/^[A-Z]/g,function($1){return $1.toLowerCase();}).replace(/s|_/g,function($1){return "-"}).replace(/-*[A-Z]/g,function($1){ return "-"+$1.replace("-","").toLowerCase()}) } spinalCase('This Is Spinal Tap');
斐波纳契奇数求和算法挑战：
给一个正整数num，返回小于或等于num的斐波纳契奇数之和。
斐波纳契序列中的前两个数字是1和1.序列中的每个附加数字是前面两个数字的和。斐波纳契序列的前六个数字是1,1,2,3,5和8。
例如，sumFibs(4)应该返回 5，因为斐波纳契数列中所有小于4的奇数是 1、1、3。
function sumFibs(num) { let arr = [1,1]; let result = [1,1]; if(num<2) { return 0; } while(true) { let length = arr.length; let next = arr[length-1] + arr[length-2]; if(next <= num) { arr.push(next); if( next % 2 == 1) { result.push(next); } } else { break; } } return result.reduce(function (accumulator, currentValue) { return accumulator + currentValue;}); } sumFibs(4);
质素求和算法挑战 ：
求小于等于给定数值的质数之和。
只有 1 和它本身两个约数的数叫质数。例如，2 是质数，因为它只能被 1 和 2 整除。1 不是质数，因为它只能被自身整除。
给定的数不一定是质数。
function sumPrimes(num) { var result = []; if(num<2) { return 0; } for(let i = 2;i <= num; i++ ) { let flag = true; for(let j = 2,k = Math.floor(Math.sqrt(i));j<=k;j++) { if(i%j==0) { flag = false; break; } } if(flag){ result.push(i); } } return result.reduce(function (a, c) { return a + c;});; } sumPrimes(10);
最小公倍数算法挑战:
找到所提供参数的最小公倍数，这两个参数可以均匀分配，以及这些参数之间范围内的所有最小公倍数。
范围是两个数字构成的数组，两个数字不一定按数字顺序排序。
例如对 1 和 3 —— 找出能被 1 和 3 和它们之间所有数字整除的最小公倍数。
function smallestCommons(arr) { let left = Math.min(arr[0],arr[1]); let right = Math.max(arr[0],arr[1]); let shift = left; let result = left; for(let i=left+1;i<=right;i++) { shift = result; while(true) { if(result % i == 0) { break; } result += shift; } } return result; } smallestCommons([1,5]);
function smallestCommons(arr) { let left = Math.min(arr[0],arr[1]); let right = Math.max(arr[0],arr[1]); let array = []; for(let i =left;i<=right;i++) { array.push(i); } return array.reduce(function(a,c){let sum = a;while(true){if(sum%c==0){return sum } else {sum += a;}}}) }
数组验证算法挑战：
写一个 function，它查找数组（第一个参数）并返回数组中第一个通过某种方法（第二个参数）验证的元素。
function find(arr, func) { let array = arr.filter(a=>func(a)); return array.length>0?array[0]:undefined; } find([1, 2, 3, 4], function(num){ return num % 2 === 0; });
数组取值算法挑战：
删除数组(第一个参数)的元素，从左边开始，直到回调函数（第二个参数）return true就停止。
第二个参数，func，是一个函数。用来测试数组的第一个元素，如果返回fasle，就从数组中抛出该元素(注意：此时数组已被改变)，继续测试数组的第一个元素，如果返回fasle，继续抛出，直到返回true。
最后返回数组的剩余部分，如果没有剩余，就返回一个空数组。
function drop(arr, func) { for(let i=0,j=arr.length;i<j;i++) { let shift = arr.shift(); if(func(shift)) { arr.unshift(shift); break; } else { arr.slice(1); } } console.log(arr) return arr; } drop([1, 2, 3], function(n) {return n < 3; });
数组平铺算法挑战：
对嵌套的数组进行平铺嵌套数组。你必须考虑到不同层级的嵌套。
function steamroller(arr) { let result = []; for(let i=0,j=arr.length;i<j;i++) { if(Array.isArray(arr[i])) { result = result.concat(steamroller(arr[i])); } else { result.push(arr[i]); } } return result; } steamroller([1, [2], [3, [[4]]]]);
二进制转字符算法挑战：
传入二进制字符串，翻译成英语句子并返回。
二进制字符串是以空格分隔的。
function binaryAgent(str) { let result = ""; let arr = str.split(" "); return arr.reduce(function(a, c) { return a + String.fromCharCode(c.split("").reverse().reduce(function(a, c, i) { return Number(a) + c * Math.pow(2, i); })) },''); } binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");
数组元素判断算法挑战:
所有的东西都是真的！
完善编辑器中的every函数，如果集合(collection)中的所有对象都存在对应的属性(第二个参数)，并且属性(第二个参数)对应的值为真。函数返回ture。反之，返回false。
function every(collection, pre) { var result = []; let flag = true; for(let i = 0,j=collection.length;i<j;i++) { let obj = collection[i]; if(obj[pre] == undefined || obj[pre]==null || obj[pre]=='' || (typeof(obj[pre])=="number" && isNaN(obj[pre])) ) { flag = !flag; break; } } return flag; } every([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");
函数迭代可选参数算法挑战 ：
创建一个计算两个参数之和的 function。如果只有一个参数，则返回一个 function，该 function 请求一个参数然后返回求和的结果。
例如，add(2, 3) 应该返回 5，而 add(2) 应该返回一个 function。
调用这个有一个参数的返回的 function，返回求和的结果：
var sumTwoAnd = add(2);
sumTwoAnd(3) 返回 5。
如果两个参数都不是有效的数字，则返回 undefined。
function add() { if(typeof arguments[0]=="number" && typeof arguments[1]=="number"){ return arguments[0]+arguments[1]; } else if(arguments.length==1 && typeof arguments[0]=="number"){ var x=arguments[0]; return function(y){ if(typeof y =="number"){ return x+y; } }; } } add(2,3);