核心提示：这是网上开源编程学习项目FCC的javascript中级编程题（Intermediate Algorithm Scripting(50 hours)），一共20题。建议时间是50个小时，对于刚入门的人来说，操作是有些难度了。
1.我们会传递给你一个包含两个数字的数组。返回这两个数字和它们之间所有数字的和。
最小的数字并非总在最前面。
简单地说，就是两个数之间的连续自然数列求和问题。项数可以用Math.abs()方法求出。
function sumAll(arr) {
var sum=(arr[1]+arr[0])*(Math.abs(arr[1]-arr[0])+1)/2;
return sum;
}
2.比较两个数组，然后返回一个新数组，该数组的元素为两个给定数组中所有独有的数组元素。换言之，返回两个数组的差异。
思路：用indexOf方法判断某个元素是否在数组中，如果不在（返回-1），则把这个元素加到新数组内。
function diff(arr1, arr2) {
var newArr = [];
for(var i=0;i<arr1.length;i++){
if(arr2.indexOf(arr1[i])==-1){
newArr.push(arr1[i]);
}
}
for(var j=0;j<arr2.length;j++){
if(arr1.indexOf(arr2[j])==-1){
newArr.push(arr2[j]);
}
}
return newArr;
}
这段代码有一定的重复，可以在第一次遍历的时候把重复检查的数组项cut掉。
3.将给定的数字转换成罗马数字。
所有返回的 罗马数字 都应该是大写形式。
基本上，罗马数字的规则我看了很久。方法就是把每个位数进行独自的判断。方法引自网上。
function convert(num) {
var alpha = [ 'I', 'V', 'X', 'L', 'C', 'D', 'M' ], roman = "", bit = 0;
while (num > 0){
var tempnum = num % 10;
switch (tempnum){
case 3:{
roman = alpha[bit] + roman;
tempnum--;
}
case 2:{
roman = alpha[bit] + roman;
tempnum--;
}
case 1:{
roman = alpha[bit] + roman;
break;
}
case 4:{
roman = alpha[bit + 1] + roman;
roman = alpha[bit] + roman;
break;
}
case 8:{
roman = alpha[bit] + roman;
tempnum--;
}
case 7:{
roman = alpha[bit] + roman;
tempnum--;
}
case 6:{
roman = alpha[bit] + roman;
tempnum--;
}
case 5:{
roman = alpha[bit + 1] + roman;
break;
}
case 9:{
roman = alpha[bit + 2] + roman;
roman = alpha[bit] + roman;
break;
}
default:{
break;
}
}
bit += 2;
num = Math.floor(num / 10);
}
return roman;
}
convert(36);
另外一个好点的思路是：
function convert(num) { if(num<=0) return null; var luoma=[['','I','II','III',"IV","V","VI","VII","VIII","IX"], ['','X','XX','XXX','XL','L','LX','LXX','LXXX','XC'], ['','C','CC','CCC','CD','D','DC','DCC','DCCC','CM']] ; var s=''; s= 'M'.repeat( Math.floor(num/1000)); num =num %1000; s+=luoma[2][Math.floor(num/100)]; num=num%100; s+=luoma[1][Math.floor(num/10)]; num=num%10; s+=luoma[0][num]; return s; }
var table = {1:"I", 4:"IV", 5:"V", 9:"IX", 10:"X", 40:"XL", 50:"L",90:"XC", 100:"C",400:"CD", 500: "D", 900:"CM", 1000:"M"};
var keys = Object.keys(table);
function convertToRoman(num) { if (num === 0) return; if (table.hasOwnProperty(num)) { return table[num]; } else { var temp = keys.filter((x) => x < num); return table[temp[temp.length -1]] + convertToRoman(num - temp[temp.length-1]); } }; console.log(convertToRoman(97));
var table = {1:"I", 4:"IV", 5:"V", 9:"IX", 10:"X", 40:"XL", 50:"L",90:"XC", 100:"C",400:"CD", 500: "D", 900:"CM", 1000:"M"};
var keys = Object.keys(table); //拿到对应的阿拉伯数字
function convertToRoman(num) { if (num === 0) return; //如果是0直接退出
if (table.hasOwnProperty(num)) { //要是阿拉伯数字跟参数一样
return table[num]; // 那就直接从表里放回相应罗马数字
} else {
var temp = keys.filter(function (x) { x < num });
//循环一遍阿拉伯数字表，把比 num 参数小的返回来给 temp 变量
// 比如 num 是97， 那就 temp 就是 [1,4,5,9,10,40,50,90]
return table[temp[temp.length -1]] + convertToRoman(num - temp[temp.length-1]);
//接着返回一个 table 最后一个元素，也就是 table[90], 也就是 'XC'
//然后再执行一次这个函数（递归），并给它 num - 90 为参数，也就是 7
//然后从头再走一遍
/* var temp = keys.filter(function (x) { x < num }); 现在这个 temp 数组是 [1, 4, 5], */
//继续递归变成 return table[temp[temp.length -1]] + convertToRoman(num - temp[temp.length-1])
//上面这句实际上就变成 return 'XC' + 'V' + convertToRoman(7 - 5) //然后继续递归，直到最后 num 变成 0， 递归结束。得出结果 XCVII(90,5,1,1) } };
3.写一个 function，它遍历一个对象数组（第一个参数）并返回一个包含相匹配的属性-值对（第二个参数）的所有对象的数组。如果返回的数组中包含 source 对象的属性-值对，那么此对象的每一个属性-值对都必须存在于 collection 的对象中。
例如，如果第一个参数是 [{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }]，第二个参数是 { last: "Capulet" }，那么你必须从数组（第一个参数）返回其中的第三个对象，因为它包含了作为第二个参数传递的属性-值对。
思路：说的非常拗口，可见这个翻译者水平是非常垃圾的。
用到的是Object.key方法。接下来就只是遍历。
function where(collection, source) {
var arr = [];
var arrSource=Object.keys(source);//把source的属性转化为数组
// What's in a name?
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;
}
4.使用给定的参数对句子执行一次查找和替换，然后返回新句子。
第一个参数是将要对其执行查找和替换的句子。
第二个参数是将被替换掉的单词（替换前的单词）。
第三个参数用于替换第二个参数（替换后的单词）。
注意：替换时保持原单词的大小写。例如，如果你想用单词 "dog" 替换单词 "Book" ，你应该替换成 "Dog"。
function myReplace(str, before, after) {
var i=0;
var arr=str.split(' ');
for(i=0;i<arr.length;i++){
if(arr[i]==before){
if(arr[i].toLowerCase()!=arr[i]){
after=after.replace(after.charAt(0),after.charAt(0).toUpperCase());
}//大小写转换，首字母大写
arr.splice(i,1,after);//替换
}
}
str=arr.join(' ');
console.log(str);
return str;
}
5. 把指定的字符串翻译成 pig latin。
Pig Latin 把一个英文单词的第一个辅音或辅音丛（consonant cluster）移到词尾，然后加上后缀 "ay"。
如果单词以元音开始，你只需要在词尾添加 "way" 就可以了。
这其实是所谓儿童黑话游戏，
function translate(str) {
var str2=str;
var i=0;
var consonant_cluster='';
while(str2==str){
switch(str[i]){
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
str=str+consonant_cluster;
switch(consonant_cluster){
case '':
str=str+'way';
break;
default:
str=str+'ay';
}
str=str.substring(consonant_cluster.length);
break;
default:
consonant_cluster+=str[i];
i+=1;
}
}
return str;
}
后来翻看人家网站的源码，发现是用正则来写的
function translate(str) {
str = str.replace(/\b([aeiou][a-z]*)\b/gi, "$1way"); // 表示，如果开头为aeiou，那么尾部加上way
str = str.replace(/\b([bcdfghjklmnpqrstvwxy]+)([a-z]*)\b/gi, "$2$1ay"); // 如果开头为辅音，第二部分——第一部分——ay
return str;
}
6.DNA 链缺少配对的碱基。依据每一个碱基，为其找到配对的碱基，然后将结果作为第二个数组返回。
Base pairs（碱基对） 是一对 AT 和 CG，为给定的字母匹配缺失的碱基。
在每一个数组中将给定的字母作为第一个碱基返回。
例如，对于输入的 GCG，相应地返回 [["G", "C"], ["C","G"],["G", "C"]]
字母和与之配对的字母在一个数组内，然后所有数组再被组织起来封装进一个数组。
function pair(str) {
var i=0;
var newStr='';
var arr=[];
for(i=0;i<str.length;i++){
switch(str[i]){
case 'A':
newStr+='T';
break;
case 'T':
newStr+='A';
break;
case 'G':
newStr+='C';
break;
case 'C':
newStr+='G';
break;
}
arr.push([str[i],newStr[i]]);
}
return arr;
}
7.从传递进来的字母序列中找到缺失的字母并返回它。
如果所有字母都在序列中，返回 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;
}
8.检查一个值是否是基本布尔类型，并返回 true 或 false。
基本布尔类型即 true 和 false。
function boo(bool) {
// What is the new fad diet for ghost developers? The Boolean.
return (typeof bool=='boolean');
}
boo(true);
好像没什么好说的。
9.写一个 function，传入两个或两个以上的数组，返回一个以给定的原始数组排序的不包含重复值的新数组。
换句话说，所有数组中的所有值都应该以原始顺序被包含在内，但是在最终的数组中不包含重复值。
非重复的数字应该以它们原始的顺序排序，但最终的数组不应该以数字顺序排序。
思路，既然原来的第一个参数是以原来的排序为准的，那就直接让原来的数组加上桥接的数段。用concat方法。
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]);
10.将字符串中的字符 &、<、>、" （双引号）, 以及 ' （单引号）转换为它们对应的 HTML 实体。
参考资料：html实体
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('');
console.log(str);
return str;
}
convert('Stuff in "quotation marks"')
或许用正则会好些。
11.将字符串转换为 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 这种形式的，也就是以连字符连接所有小写单词。
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"。
思路：陷阱很多，总之是一步一步来，不能急躁。
function spinalCase(str) {
str=str.replace(/([A-Z]+)/g,' $1');//在大写字母前面加个空格。用$来选择小括号
str=str.replace(/\s+|_+/g,'-');//空格全部替换为-
//以下是修bug
if(str[0]=='-'){
str=str.substring(1);
}//去掉可能大写开头前面的-
str=str.replace(/--/g,'-');//把中段的--（两个）替换为一个-。(因为下划线+大写导致生成了两个-)
str=str.toLowerCase();//转换小写
return str;
}
12.给一个正整数num，返回小于或等于num的斐波纳契奇数之和。
斐波纳契数列中的前几个数字是 1、1、2、3、5 和 8，随后的每一个数字都是前两个数字之和。
例如，sumFibs(4)应该返回 5，因为斐波纳契数列中所有小于4的奇数是 1、1、3。
提示：此题不能用递归来实现斐波纳契数列。因为当num较大时，内存会溢出，推荐用数组来实现。
var sumFibs = function() {
var cache = [1, 1];
return function (n) {
if (n >= cache.length) {
for (var i = cache.length; i < n ; i++ ) {
cache[i] = cache[i - 2] + cache[i - 1];
}
}
var arr=cache.filter(function(val){
return val%2!=0&&val<=n;
});
return arr.reduce(function(pre,next){
return pre+next;
});
};
}();
sumFibs(400);
方案2：
//斐波拉契数列中奇数的求和函数：根据参数n索引生成内容。
//根据索引值n返回一个数组，第一个是斐波拉契最后一个数
//第二个是该数列奇数元素的的和。
function fib(n) {
var a = 1, b = 1;
var arr=[1,1];
var tmp=0;
for(var i=3; i<=n; i++){
tmp = b;
b = a + b;
arr.push(b);
a = tmp;
}//构造斐波拉契数组
var sum=0;
for(i=0;i<arr.length;i++){
if(arr[i]%2!==0){
sum+=arr[i];
}
}//这个数组中arr奇数求和
return [arr[arr.length-1],sum];
}
function sumFibs(num){
var k=3;
while(fib(k)[0]<=num){
k++;
}
return fib(k-1)[1];
}
sumFibs(75024);
思路写在了comment里。
总的来说陷阱不多，关键是判断循环边界。
13.求小于等于给定数值的质数之和。
只有 1 和它本身两个约数的数叫质数。例如，2 是质数，因为它只能被 1 和 2 整除。1 不是质数，因为它只能被自身整除。
给定的数不一定是质数。sumPrimes(10) 应该返回一个数字。sumPrimes(10) 应该返回 17。sumPrimes(977) 应该返回 73156。
思路，这里用的是筛法。所谓筛法是运用已有最开始的质数判断。是质数的放到数组中。下个数再进行判断。
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(977);
14. 找出能被两个给定参数和它们之间的连续数字整除的最小公倍数。
范围是两个数字构成的数组，两个数字不一定按数字顺序排序。
例如对 1 和 3 —— 找出能被 1 和 3 和它们_之间_所有数字整除的最小公倍数。smallestCommons([1, 5]) 应该返回一个数字。smallestCommons([1, 5]) 应该返回 60。smallestCommons([5, 1]) 应该返回 60。smallestCommons([1, 13]) 应该返回 360360。
思路：
（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]
15.写一个 function，它浏览数组（第一个参数）并返回数组中第一个通过某种方法（第二个参数）验证的元素。
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;
}
16.队友该卖就卖，千万别舍不得。
让我们来丢弃数组(arr)的元素，从左边开始，直到回调函数return true就停止。
第二个参数，func，是一个函数。用来测试数组的第一个元素，如果返回fasle，就从数组中抛出该元素(注意：此时数组已被改变)，继续测试数组的第一个元素，如果返回fasle，继续抛出，直到返回true。
最后返回数组的剩余部分，如果没有剩余，就返回一个空数组。
如果你被卡住了，记得开大招 Read-Search-Ask。尝试与他人结伴编程。编写你自己的代码。
这是一些对你有帮助的资源:
这题翻译者好像高潮了，写了一大串lol卖队友的合理性。看篇幅还以为很难。
还是一个比较简单的思路：遍历这个数组，然后用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;
}
17.对嵌套的数组进行扁平化处理。你必须考虑到不同层级的嵌套。
teamroller([[["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;
}
18.传入二进制字符串，翻译成英语句子并返回。
二进制字符串是以空格分隔的。
先写一个二进制字符串转化为十进制字符串的函数：parseInt
把10进制编码转换为字符用String.fromCharCode()方法。
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");
有了这个思路可以用map方法来实现更加精简的语句
所谓一行的写法：
return str.split(' ').map(function(a){return String.fromCharCode(parseInt(a,2))}).join('');
19.所有的东西都是真的！
完善编辑器中的every函数，如果集合(collection)中的所有对象都存在对应的属性(pre)，并且属性(pre)对应的值为真。函数返回ture。反之，返回false。
记住：你只能通过中括号来访问对象的变量属性(pre)。
提示：你可以有多种实现方式，最简洁的方式莫过于Array.prototype.every()。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。
every([{"user": "Tinky-Winky", "sex": "male", "age": 0}, {"user": "Dipsy", "sex": "male", "age": 3}, {"user": "Laa-Laa", "sex": "female", "age": 5}, {"user": "Po", "sex": "female", "age": 4}], "age") 应该返回 false。
every([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true}, {"name": "FastFoward", "onBoat": null}], "onBoat") 应该返回 false
every([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastFoward", "onBoat": true}], "onBoat") 应该返回 true
every([{"single": "yes"}], "single") 应该返回 true
every([{"single": ""}, {"single": "double"}], "single") 应该返回 false
every([{"single": "double"}, {"single": undefined}], "single") 应该返回 false
every([{"single": "double"}, {"single": NaN}], "single") 应该返回 false
思路：这个看起来很复杂，其实只要做个json的for-in循环，就可以实现。
function every(collection, pre) {
// Is everyone being true?
var i='';
var bCheck=true;//假设为真
for(i in collection){
if(!collection[i][pre]){
bCheck=false;
}
}
return bCheck;
}
20.创建一个计算两个参数之和的 function。如果只有一个参数，则返回一个 function，该 function 请求一个参数然后返回求和的结果。
例如，add(2, 3) 应该返回 5，而 add(2) 应该返回一个 function。
调用这个有一个参数的返回的 function，返回求和的结果：
var sumTwoAnd = add(2);
sumTwoAnd(3) 返回 5。
如果两个参数都不是有效的数字，则返回 undefined。
思路：这个其实就是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];
}
}
题目来源：
FCC中文网：https://www.freecodecamp.cn/
参考资料：
[1]《javascript高级程设计》第5,7章。
[2] MOZILLA开发者社区：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript
[3] 感谢gitter中文聊天室热心的网友