1.将所有数字分开相加，知道变为一个个位数
描述：
digital_root(16)
=> 1 + 6
=> 7
digital_root(942)
=> 9 + 4 + 2
=> 15 ...
=> 1 + 5
=> 6
digital_root(132189)
=> 1 + 3 + 2 + 1 + 8 + 9
=> 24 ...
=> 2 + 4
=> 6
digital_root(493193)
=> 4 + 9 + 3 + 1 + 9 + 3
=> 29 ...
=> 2 + 9
=> 11 ...
=> 1 + 1
=> 2
我的算法：函数编程 + 递归调用
function digital_root(n) {
if (n < 10) {
return n;
}
var result = (n + "")
.split("")
.map(v => v - 0)
.reduce((p, c) => p + c);
return result > 10 ? digital_root(result) : result;
}
// 过程解析
n + "" // 将number类型 隐式的转换为 string类型， 比如 123 + "" --> "12345"
.split("") // 将字符串转变为字符串数组 ["1", "2", "3", "4", "5"]
.map(v => v - 0) // 隐式将字符串数组转变为数值数组 "1" - 0 = 1
// 得到 [1, 2, 3, 4, 5]
.reduce((p, c) => p + c) // 将数组中所有的item加起来， 1+2+3+4+5=15
// result = 15
result>10?digital_root(result):result; // 如果result < 10说明已经是个位数了，返回即可
// 如果result >10，则递归调用digital_root知道result变为个位数为止
其他算法：(比较难想到)
function digital_root(n) {
return (n - 1) % 9 + 1;
}
2.找出字符串中的唯一的奇数或偶数的位置
描述：
iqTest("2 3 4 6"); // 只有一个奇数， 位置为2（索引 + 1）
iqTest("2 7 19 23"); // 只有一个偶数， 位置为1（索引 + 1）
我的算法：
// 注意传入函数中的是一个字符串
function iqTest(numbers) {
numbers = numbers.split(" ").map(v => parseInt(v));
if (numbers.length < 3) {
throw new Error("numbers length must larger than 2");
}
var a1 = numbers[0] % 2;
var a2 = numbers[1] % 2;
var a3;
if (a1 === a2) {
for (let i = 2; i < numbers.length; i++) {
a3 = numbers[i] % 2;
if (a3 !== a1) {
return i + 1;
}
}
} else {
return a3 = numbers[2] === a1 ? 2 : 1;
}
}
// 过程解析
a1 = numbers[0] % 2; // a1为0 或 1 a2同理
if (a1 === a2) // 如果前2个数相同， 则循环后面的数， 和a1比较，如果不同则返回位置
else{} // 表明a1, a2不相同， 只需要看第3个数a3和a1, a2其中哪个数相同，
// 如果a3===a1,则表明a2不同， 返回2；反之则返回1
// 这种算法能够提升性能
别人的算法：
function iqTest(numbers){
var nums = numbers.split(" ").map(x => x % 2); // 将数组中所有的数都变为0， 1
var sum = nums.reduce((a,b) => a + b); // 将数组中的所有数加起来
var target = sum > 1 ? 0 : 1;
//若只有一个奇数，则其余的数都为0，只有一个奇数为1，sum > 1， 找到偶数0；
// 反之则找到唯一的奇数1
return nums.indexOf(target) + 1;
}
3.找到字符串中相同的字符，并用其他字符代替
描述：
有相同的字符用")"代替， 没有就用"("
Examples:
"din" => "((("
"recede" => "()()()"
"Success" => ")())())"
"(( @" => "))(("
我的算法：
function duplicateEncode(word) {
return word
.toLowerCase()
.split("")
.map((v, i, w) => {
w.indexOf(v) === w.lastIndexOf(v) ? "(" : ")"
})
.join("");
}
.split("") // 将字符串变为字符数组
.map(...) // w.indexOf(v) === w.lastIndexOf(v)
// 表明该字符只出现一次，即只有一个， 用“(”替换； 反之，则出现多次，用")"替换
别人的算法：
function duplicateEncode(word) {
word = word.toLowerCase();
return word.replace(/./g, m => word.indexOf(m) == word.lastIndexOf(m) ? '(' : ')');
}
