1.位计数(Bit Counting)

描绘：编写一个函数，该函数将整数作为参数，并回来在该数字的二进制表明方式中等于 1 的位的个数。您能够保证输入对错负数。

示例：1234(10011010010) -> 5

思路解析：

先将作为输入的整形参数转化为二进制数，由于对错负数，所以不需求考虑补码的问题。将10进制数转化为2进制数能够从低位到高位一点一点得到这个数。示例中的10011010010 = 2^10 + 2^7 + 2^6 + 2^4 + 2^1 = 1024 + 128 + 64 + 16 + 2 = 1234。

10进制转2进制能够参阅以下流程: 18 => 10010
18 % 2 = 0; (18 - 1*0)/2 = 9;  最低位为0
9 % 2 = 1; (9 - 1*1)/2 = 4;  第二位为1
4 % 2 = 0; (4 - 0)/2 = 2; 第三位为0
2 % 2 = 0; 2/2 = 1; 第四位为0
1 % 2 = 1; 0/2 = 0; 最高位为1

这样得到了整形参数的二进制字符串，就能够遍向来取得这个字符串里含有1的个位数的个数了。

代码：

var countBits = function(n) {
  let currentnum = n;
  let bit;
  let counter = 0;
  while(currentnum>0){
    bit = currentnum % 2;
    if(bit === 1)counter++;
    currentnum = (currentnum - bit)/2;
  }
  return counter;
};

需求留意的是，假如运用位运算符>>或许会导致精度丢掉，如运用 currentnum = currentnum >> 1; 代替 currentnum = (currentnum - bit)/2; 这是由于js在对整数进行位运算时会运用32位2进制数，导致高位丢掉。

2.核算重复项(Counting Duplicates)

描绘：编写一个函数，该函数将回来输入字符串中呈现一次以上的字符或数字的个数。不区分大小写，能够假定输入字符串仅包括字母（大写和小写）和数字。

示例：
“abcde” -> 0
“aabbcde” -> 2
“aabBcde” -> 2
“indivisibility” -> 1
“Indivisibilities” -> 2
“aA11” -> 2
“ABBA” -> 2

思路解析：

本题有点像 Isograms 的进阶版，能够用字典来处理。别离记载各种字母和数字的个数，然后遍历字典，假如个数大于1就让计数器加1，然后回来计数器的值就行了。留意统计字母个数之前要把字符串toLowerCase一下变满意小写字母的字符串。

代码：

function duplicateCount(text){
  let dictionary = [];
    let textarray = text.toLowerCase().split('');
    let counter = 0;
    for(let i = 0 ; i<textarray.length;i++){
      if(typeof(dictionary[textarray[i]]) == 'undefined'){
        dictionary[textarray[i]] = 1;
      }else{
        dictionary[textarray[i]] += 1;
      }
      if(dictionary[textarray[i]] === 2)counter++;
    }
  return counter;
}

这儿遍历字符串，将没有的字母或数字写进字典dictionary中，假如之前呈现过就在之前基础上加1，假如这个字母或数字呈现了2次，核算器加1。留意不要重复计数，呈现第三次及以上时计数器不用加了。

3.查找奇偶校验反常值(Find The Parity Outlier)

描绘：给你一个包括整数的数组（长度至少为 3，但或许非常大）。数组有两种状况，一种根本满是奇数但包括一个偶数，一种根本满是偶数但包括一个奇数。回来这个方枘圆凿的反常数字的值。

示例：
[2, 4, 0, 100, 4, 11, 2602, 36] -> 11
[160, 3, 1719, 19, 11, 13, -21] -> 160

思路解析：

本题首先要确定反常值的类型，然后遍历数组就能够找到反常值了。能够先记载数组中奇数和偶数的个数，哪种数的个数为1哪种数便是反常值类型。

代码：

function findOutlier(integers){
  var arr = integers;
  var oddcounter = 0;
  var evencounter = 0;
  for(let i = 0;i<arr.length;i++){
    if(arr[i]%2 === 0){
      evencounter++;
    }else{
      oddcounter++;
    }
  }
  if(evencounter === 1){
    for(let i = 0;i<arr.length;i++){
      if(arr[i]%2 === 0) return arr[i];
    }
  }else{
    for(let i = 0;i<arr.length;i++){
      if(arr[i]%2 !== 0) return arr[i];
    }
  }
}

需求留意的是数组中的数字或许为负数，负奇数模2的余数为-1。所以判别一个数是否为奇数应该判别它模2余数是否不为0。

4.皮特,面包师(Pete, the baker)

描绘：皮特喜欢烤一些蛋糕。他有一些食谱和成分。不幸的是，他的数学欠好。你能帮他找出来，考虑到他的食谱，他能烤多少蛋糕吗？

编写一个函数，该函数的参数为配方（目标）和可用成分（也是一个目标），并回来 Pete 能够烘焙的最大蛋糕数（整数）。为简单起见，没有数量单位（例如，1磅面粉或200克糖只是1或200）。物体中不存在的成分能够被视为 0。

示例：
cakes({flour: 500, sugar: 200, eggs: 1}, {flour: 1200, sugar: 1200, eggs: 5, milk: 200}); // 回来 2
cakes({apples: 3, flour: 300, sugar: 150, milk: 100, oil: 100}, {sugar: 500, flour: 2000, milk: 2000});// 回来 0

思路解析：

这儿考查了json目标的运用，经过for in来遍历json目标。遍历配方的json目标，然后每次在可用成分中找到对应的成分的含量，将$可用成分/配方成分$的商记载到一个数组里面，数组中最小的值便是答案。一起假如在可用成分中没找到配方需求的成分，就回来0。

代码：

function cakes(recipe, available) {
  let arr = [];
  let result = 0;
  for(let recipeitem in recipe){
    if(typeof(available[recipeitem]) !== "undefined"){
      arr.push(available[recipeitem]/recipe[recipeitem])
    }else{
      arr.push(0);
    }
  }
  result = arr[0];
  for(let i = 0;i<arr.length;i++){
    if(arr[i] === 0) return 0;
    if(result > Math.floor(arr[i]))result = Math.floor(arr[i])
  }
  return result;
}

这儿留意typeof(available[recipeitem]) !== "undefined"的undefined要用字符串，这是由于typeof的回来值类型为string。我们能够打印一下这个类型：console.log(typeof(typeof("test"))) //string

5.函数核算(Calculating with Functions)

描绘：界说一些函数，这些函数需求满意以下条件：

• 从 0（“零”）到 9（“九”）的每个数字必须有一个函数
• 以下每个数学运算都必须有一个函数：加、减、乘、除以
• 每个核算只包括一个运算和两个数字
• 最外层函数表明左操作数，最内层函数表明右操作数
• 除法应为整数除法。比如13应该回来0。
  
  示例：
  seven(times(five())); // must return 35
  four(plus(nine())); // must return 13
  eight(minus(three())); // must return 5
  six(dividedBy(two())); // must return 3
  

思路解析：

看描绘或许没看明白，看下编辑框就知道要干啥了。

便是让界说这14个函数，然后满意加减乘除的需求就能够了。
仔细看实例，发现加减乘除的函数的参数只有数字函数一种状况，而数字的参数有两种状况(符号函数或许啥也没有)。

• 符号函数根本就确定了，它需求回来的值便是符号的类型和它参数上的数字，很自然能想到用字符串或许数组保存这些回来值。
  
• 而数字函数的参数假如为数组，那么阐明它是最外层的函数，需求拿到参数进行核算；假如啥也没有，那么就回来对应的值就行了。

代码：

function zero(args) {return number(0,args)}
function one(args) {return number(1,args)}
function two(args) {return number(2,args)}
function three(args) {return number(3,args)}
function four(args) {return number(4,args)}
function five(args) {return number(5,args)}
function six(args) {return number(6,args)}
function seven(args) {return number(7,args)}
function eight(args) {return number(8,args)}
function nine(args) {return number(9,args)}
function plus(arg) {return symbol(0,arg)}
function minus(arg) {return symbol(1,arg)}
function times(arg) {return symbol(2,arg)}
function dividedBy(arg) {return symbol(3,arg)}
function number(n,args){
  if(typeof(args) === "object"){
    switch(args[0]){
      case 0:return n + args[1];
      case 1:return n - args[1];
      case 2:return n*args[1];
      case 3:return Math.floor(n/args[1]);
    }
  }else{
    return n;
  }
}
function symbol(n,arg){
  let arr = [];
  arr.push(n);
  arr.push(arg)
  return arr;
}

这儿能够发现js这种弱类型言语的的一个特色，便是形参假如没有的话也不会报错，由于js会自动给形参一个undefined的值。

function a(arg){
  console.log(typeof(arg))
}
a();//undefined

一起在调查高手的题解的时候发现了一个现象，便是js在运行函数时假如参数中嵌套了函数，那么它会以一种相似递归的方式来运行这些函数。

function a(arg){
  console.log('a');
}
function b(arg){
  console.log('b');
}
function c(arg){
  console.log('c');
}
function d(arg){
  console.log('d');
}
c(b(a())) //a b c
c(b(a()),d()) //a b d c

这是一个比较精简漂亮的题解 Calculating with Functions (JavaScript)