Sum All Numbers in a RangeComplete
我们会传递给你一个包含两个数字的数组。返回这两个数字和它们之间所有数字的和。
最小的数字并非总在最前面。
function sumAll(arr) {
var start = arr[0];
var end = arr[1];
if (start > end){
var temp = start;
start = end;
end = temp;
}
var sum = 0;
for (var i=start; i<=end; i++){
sum += i;
}
return sum;
}
sumAll([1, 4]);
Diff Two ArraysComplete
比较两个数组，然后返回一个新数组，该数组的元素为两个给定数组中所有独有的数组元素。换言之，返回两个数组的差异。
function diff(arr1, arr2) {
var newArr = arr1.filter(function(data){
if (arr2.indexOf(data) >= 0) return false;
else return true;
});
newArr = newArr.concat(arr2.filter(function(data){
if (arr1.indexOf(data) >= 0) return false;
else return true;
}));
// Same, same; but different.
return newArr;
}
diff([1, 2, 3, 5], [1, 2, 3, 4, 5]);
Roman Numeral Converter
将给定的数字转换成罗马数字。
所有返回的 罗马数字 都应该是大写形式。
function convert(num) {
var retStr = "";
if (num >= 4000){
console.log("input out of range");
return retStr;
}
var ROME = [['I', 'V', 'X'], ['X', 'L', 'C'], ['C', 'D', 'M'],['M', ' ', ' ']];
var count = 0;
var i = 0;
while (num > 0){
var str = "";
var d = num % 10;
if (d>0 && d<4){
for (i=0; i=5 && d<9){
str += ROME[count][1];
for (i=0; i<(d-5); i++){
str += ROME[count][0];
}
}
else if (d === 9){
str += ROME[count][0];
str += ROME[count][2];
}
retStr = str + retStr;
count++;
num = parseInt(num/10);
}
return retStr;
}
convert(36);
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 arr = [];
// What's in a name?
var keys = Object.keys(source);
arr = collection.filter(function(obj){
//sourceProps.forEach(function(prop){
for (var i=0; iSearch and Replace
使用给定的参数对句子执行一次查找和替换，然后返回新句子。
第一个参数是将要对其执行查找和替换的句子。
第二个参数是将被替换掉的单词（替换前的单词）。
第三个参数用于替换第二个参数（替换后的单词）。
注意：替换时保持原单词的大小写。例如，如果你想用单词 "dog" 替换单词 "Book" ，你应该替换成 "Dog"。
如果你被难住了，记得使用 Read-Search-Ask尝试与他人结伴编程、编写你自己的代码。
这是一些对你有帮助的资源:
Array.splice()
String.replace()
Array.join()
function myReplace(str, before, after) {
var firstLetter = before.charAt(0);
if (firstLetter >= 'A' && firstLetter <='Z'){
after = after[0].toUpperCase() + after.slice(1);
}
if (firstLetter >= 'a' && firstLetter <='z'){
after = after[0].toLowerCase() + after.slice(1);
}
return str.replace(before, after);
}
str = myReplace("He is Sleeping on the couch", "Sleeping", "sitting");
console.log(str);
高级首字符大写方式：
function firstWordUpperCase(str){
return str.toLowerCase().replace(/(\s|^)[a-z]/g, function(char){
return char.toUpperCase();
});
}
作者：qq_32578487
来源：CSDN
原文：https://blog.csdn.net/qq_32578487/article/details/77870225
版权声明：本文为博主原创文章，转载请附上博文链接！
Pig Latin
把指定的字符串翻译成 pig latin。
Pig Latin 把一个英文单词的第一个辅音或辅音丛（consonant cluster）移到词尾，然后加上后缀 "ay"。
如果单词以元音开始，你只需要在词尾添加 "way" 就可以了。
function isVowel(ch){
var VOWEL = ['a', 'e', 'i' ,'o','u'];
if (VOWEL.indexOf(ch)>=0){
return true;
}
return false;
}
function translate(str) {
if (isVowel(str[0])){
str = str + "way";
}
else {
var i = 1;
while (!isVowel(str[i])){
i++;
}
str = str.slice(i) + str.slice(0, i) + "ay";
}
return str;
}
str = translate("consonant");
DNA Pairing
DNA 链缺少配对的碱基。依据每一个碱基，为其找到配对的碱基，然后将结果作为第二个数组返回。
Base pairs（碱基对） 是一对 AT 和 CG，为给定的字母匹配缺失的碱基。
在每一个数组中将给定的字母作为第一个碱基返回。
例如，对于输入的 GCG，相应地返回 [["G", "C"], ["C","G"],["G", "C"]]
字母和与之配对的字母在一个数组内，然后所有数组再被组织起来封装进一个数组。
function pair(str) {
var arr = [];
Array.from(str).forEach(function(ch){
if (ch==='A'){
arr.push(['A', 'T']);
}
if (ch==='T'){
arr.push(['T', 'A']);
}
if (ch==='C'){
arr.push(['C', 'G']);
}
if (ch==='G'){
arr.push(['G', 'C']);
}
});
return arr;
}
pair("GCG");
高端写法：
function pair(str) {
var obj = {'A':'T','T':'A','G':'C','C':'G'};
return str.split('').map(e => [e,obj[e]]);
}
pair("GCG");
Missing letters
从传递进来的字母序列中找到缺失的字母并返回它。
如果所有字母都在序列中，返回 undefined。
如果你被卡住了，记得开大招 Read-Search-Ask。尝试与他人结伴编程、编写你自己的代码。
这是一些对你有帮助的资源:
String.charCodeAt()
String.fromCharCode()
function fearNotLetter(str) {
var norm = str[0].charCodeAt();
for (var i=1; iBoo who
检查一个值是否是基本布尔类型，并返回 true 或 false。
基本布尔类型即 true 和 false。
function boo(bool) {
// What is the new fad diet for ghost developers? The Boolean.
return typeof bool === 'boolean';
}
str = boo(true);
console.log(str);
Sorted Union
写一个 function，传入两个或两个以上的数组，返回一个以给定的原始数组排序的不包含重复值的新数组。
换句话说，所有数组中的所有值都应该以原始顺序被包含在内，但是在最终的数组中不包含重复值。
非重复的数字应该以它们原始的顺序排序，但最终的数组不应该以数字顺序排序。
function unite(arr1, arr2, arr3) {
var args = arguments;
for (var i=1; iConvert HTML Entities
将字符串中的字符 &、<、>、" （双引号）, 以及 ' （单引号）转换为它们对应的 HTML 实体。
function convert(str) {
// :)
str = str.replace(/&/g, '&');
str = str.replace(//g, '>');
str = str.replace(/"/g, '"');
str = str.replace(/'/g, ''');
return str;
}
convert("Dolce & Gabbana");
Spinal Tap Case
将字符串转换为 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 这种形式的，也就是以连字符连接所有小写单词。
如果你被卡住了，记得开大招 Read-Search-Ask。尝试与他人结伴编程、编写你自己的代码。
这是一些对你有帮助的资源:
RegExp
String.replace()
function spinalCase(str) {
// "It's such a fine line between stupid, and clever."
// --David St. Hubbins
return str.replace(/[\s_]/g, '-')
.replace(/([a-z])([A-Z])/g, '$1-$2')
.toLowerCase();
}
str = spinalCase("thisIsSpinalTap");
console.log(str);
使用正则表达式。
tips1: 思路，先把空格和下划线换成-；再把相邻的小写和大写字母之间加上-；最后全部转为小写。
tips2：第二部匹配相邻的小写和大写字母时，不能写成/[a-z][A-Z]/g，否则：
str = spinalCase("thisIsSpinalTap");
\\输出 thi$1-$2$1-$2pina$1-$2ap
参考：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/RegExp
(x)：匹配 x 并且捕获匹配项。 这被称为捕获括号（capturing parentheses）。
也就是说，想用9，必须得有()。
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 sum;
if (num <= 2){
sum = num;
}
else {
var fibPre = 1;
var fibNext = 2;
sum = 2;
while (fibNext <= num){
if (fibNext%2 !== 0){
sum += fibNext;
}
var temp = fibNext + fibPre;
fibPre = fibNext;
fibNext = temp;
console.log("fib"+fibNext);
}
}
return sum;
}
str = sumFibs(1000);
console.log(str);
Sum All Primes
求小于等于给定数值的质数之和。
只有 1 和它本身两个约数的数叫质数。例如，2 是质数，因为它只能被 1 和 2 整除。1 不是质数，因为它只能被自身整除。
给定的数不一定是质数。
function isPrime(num){
if (num<=1){
return false;
}
for (var i=2; i<=Math.pow(num, 0.5); i++){
if (num % i === 0){
return false;
}
}
return true;
}
function sumPrimes(num) {
var sum = 0;
for (var i=2; i<=num; i++) {
if (isPrime(i)){
sum += i;
}
}
return sum;
}
str = sumPrimes(10);
console.log(str);
Smallest Common Multiple
找出能被两个给定参数和它们之间的连续数字整除的最小公倍数。
范围是两个数字构成的数组，两个数字不一定按数字顺序排序。
例如对 1 和 3 —— 找出能被 1 和 3 和它们之间所有数字整除的最小公倍数。
function biggestFactor(a, b){
while (b%a !== 0){
var temp = b % a;
b = a;
a = temp;
}
return a;
}
function smallestCommons(arr) {
if (arr[0] > arr[1]){
var temp = arr[0];
arr[0] = arr[1];
arr[1] = temp;
}
var commons = arr[0];
for(var i=arr[0]+1; i<=arr[1]; i++){
commons = commons * i / biggestFactor(commons, i);
}
return commons;
}
str = smallestCommons([5,1]);
console.log(str);
Finders Keepers
写一个 function，它遍历数组 arr，并返回数组中第一个满足 func 返回值的元素。举个例子，如果 arr 为 [1, 2, 3]，func 为 function(num) {return num === 2; }，那么 find 的返回值应为 2。
function find(arr, func) {
var num = arr.filter(func)[0];
return num;
}
str = find([1, 2, 3, 4], function(num){ return num % 2 === 0; });
console.log(str);
Drop it
队友该卖就卖，千万别舍不得。
当你的队伍被敌人包围时，你选择拯救谁、抛弃谁非常重要，如果选择错误就会造成团灭。
如果是AD或AP，优先拯救。
因为AD和AP是队伍输出的核心。
其次应该拯救打野。
因为打野死了对面就可以无所顾虑地打龙。
最后才是辅助或上单。
因为辅助和上单都是肉，死了也不会对团队造成毁灭性影响，该卖就卖。
但真实中的团战远比这要复杂，你的队伍很可能会被敌人分割成2个或3个部分。
当你救了一个重要的人时，很可能其他队友也会因此获救。
举个例子：
辅助和AD经常是在一起的，打野和中单在一起，上单经常一个人。
你救了AD，辅助也经常因此获救。
让我们来丢弃数组(arr)的元素，从左边开始，直到回调函数return true就停止。
第二个参数，func，是一个函数。用来测试数组的第一个元素，如果返回fasle，就从数组中抛出该元素(注意：此时数组已被改变)，继续测试数组的第一个元素，如果返回fasle，继续抛出，直到返回true。
最后返回数组的剩余部分，如果没有剩余，就返回一个空数组。
function drop(arr, func) {
// Drop them elements.
var empty = [];
for (var i=0; i= 3;});
console.log(str);
Steamroller
对嵌套的数组进行扁平化处理。你必须考虑到不同层级的嵌套。
function steamroller(arr) {
// I'm a steamroller, baby
var retArr = [];
arr.forEach(function(item){
if (Array.isArray(item)){
retArr = retArr.concat(steamroller(item));
}
else{
retArr.push(item);
}
});
return retArr;
}
str = steamroller([1, [2], [3, [[4]]]]);
console.log(str);
Binary Agents
传入二进制字符串，翻译成英语句子并返回。
二进制字符串是以空格分隔的。
如果你被卡住了，记得开大招 Read-Search-Ask。尝试与他人结伴编程、编写你自己的代码。
这是一些对你有帮助的资源:
String.charCodeAt()
String.fromCharCode()
function binaryAgent(str) {
var arr = str.split(' ');
var retStr = "";
arr.forEach(function(item){
retStr += String.fromCharCode(parseInt(item, 2));
});
return retStr;
}
str = binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");
console.log(str);
传入二进制字符串，翻译成英语句子并返回。
二进制字符串是以空格分隔的。
Everything Be True
所有的东西都是真的！
完善编辑器中的every函数，如果集合(collection)中的所有对象都存在对应的属性(pre)，并且属性(pre)对应的值为真。函数返回ture。反之，返回false。
记住：你只能通过中括号来访问对象的变量属性(pre)。
提示：你可以有多种实现方式，最简洁的方式莫过于Array.prototype.every()。
function every(collection, pre) {
// Is everyone being true?
return collection.every(function(obj){
return obj[pre];
});
}
str = every([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");
console.log(str);
Arguments Optional
创建一个计算两个参数之和的 function。如果只有一个参数，则返回一个 function，该 function 请求一个参数然后返回求和的结果。
例如，add(2, 3) 应该返回 5，而 add(2) 应该返回一个 function。
调用这个有一个参数的返回的 function，返回求和的结果：
var sumTwoAnd = add(2);
sumTwoAnd(3) 返回 5。
如果两个参数都不是有效的数字，则返回 undefined。
如果你被卡住了，记得开大招 Read-Search-Ask。尝试与他人结伴编程、编写你自己的代码。
这是一些对你有帮助的资源:
Closures
Arguments object
function add() {
if (arguments.length === 1){
if (typeof(arguments[0]) !== "number"){
return undefined;
}
else{
var arg0 = arguments[0];
return function(num){
if (typeof(arguments[0]) !== "number"){
return undefined;
}
else {
return num + arg0;
}
};
}
}
else if (arguments.length === 2){
if (typeof(arguments[0]) !== "number" || typeof(arguments[1]) !== "number"){
return undefined;
}
else {
return arguments[0] + arguments[1];
}
}
return undefined;
}
str = add(3)(4);
console.log(str);
js检测数字：https://blog.csdn.net/sinat_26521835/article/details/79527169