题目

福彩1-33，共33个数字的6个数组合，共110万多，通过排除、筛选、自定义，输出剩余组合

可输入的变性筛选：
1. 可自定义一个起始数，然后可输入6个数字来筛选排列组合，囗代表空格，例如输入1.1.1.1.1.1.则表示每数字间隔1个空格，如果定义了1为起始，则6个数字为02.04.06.08.10.12。（囗02囗04囗06囗08囗10囗12）。6个囗分别为01.03.05.07.09.11。若输入1.2.3.4.5.6.则6个数字排列为02.05.09.14.20.27。（囗02囗囗05囗囗囗09囗囗囗囗14囗囗囗囗囗20囗囗囗囗囗囗27）。
2. 和值筛选，可输入和值范围，如80-90，6位数字相加合值为80-90以内的组合
3. 可奇偶筛选，输入3奇3偶或5奇1偶
4. 可输入需排除的多个数，可用逗号隔开，如5，12，…
硬性排除：
1. 三连号，例如1.2.3或25.26.27
2. 全奇全偶排除。
3. 区域筛选排除，排除6个数字在10个连续数字之中得组合，如全在1-10内。
可进行检查，所有硬性、变性筛选后的数据组，输入6个号码可显示是否在数据组里。

实现

/* 获取数组集合 */
function getNumArray(m, n, filterCallback, checkArray) {
    console.time('time')

    let count = 0;
    let numArray = [];
    let isInNumArray = false;

    function getArrayByIndex(index, array) {
        let length = m - n + index;
        for (let i = 1; i <= length; i++) {
            if (index > 1 && isIncludeInArray(array, i)) {
                continue;
            }
            let tempArray = [...array, i];
            if (!isAscArray(tempArray)) {
                continue;
            }
            if (n === index) {
                const currentObj = Object.assign(getArrayObj(tempArray), {
                    array: tempArray,
                    sum: getSum(tempArray),
                    oddNum: getOddEvenNum(tempArray).oddNum,
                    evenNum: getOddEvenNum(tempArray).evenNum,
                    space: getSpaceArray(tempArray),
                });
                if (filterCallback && filterCallback(currentObj)) {
                    continue;
                }
                if (checkArray && (checkArray.join(',') === tempArray.join(','))) {
                    isInNumArray = true;
                }
                numArray.push(currentObj);
                count++;
            } else {
                getArrayByIndex(index + 1, tempArray);
            }
        }
    }

/*判断是否有重复的内容*/
function isIncludeInArray(array, num) {
    let bool = false;
    let length = array.length;
    for (let i = 0; i < length; i++) {
        if (array[i] === num) {
            bool = true;
            break;
        }
    }
    return bool;
}

/* 判断是否升序数组 */
function isAscArray(array) {
    let bool = true;
    let length = array.length - 1;
    for (let i = 0; i < length; i++) {
        if (array[i + 1] < array[i]) {
            bool = false;
            break;
        }
    }
    return bool;
}

/* 获取数组和值 */
function getSum(array) {
    let sum = 0;
    array.forEach(item => {
        sum += item;
    })
    return sum;
}

/* 获取数组奇偶数数量 */
function getOddEvenNum(array) {
    let oddNum = 0, evenNum = 0;
    let length = array.length;
    for (let i = 0; i < length; i++) {
        if (array[i] % 2 === 1) {
            oddNum = oddNum + 1;
        }
        if (array[i] % 2 === 0) {
            evenNum = evenNum + 1;
        }
    }
    return {oddNum, evenNum};
}

/* 获取数组见各个数之间的间隔数组 */
function getSpaceArray(array) {
    let spaceArray = [];
    let length = array.length - 1;
    for (let i = 0; i < length; i++) {
        spaceArray.push(array[i + 1] - array[i] - 1);
    }
    return spaceArray.join(',');
}

/*获取数组对象*/
function getArrayObj(array) {
    let obj = {};
    array.forEach((value, index) => {
        obj[`n${index + 1}`] = value;
    })
    return obj;
}

/*判断是否连号*/
function isSequential(array, count) {
    let bool = false;
    let space = count - 1;
    let length = array.length - space;
    for (let i = 0; i < length; i++) {
        if (array[i + space] - array[i] === space) {
            bool = true;
            break;
        }
    }
    return bool;
}

/*过滤条件一 可自定义一个起始数，然后可输入6个数字来筛选排列组合 */
function filter1(current, p_start, p_spaceArray) {
    const {n1, space} = current;
    if (p_start && p_spaceArray) {
        let newArray = [...p_spaceArray];
        newArray.shift()
        if (!(n1 === p_start + p_spaceArray[0] && space === newArray.join(','))) {
            return true;
        }
    }
    return false;
}

/*过滤条件二 和值筛选*/
function filter2(current, p_rangeSumMin, p_rangeSumMax) {
    const {sum} = current;
    if (p_rangeSumMin && !p_rangeSumMax) {
        if (sum < p_rangeSumMin) {
            return true
        }
    } else if (!p_rangeSumMin && p_rangeSumMax) {
        if (sum > p_rangeSumMax) {
            return true
        }
    } else if (p_rangeSumMin && p_rangeSumMax) {
        if (sum < p_rangeSumMin || sum > p_rangeSumMax) {
            return true
        }
    }
    return false;
}

/*过滤条件三 奇偶筛选*/
function filter3(current, p_evenNum, p_oddNum) {
    const {evenNum, oddNum} = current;
    if (p_evenNum && !p_oddNum) {
        if (evenNum !== p_evenNum) {
            return true
        }
    } else if (!p_evenNum && p_oddNum) {
        if (oddNum !== p_oddNum) {
            return true
        }
    } else if (p_evenNum && p_oddNum) {
        if (oddNum !== p_oddNum) {
            return true
        }
    }
    return false;
}

/*过滤条件四 排除的多个数*/
function filter4(current, p_filterNums) {
    const {array} = current;
    let length = array.length;
    let bool = false;
    if (p_filterNums) {
        for (let i = 0; i < length; i++) {
            if (p_filterNums.includes(array[i])) {
                bool = true;
                break;
            }
        }
    }
    return bool;
}

/*实现函数*/
function check_filter_number(
    {
        p_start,
        p_spaceArray,
        p_rangeSumMin,
        p_rangeSumMax,
        p_evenNum,
        p_oddNum,
        p_filterNums,
        p_checkNums
    }
) {
    if (p_start && p_spaceArray) {
        console.log(`起始数字${p_start},数字间隔：${p_start}`);
    }
    if (p_rangeSumMin && p_rangeSumMax) {
        console.log(`和值范围 ${p_rangeSumMin}-${p_rangeSumMax}`);
    }
    if (p_oddNum && p_evenNum) {
        console.log(`其中奇数：${p_oddNum},偶数：${p_evenNum}`);
    }
    if (p_filterNums) {
        console.log(`排除数字${p_filterNums}`);
    }
    return getNumArray(
        33,
        6,
        function (currentObj) {
            const {array, n1, n6, oddNum, evenNum} = currentObj;
            return isSequential(array, 3) ||
                (evenNum === 6 || oddNum === 6) ||
                ((n6 - n1) <= 9) ||
                filter1(currentObj, p_start, p_spaceArray) ||
                filter2(currentObj, p_rangeSumMin, p_rangeSumMax) ||
                filter3(currentObj, p_evenNum, p_oddNum) ||
                filter4(currentObj, p_filterNums)
        },
        p_checkNums
    );

}

/*执行函数*/
check_filter_number({
    p_start: 1,
    p_spaceArray: null,
    p_rangeSumMin: 80,
    p_rangeSumMax: 90,
    p_evenNum: 3,
    p_oddNum: 3,
    p_filterNums: [4, 7],
    p_checkNums: null,
})

执行结果

福彩33选6，筛选算法

题目

实现