JS案例：质数判断、质因数分解、两个正整数的最大公因数和最小公倍数

JavaScript示例：1、判断一个数是否是质数的函数；2、编写一个可以对任意自然数进行质因数分解的函数；3、编写代码要求可以求两个正整数的最大公因数以及最小公倍数。通过对699、996进行质因数分解以及求两者的最大公约数和最小公倍数验算编程是否正确吧。

699=3x233；996=2x2x3x83

699与996的最大公因数为3，最小公倍数为232068。

数学相关基础词义解释：

1、质数：质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。

2、最大公因数：最大公因数又称为最大公约数，是指两个或多个整数中共有约数中最大的一个，a，b的最大公约数记为（a，b）。

3、最小公倍数：两个或多个整数公有的倍数叫做它们的公倍数，其中除0以外最小的一个公倍数就叫做这几个整数的最小公倍数，整数a,b的最小公倍数记为[a，b]。

4、关于最小公倍数与最大公约数，我们有这样的定理：(a,b)x[a,b]=ab(a,b均为整数)。

一、判断一个正整数是否是质数：

 /* 判断一个大于0的自然整数是否是质数分情况判断：
         思路：
         1、判断的参数x取值范围[1,+∞）；
         2、若一个正整数x除以[2,x-1]区间内的所有整数，没有数令其求模为0，那么意味着该数为质数。需要用循环。
        * （1）1不是质数也不是合数；
        （2）[2,x-1]区间内整数采用for循环 for (var i = 2; i < x; i++){……} 循环考虑的是x>2时的情况，
        需要对x=2时的情况进行单独判断。if(x==2){return false},只不过该判断在后面代码中进行合并而省去；
        *  
        *
        */
        function isPrime(x) {
            if (x == 1) {
                console.log(x + '非质数也非合数');
                console.log('1')
                return false;
            } else {
                for (var i = 2; i < x; i++) {
                    if (x % i == 0) {
                        console.log(x + "不是质数");
                        return false;
                    }
                }
                console.log(x + "质数");
                return true;
            }
        }
                }
                console.log(x + "质数");
                return true;
            }
        }

　　

二、对正整数进行质因数分解

       /* 质因数分解函数 */
        /* 根据短除法的质因数分解可以用循环来模拟短除法。
         * num为每次短除法的商，若商为合数，则需要用所得商进行继续循环；若商为质数，则不必进行下轮迭代。
         */
        function primeFactorization(x) {
            var result = [];
            var num;
            /* 获取该数的最小质因数以及该数与最小质因数的商 */
            function quotient(x) {
                for (var i = 2; i < x; i++) {
                    if (x % i === 0) {
                        result.push(i);
                        num = x / i;
                        console.log(result);
                        break;
                    }
                };
            }

            /* 如果商为质数，则加入result数组；否则继续根据quotient函数继续求商。
             *
             */
            function f(x) {
                if (isPrime(x)) {
                    result.push(x);
                    console.log(result);
                } else {
                    quotient(x);
                    if (isPrime(num) == false) {
                        arguments.callee(num);
                    } else {
                        result.push(num);
                        console.log(result);
                    }
                }
            }
            f(x);

            return result;
        }
        primeFactorization(996);//=> [2, 2, 3, 83]
        primeFactorization(699);//=>[3, 233]

　　

二、996和699最大公因数和最小公倍数

       /* 
         *indexNum为aPrime数组（较多）中元素的索引，该被索引元素为aPrime数组（较少）
         中每个元素与aPrime中的元素进行匹配，来确定两者的质数公约数。   
         *arrResult为求出的两个数的质数公因数数组，
         *indexArr为两个数质因数数组的组合数组
         * 求出两个数组中共同拥有的元素，通过循环较少数组中的每个值在多数组中进行检索
         */

        function maxDivisor(a, b) {
            var arrResult = [];
            var arrIndex = [];
            var aPrime = primeFactorization(a),
                bPrime = primeFactorization(b);
            var indexArr = [aPrime, bPrime];
            indexArr.sort(function (x, y) {
                return x.length - y.length;
            });
            console.log(indexArr);

            var indexNum = 0;

            for (var i = 0; i < indexArr[0].length; i++) {
                if (indexArr[1].indexOf(indexArr[0][i], indexNum) >= 0) {
                    indexNum = indexArr[1].indexOf(indexArr[0][i], indexNum);
                    indexNum++;
                    /*  console.log(indexArr[0][i]); */
                    arrResult.push(indexArr[0][i])
                    /*  console.log(arrResult); */

                }
            }

            /* maxCommonDivisor最大公约数 */
            let maxCommonDivisor = 1;
            if (arrResult.length > 0) {
                for (let i = 0; i < arrResult.length; i++) {
                    maxCommonDivisor *= arrResult[i];
                }
            }

            /* minCommonMultiple最小公倍数 */
            let minCommonMultiple = a * b / maxCommonDivisor;

            console.log([maxCommonDivisor, minCommonMultiple])
        }
        maxDivisor(699, 996); //=>[3, 232068]