Freecodecamp 算法题 （二）
1. Sum All Numbers in a Range
我们会传递给你一个包含两个数字的数组。返回这两个数字和它们之间所有数字的和。
最小的数字并非总在最前面。
function sumAll(arr) {
var sum=0;
if(arr[0]<arr[1]){
for(let i=arr[0]; i<=arr[1];i++){
sum+=i;
}
}
else if(arr[1]<arr[0]){
for(let k=arr[1]; k<=arr[0];k++){
sum+=k;
}
}
return sum;
}
sumAll([1, 4]);
第二种方法：
Math.max()
Math.min()
Array.reduce()
function sumAll(arr) {
var max = Math.max(arr[0],arr[1]);
var min = Math.min(arr[0],arr[1]);
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) {
return arr1.filter(function(e){
return arr2.indexOf(e) === -1;
}).concat(arr2.filter(function(e){
return arr1.indexOf(e) === -1;
}));
}
diff([1, 2, 3, 5], [1, 2, 3, 4, 5]); // [4]
3. Roman Numeral Converter
将给定的数字转换成罗马数字。
所有返回的 罗马数字 都应该是大写形式。
function convert(num) {
var number = [1000,900,500,400,100,90,50,40,10,9,5,4,1];
var roman_number =["M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"];
var result = "";
number.forEach(function(item,index,array){
while(num>=item){
//如果num大于number数组中的数
result += roman_number[index]; //将这个数对应的罗马数字加到result中 num -=item; //减去这个数，直到结束。
}
});
return result;
}
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) {
//source 的key
var keys = Object.keys(source);
var arr =[];
arr = collection.filter(function(item){
for(var i=0;i<keys.length;i++){
if(!item.hasOwnProperty(keys[i]) || item[keys[i]]!== source[keys[i]]){
return false;
}
}
return true;
});
return arr;
}
where([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });
思路
如果把一个对象表示为 {key1: value1,key2: value2,...,keyN: valueN} 形式，那么 Object.keys() 就能拿到 [key1,key2,...,keyN] 的集合。Object.keys() 方法会返回一个由给定对象的所有可枚举自身属性的属性名组成的数组，数组中属性名的排列顺序和使用for-in循环遍历该对象时返回的顺序一致。
我们先拿到 source 的 key 值，然后再一一与 collection 中的每一项比较。
var keys = Object.keys(source);
var arr = collection.filter(function(item){
//do something...
});
obj.hasOwnProperty(prop) 在属性 prop 存在于对象实例时返回 true。
if(!item.hasOwnProperty(keys[i]) || item[keys[i]]!== source[keys[i]]){
return false;
}
解释这个if判断语句：当 collection 的某一项不存在属性 keys[i]时(!item.hasOwnProperty(keys[i])，返回 false；
item[keys[i]]!== source[keys[i]])
item 在 key 值为 keys[i] 时 value 值不等于同 key 值时 source 的 value值，返回 false.
5. Search and Replace
使用给定的参数对句子执行一次查找和替换，然后返回新句子。
第一个参数是将要对其执行查找和替换的句子。
第二个参数是将被替换掉的单词（替换前的单词）。
第三个参数用于替换第二个参数（替换后的单词）。
注意：替换时保持原单词的大小写。例如，如果你想用单词 "dog" 替换单词 "Book" ，你应该替换成 "Dog"。
function myReplace(str, before, after) {
if(before[0] === before[0].toUpperCase()){
after = after[0].toUpperCase()+after.slice(1);
}
return str=str.replace(before, after);
}
myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");
6. Pig Latin
把指定的字符串翻译成 pig latin。
Pig Latin 把一个英文单词的第一个辅音或辅音丛（consonant cluster）移到词尾，然后加上后缀 "ay"。
如果单词以元音开始，你只需要在词尾添加 "way" 就可以了
function translate(str) {
var temp = ['a','e','i','o','u'];
if(temp.indexOf(str[0])>=0){
return str+ 'way';
}
while(temp.indexOf(str[0])<0){
str = str.substr(1)+str.substr(0,1);
}
return str+'ay';
}
translate("california");
7. DNA Pairing
DNA 链缺少配对的碱基。依据每一个碱基，为其找到配对的碱基，然后将结果作为第二个数组返回。
Base pairs（碱基对） 是一对 AT 和 CG，为给定的字母匹配缺失的碱基。
在每一个数组中将给定的字母作为第一个碱基返回。
例如，对于输入的 GCG，相应地返回 [["G", "C"], ["C","G"],["G", "C"]]
字母和与之配对的字母在一个数组内，然后所有数组再被组织起来封装进一个数组。
方法一 :
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");
方法二：
function pair(str) {
var obj = {'A':'T','T':'A','G':'C','C':'G'};
var result =str.split('').map(e=>[e,obj[e]]);
return result;
}
pair("GCG");
8. Missing letters
从传递进来的字母序列中找到缺失的字母并返回它。
如果所有字母都在序列中，返回 undefined。
function fearNotLetter(str) {
for(let i=0;i<str.length;i++){
if(str.charCodeAt(i+1)-str.charCodeAt(i)>1){
return String.fromCharCode(str.charCodeAt(i)+1);
}
}
return undefined;
}
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(arr1, arr2, arr3) {
var args = Array.from(arguments);
var arr = args.reduce(function(prev,cur,index,array){
return prev.concat(cur);
});
var result = arr.filter(function(item,index){
return arr.indexOf(item)===index;
});
return result;
}
unite([1, 3, 2], [5, 2, 1, 4], [2, 1]);
注意：
数组去重的最直接的方法
var result = arr.filter(function(item,index){
return arr.indexOf(item)===index;
});
11. Convert HTML Entities
将字符串中的字符 &、<、>、" （双引号）, 以及 ' （单引号）转换为它们对应的 HTML 实体。
function convert(str) {
var htmlEntities = {
'&':'&',
'<':'<',
'>':'>',
'\"':'"',
'\'':"'"
};
str = str.split('').map(function(entity){
return htmlEntities[entity] || entity;
});
return str.join('');
}
convert("Dolce & Gabbana");
12. Spinal Tap Case
将字符串转换为 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) {
return str.replace(/\s|_/g,'-').replace(/([a-z])([A-Z])/g,'$1-$2').toLowerCase();
}
spinalCase('thisIsSpinalTap');
13. Sum All Odd Fibonacci Numbers
给一个正整数num，返回小于或等于num的斐波纳契奇数之和。
斐波纳契数列中的前几个数字是 1、1、2、3、5 和 8，随后的每一个数字都是前两个数字之和。
function sumFibs(num) {
var prev = 0;
var cur = 1;
var sum = 0;
while(cur <= num){
if(cur%2 !== 0){
sum += cur;
}
cur += prev;
prev = cur - prev;
}
return sum;
}
sumFibs(4);
14. Sum All Primes
求小于等于给定数值的质数之和。
只有 1 和它本身两个约数的数叫质数。例如，2 是质数，因为它只能被 1 和 2 整除。1 不是质数，因为它只能被自身整除。
给定的数不一定是质数。
function sumPrimes(num) {
if(num===1) return false;
function checkPrime(i){
for(var k=2;k<i;k++){
if(i%k===0){
return false;
}
}
return true;
}
var sum=0;
for(var i=2;i<=num;i++){
if(checkPrime(i)){
sum+=i;
}
}
return sum;
}
sumPrimes(10);
15. Smallest Common Multiple
找出能被两个给定参数和它们之间的连续数字整除的最小公倍数。
范围是两个数字构成的数组，两个数字不一定按数字顺序排序。
例如对 1 和 3 —— 找出能被 1 和 3 和它们之间所有数字整除的最小公倍数。
思路：假如区间为[1,5]，所求的数值是60，也就是说需要求出来的值是的1,2,3,4,5的公倍数。
两个数字最小公倍数的求法:A*B/(AB两数的最大公约数)
function smallestCommons(arr) {
arr = arr.sort(function(a,b){
return a-b;
});
var num = arr[0];
for(var i=num;i<=arr[1];i++){
num*= i/gcd(num,i);
}
return num;
}
//欧几里得算法 求最大公约数
function gcd(m,n){
if(m%n===0){
return n;
}else{
return gcd(n,m%n);
}
}
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) {
var num = 0;
num = arr.filter(func);
return num[0];
}
find([1, 2, 3, 4], function(num){ return num % 2 === 0; });
17. Drop it
让我们来丢弃数组(arr)的元素，从左边开始，直到回调函数return true就停止。
第二个参数，func，是一个函数。用来测试数组的第一个元素，如果返回fasle，就从数组中抛出该元素(注意：此时数组已被改变)，继续测试数组的第一个元素，如果返回fasle，继续抛出，直到返回true。
最后返回数组的剩余部分，如果没有剩余，就返回一个空数组。
function drop(arr, func) {
while(arr.length>0 && !func(arr[0])){
arr.shift();
}
return arr;
}
drop([1, 2, 3], function(n) {return n < 3; });
18. 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]。
function steamroller(arr) {
var tempArr = [];
// I'm a steamroller, baby
function falttenArray(arg){
if(!Array.isArray(arg)){
tempArr.push(arg);
}else{
for(var i in arg){
falttenArray(arg[i]);
}
}
}
arr.forEach(falttenArray);
return tempArr;
}
steamroller([1, [2], [3, [[4]]]]);
19. Binary Agents
传入二进制字符串，翻译成英语句子并返回。
二进制字符串是以空格分隔的。
function binaryAgent(str) {
str = str.split(' ');
var arr =[];
var result=[];
for(var i=0;i<str.length;i++){
arr.push(parseInt(str[i],2));
result.push(String.fromCharCode(arr[i]));
}
return result.join('');
}
binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");
19. Everything Be True
所有的东西都是真的！
完善编辑器中的every函数，如果集合(collection)中的所有对象都存在对应的属性(pre)，并且属性(pre)对应的值为真。函数返回ture。反之，返回false。
记住：你只能通过中括号来访问对象的变量属性(pre)
function every(collection, pre) {
// Is everyone being true?
return collection.every(function(val){
return val[pre];
});
}
every([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");
20. Arguments Optional
创建一个计算两个参数之和的 function。如果只有一个参数，则返回一个 function，该 function 请求一个参数然后返回求和的结果。
例如，add(2, 3) 应该返回 5，而 add(2) 应该返回一个 function。
调用这个有一个参数的返回的 function，返回求和的结果：
var sumTwoAnd = add(2);
sumTwoAnd(3) 返回 5。
如果两个参数都不是有效的数字，则返回 undefined。
function add() {
var args = Array.from(arguments);
if(typeof args[0] ==='number' && typeof args[1]==='number'){
return args[0]+args[1];
}
if(args.length===1 && typeof args[0] ==='number'){
return function(y){
if(typeof y==='number') {
return args[0]+y;
}
};
}
}
add(2,3);
网友评论