1.Sum All Numbers in a Range
一个数组。返回最大最小的两个数字和它们之间所有数字的和。
function sumAll(arr) {
var max = Math.max.apply(this,arr);
var min = Math.min.apply(this,arr);
var sum=0;
for(var i = min;i<=max;i++){
sum +=i;
}
return sum;
}
sumAll([1, 4]);
2.Diff Two Arrays
比较两个数组，然后返回一个新数组，该数组的元素为两个给定数组中所有独有的数组元素
function diff(arr1, arr2) {
var newArr = [],arr3=[];
newArr = arr1.filter(function(value){
return arr2.indexOf(value)>=0;
});console.log(newArr);
arr3 = arr1.concat(arr2);
newArr = arr3.filter(function(value){
return newArr.indexOf(value)<0;
});
return newArr;
}
3.Roman Numeral Converter
将给定的数字转换成罗马数字。
所有返回的 罗马数字 都应该是大写形式。
function convert(num) {
const romanNum = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1],
roman = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"];
let i = 0,
str = "";
while (num > 0) {
if (num < romanNum[i]) {
i++;
} else {
str += roman[i];
num -= romanNum[i];
}
}
return str;
}
convert(36);
4.Where art thou
写一个 function，它遍历一个对象数组（第一个参数）并返回一个包含相匹配的属性-值对（第二个参数）的所有对象的数组。如果返回的数组中包含 source 对象的属性-值对，那么此对象的每一个属性-值对都必须存在于 collection 的对象中。
例如，如果第一个参数是 [{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }]，第二个参数是 { last: "Capulet" }，那么你必须从数组（第一个参数）返回其中的第三个对象，因为它包含了作为第二个参数传递的属性-值对。
function where(collection, source) {
var sourceKeys = Object.keys(source),
arr = [];
collection.forEach(function(obj) {
for (var i = 0; i < sourceKeys.length; i++) {
if (!obj.hasOwnProperty(sourceKeys[i])) {
return false;
} else {
if (source[sourceKeys[i]] !== obj[sourceKeys[i]]) {
return false;
}
}
}
arr.push(obj);
}, this);
return arr;
}
where([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });
5.Search and Replace
使用给定的参数对句子执行一次查找和替换，然后返回新句子。
第一个参数是将要对其执行查找和替换的句子。
第二个参数是将被替换掉的单词（替换前的单词）。
第三个参数用于替换第二个参数（替换后的单词）。
注意：替换时保持原单词的大小写。例如，如果你想用单词 "dog" 替换单词 "Book" ，你应该替换成 "Dog"。
function myReplace(str, before, after) {
if (/[A-Z]/.test(before[0])) {
after = after[0].toUpperCase() + after.slice(1);
}
return str.replace(before, after);
}
myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");
6.Pig Latin
把一个英文单词的第一个辅音或辅音丛（consonant cluster）移到词尾，然后加上后缀 "ay"。
如果单词以元音开始，你只需要在词尾添加 "way" 就可以了。
function translate(str) {
var i = 0,
newStr = '';
if (/[aeiou]/.test(str[0])) {
str += "way";
} else {
while (i < str.length) {
if (/[aeiou]/.test(str[i])) {
return str.substr(i) + str.substr(0, i) + "ay";
} else {
i++;
}
}
}
return str;
}
translate("consonant");
7.DNA Pairing
在每一个数组中将给定的字母作为第一个碱基返回。
例如，对于输入的 GCG，相应地返回 [["G", "C"], ["C","G"],["G", "C"]]
字母和与之配对的字母在一个数组内，然后所有数组再被组织起来封装进一个数组。
function pair(str) {
var pairs = [],
DNA = {
A: "T",
T: "A",
C: "G",
G: "C"
},
dnaArr = str.split("");
dnaArr.forEach(function(item) {
var newArr = [item];newArr.push(DNA[item]);
pairs.push(newArr);
});
return pairs;
}
pair("GCG");
8.Missing letters
从传递进来的字母序列中找到缺失的字母并返回它。
如果所有字母都在序列中，返回 undefined。
function fearNotLetter(str) {
var length = str.length,
first = str.charCodeAt(0),
last = str.charCodeAt(length - 1),
newStr = "";
if (last - first === length - 1) {
newStr = undefined;
} else {
for (var i = 1; i < last - first; i++) {
console.log(str.charCodeAt(i) - str.charCodeAt(i - 1));
if (str.charCodeAt(i) - str.charCodeAt(i - 1) !== 1) {
newStr = String.fromCharCode(str.charCodeAt(i) - 1);
}
}
}
return newStr;
}
fearNotLetter("abce");
9.Boo who
检查一个值是否是基本布尔类型，并返回 true 或 false。
基本布尔类型即 true 和 false。
function boo(bool) {
// What is the new fad diet for ghost developers? The Boolean.
return typeof bool==='boolean';
}
boo(null);
10.Sorted Union
写一个 function，传入两个或两个以上的数组，返回一个以给定的原始数组排序的不包含重复值的新数组。
换句话说，所有数组中的所有值都应该以原始顺序被包含在内，但是在最终的数组中不包含重复值。
非重复的数字应该以它们原始的顺序排序，但最终的数组不应该以数字顺序排序。
function unite(arg) {
let arr = Array.prototype.slice.call(arguments);
let newArr = arr.reduce(function(a,b){
return a.concat(b);
},[]);
let newArr2= []
for(let i=0;i<newArr.length;i++){
if(newArr2.indexOf(newArr[i])<0){
newArr2.push(newArr[i]);
}
}
return newArr2;
}
unite([1, 3, 2], [5, 2, 1, 4], [2, 1]);
11.Convert HTML Entities
将字符串中的字符 &、<、>、" （双引号）, 以及 ' （单引号）转换为它们对应的 HTML 实体。
function convert(str) {
return str.replace(/[&<>"']/g, function($0) {
return "&" + {"&":"amp", "<":"lt", ">":"gt", '"':"quot", "'":"apos"}[$0] + ";";
});
}
12.Spinal Tap Case
将字符串转换为 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 这种形式的，也就是以连字符连接所有小写单词。
function spinalCase(str) {
return str.replace(/([A-Z])/g," $1")
.replace(/^\s/,"")
.replace(/[_]/g," ")
.replace(/\s+/g,"-")
.toLowerCase();
}
spinalCase('This Is Spinal Tap');
13.Sum All Odd Fibonacci Numbers
给一个正整数num，返回小于或等于num的斐波纳契奇数之和。
斐波纳契数列中的前几个数字是 1、1、2、3、5 和 8，随后的每一个数字都是前两个数字之和。
例如，sumFibs(4)应该返回 5，因为斐波纳契数列中所有小于4的奇数是 1、1、3。
提示：此题不能用递归来实现斐波纳契数列。因为当num较大时，内存会溢出，推荐用数组来实现。
function sumFibs(num) {
var fib = [1,1],
sum = 2;
while(true){
var item = fib[0] + fib[1];
if(item>num){
return sum;
}
if(item % 2){
sum += item;
}
fib[0] = fib[1];
fib[1] = item;
}
}
sumFibs(4);
14.Sum All Primes
求小于等于给定数值的质数之和。
function sumPrimes(num) {
let arr= [2],sum=2;
if(num<=2){
return num;
}
for(var i=3;i<=num;i++){
if(arr.every(item => i%item !=0)){
arr.push(i);
sum+=i;
}
}
return sum;
}
sumPrimes(10);
15.Smallest Common Multiple
找出能被两个给定参数和它们之间的连续数字整除的最小公倍数。
范围是两个数字构成的数组，两个数字不一定按数字顺序排序。
例如对 1 和 3 —— 找出能被 1 和 3 和它们之间所有数字整除的最小公倍数。
function smallestCommons(arr) {
let min = Math.min.apply(this,arr),
max = Math.max.apply(this,arr),
val=min;
for(let i= min;i<=max;i++){
sum *=i/gcd(val,i);
}
return sum;
}
function gcd(a,b) {
if(a%b){
return gcd(b,a%b);
}else{
return b;
}
}
smallestCommons([1,5]);
16.Finders Keepers
写一个 function，它遍历数组 arr，并返回数组中第一个满足 func 返回值的元素。举个例子，如果 arr 为 [1, 2, 3]，func 为 function(num) {return num === 2; }，那么 find 的返回值应为 2。
function find(arr, func) {
return arr.find(func);
}
find([1, 2, 3, 4], function(num){ return num % 2 === 0; });
17.Drop it
function drop(arr, func) {
// Drop them elements.
while(arr.length>0 && !(func.call(this,arr[0]))){
arr.shift();
}
return arr;
}
drop([1, 2, 3], function(n) {return n < 3; });
18.Steamroller
对嵌套的数组进行扁平化处理。你必须考虑到不同层级的嵌套。
function steamroller(arr) {
// I'm a steamroller, baby
var result = [];
for(var i = 0; i < arr.length; i++){
if(Array.isArray(arr[i])){
result = result.concat(steamroller(arr[i]));
}else{
result.push(arr[i]);
}
}
return result;
}
steamroller([1, [2], [3, [[4]]]]);
19.Binary Agents
传入二进制字符串，翻译成英语句子并返回。
function binaryAgent(str) {
let arr = str.split(" ");
let newArr = arr.map((x) =>{
return parseInt(x,2);
})
return String.fromCharCode.apply(this,newArr);
}
binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");
20.Everything Be True
完善编辑器中的every函数，如果集合(collection)中的所有对象都存在对应的属性(pre)，并且属性(pre)对应的值为真。函数返回ture。反之，返回false。
function every(collection, pre) {
// Is everyone being true?
return collection.every((x) =>{
return x[pre];
})
}
every([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");
21.Arguments Optional
创建一个计算两个参数之和的 function。如果只有一个参数，则返回一个 function，该 function 请求一个参数然后返回求和的结果。
例如，add(2, 3) 应该返回 5，而 add(2) 应该返回一个 function。
调用这个有一个参数的返回的 function，返回求和的结果：
var sumTwoAnd = add(2);
sumwoAnd(3) 返回 5。
如果两个参数都不是有效的数字，则返回 undefined。
function add() {
let arg = Array.prototype.slice.call(arguments),
result = arg.every((x) => {
return Number.isFinite(x);
});
if (result) {
if (arg.length === 2) {
return arg[0] + arg[1];
} else {
var a = arg[0];
return function (b) {
if (Number.isFinite(b)) {
return a + b;
} else {
return undefined;
}
}
}
} else {
return undefined;
}
}
add(2, 3);