给出一个区间[a, b]，盘算区间内“奇异数”的个数。
奇异数的定义：存在差别位置的两个数位，构成一个两位数（且不含前导0），且这个两位数为质数。
比方：153，能够运用数字3和数字1构成13，13是质数，满足奇异数。一样153能够找到31和53也为质数，只需找到一个质数即满足奇异数。
输入形貌:
输入为两个整数a和b，代表[a, b]区间 (1 ≤ a ≤ b ≤ 10000)。

输出形貌:
输出为一个整数，示意区间内满足前提的整数个数

输入例子:
11 20

输出例子:
6

在网上看到的一些题，查找奇异数字，以为蛮风趣，跟小时候做题一样，实在比较简单，然则照样把他记录下来吧。没有怎样优化过，也没有对边值和新鲜值举行处置惩罚，后续再说吧

/**
     * 检测是不是为质数
     * @param  {[type]} num [description]
     * @return {[type]}     [description]
     */
     function isPrime(num){
         num=parseInt(num);
        //如果能整除2或许5且相加能被3整除都不必轮回
        if(num%2===0||num%3===0){
            return false;
        }
        if(num%5===0&&num>=10){
            return false;
        }

        for(var i=3;i<num/2;i++){
            if(num%i===0){
                return false;
            }
        }
        return true;
    }
    /**
     * 排列组合的能够
     * @param  {[type]} num [description]
     * @return {[type]}     [description] 
     * 比方 153 能够组合成15 13 和 51 53 以及 31 35
     */
    function lineNum(num){
        var stringNum=String(num);
        var numArr=stringNum.split('');
        var numLen=numArr.length;
        var times=numLen*(numLen-1)
        var allNum=[];
        for(var i=0;i<numLen;i++){
            for(var j=0;j<numLen;j++){
                if(j!=i&&numArr[i]!=0){
                    allNum.push(numArr[i]+numArr[j])
                }
            }
        }
        return allNum;

    }
    /**
     * 查找奇异数
     * @param  {[type]} a [description]
     * @param  {[type]} b [description]
     * @return {[type]}   [description]
     */
     function findMagicNum(a,b){
         var allMagics=[];
         var times=0;
         for(var i=a;i<=b;i++){
             if(isPrime(i)&&allMagics.indexOf(i)<0){
                 allMagics.push(i);
                 times++;
             }
             else if(!isPrime(i)){
                 var numLine=lineNum(i)
                 for(var j=0;j<numLine.length;j++){
                     if(isPrime(numLine[j])&&allMagics.indexOf(i)<0){
                         allMagics.push(i);
                         times++;
                     }
                 }
             }

         }
         return {
             allMagics:allMagics,
             num:times
         }
     }
     var obj=findMagicNum(11, 20);
     console.log(obj)

第二道

牛牛想对一个数做多少次变更，直到这个数只剩下一名数字。
变更的规则是：将这个数变成 一切位数上的数字的乘积。比方285经由一次变更后转化成285=80.
问题是，要做多少次变更，使得这个数变成个位数。
输入形貌:
输入一个整数。小于即是2,000,000,000。

输出形貌:
输出一个整数，示意变更次数。

输入例子:
285

输出例子:
2

     var time=1;
     function changeTime(num){
         if(num<10){
             time=0;
         }else{
             var stringNum=String(num);
             var numArr=stringNum.split('');
             var sum=1;
             for(var i=0;i<numArr.length;i++){
                 sum*=numArr[i];
             }
             if(sum>10){
                 time++;
                 changeTime(sum)
             }
         }

         return time;
     }
     console.log(changeTime(2869))

js完成三数之和
给定一个包括 n 个整数的数组 nums，推断 nums 中是不是存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出一切满足前提且不反复的三元组。

注重：答案中不能够包括反复的三元组。

比方, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
  [-1, 0, 1],
  [-1, -1, 2]
]

var threeSum = function(nums) {
    var i,j,k,len=nums.length;
    var arr=[],obj={};

    for(i=0;i<len;i++){
        for(j=i+1;j<len;j++){
            for(k=i+2;k<len;k++){
                if(nums[i]+nums[j]+nums[k]===0){
                    var arrItem=[];
                    let itemObj={};
                    arrItem.push(nums[i],nums[j],nums[k]);
                    arrItem.sort(function(a,b){return a-b})
                   
                    let str=arrItem.join();
                    if(!obj[str]){
                        obj[str]=true;
                        arr.push(arrItem)
                    }
                }
                    
               
            }
        }
    }
    return arr
    
};