?反转字符串
function reverseString(str) {
return str;
}
reverseString("hello");
通过
reverseString将hello输出为olleh
利用数组 reverse方法实现
function reverseString(str) {
return str.split("").reverse().join("");
}
reverseString("hello"); // olleh
从目标字符串最后一位开始向前把每一项，用新字符串拼接
function reverseString(str) {
let newStr = ''
for(let i = str.length-1;i>=0;i--) {
newStr += str[i]
}
return newStr
}
console.log(reverseString('hello')) // olleh
利用递归
function reverseString(str) {
return (str === '') ? '' : reverseString(str.substr(1)) + str.charAt(0);
}
?计算一个整数的阶乘
如果用字母n来代表一个整数，阶乘代表着所有小于或等于n的整数的乘积。阶乘通常简写成 n!
例如: 5! = 1 * 2 * 3 * 4 * 5 = 120
递归实现
function factorialize(num) {
if (num == 0) return 1;
return num * factorialize(num - 1)
}
let r = factorialize(5) // 120
循环遍历
function factorialize(num) {
let result = num
while(num > 1) {
num--
result*= num
}
return result
}
let r = factorialize(5)
function factorialize(num) {
if (num === 0 || num === 1)
return 1;
for (var i = num - 1; i >= 1; i--) {
num *= i;
}
return num;
}
factorialize(5);
?检查回文
function palindrome(str) {}
palindrome("eye");
测试用例
palindrome('eye') // true
palindrome('A man, a plan, a canal. Panama') // true
从右到左的和从左到右含义一样
function palindrome(str) {
var re = /[\W_]/g;
var lowRegStr = str.toLowerCase().replace(re, '');
var reverseStr = lowRegStr.split('').reverse().join('');
return reverseStr === lowRegStr;
}
palindrome("A man, a plan, a canal. Panama");
function palindrome(str) {
var re = /[^A-Za-z0-9]/g;
str = str.toLowerCase().replace(re, '');
var len = str.length;
for (var i = 0; i < len/2; i++) {
if (str[i] !== str[len - 1 - i]) {
return false;
}
}
return true;
}
palindrome("A man, a plan, a canal. Panama");
开始第一项往后和最后一位往前还是比较，循环length/2次
Find the Longest Word in a String
function findLongestWord(str) {
return str.length;
}
findLongestWord("The quick brown fox jumped over the lazy dog");
- answer
function findLongestWord(str) {
var maxlength = 0;
var maxStr = '';
str.split(' ').forEach((item) => {
item.length > maxlength ? maxlength = item.length : null;
});
return maxlength;
}
findLongestWord("The quick brown fox jumped over the lazy dog");
Title Case a Sentence
function titleCase(str) {
return str;
}
titleCase("I'm a little tea pot");
- answer
function titleCase(str) {
str = str.toLowerCase().split(' ').map((word) => {
return word.charAt(0).toLocaleUpperCase() + word.slice(1)
})
return str.join(' ')
}
console.log(titleCase("I'm a little tea pot"));
Return Largest Numbers in Arrays
function largestOfFour(arr) {
return arr;
}
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
- answer
1.
function largestOfFour(mainArray) {
return mainArray.map(function (subArray){
return subArray.reduce(function (previousLargestNumber, currentLargestNumber) {
return (currentLargestNumber > previousLargestNumber) ? currentLargestNumber : previousLargestNumber;
}, 0);
});
}
console.log(largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]));
2.
function largestOfFour(mainArray) {
return mainArray.map(function(subArray) {
return Math.max.apply(null, subArray);
});
}
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
tips:
- Math,max可以传递任意数量的参数返回最大值.
- console.log(Math.max(4,5,1,3)); // logs 5
- 但是不能把一串数组直接传递像这样：
- var num = [4,5,1,3];
- console.log(Math.max(num)); // logs NaN
- 这里借用apply方法
- var num = [4,5,1,3];
- console.log(Math.max.apply(null, num)); // logs 5
Confirm the Ending
判断一个字符串(str)是否以指定的字符串(target)结尾。
如果是，返回true;如果不是，返回false。
function confirmEnding(string, target) {
return string;
}
confirmEnding("Bastian", "n");
Provided test cases
confirmEnding("He has to give me a new name", "name") 应该返回 true.
confirmEnding("He has to give me a new name", "me") 应该返回 true.
- answer
1.
function confirmEnding(string, target) {
return (string.substr(-target.length) === target) ? true : false;
}
confirmEnding('Bastian', 'n');
2.
function confirmEnding(string, target) {
return string.substr(-target.length) === target;
}
confirmEnding('Bastian', 'n');
3.
function confirmEnding(string, target) {
return string.endsWith(target); // 'Bastian'.endsWith('n')
}
confirmEnding('Bastian', 'n');
Repeat a string repeat a string
重复一个指定的字符串 num次，如果num是一个负数则返回一个空字符串。
function repeat(str, num) {
return str;
}
repeat("abc", 3);
- answer
1.
function repeat(str, num) {
if (num <= 0) {
return ''
}
let newStr = []
for (var i = 0; i < num; i++) {
newStr.push(str)
}
return newStr.join('');
}
console.log(repeat("abc", 3))
2.
function repeatStringNumTimes(string, times) {
var repeatedString = "";
while (times > 0) {
repeatedString += string;
times--;
}
return repeatedString;
}
repeatStringNumTimes("abc", 3);
3.
function repeatStringNumTimes(string, times) {
if(times < 0)
return "";
if(times === 1)
return string;
else
return string + repeatStringNumTimes(string, times - 1);
}
repeatStringNumTimes("abc", 3);
4.
function repeatStringNumTimes(string, times) {
return times > 0 ? string.repeat(times) : "";
}
repeatStringNumTimes("abc", 3);
Truncate a string
function truncate(str, num) {
return str;
}
truncate("A-tisket a-tasket A green and yellow basket", 11);
如果字符串的长度比指定的参数num长，则把多余的部分用...来表示。
切记，插入到字符串尾部的三个点号也会计入字符串的长度。
但是，如果指定的参数num小于或等于3，则添加的三个点号不会计入字符串的长度。
function truncateString(str, num) {
if(num <=3){
return str.slice(0,num) + '…';
}
if (num >= str.length){
return str
}
return str.slice(0,num-3) + '…';
}
truncateString('A-tisket a-tasket A green and yellow basket', 11);
Chunky Monkey
function chunk(arr, size) {
return arr;
}
chunk(["a", "b", "c", "d"], 2);
把一个数组arr按照指定的数组大小size分割成若干个数组块。
例如:chunk([1,2,3,4],2)=[[1,2],[3,4]];
chunk([1,2,3,4,5],2)=[[1,2],[3,4],[5]]
1.
function chunk(arr, size) {
var temp = [];
var result = [];
for (var a = 0; a < arr.length; a++) {
//a % size = 0,1,2,0
if (a % size !== size - 1) {
temp.push(arr[a])
}
else {
temp.push(arr[a]);
result.push(temp);
temp = [];
}
}
if (temp.length !== 0)
result.push(temp);
return result;
}
// temp = [], result = [] size = 3
// 1. a % size = 0,1,2,0 => if(a % size ！= 2) temp = [a,b]
// 2. temp = [a,b,c] reslut = [[a,b,c]]
// 3. temp = [] temp = [d] result.push(temp) => result = [[a,b,c],[d]]
chunk(["a", "b", "c", "d"], 3)
2.
function chunk(arr, size) {
var newArr = [];
var i = 0;
while (i < arr.length) {
newArr.push(arr.slice(i, i+size));
i += size;
}
return newArr;
}
chunk(["a", "b", "c", "d"], 2); //[ [ 'a', 'b' ], [ 'c', 'd' ] ]
Slasher Flick
function slasher(arr, howMany) {
return arr;
}
slasher([1, 2, 3], 2);
截断数组
返回一个数组被截断n个元素后还剩余的元素，截断从索引0开始。
function slasher(arr, howMany) {
var newArr = arr.slice(howMany);
return newArr;
}
slasher([1, 2, 3], 2); //[ 3 ]
Mutations
function mutation(arr) {
return arr;
}
mutation(["hello", "hey"]);
比较字符串
（蛤蟆可以吃队友，也可以吃对手）
如果数组第一个字符串元素包含了第二个字符串元素的所有字符，函数返回true。
举例，["hello", "Hello"]应该返回true，因为在忽略大小写的情况下，第二个字符串的所有字符都可以在第一个字符串找到。
["hello", "hey"]应该返回false，因为字符串"hello"并不包含字符"y"。
["Alien", "line"]应该返回true，因为"line"中所有字符都可以在"Alien"找到。
1.
function mutation(arr) {
var test = arr[1].toLowerCase();
var target = arr[0].toLowerCase();
for (i=0;i<test.length;i++) {
if (target.indexOf(test[i]) === -1)
return false;
}
return true;
}
2.
function mutation(arr) {
return arr[1].toLowerCase()
.split('')
.every(function(letter) {
return arr[0].toLowerCase()
.indexOf(letter) !== -1;
});
}
Falsy Bouncer
function bouncer(arr) {
return arr;
}
bouncer([7, "ate", "", false, 9]);
过滤数组假值
（真假美猴王）
删除数组中的所有假值。
在JavaScript中，假值有false、null、0、""、undefined 和 NaN。
function bouncer(arr) {
return arr.filter(Boolean);
}
bouncer([7, "ate", "", false, 9]);
function bouncer(arr) {
var check = arr.filter(function(i) {
return Boolean(i);
});
return check;
}
bouncer([7, "ate", "", false, 9]);
Seek and Destroy
function destroyer(arr) {
return arr;
}
destroyer([1, 2, 3, 1, 2, 3], 2, 3);
摧毁数组
金克斯的迫击炮！
实现一个摧毁(destroyer)函数，第一个参数是待摧毁的数组，其余的参数是待摧毁的值。
function destroyer(arr) {
console.log(arr);
//logs [ 1, 2, 3, 1, 2, 3 ]
console.log(arguments)
// logs { ‘0’: [ 1, 2, 3, 1, 2, 3 ], ‘1’: 2, ‘2’: 3 }
}
destroyer([1, 2, 3, 1, 2, 3], 2, 3);
console.log(arguments)是一个类数组，我们要转化成数组
var args = Array.prototype.slice.call(arguments);
var args = [].slice.call(arguments);
and,
var args = Array.from(arguments);
var args = [...arguments];
function destroyer(arr) {
var args = [...arguments]
args.splice(0,1) // [2,3]
return arr.filter((val) => {
return args.indexOf(val) === -1 // 返回args中不存在的那一项
})
return arr;
}
console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3)); //[ 1, 1 ]
Where do I belong
function where(arr, num) {
return num;
}
where([40, 60], 50);
数组排序并找出元素索引
先给数组排序，然后找到指定的值在数组的位置，最后返回位置对应的索引。
举例：where([1,2,3,4], 1.5) 应该返回 1。因为1.5插入到数组[1,2,3,4]后变成[1,1.5,2,3,4]，而1.5对应的索引值就是1。
同理，where([20,3,5], 19) 应该返回 2。因为数组会先排序为 [3,5,20]，19插入到数组[3,5,20]后变成[3,5,19,20]，而19对应的索引值就是2。
function where(arr, num) {
arr.push(num)
arr.sort((a,b) => {
return a-b
});
var index = arr.indexOf(num)
return index;
}
console.log(where([40, 60], 50)); // 1
Caesars Cipher
function rot13(str) {
return str;
}
rot13("SERR PBQR PNZC");
凯撒密码
（让上帝的归上帝，凯撒的归凯撒）
下面我们来介绍风靡全球的凯撒密码Caesar cipher，又叫移位密码。
移位密码也就是密码中的字母会按照指定的数量来做移位。
一个常见的案例就是ROT13密码，字母会移位13个位置。由'A' ↔ 'N', 'B' ↔ 'O'，以此类推。
写一个ROT13函数，实现输入加密字符串，输出解密字符串。
所有的字母都是大写，不要转化任何非字母形式的字符(例如：空格，标点符号)，遇到这些特殊字符，跳过它们。
function rot13(str) {
return str.split('').map((char) => {
x = char.charCodeAt(0);
if (x < 65 || x > 90) {
return String.fromCharCode(x)
} else if (x < 78) {
return String.fromCharCode(x + 13)
} else {
return String.fromCharCode(x - 13)
}
}).join('')
}
手机号中间四位加密
1. this.numEnc = queryNum.substr(0, 3) + queryNum.substr(3, 4).replace(/[\d+]/g, '*') + queryNum.substr(7)
2. let queryNum = this.$route.query.num
this.numEnc = queryNum.split('').map((w, index) => {
return (index > 2 && index < 7) ? '*' : w
}).join('')
3. this.numEnc = queryNum.substr(0, 3) + queryNum.substr(3, 4).replace(/[\d+]/g, '*') + queryNum.substr(7)
找到规定数组内缺失的那一项
用例
find_missing([1, 14, 11, 51, 15], 10, 15) //[ 10, 12, 13 ]
1.
function find_missing(A,low,high) {
let newArr = []
for(let i=low;i<high;i++) {
newArr.push(i)
}
let result = newArr.filter((i) => {
return A.indexOf(i) === -1
})
return result
}
2.
function find_missing(A, low, height) {
let resArr = []
let newArr = A.filter(x => x > low && x < height)
for (let i = low; i < height; i++) {
if(!newArr.some(x=>x===i)){
resArr.push(i)
}
}
return resArr
}
Sum All Numbers in a Range
function sumAll(arr) {
return 1;
}
sumAll([1, 4]);
传递给你一个包含两个数字的数组。返回这两个数字和它们之间所有数字的和。
最小的数字并非总在最前面。
function sumAll(arr) {
let max = Math.max.apply(null, arr)
let min = Math.min.apply(null, arr)
let result = []
for(let i= min; i<=max; i++) {
result.push(i)
}
return result.reduce((prev,next) => {
return prev + next
},0)
}
console.log(sumAll([1, 4])); // 10
用到：
Math.max()Math.min()Math max/min Apply methodArray.reduce
Diff Two Arrays
function diff(arr1, arr2) {
var newArr = [];
// Same, same; but different.
return newArr;
}
diff([1, 2, 3, 5], [1, 2, 3, 4, 5]);
比较两个数组，然后返回一个新数组，该数组的元素为两个给定数组中所有独有的数组元素。换言之，返回两个数组的差异。
function diff(arr1, arr2) {
let arr1Filtered = arr1.filter((val) => {
return arr2.indexOf(val) === -1
})
let arr2Filtered = arr2.filter((val) => {
return arr1.indexOf(val) === -1
})
return arr1Filtered.concat(arr2Filtered)
}
diff([1, 2, 3, 5], [1, 2, 3, 4, 5]); // [4]
Array.indexOf()当前数组不包含返回 -1arr.filter()
function diff(arr1, arr2) {
return arr1
.filter(el => !arr2.includes(el))
.concat(
arr2.filter(el => !arr1.includes(el))
)
}
diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]);
Array.filter返回为true的这一项，并把它放入新数组中Array.includes判断数组是否包含传入参数
Roman Numeral Converter
function convert(num) {
return num;
}
convert(36);
将给定的数字转换成罗马数字。
所有返回的 罗马数字 都应该是大写形式。
function convert(num) {
var roman = "", romanNumeral = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I'],
numbers = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
numbers.forEach((item, index) => {
while (num >= item) {
roman += romanNumeral[index]
num-= item
}
})
return roman;
}
console.log(convert(36)); // XXXVI
Where art thou
function where(collection, source) {
var arr = [];
// What's in a name?
return arr;
}
where([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });
写一个 function，它遍历一个对象数组（第一个参数）并返回一个包含相匹配的属性-值对（第二个参数）的所有对象的数组。如果返回的数组中包含 source 对象的属性-值对，那么此对象的每一个属性-值对都必须存在于 collection 的对象中。
例如，如果第一个参数是 [{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }]，第二个参数是 { last: "Capulet" }，那么你必须从数组（第一个参数）返回其中的第三个对象，因为它包含了作为第二个参数传递的属性-值对。
function where(collection, source) {
let sourceKey = Object.keys(source)
return collection.filter((collectItem) => {
return sourceKey.every((sourceItem) => {
return collectItem[sourceItem] === source[sourceItem]
})
})
}
console.log(where([{first: "Romeo", last: "Montague"}, {first: "Mercutio", last: null}, {
first: "Tybalt",
last: "Capulet"
}], {last: "Capulet"})); // [ { first: 'Tybalt', last: 'Capulet' } ]
Object.keys返回一个对象中的key值以数组返回
Array.every()根据条件遍历数组，如果碰到不成立,立即返回false,循环终止。如更到最后成立，最终返回true
Array.some()根据条件遍历数组中每一项,如果碰到成立,立即返回true，循环终止，如果到最后都不成立,最终返回false
Search and Replace
function myReplace(str, before, after) {
return str;
}
myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");
使用给定的参数对句子执行一次查找和替换，然后返回新句子。
第一个参数是将要对其执行查找和替换的句子。
第二个参数是将被替换掉的单词（替换前的单词）。
第三个参数用于替换第二个参数（替换后的单词）。
注意：替换时保持原单词的大小写。例如，如果你想用单词 "dog" 替换单词 "Book" ，你应该替换成 "Dog"。
function myReplace(str, before, after) {
if(before[0] === before[0].toUpperCase()) {
after = after[0].toUpperCase() + after.slice(1)
}
return str.replace(before, after)
}
console.log(myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped"));
// A quick brown fox leaped over the lazy dog
String.repalce()可以替换字符串中的匹配项
var str = 'A B'
console.log(str.replace('A', 'B'));
// returns “B B”
Pig Latin
function translate(str) {
return str;
}
translate("consonant");
把指定的字符串翻译成 pig latin。
Pig Latin 把一个英文单词的第一个辅音或辅音丛（consonant cluster）移到词尾，然后加上后缀 "ay"。
如果单词以元音开始，你只需要在词尾添加 "way" 就可以了
function translate(str) {
var pigLatin = '';
var regex = /[aeiou]/gi;
if (str[0].match(regex)) {
pigLatin = str + 'way';
} else {
var vowelIndice = str.indexOf(str.match(regex)[0]);
pigLatin = str.substr(vowelIndice) + str.substr(0, vowelIndice) + 'ay';
}
return pigLatin;
}
translatePigLatin('glove');
Missing letters
function fearNotLetter(str) {
return str;
}
fearNotLetter("abce");
从传递进来的字母序列中找到缺失的字母并返回它。
如果所有字母都在序列中，返回 undefined。
测试用例
fearNotLetter("abce") 应该返回 "d"。
fearNotLetter("abcdefghjklmno") 应该返回 "i"。
fearNotLetter("bcd") 应该返回 undefined。
fearNotLetter("yz") 应该返回 undefined。
function fearNotLetter(str) {
let startCode = str.charCodeAt(0)
for(let i= 0; i<str.length;i++) {
if (str.charCodeAt(i) !== startCode) {
return String.fromCharCode(startCode)
} else {
startCode++
}
}
}
console.log(fearNotLetter("abce")); //d
String charCodeAt()返回指定位置的字符的 Unicode 编码String fromCharCode()接受一个或多个 Unicode 值返回对应的字符
Boo who
function boo(bool) {
// What is the new fad diet for ghost developers? The Boolean.
return bool;
}
boo(null);
检查一个值是否是基本布尔类型，并返回 true 或 false。
基本布尔类型即 true 和 false。
测试用例
boo(true) 应该返回 true。
boo(false) 应该返回 true。
boo([1, 2, 3]) 应该返回 false。
boo([].slice) 应该返回 false。
boo({ "a": 1 }) 应该返回 false。
boo(1) 应该返回 false。
boo(NaN) 应该返回 false。
boo("a") 应该返回 false。
boo("true") 应该返回 false。
boo("false") 应该返回 false。
function boo(bool) {
return typeof bool === 'boolean';
}
Sorted Union
function unite(arr1, arr2, arr3) {
return arr1;
}
unite([1, 3, 2], [5, 2, 1, 4], [2, 1]);
写一个 function，传入两个或两个以上的数组，返回一个以给定的原始数组排序的不包含重复值的新数组。
换句话说，所有数组中的所有值都应该以原始顺序被包含在内，但是在最终的数组中不包含重复值。
非重复的数字应该以它们原始的顺序排序，但最终的数组不应该以数字顺序排序。
测试用例
unite([1, 3, 2], [5, 2, 1, 4], [2, 1]) 应该返回 [1, 3, 2, 5, 4]。
unite([1, 3, 2], [1, [5]], [2, [4]]) 应该返回 [1, 3, 2, [5], [4]]。
unite([1, 2, 3], [5, 2, 1]) 应该返回 [1, 2, 3, 5]。
unite([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8]) 应该返回 [1, 2, 3, 5, 4, 6, 7, 8]。
类数组转成数组的方法
Array.prototype.slice.call(arguments)[].slice.call(arguments)Array.from(arguments)var args = [...arguments]
var args = Array.from(arguments),
merged = [].concat.apply([],args),
test =[]
return merged.filter((val) => {
if(test.indexOf(val) === -1) {
test.push(val);
return true
} else {
return false
}
})
Convert HTML Entities
将字符串中的字符 &、<、>、" （双引号）, 以及 ' （单引号）转换为它们对应的 HTML 实体。
测试用例
convert("Dolce & Gabbana") 应该返回 Dolce & Gabbana。
convert("Hamburgers < Pizza < Tacos") 应该返回 Hamburgers < Pizza < Tacos。
convert("Sixty > twelve") 应该返回 Sixty > twelve。
convert('Stuff in "quotation marks"') 应该返回 Stuff in "quotation marks"。
convert("Shindler's List") 应该返回 Shindler's List。
convert("<>") 应该返回 <>。
convert("abc") 应该返回 abc。
function convert(str) {
let regObj = {
"&":"&",
"<":"<",
">":">",
'"':""",
"'":"'"
}
var reg = /[&<>"']/g
var arr = str.match(reg)
if(arr) {
for(let i in arr) {
str = str.replace(arr[i], regObj[arr[i]])
}
}
return str
}
convert("Dolce & Gabbana") // Dolce & Gabbana
Spinal Tap Case
function spinalCase(str) {
// "It's such a fine line between stupid, and clever."
// --David St. Hubbins
return str;
}
spinalCase('This Is Spinal Tap');
将字符串转换为 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();
}
console.log(spinalCase('thisIsSpinalTap')); // this-is-spinal-tap
Sum All Odd Fibonacci Numbers
function sumFibs(num) {
return num;
}
sumFibs(4);
给一个正整数num，返回小于或等于num的斐波纳契奇数之和。
斐波纳契数列中的前几个数字是 1、1、2、3、5 和 8，随后的每一个数字都是前两个数字之和。
例如，sumFibs(4)应该返回 5，因为斐波纳契数列中所有小于4的奇数是 1、1、3。
提示：此题不能用递归来实现斐波纳契数列。因为当num较大时，内存会溢出，推荐用数组来实现。
测试用例
sumFibs(1) 应该返回一个数字。
sumFibs(1000) 应该返回 1785。
sumFibs(4000000) 应该返回 4613732。
sumFibs(4) 应该返回 5。
sumFibs(75024) 应该返回 60696。
sumFibs(75025) 应该返回 135721。
取出字符串中出现最多的元素和出现的次数
let obj = '111222233333444444'
function maxEle(source) {
let arr = source.split('')
let res = {}
arr.forEach(item => {
if (!res[item]) {
res[item] = 1
} else {
res[item]++
}
});
let maxNum = 0;
let maxEle;
let keys = Object.keys(res)
keys.forEach(item => {
if (res[item] > maxNum) {
maxNum = res[item]
maxEle = item
}
})
console.log(maxNum, maxEle)
}
let result = maxEle(obj)
// 出现最多的元素e 一共出现6次
实现类似map的函数
测试用例
/**
*
* 要求，尝试完成如下功能：
*
* map([1, 2], function(i) {
* return i * 2
* })
* 要求输出： [2, 4]
*
* map([{name: 'nanfeng', age: 25}, {name: 'beifang', age: 33}], function(i) {
* return i.age
* })
* 要求输出： [25, 33]
*
* map([5, 7], function(i) {
* return this + i
* }, 2)
* 要求输出： [7, 9]
*
**
function map(arr, func, ctx) {
let newArr = []
arr.forEach(item => {
if(ctx) {
newArr.push(func.call(ctx, item))
} else {
newArr.push(func.call(null, item))
}
});
return newArr
}
使一个数组乱序，并计算前十项
let a = [5,8,2,4,2,1,5,1,2,45,1,5,1,45,12,451]
/*
* Math.random随机生成0-1之间的小数 sort特性a,b比较这一项小于0
*/
a.sort((a,b)=> Math.random() > 0.5? 1: -1)
let newa = a.slice(0, 10).reduce((prev,next) => prev + next,0)
生成一个长度为15的数组 list， 每个元素的值没1-100的随机整数
let a = Array.from(new Array(15), item => Math.parseInt(Math.random() * (99) + 1))
a // [ 50, 11, 27, 54, 62, 86, 96, 46, 16, 26, 50, 45, 67, 73, 46 ]
