6010 lines
275 KiB
Java
6010 lines
275 KiB
Java
package com.xy.xyaicpzs.service;
|
||
|
||
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
||
import com.xy.xyaicpzs.domain.entity.*;
|
||
import com.xy.xyaicpzs.mapper.*;
|
||
import lombok.extern.slf4j.Slf4j;
|
||
import org.springframework.beans.factory.annotation.Autowired;
|
||
import org.springframework.stereotype.Service;
|
||
|
||
import java.math.BigDecimal;
|
||
import java.math.RoundingMode;
|
||
import java.util.*;
|
||
import java.util.stream.Collectors;
|
||
|
||
import com.xy.xyaicpzs.domain.vo.BallHitRateVO;
|
||
import com.xy.xyaicpzs.domain.vo.PrizeEstimateVO;
|
||
import com.xy.xyaicpzs.domain.vo.RedBallHitRateVO;
|
||
import com.xy.xyaicpzs.domain.vo.BallAnalysisResultVO;
|
||
import com.xy.xyaicpzs.domain.vo.FollowBallAnalysisResultVO;
|
||
import com.xy.xyaicpzs.domain.vo.BlueBallAnalysisResultVO;
|
||
|
||
/**
|
||
* 球号分析服务类
|
||
* 实现复杂的球号分析算法
|
||
*/
|
||
@Slf4j
|
||
@Service
|
||
public class BallAnalysisService {
|
||
|
||
/**
|
||
* 球号和系数的对应关系
|
||
*/
|
||
public static class BallWithCoefficient {
|
||
private Integer ballNumber;
|
||
private Double coefficient;
|
||
private Integer masterBallNumber; // 主球号，用于标识来源
|
||
|
||
public BallWithCoefficient(Integer ballNumber, Double coefficient, Integer masterBallNumber) {
|
||
this.ballNumber = ballNumber;
|
||
this.coefficient = coefficient;
|
||
this.masterBallNumber = masterBallNumber;
|
||
}
|
||
|
||
public Integer getBallNumber() { return ballNumber; }
|
||
public Double getCoefficient() { return coefficient; }
|
||
public Integer getMasterBallNumber() { return masterBallNumber; }
|
||
|
||
@Override
|
||
public String toString() {
|
||
return String.format("球号:%d,系数:%.4f,主球:%d", ballNumber, coefficient, masterBallNumber);
|
||
}
|
||
}
|
||
|
||
@Autowired
|
||
private T3Mapper t3Mapper;
|
||
|
||
@Autowired
|
||
private T4Mapper t4Mapper;
|
||
|
||
@Autowired
|
||
private HistoryTopMapper historyTopMapper;
|
||
|
||
@Autowired
|
||
private HistoryTop100Mapper historyTop100Mapper;
|
||
|
||
@Autowired
|
||
private T7Mapper t7Mapper;
|
||
|
||
@Autowired
|
||
private T5Mapper t5Mapper;
|
||
|
||
@Autowired
|
||
private T6Mapper t6Mapper;
|
||
|
||
@Autowired
|
||
private T8Mapper t8Mapper;
|
||
|
||
@Autowired
|
||
private BlueHistoryTop100Mapper blueHistoryTop100Mapper;
|
||
|
||
@Autowired
|
||
private BlueHistoryTopMapper blueHistoryTopMapper;
|
||
|
||
@Autowired
|
||
private PredictRecordMapper predictRecordMapper;
|
||
|
||
@Autowired
|
||
private LotteryDrawsService lotteryDrawsService;
|
||
|
||
/**
|
||
* 辅助：查询给定主球在T7表中指定从球集合的面系数，返回BallWithCoefficient列表
|
||
*/
|
||
private List<BallWithCoefficient> getT7CoefficientsFor(Integer masterBallNumber, List<Integer> slaveBallNumbers) {
|
||
if (slaveBallNumbers == null || slaveBallNumbers.isEmpty()) {
|
||
return new ArrayList<>();
|
||
}
|
||
QueryWrapper<T7> qw = new QueryWrapper<>();
|
||
qw.eq("masterBallNumber", masterBallNumber)
|
||
.in("slaveBallNumber", slaveBallNumbers);
|
||
List<T7> rows = t7Mapper.selectList(qw);
|
||
// 用球号->系数映射，避免顺序问题
|
||
Map<Integer, Double> num2Coeff = rows.stream()
|
||
.collect(Collectors.toMap(T7::getSlaveBallNumber, T7::getFaceCoefficient, (a,b)->a));
|
||
List<BallWithCoefficient> result = new ArrayList<>();
|
||
for (Integer num : slaveBallNumbers) {
|
||
Double coeff = num2Coeff.get(num);
|
||
if (coeff != null) {
|
||
result.add(new BallWithCoefficient(num, coeff, masterBallNumber));
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 辅助：查询给定主球在T8表中指定从球集合的面系数，返回BallWithCoefficient列表
|
||
*/
|
||
private List<BallWithCoefficient> getT8CoefficientsFor(Integer masterBallNumber, List<Integer> slaveBallNumbers) {
|
||
if (slaveBallNumbers == null || slaveBallNumbers.isEmpty()) {
|
||
return new ArrayList<>();
|
||
}
|
||
QueryWrapper<T8> qw = new QueryWrapper<>();
|
||
qw.eq("masterBallNumber", masterBallNumber)
|
||
.in("slaveBallNumber", slaveBallNumbers);
|
||
List<T8> rows = t8Mapper.selectList(qw);
|
||
Map<Integer, Double> num2Coeff = rows.stream()
|
||
.collect(Collectors.toMap(T8::getSlaveBallNumber, T8::getFaceCoefficient, (a,b)->a));
|
||
List<BallWithCoefficient> result = new ArrayList<>();
|
||
for (Integer num : slaveBallNumbers) {
|
||
Double coeff = num2Coeff.get(num);
|
||
if (coeff != null) {
|
||
result.add(new BallWithCoefficient(num, coeff, masterBallNumber));
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 球号分析算法主方法
|
||
* @param level 高位/中位/低位标识 (H/M/L)
|
||
* @param redBalls 6个红球号码
|
||
* @param blueBall 1个蓝球号码
|
||
* @return 分析结果：出现频率最高的前11位数字
|
||
*/
|
||
public List<Integer> analyzeBalls(String level, List<Integer> redBalls, Integer blueBall) {
|
||
log.info("开始球号分析算法，级别：{}，红球：{}，蓝球：{}", level, redBalls, blueBall);
|
||
|
||
// 验证输入参数
|
||
if (redBalls == null || redBalls.size() != 6) {
|
||
throw new IllegalArgumentException("红球数量必须为6个");
|
||
}
|
||
if (blueBall == null) {
|
||
throw new IllegalArgumentException("蓝球不能为空");
|
||
}
|
||
if (!Arrays.asList("H", "M", "L").contains(level)) {
|
||
throw new IllegalArgumentException("级别必须为H、M或L");
|
||
}
|
||
|
||
List<Integer> allNumbers = new ArrayList<>();
|
||
// 第一步：记录球号和系数的对应关系
|
||
List<BallWithCoefficient> ballsWithCoefficients = new ArrayList<>();
|
||
|
||
// 第一步：处理6个红球，每个红球获取17个数字
|
||
log.info("第一步：处理6个红球，使用{}级别算法", level);
|
||
for (int i = 0; i < redBalls.size(); i++) {
|
||
Integer redBall = redBalls.get(i);
|
||
log.info("处理第{}个红球：{}", i + 1, redBall);
|
||
|
||
List<BallWithCoefficient> ballsWithCoeffs = getTop17FromT3WithCoefficients(redBall, level);
|
||
ballsWithCoefficients.addAll(ballsWithCoeffs);
|
||
|
||
List<Integer> ballNumbers = ballsWithCoeffs.stream()
|
||
.map(BallWithCoefficient::getBallNumber)
|
||
.collect(Collectors.toList());
|
||
allNumbers.addAll(ballNumbers);
|
||
|
||
log.info("红球{}获取到{}个数字：{}", redBall, ballNumbers.size(), ballNumbers);
|
||
}
|
||
|
||
// 记录第一步的球号和系数统计
|
||
log.info("=== 第一步球号和系数统计（共{}个） ===", ballsWithCoefficients.size());
|
||
for (int i = 0; i < ballsWithCoefficients.size(); i++) {
|
||
BallWithCoefficient ballWithCoeff = ballsWithCoefficients.get(i);
|
||
log.info("第{}个：{}", i + 1, ballWithCoeff.toString());
|
||
}
|
||
log.info("=== 第一步统计结束 ===");
|
||
|
||
// 第二步：从history_top获取前3个球号
|
||
log.info("第二步：从history_top获取前3个球号");
|
||
List<Integer> top3Numbers = getTop3FromHistoryTop();
|
||
allNumbers.addAll(top3Numbers);
|
||
log.info("从history_top获取到{}个数字：{}", top3Numbers.size(), top3Numbers);
|
||
|
||
// 第三步：用蓝球从t4表获取17个数字
|
||
log.info("第三步：用蓝球{}从t4表获取17个数字，使用{}级别算法", blueBall, level);
|
||
List<Integer> blueNumbers = getTop17FromT4(blueBall, level);
|
||
allNumbers.addAll(blueNumbers);
|
||
log.info("蓝球{}获取到{}个数字：{}", blueBall, blueNumbers.size(), blueNumbers);
|
||
|
||
log.info("总共收集到{}个数字", allNumbers.size());
|
||
|
||
// 第四步：统计频率并获取前11个
|
||
List<Integer> result = getTop11ByFrequency(allNumbers, ballsWithCoefficients);
|
||
|
||
log.info("球号分析算法完成，结果：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 球号分析算法（包含筛选过程说明）
|
||
* @param level 高位/中位/低位标识 (H/M/L)
|
||
* @param redBalls 6个红球号码
|
||
* @param blueBall 蓝球号码
|
||
* @return 分析结果：出现频率最高的前11位数字及筛选过程说明
|
||
*/
|
||
public BallAnalysisResultVO analyzeBallsWithProcess(String level, List<Integer> redBalls, Integer blueBall) {
|
||
log.info("开始球号分析算法（含过程说明），级别：{}，红球：{}，蓝球：{}", level, redBalls, blueBall);
|
||
|
||
// 验证输入参数
|
||
if (redBalls == null || redBalls.size() != 6) {
|
||
throw new IllegalArgumentException("红球数量必须为6个");
|
||
}
|
||
if (blueBall == null) {
|
||
throw new IllegalArgumentException("蓝球不能为空");
|
||
}
|
||
if (!Arrays.asList("H", "M", "L").contains(level)) {
|
||
throw new IllegalArgumentException("级别必须为H、M或L");
|
||
}
|
||
|
||
List<Integer> allNumbers = new ArrayList<>();
|
||
// 第一步：记录球号和系数的对应关系
|
||
List<BallWithCoefficient> ballsWithCoefficients = new ArrayList<>();
|
||
|
||
// 第一步：处理6个红球，每个红球获取17个数字
|
||
log.info("第一步：处理6个红球，使用{}级别算法", level);
|
||
for (int i = 0; i < redBalls.size(); i++) {
|
||
Integer redBall = redBalls.get(i);
|
||
log.info("处理第{}个红球：{}", i + 1, redBall);
|
||
|
||
List<BallWithCoefficient> ballsWithCoeffs = getTop17FromT3WithCoefficients(redBall, level);
|
||
ballsWithCoefficients.addAll(ballsWithCoeffs);
|
||
|
||
List<Integer> ballNumbers = ballsWithCoeffs.stream()
|
||
.map(BallWithCoefficient::getBallNumber)
|
||
.collect(Collectors.toList());
|
||
allNumbers.addAll(ballNumbers);
|
||
|
||
log.info("红球{}获取到{}个数字：{}", redBall, ballNumbers.size(), ballNumbers);
|
||
}
|
||
|
||
// 记录第一步的球号和系数统计
|
||
log.info("=== 第一步球号和系数统计（共{}个） ===", ballsWithCoefficients.size());
|
||
for (int i = 0; i < ballsWithCoefficients.size(); i++) {
|
||
BallWithCoefficient ballWithCoeff = ballsWithCoefficients.get(i);
|
||
log.info("第{}个：{}", i + 1, ballWithCoeff.toString());
|
||
}
|
||
log.info("=== 第一步统计结束 ===");
|
||
|
||
// 第二步：从history_top获取前3个球号
|
||
log.info("第二步：从history_top获取前3个球号");
|
||
List<Integer> top3Numbers = getTop3FromHistoryTop();
|
||
allNumbers.addAll(top3Numbers);
|
||
log.info("从history_top获取到{}个数字：{}", top3Numbers.size(), top3Numbers);
|
||
|
||
// 第三步：用蓝球从t4表获取17个数字
|
||
log.info("第三步：用蓝球{}从t4表获取17个数字，使用{}级别算法", blueBall, level);
|
||
List<Integer> blueNumbers = getTop17FromT4(blueBall, level);
|
||
allNumbers.addAll(blueNumbers);
|
||
log.info("蓝球{}获取到{}个数字：{}", blueBall, blueNumbers.size(), blueNumbers);
|
||
|
||
log.info("总共收集到{}个数字", allNumbers.size());
|
||
|
||
// 第四步：统计频率并获取前11个（包含过程说明）
|
||
BallAnalysisResultVO result = getTop11ByFrequencyWithProcess(allNumbers, ballsWithCoefficients);
|
||
|
||
log.info("球号分析算法完成，结果：{}", result.getResult());
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 从T3表获取指定主球的17个从球号及其系数
|
||
* 根据不同级别使用不同的选择策略
|
||
* @param masterBallNumber 主球号
|
||
* @param level 级别：H-高位，M-中位，L-低位
|
||
* @return 球号和系数的对应关系列表
|
||
*/
|
||
private List<BallWithCoefficient> getTop17FromT3WithCoefficients(Integer masterBallNumber, String level) {
|
||
log.debug("从T3表查询主球{}的线系数数据（含系数），级别：{}", masterBallNumber, level);
|
||
|
||
// 查询指定主球的所有数据，按线系数降序排列
|
||
QueryWrapper<T3> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", masterBallNumber)
|
||
.orderByDesc("lineCoefficient")
|
||
.orderByAsc("slaveBallNumber"); // 线系数相同时按从球号升序
|
||
|
||
List<T3> t3List = t3Mapper.selectList(queryWrapper);
|
||
|
||
if (t3List.isEmpty()) {
|
||
log.warn("T3表中主球{}没有数据", masterBallNumber);
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
List<BallWithCoefficient> result = new ArrayList<>();
|
||
|
||
switch (level) {
|
||
case "H":
|
||
// 高位：取前17个（按线系数从大到小排列）
|
||
result = getHighLevelBallsWithCoefficients(t3List, masterBallNumber);
|
||
break;
|
||
case "M":
|
||
// 中位：取线系数平均值向上9个球（含），向下8个球，共17个
|
||
result = getMiddleLevelBallsWithCoefficients(t3List, masterBallNumber);
|
||
break;
|
||
case "L":
|
||
// 低位：取最小值向上17个球，含最小值
|
||
result = getLowLevelBallsWithCoefficients(t3List, masterBallNumber);
|
||
break;
|
||
}
|
||
|
||
log.debug("T3表主球{}{}级别最终选择的{}个从球（含系数）：{}", masterBallNumber, level, result.size(), result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 从T3表获取指定主球的17个从球号
|
||
* 根据不同级别使用不同的选择策略
|
||
* @param masterBallNumber 主球号
|
||
* @param level 级别：H-高位，M-中位，L-低位
|
||
*/
|
||
private List<Integer> getTop17FromT3(Integer masterBallNumber, String level) {
|
||
log.debug("从T3表查询主球{}的线系数数据，级别：{}", masterBallNumber, level);
|
||
|
||
// 查询指定主球的所有数据，按线系数降序排列
|
||
QueryWrapper<T3> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", masterBallNumber)
|
||
.orderByDesc("lineCoefficient")
|
||
.orderByAsc("slaveBallNumber"); // 线系数相同时按从球号升序
|
||
|
||
List<T3> t3List = t3Mapper.selectList(queryWrapper);
|
||
|
||
if (t3List.isEmpty()) {
|
||
log.warn("T3表中主球{}没有数据", masterBallNumber);
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
switch (level) {
|
||
case "H":
|
||
// 高位：取前17个（按线系数从大到小排列）
|
||
result = getHighLevelBalls(t3List);
|
||
break;
|
||
case "M":
|
||
// 中位：取线系数平均值向上9个球（含），向下8个球，共17个
|
||
result = getMiddleLevelBalls(t3List);
|
||
break;
|
||
case "L":
|
||
// 低位：取最小值向上17个球，含最小值
|
||
result = getLowLevelBalls(t3List);
|
||
break;
|
||
}
|
||
|
||
log.debug("T3表主球{}{}级别最终选择的{}个从球：{}", masterBallNumber, level, result.size(), result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 从T4表获取指定主球的17个从球号
|
||
* 根据不同级别使用不同的选择策略
|
||
* @param masterBallNumber 主球号
|
||
* @param level 级别：H-高位，M-中位，L-低位
|
||
*/
|
||
private List<Integer> getTop17FromT4(Integer masterBallNumber, String level) {
|
||
log.debug("从T4表查询主球{}的线系数数据，级别：{}", masterBallNumber, level);
|
||
|
||
// 查询指定主球的所有数据，按线系数降序排列
|
||
QueryWrapper<T4> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", masterBallNumber)
|
||
.orderByDesc("lineCoefficient")
|
||
.orderByAsc("slaveBallNumber"); // 线系数相同时按从球号升序
|
||
|
||
List<T4> t4List = t4Mapper.selectList(queryWrapper);
|
||
|
||
if (t4List.isEmpty()) {
|
||
log.warn("T4表中主球{}没有数据", masterBallNumber);
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
switch (level) {
|
||
case "H":
|
||
// 高位：取前17个（按线系数从大到小排列）
|
||
result = getHighLevelBallsFromT4(t4List);
|
||
break;
|
||
case "M":
|
||
// 中位：取线系数平均值向上9个球（含），向下8个球，共17个
|
||
result = getMiddleLevelBallsFromT4(t4List);
|
||
break;
|
||
case "L":
|
||
// 低位：取最小值向上17个球，含最小值
|
||
result = getLowLevelBallsFromT4(t4List);
|
||
break;
|
||
}
|
||
|
||
log.debug("T4表主球{}{}级别最终选择的{}个从球：{}", masterBallNumber, level, result.size(), result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 高位算法：从T3表取前17个（按线系数从大到小排列）
|
||
*/
|
||
private List<Integer> getHighLevelBalls(List<T3> t3List) {
|
||
if (t3List.size() < 17) {
|
||
log.warn("T3表数据不足17条，实际{}条", t3List.size());
|
||
return t3List.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 获取前16个
|
||
List<Integer> result = new ArrayList<>();
|
||
for (int i = 0; i < 16; i++) {
|
||
result.add(t3List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理第17个位置：检查是否有相同的线系数
|
||
Double targetCoefficient = t3List.get(16).getLineCoefficient();
|
||
List<T3> candidatesFor17th = new ArrayList<>();
|
||
|
||
// 找出所有线系数等于第17个位置线系数的记录
|
||
for (int i = 16; i < t3List.size(); i++) {
|
||
if (t3List.get(i).getLineCoefficient().equals(targetCoefficient)) {
|
||
candidatesFor17th.add(t3List.get(i));
|
||
} else {
|
||
break; // 线系数不同，停止查找
|
||
}
|
||
}
|
||
|
||
if (candidatesFor17th.size() == 1) {
|
||
// 只有一个候选，直接添加
|
||
result.add(candidatesFor17th.get(0).getSlaveBallNumber());
|
||
} else {
|
||
// 有多个候选，通过history_top_100表的点系数排序
|
||
log.debug("第17位有{}个相同线系数的候选：{}", candidatesFor17th.size(),
|
||
candidatesFor17th.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallFromHistoryTop100(
|
||
candidatesFor17th.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.add(bestBall);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 高位算法：从T3表取前17个（按线系数从大到小排列），包含系数信息
|
||
*/
|
||
private List<BallWithCoefficient> getHighLevelBallsWithCoefficients(List<T3> t3List, Integer masterBallNumber) {
|
||
if (t3List.size() < 17) {
|
||
log.warn("T3表数据不足17条，实际{}条", t3List.size());
|
||
return t3List.stream()
|
||
.map(t3 -> new BallWithCoefficient(t3.getSlaveBallNumber(), t3.getLineCoefficient(), masterBallNumber))
|
||
.collect(Collectors.toList());
|
||
}
|
||
|
||
// 获取前17个
|
||
List<BallWithCoefficient> result = new ArrayList<>();
|
||
for (int i = 0; i < 17 && i < t3List.size(); i++) {
|
||
T3 t3 = t3List.get(i);
|
||
result.add(new BallWithCoefficient(t3.getSlaveBallNumber(), t3.getLineCoefficient(), masterBallNumber));
|
||
}
|
||
|
||
// 处理第17个位置（系数最小的球号）的毛边情况
|
||
if (result.size() == 17) {
|
||
int lastIndex = 16; // 第17个位置的索引
|
||
Double lastCoefficient = result.get(lastIndex).getCoefficient();
|
||
|
||
// 查找第17个位置向下相同系数值的球号
|
||
List<T3> candidatesFor17th = new ArrayList<>();
|
||
|
||
// 添加第17个位置本身
|
||
candidatesFor17th.add(t3List.get(16));
|
||
|
||
// 向下查找相同系数值的球号
|
||
for (int i = 17; i < t3List.size(); i++) {
|
||
if (t3List.get(i).getLineCoefficient().equals(lastCoefficient)) {
|
||
candidatesFor17th.add(t3List.get(i));
|
||
} else {
|
||
break; // 系数不同就停止查找
|
||
}
|
||
}
|
||
|
||
if (candidatesFor17th.size() > 1) {
|
||
log.debug("第17个位置及其向下有{}个相同线系数的候选：{}", candidatesFor17th.size(),
|
||
candidatesFor17th.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallWithFallback(
|
||
candidatesFor17th.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
|
||
// 找到对应的T3对象并替换第17个位置
|
||
T3 selectedT3 = candidatesFor17th.stream()
|
||
.filter(t3 -> t3.getSlaveBallNumber().equals(bestBall))
|
||
.findFirst()
|
||
.orElse(candidatesFor17th.get(0));
|
||
result.set(lastIndex, new BallWithCoefficient(selectedT3.getSlaveBallNumber(), selectedT3.getLineCoefficient(), masterBallNumber));
|
||
|
||
log.debug("第17个位置毛边处理完成，最终选择：{}", bestBall);
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 中位算法：从T3表取线系数平均值向上8个球，向下8个球，共17个
|
||
*/
|
||
private List<Integer> getMiddleLevelBalls(List<T3> t3List) {
|
||
if (t3List.size() < 17) {
|
||
log.warn("T3表数据不足17条，实际{}条", t3List.size());
|
||
return t3List.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 计算线系数平均值
|
||
double avgCoefficient = t3List.stream()
|
||
.mapToDouble(T3::getLineCoefficient)
|
||
.average()
|
||
.orElse(0.0);
|
||
|
||
log.debug("T3表线系数平均值：{}", avgCoefficient);
|
||
|
||
// 找到大于平均值且最接近的位置（如果有多个相同值，选择最后一个）
|
||
int avgIndex = -1;
|
||
double minDiff = Double.MAX_VALUE;
|
||
for (int i = 0; i < t3List.size(); i++) {
|
||
double coefficient = t3List.get(i).getLineCoefficient();
|
||
// 只考虑大于平均值的值
|
||
if (coefficient > avgCoefficient) {
|
||
double diff = coefficient - avgCoefficient;
|
||
if (diff <= minDiff) { // 使用 <= 来选择最后一个相同值
|
||
minDiff = diff;
|
||
avgIndex = i;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 如果没有找到大于平均值的，则取最大值
|
||
if (avgIndex == -1) {
|
||
avgIndex = 0; // T3表按线系数降序排列，第一个就是最大值
|
||
log.debug("未找到大于平均值的位置，使用最大值位置：{}，线系数：{}", avgIndex, t3List.get(avgIndex).getLineCoefficient());
|
||
} else {
|
||
log.debug("找到大于平均值且最接近的位置：{}，线系数：{}", avgIndex, t3List.get(avgIndex).getLineCoefficient());
|
||
}
|
||
|
||
// 向上8个，向下8个，共17个
|
||
int startIndex = Math.max(0, avgIndex - 8);
|
||
int endIndex = Math.min(t3List.size() - 1, avgIndex + 8);
|
||
|
||
// 确保总共17个数字
|
||
while (endIndex - startIndex + 1 < 17 && (startIndex > 0 || endIndex < t3List.size() - 1)) {
|
||
if (startIndex > 0) {
|
||
startIndex--;
|
||
}
|
||
if (endIndex < t3List.size() - 1 && endIndex - startIndex + 1 < 17) {
|
||
endIndex++;
|
||
}
|
||
}
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
for (int i = startIndex; i <= endIndex && result.size() < 17; i++) {
|
||
result.add(t3List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理边界位置的相同线系数情况
|
||
result = handleT3BoundaryConflicts(t3List, result, startIndex, endIndex);
|
||
|
||
log.debug("中位算法选择范围：[{}, {}]，共{}个球", startIndex, endIndex, result.size());
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 处理T3表边界位置的线系数冲突
|
||
*/
|
||
private List<Integer> handleT3BoundaryConflicts(List<T3> t3List, List<Integer> candidates, int startIndex, int endIndex) {
|
||
List<Integer> result = new ArrayList<>(candidates);
|
||
if (result.size() >= 17) {
|
||
// 检查第1个位置（最大线系数）的冲突
|
||
Double firstCoefficient = t3List.get(startIndex).getLineCoefficient();
|
||
List<T3> candidatesForFirst = new ArrayList<>();
|
||
candidatesForFirst.add(t3List.get(startIndex)); // 边界本身
|
||
for (int i = 0; i < startIndex; i++) {
|
||
if (t3List.get(i).getLineCoefficient().equals(firstCoefficient)) {
|
||
candidatesForFirst.add(t3List.get(i));
|
||
}
|
||
}
|
||
if (candidatesForFirst.size() > 1) {
|
||
log.debug("第一位及其上面有{}个相同线系数的候选：{}", candidatesForFirst.size(),
|
||
candidatesForFirst.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList()));
|
||
Integer bestBall = selectBestBallWithFallback(
|
||
candidatesForFirst.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.set(0, bestBall);
|
||
}
|
||
// 检查最后一个位置（最小线系数）的冲突
|
||
Double lastCoefficient = t3List.get(endIndex).getLineCoefficient();
|
||
List<T3> candidatesForLast = new ArrayList<>();
|
||
candidatesForLast.add(t3List.get(endIndex)); // 边界本身
|
||
for (int i = endIndex + 1; i < t3List.size(); i++) {
|
||
if (t3List.get(i).getLineCoefficient().equals(lastCoefficient)) {
|
||
candidatesForLast.add(t3List.get(i));
|
||
}
|
||
}
|
||
if (candidatesForLast.size() > 1) {
|
||
log.debug("最后一位及其下面有{}个相同线系数的候选：{}", candidatesForLast.size(),
|
||
candidatesForLast.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList()));
|
||
Integer bestBall = selectBestBallWithFallback(
|
||
candidatesForLast.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.set(result.size() - 1, bestBall);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 中位算法：从T3表取线系数平均值向上8个球，向下8个球，共17个，包含系数信息
|
||
*/
|
||
private List<BallWithCoefficient> getMiddleLevelBallsWithCoefficients(List<T3> t3List, Integer masterBallNumber) {
|
||
if (t3List.size() < 17) {
|
||
log.warn("T3表数据不足17条，实际{}条", t3List.size());
|
||
return t3List.stream()
|
||
.map(t3 -> new BallWithCoefficient(t3.getSlaveBallNumber(), t3.getLineCoefficient(), masterBallNumber))
|
||
.collect(Collectors.toList());
|
||
}
|
||
|
||
// 计算线系数平均值
|
||
double avgCoefficient = t3List.stream()
|
||
.mapToDouble(T3::getLineCoefficient)
|
||
.average()
|
||
.orElse(0.0);
|
||
|
||
log.debug("T3表线系数平均值：{}", avgCoefficient);
|
||
|
||
// 找到大于平均值且最接近的位置（如果有多个相同值，选择最后一个）
|
||
int avgIndex = -1;
|
||
double minDiff = Double.MAX_VALUE;
|
||
for (int i = 0; i < t3List.size(); i++) {
|
||
double coefficient = t3List.get(i).getLineCoefficient();
|
||
// 只考虑大于平均值的值
|
||
if (coefficient > avgCoefficient) {
|
||
double diff = coefficient - avgCoefficient;
|
||
if (diff <= minDiff) { // 使用 <= 来选择最后一个相同值
|
||
minDiff = diff;
|
||
avgIndex = i;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 如果没有找到大于平均值的，则取最大值
|
||
if (avgIndex == -1) {
|
||
avgIndex = 0; // T3表按线系数降序排列，第一个就是最大值
|
||
log.debug("未找到大于平均值的位置，使用最大值位置：{}，线系数：{}", avgIndex, t3List.get(avgIndex).getLineCoefficient());
|
||
} else {
|
||
log.debug("找到大于平均值且最接近的位置：{}，线系数：{}", avgIndex, t3List.get(avgIndex).getLineCoefficient());
|
||
}
|
||
|
||
// 向上8个，向下8个，共17个
|
||
int startIndex = Math.max(0, avgIndex - 8);
|
||
int endIndex = Math.min(t3List.size() - 1, avgIndex + 8);
|
||
|
||
// 确保总共17个数字
|
||
while (endIndex - startIndex + 1 < 17 && (startIndex > 0 || endIndex < t3List.size() - 1)) {
|
||
if (startIndex > 0) {
|
||
startIndex--;
|
||
}
|
||
if (endIndex < t3List.size() - 1 && endIndex - startIndex + 1 < 17) {
|
||
endIndex++;
|
||
}
|
||
}
|
||
|
||
List<BallWithCoefficient> result = new ArrayList<>();
|
||
for (int i = startIndex; i <= endIndex && result.size() < 17; i++) {
|
||
T3 t3 = t3List.get(i);
|
||
result.add(new BallWithCoefficient(t3.getSlaveBallNumber(), t3.getLineCoefficient(), masterBallNumber));
|
||
}
|
||
|
||
// 处理边界毛边情况
|
||
if (result.size() >= 8) {
|
||
// 处理向上8个球号的第8个位置（对应区间起点 startIndex，即 result[0]）的毛边情况
|
||
int upBoundaryIndex = 0; // 向上第8个球号在 result 中的索引
|
||
if (upBoundaryIndex < result.size()) {
|
||
Double upBoundaryCoefficient = result.get(upBoundaryIndex).getCoefficient();
|
||
|
||
// 查找向上还有没有相同系数值的球号
|
||
List<T3> upCandidates = new ArrayList<>();
|
||
int actualUpIndex = startIndex + upBoundaryIndex; // 即 startIndex
|
||
|
||
// 添加边界球号本身
|
||
upCandidates.add(t3List.get(actualUpIndex));
|
||
|
||
// 向上查找相同系数值的球号（在 startIndex 之上）
|
||
for (int i = actualUpIndex - 1; i >= 0; i--) {
|
||
if (t3List.get(i).getLineCoefficient().equals(upBoundaryCoefficient)) {
|
||
upCandidates.add(t3List.get(i));
|
||
} else {
|
||
break; // 系数不同就停止查找
|
||
}
|
||
}
|
||
|
||
if (upCandidates.size() > 1) {
|
||
log.debug("向上第8个球号（startIndex）及其上面有{}个相同线系数的候选：{}", upCandidates.size(),
|
||
upCandidates.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallWithFallback(
|
||
upCandidates.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
|
||
// 找到对应的T3对象并替换 result[0]
|
||
T3 selectedT3 = upCandidates.stream()
|
||
.filter(t3 -> t3.getSlaveBallNumber().equals(bestBall))
|
||
.findFirst()
|
||
.orElse(upCandidates.get(0));
|
||
result.set(upBoundaryIndex, new BallWithCoefficient(selectedT3.getSlaveBallNumber(), selectedT3.getLineCoefficient(), masterBallNumber));
|
||
|
||
log.debug("向上第8个球号毛边处理完成，最终选择：{}", bestBall);
|
||
}
|
||
}
|
||
|
||
// 处理向下8个球号的第8个位置（对应区间终点 endIndex，即 result[last]）的毛边情况
|
||
int downBoundaryIndex = Math.min(16, result.size() - 1); // 向下第8个球号在 result 中的索引
|
||
if (downBoundaryIndex >= 8 && downBoundaryIndex < result.size()) {
|
||
Double downBoundaryCoefficient = result.get(downBoundaryIndex).getCoefficient();
|
||
|
||
// 查找向下还有没有相同系数值的球号
|
||
List<T3> downCandidates = new ArrayList<>();
|
||
int actualDownIndex = startIndex + downBoundaryIndex; // 即 endIndex
|
||
|
||
// 添加边界球号本身
|
||
downCandidates.add(t3List.get(actualDownIndex));
|
||
|
||
// 向下查找相同系数值的球号（在 endIndex 之下）
|
||
for (int i = actualDownIndex + 1; i < t3List.size(); i++) {
|
||
if (t3List.get(i).getLineCoefficient().equals(downBoundaryCoefficient)) {
|
||
downCandidates.add(t3List.get(i));
|
||
} else {
|
||
break; // 系数不同就停止查找
|
||
}
|
||
}
|
||
|
||
if (downCandidates.size() > 1) {
|
||
log.debug("向下第8个球号（endIndex）及其下面有{}个相同线系数的候选：{}", downCandidates.size(),
|
||
downCandidates.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallWithFallback(
|
||
downCandidates.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
|
||
// 找到对应的T3对象并替换 result[last]
|
||
T3 selectedT3 = downCandidates.stream()
|
||
.filter(t3 -> t3.getSlaveBallNumber().equals(bestBall))
|
||
.findFirst()
|
||
.orElse(downCandidates.get(0));
|
||
result.set(downBoundaryIndex, new BallWithCoefficient(selectedT3.getSlaveBallNumber(), selectedT3.getLineCoefficient(), masterBallNumber));
|
||
|
||
log.debug("向下第8个球号毛边处理完成，最终选择：{}", bestBall);
|
||
}
|
||
}
|
||
}
|
||
|
||
log.debug("中位算法选择范围：[{}, {}]，共{}个球", startIndex, endIndex, result.size());
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 低位算法：从T3表取最小值向上17个球，含最小值
|
||
*/
|
||
private List<Integer> getLowLevelBalls(List<T3> t3List) {
|
||
if (t3List.size() < 17) {
|
||
log.warn("T3表数据不足17条，实际{}条", t3List.size());
|
||
return t3List.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 从最后17个开始（最小的线系数）
|
||
int startIndex = Math.max(0, t3List.size() - 17);
|
||
List<Integer> candidates = new ArrayList<>();
|
||
|
||
for (int i = startIndex; i < t3List.size(); i++) {
|
||
candidates.add(t3List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理第一个位置（最大线系数）的相同值情况
|
||
if (candidates.size() >= 17) {
|
||
Double firstCoefficient = t3List.get(startIndex).getLineCoefficient();
|
||
List<T3> candidatesForFirst = new ArrayList<>();
|
||
|
||
// 找出所有线系数等于第一个位置线系数的记录
|
||
for (int i = 0; i < t3List.size(); i++) {
|
||
if (t3List.get(i).getLineCoefficient().equals(firstCoefficient)) {
|
||
candidatesForFirst.add(t3List.get(i));
|
||
}
|
||
}
|
||
|
||
if (candidatesForFirst.size() > 1) {
|
||
// 有多个候选，通过带回退的多级筛选
|
||
log.debug("第一位有{}个相同线系数的候选：{}", candidatesForFirst.size(),
|
||
candidatesForFirst.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallWithFallback(
|
||
candidatesForFirst.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
|
||
// 替换第一个位置
|
||
candidates.set(0, bestBall);
|
||
}
|
||
}
|
||
|
||
log.debug("低位算法选择范围：[{}, {}]，共{}个球", startIndex, t3List.size() - 1, candidates.size());
|
||
return candidates.subList(0, Math.min(17, candidates.size()));
|
||
}
|
||
|
||
/**
|
||
* 低位算法：从T3表取最小值向上17个球，含最小值，包含系数信息
|
||
*/
|
||
private List<BallWithCoefficient> getLowLevelBallsWithCoefficients(List<T3> t3List, Integer masterBallNumber) {
|
||
if (t3List.size() < 17) {
|
||
log.warn("T3表数据不足17条，实际{}条", t3List.size());
|
||
return t3List.stream()
|
||
.map(t3 -> new BallWithCoefficient(t3.getSlaveBallNumber(), t3.getLineCoefficient(), masterBallNumber))
|
||
.collect(Collectors.toList());
|
||
}
|
||
|
||
// 从最后17个开始（最小的线系数）
|
||
int startIndex = Math.max(0, t3List.size() - 17);
|
||
List<BallWithCoefficient> candidates = new ArrayList<>();
|
||
|
||
for (int i = startIndex; i < t3List.size(); i++) {
|
||
T3 t3 = t3List.get(i);
|
||
candidates.add(new BallWithCoefficient(t3.getSlaveBallNumber(), t3.getLineCoefficient(), masterBallNumber));
|
||
}
|
||
|
||
// 处理第17个位置（系数最大的球号）的毛边情况
|
||
if (candidates.size() == 17) {
|
||
int lastIndex = 0; // 第17个位置的索引
|
||
Double lastCoefficient = candidates.get(lastIndex).getCoefficient();
|
||
int actualLastIndex = startIndex + lastIndex;
|
||
|
||
// 查找第17个位置向上相同系数值的球号
|
||
List<T3> candidatesFor17th = new ArrayList<>();
|
||
|
||
// 添加第17个位置本身
|
||
candidatesFor17th.add(t3List.get(actualLastIndex));
|
||
|
||
// 向上查找相同系数值的球号
|
||
for (int i = actualLastIndex - 1; i >= 0; i--) {
|
||
if (t3List.get(i).getLineCoefficient().equals(lastCoefficient)) {
|
||
candidatesFor17th.add(t3List.get(i));
|
||
} else {
|
||
break; // 系数不同就停止查找
|
||
}
|
||
}
|
||
|
||
if (candidatesFor17th.size() > 1) {
|
||
log.debug("第17个位置及其向上有{}个相同线系数的候选：{}", candidatesFor17th.size(),
|
||
candidatesFor17th.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallFromHistoryTop100(
|
||
candidatesFor17th.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
|
||
// 找到对应的T3对象并替换第17个位置
|
||
T3 selectedT3 = candidatesFor17th.stream()
|
||
.filter(t3 -> t3.getSlaveBallNumber().equals(bestBall))
|
||
.findFirst()
|
||
.orElse(candidatesFor17th.get(0));
|
||
candidates.set(lastIndex, new BallWithCoefficient(selectedT3.getSlaveBallNumber(), selectedT3.getLineCoefficient(), masterBallNumber));
|
||
|
||
log.debug("第17个位置毛边处理完成，最终选择：{}", bestBall);
|
||
}
|
||
}
|
||
|
||
log.debug("低位算法选择范围：[{}, {}]，共{}个球", startIndex, t3List.size() - 1, candidates.size());
|
||
return candidates.subList(0, Math.min(17, candidates.size()));
|
||
}
|
||
|
||
/**
|
||
* 高位算法：从T4表取前17个（按线系数从大到小排列）
|
||
*/
|
||
private List<Integer> getHighLevelBallsFromT4(List<T4> t4List) {
|
||
if (t4List.size() < 17) {
|
||
log.warn("T4表数据不足17条，实际{}条", t4List.size());
|
||
return t4List.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 获取前16个
|
||
List<Integer> result = new ArrayList<>();
|
||
for (int i = 0; i < 16; i++) {
|
||
result.add(t4List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理第17个位置：检查是否有相同的线系数
|
||
Double targetCoefficient = t4List.get(16).getLineCoefficient();
|
||
List<T4> candidatesFor17th = new ArrayList<>();
|
||
|
||
// 找出所有线系数等于第17个位置线系数的记录
|
||
for (int i = 16; i < t4List.size(); i++) {
|
||
if (t4List.get(i).getLineCoefficient().equals(targetCoefficient)) {
|
||
candidatesFor17th.add(t4List.get(i));
|
||
} else {
|
||
break; // 线系数不同，停止查找
|
||
}
|
||
}
|
||
|
||
if (candidatesFor17th.size() == 1) {
|
||
// 只有一个候选，直接添加
|
||
result.add(candidatesFor17th.get(0).getSlaveBallNumber());
|
||
} else {
|
||
// 有多个候选，通过history_top_100表的点系数排序
|
||
log.debug("第17位有{}个相同线系数的候选：{}", candidatesFor17th.size(),
|
||
candidatesFor17th.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallFromHistoryTop100(
|
||
candidatesFor17th.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.add(bestBall);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 中位算法：从T4表取线系数平均值向上8个球，向下8个球，共17个
|
||
*/
|
||
private List<Integer> getMiddleLevelBallsFromT4(List<T4> t4List) {
|
||
if (t4List.size() < 17) {
|
||
log.warn("T4表数据不足17条，实际{}条", t4List.size());
|
||
return t4List.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 计算线系数平均值
|
||
double avgCoefficient = t4List.stream()
|
||
.mapToDouble(T4::getLineCoefficient)
|
||
.average()
|
||
.orElse(0.0);
|
||
|
||
log.debug("T4表线系数平均值：{}", avgCoefficient);
|
||
|
||
// 找到大于平均值且最接近的位置（如果有多个相同值，选择最后一个）
|
||
int avgIndex = -1;
|
||
double minDiff = Double.MAX_VALUE;
|
||
for (int i = 0; i < t4List.size(); i++) {
|
||
double coefficient = t4List.get(i).getLineCoefficient();
|
||
// 只考虑大于平均值的值
|
||
if (coefficient > avgCoefficient) {
|
||
double diff = coefficient - avgCoefficient;
|
||
if (diff <= minDiff) { // 使用 <= 来选择最后一个相同值
|
||
minDiff = diff;
|
||
avgIndex = i;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 如果没有找到大于平均值的，则取最大值
|
||
if (avgIndex == -1) {
|
||
avgIndex = 0; // T4表按线系数降序排列，第一个就是最大值
|
||
log.debug("未找到大于平均值的位置，使用最大值位置：{}，线系数：{}", avgIndex, t4List.get(avgIndex).getLineCoefficient());
|
||
} else {
|
||
log.debug("找到大于平均值且最接近的位置：{}，线系数：{}", avgIndex, t4List.get(avgIndex).getLineCoefficient());
|
||
}
|
||
|
||
// 向上8个，向下8个，共17个
|
||
int startIndex = Math.max(0, avgIndex - 8);
|
||
int endIndex = Math.min(t4List.size() - 1, avgIndex + 8);
|
||
|
||
// 确保总共17个数字
|
||
while (endIndex - startIndex + 1 < 17 && (startIndex > 0 || endIndex < t4List.size() - 1)) {
|
||
if (startIndex > 0) {
|
||
startIndex--;
|
||
}
|
||
if (endIndex < t4List.size() - 1 && endIndex - startIndex + 1 < 17) {
|
||
endIndex++;
|
||
}
|
||
}
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
for (int i = startIndex; i <= endIndex && result.size() < 17; i++) {
|
||
result.add(t4List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理边界位置的相同线系数情况
|
||
result = handleT4BoundaryConflicts(t4List, result, startIndex, endIndex);
|
||
|
||
log.debug("中位算法选择范围：[{}, {}]，共{}个球", startIndex, endIndex, result.size());
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 处理T4表边界位置的线系数冲突
|
||
*/
|
||
private List<Integer> handleT4BoundaryConflicts(List<T4> t4List, List<Integer> candidates,
|
||
int startIndex, int endIndex) {
|
||
List<Integer> result = new ArrayList<>(candidates);
|
||
|
||
if (result.size() >= 17) {
|
||
// 检查第1个位置（最大线系数）的冲突
|
||
Double firstCoefficient = t4List.get(startIndex).getLineCoefficient();
|
||
List<T4> candidatesForFirst = new ArrayList<>();
|
||
|
||
// 先包含第一个位置本身
|
||
candidatesForFirst.add(t4List.get(startIndex));
|
||
|
||
// 找出第一个位置上面（如果存在）的所有相同线系数的记录
|
||
for (int i = 0; i < startIndex; i++) {
|
||
if (t4List.get(i).getLineCoefficient().equals(firstCoefficient)) {
|
||
candidatesForFirst.add(t4List.get(i));
|
||
}
|
||
}
|
||
|
||
if (candidatesForFirst.size() > 1) {
|
||
// 有多个候选，通过带回退的多级筛选
|
||
log.debug("第一位上面及自身有{}个相同线系数的候选：{}", candidatesForFirst.size(),
|
||
candidatesForFirst.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallWithFallback(
|
||
candidatesForFirst.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
|
||
// 替换第一个位置
|
||
result.set(0, bestBall);
|
||
}
|
||
|
||
// 检查最后一个位置（最小线系数）的冲突
|
||
Double lastCoefficient = t4List.get(endIndex).getLineCoefficient();
|
||
List<T4> candidatesForLast = new ArrayList<>();
|
||
|
||
// 先包含最后一个位置本身
|
||
candidatesForLast.add(t4List.get(endIndex));
|
||
|
||
// 找出最后一个位置下面（如果存在）的所有相同线系数的记录
|
||
for (int i = endIndex + 1; i < t4List.size(); i++) {
|
||
if (t4List.get(i).getLineCoefficient().equals(lastCoefficient)) {
|
||
candidatesForLast.add(t4List.get(i));
|
||
}
|
||
}
|
||
|
||
if (candidatesForLast.size() > 1) {
|
||
// 有多个候选，通过带回退的多级筛选
|
||
log.debug("最后一位下面及自身有{}个相同线系数的候选：{}", candidatesForLast.size(),
|
||
candidatesForLast.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallWithFallback(
|
||
candidatesForLast.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
|
||
// 替换最后一个位置
|
||
result.set(result.size() - 1, bestBall);
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 低位算法：从T4表取最小值向上17个球，含最小值，共17个球号
|
||
*/
|
||
private List<Integer> getLowLevelBallsFromT4(List<T4> t4List) {
|
||
if (t4List.size() < 17) {
|
||
log.warn("T4表数据不足17条，实际{}条", t4List.size());
|
||
return t4List.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 从最后17个开始（最小的线系数）
|
||
int startIndex = Math.max(0, t4List.size() - 17);
|
||
List<Integer> candidates = new ArrayList<>();
|
||
|
||
for (int i = startIndex; i < t4List.size(); i++) {
|
||
candidates.add(t4List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理第17个位置（系数最大的球号）的毛边情况
|
||
if (candidates.size() == 17) {
|
||
int lastIndex = 0; // 第17个位置的索引
|
||
Double lastCoefficient = t4List.get(lastIndex).getLineCoefficient();
|
||
int actualLastIndex = lastIndex;
|
||
|
||
// 查找第17个位置向上相同系数值的球号
|
||
List<T4> candidatesFor17th = new ArrayList<>();
|
||
|
||
// 添加第17个位置本身
|
||
candidatesFor17th.add(t4List.get(actualLastIndex));
|
||
|
||
// 向上查找相同系数值的球号
|
||
for (int i = actualLastIndex - 1; i >= 0; i--) {
|
||
if (t4List.get(i).getLineCoefficient().equals(lastCoefficient)) {
|
||
candidatesFor17th.add(t4List.get(i));
|
||
} else {
|
||
break; // 系数不同就停止查找
|
||
}
|
||
}
|
||
|
||
if (candidatesFor17th.size() > 1) {
|
||
log.debug("第17个位置及其向上有{}个相同线系数的候选：{}", candidatesFor17th.size(),
|
||
candidatesFor17th.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallWithFallback(
|
||
candidatesFor17th.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
|
||
// 替换第17个位置的球号
|
||
candidates.set(lastIndex, bestBall);
|
||
|
||
log.debug("第17个位置毛边处理完成，最终选择：{}", bestBall);
|
||
}
|
||
}
|
||
|
||
log.debug("T4低位算法选择范围：[{}, {}]，共{}个球", startIndex, t4List.size() - 1, candidates.size());
|
||
return candidates.subList(0, Math.min(17, candidates.size()));
|
||
}
|
||
|
||
/**
|
||
* 处理T4表边界位置的线系数冲突（10个球版本）
|
||
*/
|
||
private List<Integer> handleT4BoundaryConflictsFor10(List<T4> t4List, List<Integer> candidates,
|
||
int startIndex, int endIndex) {
|
||
List<Integer> result = new ArrayList<>(candidates);
|
||
|
||
if (result.size() >= 10) {
|
||
// 检查第1个位置（最大线系数）的冲突
|
||
Double firstCoefficient = t4List.get(startIndex).getLineCoefficient();
|
||
List<T4> candidatesForFirst = new ArrayList<>();
|
||
|
||
// 找出第一个位置上面（如果存在）的所有相同线系数的记录
|
||
for (int i = 0; i < startIndex; i++) {
|
||
if (t4List.get(i).getLineCoefficient().equals(firstCoefficient)) {
|
||
candidatesForFirst.add(t4List.get(i));
|
||
}
|
||
}
|
||
|
||
if (candidatesForFirst.size() > 0) {
|
||
log.debug("第1位上面有{}个相同线系数的候选：{}", candidatesForFirst.size(),
|
||
candidatesForFirst.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallWithFallback(
|
||
candidatesForFirst.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.set(0, bestBall);
|
||
}
|
||
|
||
// 检查第10个位置（最小线系数）的冲突
|
||
Double lastCoefficient = t4List.get(endIndex).getLineCoefficient();
|
||
List<T4> candidatesForLast = new ArrayList<>();
|
||
|
||
// 找出第10个位置下面（如果存在）的所有相同线系数的记录
|
||
for (int i = endIndex + 1; i < t4List.size(); i++) {
|
||
if (t4List.get(i).getLineCoefficient().equals(lastCoefficient)) {
|
||
candidatesForLast.add(t4List.get(i));
|
||
}
|
||
}
|
||
|
||
if (candidatesForLast.size() > 0) {
|
||
log.debug("第10位下面有{}个相同线系数的候选：{}", candidatesForLast.size(),
|
||
candidatesForLast.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallWithFallback(
|
||
candidatesForLast.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.set(result.size() - 1, bestBall);
|
||
}
|
||
}
|
||
|
||
return result.subList(0, Math.min(10, result.size()));
|
||
}
|
||
|
||
/**
|
||
* 从history_top表获取前3个球号（按点系数排行）
|
||
* 如果点系数相同，通过history_top_100表比较
|
||
*/
|
||
private List<Integer> getTop3FromHistoryTop() {
|
||
log.debug("从history_top表获取前3个球号");
|
||
|
||
// 查询前3个排行的数据
|
||
QueryWrapper<HistoryTop> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.orderByAsc("no").last("LIMIT 3");
|
||
|
||
List<HistoryTop> topList = historyTopMapper.selectList(queryWrapper);
|
||
|
||
if (topList.size() < 3) {
|
||
log.warn("history_top表数据不足3条，实际{}条", topList.size());
|
||
return topList.stream().map(HistoryTop::getBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
// 处理每个位置，检查是否有相同点系数的情况
|
||
for (int i = 0; i < 3; i++) {
|
||
HistoryTop current = topList.get(i);
|
||
|
||
// 查找所有具有相同排行的记录
|
||
QueryWrapper<HistoryTop> sameRankQuery = new QueryWrapper<>();
|
||
sameRankQuery.eq("no", current.getNo());
|
||
List<HistoryTop> sameRankList = historyTopMapper.selectList(sameRankQuery);
|
||
|
||
if (sameRankList.size() == 1) {
|
||
// 只有一个，直接添加
|
||
result.add(current.getBallNumber());
|
||
} else {
|
||
// 有多个相同排行，通过history_top_100表比较点系数
|
||
log.debug("排行{}有{}个相同的球号：{}", current.getNo(), sameRankList.size(),
|
||
sameRankList.stream().map(HistoryTop::getBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallWithFallback(
|
||
sameRankList.stream().map(HistoryTop::getBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.add(bestBall);
|
||
}
|
||
}
|
||
|
||
log.debug("history_top表最终选择的3个球号：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 从候选球号中选择history_top_100表中点系数最大的球号
|
||
*/
|
||
private Integer selectBestBallFromHistoryTop100(List<Integer> candidates) {
|
||
if (candidates.isEmpty()) {
|
||
throw new IllegalArgumentException("候选球号列表不能为空");
|
||
}
|
||
|
||
if (candidates.size() == 1) {
|
||
return candidates.get(0);
|
||
}
|
||
|
||
log.debug("从history_top_100表中比较候选球号：{}", candidates);
|
||
|
||
// 查询这些球号在history_top_100表中的点系数
|
||
QueryWrapper<HistoryTop100> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.in("ballNumber", candidates)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber"); // 点系数相同时按球号升序
|
||
|
||
List<HistoryTop100> top100List = historyTop100Mapper.selectList(queryWrapper);
|
||
|
||
if (top100List.isEmpty()) {
|
||
log.warn("候选球号{}在history_top_100表中未找到数据，返回第一个", candidates);
|
||
return candidates.get(0);
|
||
}
|
||
|
||
Integer bestBall = top100List.get(0).getBallNumber();
|
||
log.debug("从候选{}中选择最佳球号：{}（点系数：{}）", candidates, bestBall, top100List.get(0).getPointCoefficient());
|
||
|
||
return bestBall;
|
||
}
|
||
|
||
/**
|
||
* 在候选球号中进行多级回退选择：
|
||
* 1) 先用 history_top_100 的点系数最高者；
|
||
* 2) 若全部不在 history_top_100，则用 history_top 的点系数最高者；
|
||
* 3) 若仍无法区分，则随机选择一个。
|
||
*/
|
||
private Integer selectBestBallWithFallback(List<Integer> candidates) {
|
||
if (candidates == null || candidates.isEmpty()) {
|
||
throw new IllegalArgumentException("候选球号列表不能为空");
|
||
}
|
||
|
||
if (candidates.size() == 1) {
|
||
return candidates.get(0);
|
||
}
|
||
|
||
// 优先：history_top_100
|
||
QueryWrapper<HistoryTop100> top100Query = new QueryWrapper<>();
|
||
top100Query.in("ballNumber", candidates)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber");
|
||
List<HistoryTop100> top100List = historyTop100Mapper.selectList(top100Query);
|
||
if (top100List != null && !top100List.isEmpty()) {
|
||
return top100List.get(0).getBallNumber();
|
||
}
|
||
|
||
// 其次：history_top
|
||
QueryWrapper<HistoryTop> topQuery = new QueryWrapper<>();
|
||
topQuery.in("ballNumber", candidates)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber");
|
||
List<HistoryTop> topList = historyTopMapper.selectList(topQuery);
|
||
if (topList != null && !topList.isEmpty()) {
|
||
return topList.get(0).getBallNumber();
|
||
}
|
||
|
||
// 最后：随机
|
||
Collections.shuffle(candidates);
|
||
return candidates.get(0);
|
||
}
|
||
|
||
/**
|
||
* 统计数字出现频率，返回频率最高的前11个数字
|
||
* 如果频次相同的球号超过11个，使用多层筛选：
|
||
* 1. ballNumbersWithCoefficients系数和筛选
|
||
* 2. history_top_100表排名筛选
|
||
* 3. history_top表点系数筛选
|
||
* 4. 随机选择
|
||
*/
|
||
private List<Integer> getTop11ByFrequency(List<Integer> allNumbers, List<BallWithCoefficient> ballsWithCoefficients) {
|
||
log.debug("统计{}个数字的出现频率", allNumbers.size());
|
||
|
||
// 统计频率
|
||
Map<Integer, Integer> frequencyMap = new HashMap<>();
|
||
for (Integer number : allNumbers) {
|
||
frequencyMap.put(number, frequencyMap.getOrDefault(number, 0) + 1);
|
||
}
|
||
|
||
log.debug("数字频率统计：{}", frequencyMap);
|
||
|
||
// 打印所有球号出现频率的详细信息
|
||
log.info("=== 所有球号出现频率统计 ===");
|
||
List<Map.Entry<Integer, Integer>> sortedEntries = frequencyMap.entrySet().stream()
|
||
.sorted(Map.Entry.<Integer, Integer>comparingByValue().reversed()
|
||
.thenComparing(Map.Entry.comparingByKey()))
|
||
.collect(Collectors.toList());
|
||
|
||
for (int i = 0; i < sortedEntries.size(); i++) {
|
||
Map.Entry<Integer, Integer> entry = sortedEntries.get(i);
|
||
log.info("第{}位：数字{}，出现{}次", i + 1, entry.getKey(), entry.getValue());
|
||
}
|
||
log.info("=== 频率统计结束 ===");
|
||
|
||
// 按频率分组
|
||
Map<Integer, List<Integer>> frequencyGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
|
||
Integer frequency = entry.getValue();
|
||
Integer ballNumber = entry.getKey();
|
||
|
||
frequencyGroups.computeIfAbsent(frequency, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.debug("按频率分组：{}", frequencyGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
// 按频率从高到低处理
|
||
for (Map.Entry<Integer, List<Integer>> group : frequencyGroups.entrySet()) {
|
||
Integer frequency = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
// 对同频率的球号按数字升序排序
|
||
Collections.sort(balls);
|
||
|
||
log.info("频率{}的球号：{}", frequency, balls);
|
||
|
||
// 检查加入这组球号后是否会超过11个
|
||
if (result.size() + balls.size() <= 11) {
|
||
// 不会超过11个，直接添加所有球号
|
||
result.addAll(balls);
|
||
log.info("直接添加{}个球号，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过11个，需要从这组球号中选择部分
|
||
int remainingSlots = 11 - result.size();
|
||
log.info("需要从{}个频率相同的球号中选择{}个，开始多层筛选", balls.size(), remainingSlots);
|
||
|
||
List<Integer> selectedBalls = selectBallsByMultiLevelFiltering(balls, remainingSlots, ballsWithCoefficients);
|
||
result.addAll(selectedBalls);
|
||
|
||
log.info("多层筛选完成，最终选择：{}", selectedBalls);
|
||
break; // 已经达到11个，结束
|
||
}
|
||
|
||
// 如果已经有11个，结束
|
||
if (result.size() >= 11) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
log.info("频率统计最终结果（共{}个）：{}", result.size(), result);
|
||
|
||
// 打印详细的频率信息
|
||
for (int i = 0; i < result.size(); i++) {
|
||
Integer ballNumber = result.get(i);
|
||
Integer frequency = frequencyMap.get(ballNumber);
|
||
log.info("第{}位：数字{}，出现{}次", i + 1, ballNumber, frequency);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 统计数字出现频率，返回频率最高的前11个数字（包含筛选过程说明）
|
||
* 如果频次相同的球号超过11个，使用多层筛选：
|
||
* 1. ballNumbersWithCoefficients系数和筛选
|
||
* 2. history_top_100表排名筛选
|
||
* 3. history_top表点系数筛选
|
||
* 4. 随机选择
|
||
*/
|
||
private BallAnalysisResultVO getTop11ByFrequencyWithProcess(List<Integer> allNumbers, List<BallWithCoefficient> ballsWithCoefficients) {
|
||
log.debug("统计{}个数字的出现频率", allNumbers.size());
|
||
StringBuilder processDescription = new StringBuilder();
|
||
|
||
// 统计频率
|
||
Map<Integer, Integer> frequencyMap = new HashMap<>();
|
||
for (Integer number : allNumbers) {
|
||
frequencyMap.put(number, frequencyMap.getOrDefault(number, 0) + 1);
|
||
}
|
||
|
||
log.debug("数字频率统计：{}", frequencyMap);
|
||
|
||
// 按频率分组
|
||
Map<Integer, List<Integer>> frequencyGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
|
||
Integer frequency = entry.getValue();
|
||
Integer ballNumber = entry.getKey();
|
||
|
||
frequencyGroups.computeIfAbsent(frequency, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
boolean needMultiLevelFiltering = false;
|
||
List<Integer> multiLevelCandidates = new ArrayList<>();
|
||
List<Integer> directlySelectedBalls = new ArrayList<>();
|
||
List<Integer> secondaryFilteredBalls = new ArrayList<>();
|
||
|
||
// 统计所有参与筛选的高频球号（用于显示）
|
||
Map<Integer, List<Integer>> allCandidateFrequencyGroups = new LinkedHashMap<>();
|
||
int highestFrequency = frequencyGroups.keySet().iterator().next();
|
||
|
||
// 收集所有可能参与筛选的球号（不只是最高频率，而是前几个高频率组）
|
||
int frequencyThreshold = Math.max(1, highestFrequency - 2); // 显示最高频率、次高频率、第三高频率等
|
||
for (Map.Entry<Integer, List<Integer>> group : frequencyGroups.entrySet()) {
|
||
Integer frequency = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
Collections.sort(balls);
|
||
|
||
// 只收集较高频率的球号用于显示
|
||
if (frequency >= frequencyThreshold) {
|
||
allCandidateFrequencyGroups.put(frequency, new ArrayList<>(balls));
|
||
}
|
||
}
|
||
|
||
// 按频率从高到低处理，进行实际筛选
|
||
for (Map.Entry<Integer, List<Integer>> group : frequencyGroups.entrySet()) {
|
||
List<Integer> balls = group.getValue();
|
||
Collections.sort(balls);
|
||
|
||
// 检查加入这组球号后是否会超过11个
|
||
if (result.size() + balls.size() <= 11) {
|
||
// 不会超过11个，直接添加所有球号
|
||
result.addAll(balls);
|
||
directlySelectedBalls.addAll(balls);
|
||
log.info("直接添加{}个球号，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过11个，需要从这组球号中选择部分
|
||
int remainingSlots = 11 - result.size();
|
||
log.info("需要从{}个频率相同的球号中选择{}个，开始多层筛选", balls.size(), remainingSlots);
|
||
|
||
needMultiLevelFiltering = true;
|
||
multiLevelCandidates = new ArrayList<>(balls);
|
||
|
||
// 使用新的筛选方法，返回详细的筛选步骤信息
|
||
MultiLevelFilteringResult filteringResult = performMultiLevelFilteringWithDetails(balls, remainingSlots, ballsWithCoefficients);
|
||
result.addAll(filteringResult.getSelectedBalls());
|
||
secondaryFilteredBalls = new ArrayList<>(filteringResult.getSelectedBalls());
|
||
|
||
// 记录筛选步骤信息
|
||
processDescription.append("筛选步骤：").append(filteringResult.getStepsDescription());
|
||
if (!filteringResult.getDetailedStepsInfo().isEmpty()) {
|
||
processDescription.append(" ").append(filteringResult.getDetailedStepsInfo());
|
||
}
|
||
|
||
log.info("多层筛选完成，最终选择：{}", filteringResult.getSelectedBalls());
|
||
break; // 已经达到11个，结束
|
||
}
|
||
|
||
// 如果已经有11个，结束
|
||
if (result.size() >= 11) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 构建详细的筛选过程说明
|
||
StringBuilder detailedDescription = new StringBuilder();
|
||
|
||
if (allCandidateFrequencyGroups.isEmpty()) {
|
||
detailedDescription.append("所有球号出现频率相同，");
|
||
} else {
|
||
detailedDescription.append("参与筛选的候选球号按频率分布为")
|
||
.append(formatBallNumbersWithFrequency(allCandidateFrequencyGroups))
|
||
.append("；");
|
||
}
|
||
|
||
if (!needMultiLevelFiltering) {
|
||
detailedDescription.append("直接按频率筛选出前11个球号：")
|
||
.append(formatBallNumbersComplete(result))
|
||
.append("。筛选步骤：通过频率筛选确定所有球号，无需进行T3系数和筛选、百期排位、历史排位。");
|
||
} else {
|
||
detailedDescription.append("无法直接筛选出前11个");
|
||
|
||
if (!directlySelectedBalls.isEmpty()) {
|
||
detailedDescription.append("，其中")
|
||
.append(formatBallNumbers(directlySelectedBalls))
|
||
.append("直接入选");
|
||
}
|
||
|
||
detailedDescription.append("，")
|
||
.append(formatBallNumbers(multiLevelCandidates))
|
||
.append("需要进行二次筛选，最终筛选出")
|
||
.append(formatBallNumbers(secondaryFilteredBalls))
|
||
.append("，组成前11个球号：")
|
||
.append(formatBallNumbersComplete(result))
|
||
.append("。")
|
||
.append(processDescription.toString());
|
||
}
|
||
|
||
log.info("频率统计最终结果（共{}个）：{}", result.size(), result);
|
||
|
||
return BallAnalysisResultVO.builder()
|
||
.result(result)
|
||
.filteringProcess(detailedDescription.toString())
|
||
.build();
|
||
}
|
||
|
||
/**
|
||
* 多层筛选：ballNumbersWithCoefficients系数和筛选 -> history_top_100表排名 -> history_top表点系数 -> 随机选择
|
||
*/
|
||
private List<Integer> selectBallsByMultiLevelFiltering(List<Integer> candidateBalls, int selectCount, List<BallWithCoefficient> ballsWithCoefficients) {
|
||
log.debug("开始多层筛选，候选球号：{}，需要选择：{}个", candidateBalls, selectCount);
|
||
|
||
if (candidateBalls.size() <= selectCount) {
|
||
return new ArrayList<>(candidateBalls);
|
||
}
|
||
|
||
List<Integer> currentCandidates = new ArrayList<>(candidateBalls);
|
||
|
||
// 第一层：ballNumbersWithCoefficients系数和筛选
|
||
log.debug("=== 第一层：ballNumbersWithCoefficients系数和筛选 ===");
|
||
List<Integer> ballNumbersFiltered = selectBallsByBallNumbersWithCoefficients(currentCandidates, selectCount, ballsWithCoefficients);
|
||
log.debug("ballNumbersWithCoefficients系数和筛选结果：{}", ballNumbersFiltered);
|
||
|
||
// 如果ballNumbersWithCoefficients筛选后的结果数量等于selectCount，说明没有相同系数和的情况，直接返回
|
||
if (ballNumbersFiltered.size() == selectCount) {
|
||
log.debug("ballNumbersWithCoefficients系数和筛选完成，选择：{}", ballNumbersFiltered);
|
||
return ballNumbersFiltered;
|
||
}
|
||
|
||
// 如果ballNumbersWithCoefficients筛选后的结果数量超过selectCount，说明有系数和相同的情况，继续下一层筛选
|
||
currentCandidates = ballNumbersFiltered;
|
||
log.debug("ballNumbersWithCoefficients筛选后剩余候选：{}", currentCandidates);
|
||
|
||
// 第二层：history_top_100表排名筛选
|
||
log.debug("=== 第二层：history_top_100表排名筛选 ===");
|
||
List<Integer> historyTop100Filtered = selectBallsByHistoryTop100Ranking(currentCandidates, selectCount);
|
||
log.debug("history_top_100表排名筛选结果：{}", historyTop100Filtered);
|
||
|
||
if (historyTop100Filtered.size() == selectCount) {
|
||
log.debug("history_top_100表排名筛选完成，选择：{}", historyTop100Filtered);
|
||
return historyTop100Filtered;
|
||
}
|
||
currentCandidates = historyTop100Filtered;
|
||
log.debug("history_top_100表筛选后剩余候选：{}", currentCandidates);
|
||
|
||
// 第三层：history_top表点系数筛选
|
||
log.debug("=== 第三层：history_top表点系数筛选 ===");
|
||
List<Integer> historyTopFiltered = selectBallsByHistoryTopPointCoefficient(currentCandidates, selectCount);
|
||
log.debug("history_top表点系数筛选结果：{}", historyTopFiltered);
|
||
|
||
if (historyTopFiltered.size() == selectCount) {
|
||
log.debug("history_top表点系数筛选完成，选择：{}", historyTopFiltered);
|
||
return historyTopFiltered;
|
||
}
|
||
currentCandidates = historyTopFiltered;
|
||
log.debug("history_top表筛选后剩余候选：{}", currentCandidates);
|
||
|
||
// 第四层：随机选择
|
||
log.debug("=== 第四层：随机选择 ===");
|
||
List<Integer> randomSelected = selectBallsRandomly(currentCandidates, selectCount);
|
||
log.debug("随机筛选完成，选择：{}", randomSelected);
|
||
return randomSelected;
|
||
}
|
||
|
||
/**
|
||
* 多层筛选（包含过程说明）：ballNumbersWithCoefficients系数和筛选 -> history_top_100表排名 -> history_top表点系数 -> 随机选择
|
||
*/
|
||
private List<Integer> selectBallsByMultiLevelFilteringWithProcess(List<Integer> candidateBalls, int selectCount,
|
||
List<BallWithCoefficient> ballsWithCoefficients, StringBuilder processDescription) {
|
||
log.debug("开始多层筛选（含过程说明），候选球号：{}，需要选择：{}个", candidateBalls, selectCount);
|
||
|
||
if (candidateBalls.size() <= selectCount) {
|
||
return new ArrayList<>(candidateBalls);
|
||
}
|
||
|
||
List<Integer> currentCandidates = new ArrayList<>(candidateBalls);
|
||
List<String> filteringSteps = new ArrayList<>();
|
||
|
||
// 第一层：ballNumbersWithCoefficients系数和筛选
|
||
log.debug("=== 第一层：ballNumbersWithCoefficients系数和筛选 ===");
|
||
List<Integer> ballNumbersFiltered = selectBallsByBallNumbersWithCoefficients(currentCandidates, selectCount, ballsWithCoefficients);
|
||
log.debug("ballNumbersWithCoefficients系数和筛选结果：{}", ballNumbersFiltered);
|
||
|
||
if (ballNumbersFiltered.size() < currentCandidates.size()) {
|
||
filteringSteps.add("T3系数和筛选");
|
||
}
|
||
|
||
// 如果ballNumbersWithCoefficients筛选后的结果数量等于selectCount，说明没有相同系数和的情况，直接返回
|
||
if (ballNumbersFiltered.size() == selectCount) {
|
||
log.debug("ballNumbersWithCoefficients系数和筛选完成，选择：{}", ballNumbersFiltered);
|
||
return ballNumbersFiltered;
|
||
}
|
||
|
||
// 如果ballNumbersWithCoefficients筛选后的结果数量超过selectCount，说明有系数和相同的情况，继续下一层筛选
|
||
currentCandidates = ballNumbersFiltered;
|
||
log.debug("ballNumbersWithCoefficients筛选后剩余候选：{}", currentCandidates);
|
||
|
||
// 第二层：history_top_100表排名筛选
|
||
log.debug("=== 第二层：history_top_100表排名筛选 ===");
|
||
List<Integer> historyTop100Filtered = selectBallsByHistoryTop100Ranking(currentCandidates, selectCount);
|
||
log.debug("history_top_100表排名筛选结果：{}", historyTop100Filtered);
|
||
|
||
if (historyTop100Filtered.size() < currentCandidates.size()) {
|
||
filteringSteps.add("history_top_100表排名筛选");
|
||
}
|
||
|
||
if (historyTop100Filtered.size() == selectCount) {
|
||
log.debug("history_top_100表排名筛选完成，选择：{}", historyTop100Filtered);
|
||
return historyTop100Filtered;
|
||
}
|
||
currentCandidates = historyTop100Filtered;
|
||
log.debug("history_top_100表筛选后剩余候选：{}", currentCandidates);
|
||
|
||
// 第三层：history_top表点系数筛选
|
||
log.debug("=== 第三层：history_top表点系数筛选 ===");
|
||
List<Integer> historyTopFiltered = selectBallsByHistoryTopPointCoefficient(currentCandidates, selectCount);
|
||
log.debug("history_top表点系数筛选结果：{}", historyTopFiltered);
|
||
|
||
if (historyTopFiltered.size() < currentCandidates.size()) {
|
||
filteringSteps.add("history_top表点系数筛选");
|
||
}
|
||
|
||
if (historyTopFiltered.size() == selectCount) {
|
||
log.debug("history_top表点系数筛选完成，选择：{}", historyTopFiltered);
|
||
return historyTopFiltered;
|
||
}
|
||
currentCandidates = historyTopFiltered;
|
||
log.debug("history_top表筛选后剩余候选：{}", currentCandidates);
|
||
|
||
// 第四层：随机选择
|
||
log.debug("=== 第四层：随机选择 ===");
|
||
List<Integer> randomSelected = selectBallsRandomly(currentCandidates, selectCount);
|
||
log.debug("随机筛选完成，选择：{}", randomSelected);
|
||
|
||
if (currentCandidates.size() > selectCount) {
|
||
filteringSteps.add("随机选择");
|
||
}
|
||
|
||
return randomSelected;
|
||
}
|
||
|
||
/**
|
||
* 筛选详情结果内部类
|
||
*/
|
||
private static class FilteringDetailResult {
|
||
private List<Integer> filteredBalls;
|
||
private String detailInfo;
|
||
|
||
public FilteringDetailResult(List<Integer> filteredBalls, String detailInfo) {
|
||
this.filteredBalls = filteredBalls;
|
||
this.detailInfo = detailInfo;
|
||
}
|
||
|
||
public List<Integer> getFilteredBalls() {
|
||
return filteredBalls;
|
||
}
|
||
|
||
public String getDetailInfo() {
|
||
return detailInfo;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 多层筛选结果内部类
|
||
*/
|
||
private static class MultiLevelFilteringResult {
|
||
private List<Integer> selectedBalls;
|
||
private String stepsDescription;
|
||
private String detailedStepsInfo;
|
||
|
||
public MultiLevelFilteringResult(List<Integer> selectedBalls, String stepsDescription) {
|
||
this.selectedBalls = selectedBalls;
|
||
this.stepsDescription = stepsDescription;
|
||
this.detailedStepsInfo = "";
|
||
}
|
||
|
||
public MultiLevelFilteringResult(List<Integer> selectedBalls, String stepsDescription, String detailedStepsInfo) {
|
||
this.selectedBalls = selectedBalls;
|
||
this.stepsDescription = stepsDescription;
|
||
this.detailedStepsInfo = detailedStepsInfo;
|
||
}
|
||
|
||
public List<Integer> getSelectedBalls() {
|
||
return selectedBalls;
|
||
}
|
||
|
||
public String getStepsDescription() {
|
||
return stepsDescription;
|
||
}
|
||
|
||
public String getDetailedStepsInfo() {
|
||
return detailedStepsInfo;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 跟随球号多级筛选结果内部类
|
||
*/
|
||
private static class FollowBallMultiLevelFilteringResult {
|
||
private List<Integer> selectedBalls;
|
||
private String stepsDescription;
|
||
private String detailedStepsInfo;
|
||
|
||
public FollowBallMultiLevelFilteringResult(List<Integer> selectedBalls, String stepsDescription) {
|
||
this.selectedBalls = selectedBalls;
|
||
this.stepsDescription = stepsDescription;
|
||
this.detailedStepsInfo = "";
|
||
}
|
||
|
||
public FollowBallMultiLevelFilteringResult(List<Integer> selectedBalls, String stepsDescription, String detailedStepsInfo) {
|
||
this.selectedBalls = selectedBalls;
|
||
this.stepsDescription = stepsDescription;
|
||
this.detailedStepsInfo = detailedStepsInfo;
|
||
}
|
||
|
||
public List<Integer> getSelectedBalls() {
|
||
return selectedBalls;
|
||
}
|
||
|
||
public String getStepsDescription() {
|
||
return stepsDescription;
|
||
}
|
||
|
||
public String getDetailedStepsInfo() {
|
||
return detailedStepsInfo;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 跟随球号多级筛选（带详细过程说明）
|
||
* @param candidateBalls 候选球号
|
||
* @param selectCount 需要选择的数量
|
||
* @param step1BallsWithCoefficients 第一步T7面系数数据
|
||
* @return 筛选结果和详细说明
|
||
*/
|
||
private FollowBallMultiLevelFilteringResult performFollowBallMultiLevelFilteringWithDetails(List<Integer> candidateBalls, int selectCount, List<BallWithCoefficient> step1BallsWithCoefficients) {
|
||
List<String> completedSteps = new ArrayList<>();
|
||
List<String> skippedSteps = new ArrayList<>();
|
||
|
||
// 构建 step1 球号->面系数 映射（找不到则为0）
|
||
Map<Integer, Double> num2Coeff = new HashMap<>();
|
||
if (step1BallsWithCoefficients != null) {
|
||
for (BallWithCoefficient bwc : step1BallsWithCoefficients) {
|
||
num2Coeff.put(bwc.getBallNumber(), bwc.getCoefficient());
|
||
}
|
||
}
|
||
|
||
// 先按面系数降序，再按球号升序
|
||
List<Integer> sortedByT7 = new ArrayList<>(candidateBalls);
|
||
sortedByT7.sort((a, b) -> {
|
||
double ca = num2Coeff.getOrDefault(a, 0.0);
|
||
double cb = num2Coeff.getOrDefault(b, 0.0);
|
||
if (Double.compare(cb, ca) != 0) {
|
||
return Double.compare(cb, ca);
|
||
}
|
||
return Integer.compare(a, b);
|
||
});
|
||
|
||
// 记录所有候选球号的T7面系数详情
|
||
StringBuilder t7Details = new StringBuilder();
|
||
Map<Double, List<Integer>> t7Groups = new TreeMap<>(Collections.reverseOrder());
|
||
for (Integer ball : candidateBalls) {
|
||
double coeff = num2Coeff.getOrDefault(ball, 0.0);
|
||
t7Groups.computeIfAbsent(coeff, k -> new ArrayList<>()).add(ball);
|
||
}
|
||
for (Map.Entry<Double, List<Integer>> entry : t7Groups.entrySet()) {
|
||
List<Integer> balls = entry.getValue();
|
||
Collections.sort(balls);
|
||
if (t7Details.length() > 0) t7Details.append("，");
|
||
t7Details.append(formatBallNumbers(balls)).append("（T7面系数").append(String.format("%.2f", entry.getKey())).append("）");
|
||
}
|
||
|
||
// 如果正好能取齐，直接取
|
||
if (sortedByT7.size() <= selectCount) {
|
||
completedSteps.add("通过T7面系数筛选确定");
|
||
skippedSteps.add("百期排位");
|
||
skippedSteps.add("历史排位");
|
||
skippedSteps.add("随机选择");
|
||
|
||
String stepsDesc = buildFollowBallStepsDescription(completedSteps, skippedSteps);
|
||
String detailInfo = "T7面系数筛选：" + formatBallNumbers(candidateBalls) + "参与筛选，" +
|
||
formatBallNumbers(sortedByT7) + "通过T7面系数筛选出来。" +
|
||
"T7面系数详情：" + t7Details.toString() + "。";
|
||
|
||
return new FollowBallMultiLevelFilteringResult(sortedByT7, stepsDesc, detailInfo);
|
||
}
|
||
|
||
// 检查是否存在边界相同面系数
|
||
double thresholdCoeff = num2Coeff.getOrDefault(sortedByT7.get(selectCount - 1), 0.0);
|
||
|
||
// 统计与阈值系数相同的球号数量
|
||
long countAtThreshold = sortedByT7.stream()
|
||
.mapToDouble(bn -> num2Coeff.getOrDefault(bn, 0.0))
|
||
.filter(c -> Double.compare(c, thresholdCoeff) == 0)
|
||
.count();
|
||
|
||
// 如果阈值系数只有1个球号，说明没有边界重复，直接取前selectCount个
|
||
if (countAtThreshold == 1) {
|
||
List<Integer> directSelected = sortedByT7.subList(0, selectCount);
|
||
completedSteps.add("通过T7面系数筛选确定");
|
||
skippedSteps.add("百期排位");
|
||
skippedSteps.add("历史排位");
|
||
skippedSteps.add("随机选择");
|
||
|
||
String stepsDesc = buildFollowBallStepsDescription(completedSteps, skippedSteps);
|
||
String detailInfo = "T7面系数筛选：" + formatBallNumbers(candidateBalls) + "参与筛选，" +
|
||
formatBallNumbers(directSelected) + "通过T7面系数筛选出来。" +
|
||
"T7面系数详情：" + t7Details.toString() + "。";
|
||
|
||
return new FollowBallMultiLevelFilteringResult(directSelected, stepsDesc, detailInfo);
|
||
}
|
||
|
||
// 存在边界相同面系数：拆分高于阈值与阈值相等的集合
|
||
List<Integer> higherThanThreshold = new ArrayList<>();
|
||
List<Integer> equalThresholdGroup = new ArrayList<>();
|
||
for (Integer bn : sortedByT7) {
|
||
double c = num2Coeff.getOrDefault(bn, 0.0);
|
||
if (c > thresholdCoeff) {
|
||
higherThanThreshold.add(bn);
|
||
} else if (Double.compare(c, thresholdCoeff) == 0) {
|
||
equalThresholdGroup.add(bn);
|
||
}
|
||
}
|
||
|
||
List<Integer> result = new ArrayList<>(higherThanThreshold);
|
||
int stillNeed = selectCount - higherThanThreshold.size();
|
||
|
||
if (stillNeed > 0) {
|
||
// 需要进一步筛选
|
||
FollowBallTop100HistoryFilteringResult furtherResult = selectByTop100ThenHistoryTopWithDetails(equalThresholdGroup, stillNeed);
|
||
result.addAll(furtherResult.getSelectedBalls());
|
||
|
||
completedSteps.add("通过T7面系数和百期排位、历史排位筛选确定");
|
||
|
||
StringBuilder allDetails = new StringBuilder();
|
||
allDetails.append("T7面系数筛选：").append(formatBallNumbers(candidateBalls)).append("参与筛选，");
|
||
allDetails.append(formatBallNumbers(higherThanThreshold)).append("通过T7面系数直接筛选出来，");
|
||
allDetails.append(formatBallNumbers(equalThresholdGroup)).append("因T7面系数相同需要进入百期排位、历史排位筛选。");
|
||
allDetails.append("T7面系数详情：").append(t7Details.toString()).append("。");
|
||
if (!furtherResult.getDetailedInfo().isEmpty()) {
|
||
allDetails.append(" ").append(furtherResult.getDetailedInfo());
|
||
}
|
||
|
||
String stepsDesc = buildFollowBallStepsDescription(completedSteps, skippedSteps);
|
||
return new FollowBallMultiLevelFilteringResult(result, stepsDesc, allDetails.toString());
|
||
} else {
|
||
completedSteps.add("通过T7面系数筛选确定");
|
||
skippedSteps.add("百期排位");
|
||
skippedSteps.add("历史排位");
|
||
skippedSteps.add("随机选择");
|
||
|
||
String stepsDesc = buildFollowBallStepsDescription(completedSteps, skippedSteps);
|
||
String detailInfo = "T7面系数筛选：" + formatBallNumbers(candidateBalls) + "参与筛选，" +
|
||
formatBallNumbers(result) + "通过T7面系数筛选出来。" +
|
||
"T7面系数详情：" + t7Details.toString() + "。";
|
||
|
||
return new FollowBallMultiLevelFilteringResult(result, stepsDesc, detailInfo);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 跟随球号百期排位和历史排位筛选结果
|
||
*/
|
||
private static class FollowBallTop100HistoryFilteringResult {
|
||
private List<Integer> selectedBalls;
|
||
private String detailedInfo;
|
||
|
||
public FollowBallTop100HistoryFilteringResult(List<Integer> selectedBalls, String detailedInfo) {
|
||
this.selectedBalls = selectedBalls;
|
||
this.detailedInfo = detailedInfo;
|
||
}
|
||
|
||
public List<Integer> getSelectedBalls() {
|
||
return selectedBalls;
|
||
}
|
||
|
||
public String getDetailedInfo() {
|
||
return detailedInfo;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 蓝球多级筛选结果内部类
|
||
*/
|
||
private static class BlueBallMultiLevelFilteringResult {
|
||
private List<Integer> selectedBalls;
|
||
private String stepsDescription;
|
||
private String detailedStepsInfo;
|
||
|
||
public BlueBallMultiLevelFilteringResult(List<Integer> selectedBalls, String stepsDescription) {
|
||
this.selectedBalls = selectedBalls;
|
||
this.stepsDescription = stepsDescription;
|
||
this.detailedStepsInfo = "";
|
||
}
|
||
|
||
public BlueBallMultiLevelFilteringResult(List<Integer> selectedBalls, String stepsDescription, String detailedStepsInfo) {
|
||
this.selectedBalls = selectedBalls;
|
||
this.stepsDescription = stepsDescription;
|
||
this.detailedStepsInfo = detailedStepsInfo;
|
||
}
|
||
|
||
public List<Integer> getSelectedBalls() {
|
||
return selectedBalls;
|
||
}
|
||
|
||
public String getStepsDescription() {
|
||
return stepsDescription;
|
||
}
|
||
|
||
public String getDetailedStepsInfo() {
|
||
return detailedStepsInfo;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 通过百期排位和历史排位进行筛选（带详细信息）
|
||
*/
|
||
private FollowBallTop100HistoryFilteringResult selectByTop100ThenHistoryTopWithDetails(List<Integer> candidateBalls, int needCount) {
|
||
if (candidateBalls == null || candidateBalls.isEmpty() || needCount <= 0) {
|
||
return new FollowBallTop100HistoryFilteringResult(new ArrayList<>(), "");
|
||
}
|
||
|
||
StringBuilder detailedInfo = new StringBuilder();
|
||
|
||
// 在同T7系数的候选中，先用100期逐组加入
|
||
QueryWrapper<HistoryTop100> query = new QueryWrapper<>();
|
||
query.in("ballNumber", candidateBalls)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber");
|
||
List<HistoryTop100> top100List = historyTop100Mapper.selectList(query);
|
||
|
||
List<Integer> selectedByTop100 = new ArrayList<>();
|
||
List<Integer> undecidedGroup = new ArrayList<>();
|
||
StringBuilder top100Details = new StringBuilder();
|
||
|
||
if (top100List != null && !top100List.isEmpty()) {
|
||
// 记录所有球号的百期排位详情
|
||
Map<Double, List<Integer>> top100Groups = new TreeMap<>(Collections.reverseOrder());
|
||
for (HistoryTop100 item : top100List) {
|
||
top100Groups.computeIfAbsent(item.getPointCoefficient(), k -> new ArrayList<>()).add(item.getBallNumber());
|
||
}
|
||
for (Map.Entry<Double, List<Integer>> entry : top100Groups.entrySet()) {
|
||
List<Integer> balls = entry.getValue();
|
||
Collections.sort(balls);
|
||
if (top100Details.length() > 0) top100Details.append("，");
|
||
top100Details.append(formatBallNumbers(balls)).append("（百期排位").append(String.format("%.2f", entry.getKey())).append("）");
|
||
}
|
||
|
||
// 记录不在百期表中的球号
|
||
List<Integer> notInTop100 = new ArrayList<>(candidateBalls);
|
||
List<Integer> inTop100 = top100List.stream().map(HistoryTop100::getBallNumber).collect(Collectors.toList());
|
||
notInTop100.removeAll(inTop100);
|
||
if (!notInTop100.isEmpty()) {
|
||
Collections.sort(notInTop100);
|
||
if (top100Details.length() > 0) top100Details.append("，");
|
||
top100Details.append(formatBallNumbers(notInTop100)).append("（无百期排位）");
|
||
}
|
||
|
||
// 分组筛选
|
||
Map<Double, List<Integer>> groups = new LinkedHashMap<>();
|
||
for (HistoryTop100 item : top100List) {
|
||
groups.computeIfAbsent(item.getPointCoefficient(), k -> new ArrayList<>())
|
||
.add(item.getBallNumber());
|
||
}
|
||
for (Map.Entry<Double, List<Integer>> entry : groups.entrySet()) {
|
||
List<Integer> groupBalls = entry.getValue();
|
||
if (selectedByTop100.size() + groupBalls.size() <= needCount) {
|
||
selectedByTop100.addAll(groupBalls);
|
||
} else {
|
||
undecidedGroup.addAll(groupBalls);
|
||
break;
|
||
}
|
||
if (selectedByTop100.size() == needCount) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (selectedByTop100.size() >= needCount) {
|
||
detailedInfo.append("百期排位筛选：").append(formatBallNumbers(candidateBalls)).append("参与筛选，");
|
||
detailedInfo.append(formatBallNumbers(selectedByTop100.subList(0, needCount))).append("通过百期排位筛选出来。");
|
||
detailedInfo.append("百期排位详情：").append(top100Details.toString()).append("。");
|
||
return new FollowBallTop100HistoryFilteringResult(selectedByTop100.subList(0, needCount), detailedInfo.toString());
|
||
}
|
||
|
||
// 还需要历史排位筛选
|
||
int stillNeed = needCount - selectedByTop100.size();
|
||
List<Integer> forHistoryTop = !undecidedGroup.isEmpty() ? new ArrayList<>(undecidedGroup) :
|
||
(top100List == null || top100List.isEmpty() ? new ArrayList<>(candidateBalls) : new ArrayList<>());
|
||
|
||
List<Integer> selectedByHistoryTop = new ArrayList<>();
|
||
StringBuilder historyDetails = new StringBuilder();
|
||
|
||
if (!forHistoryTop.isEmpty()) {
|
||
QueryWrapper<HistoryTop> historyQuery = new QueryWrapper<>();
|
||
historyQuery.in("ballNumber", forHistoryTop)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber");
|
||
List<HistoryTop> historyTopList = historyTopMapper.selectList(historyQuery);
|
||
|
||
if (historyTopList != null && !historyTopList.isEmpty()) {
|
||
// 记录所有球号的历史排位详情
|
||
Map<Double, List<Integer>> historyGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (HistoryTop item : historyTopList) {
|
||
historyGroups.computeIfAbsent(item.getPointCoefficient(), k -> new ArrayList<>()).add(item.getBallNumber());
|
||
}
|
||
for (Map.Entry<Double, List<Integer>> entry : historyGroups.entrySet()) {
|
||
List<Integer> balls = entry.getValue();
|
||
Collections.sort(balls);
|
||
if (historyDetails.length() > 0) historyDetails.append("，");
|
||
historyDetails.append(formatBallNumbers(balls)).append("（历史点系数").append(String.format("%.2f", entry.getKey())).append("）");
|
||
}
|
||
|
||
// 记录不在历史表中的球号
|
||
List<Integer> notInHistory = new ArrayList<>(forHistoryTop);
|
||
List<Integer> inHistory = historyTopList.stream().map(HistoryTop::getBallNumber).collect(Collectors.toList());
|
||
notInHistory.removeAll(inHistory);
|
||
if (!notInHistory.isEmpty()) {
|
||
Collections.sort(notInHistory);
|
||
if (historyDetails.length() > 0) historyDetails.append("，");
|
||
historyDetails.append(formatBallNumbers(notInHistory)).append("（无历史数据）");
|
||
}
|
||
|
||
// 按点系数筛选
|
||
selectedByHistoryTop.addAll(historyTopList.stream()
|
||
.limit(stillNeed)
|
||
.map(HistoryTop::getBallNumber)
|
||
.collect(Collectors.toList()));
|
||
}
|
||
}
|
||
|
||
List<Integer> finalResult = new ArrayList<>(selectedByTop100);
|
||
finalResult.addAll(selectedByHistoryTop);
|
||
|
||
// 构建详细信息
|
||
detailedInfo.append("百期排位筛选：").append(formatBallNumbers(candidateBalls)).append("参与筛选，");
|
||
if (!selectedByTop100.isEmpty()) {
|
||
detailedInfo.append(formatBallNumbers(selectedByTop100)).append("通过百期排位筛选出来，");
|
||
}
|
||
if (!forHistoryTop.isEmpty()) {
|
||
detailedInfo.append(formatBallNumbers(forHistoryTop)).append("因百期排位不足或相同需要进入历史排位筛选。");
|
||
}
|
||
if (top100Details.length() > 0) {
|
||
detailedInfo.append("百期排位详情：").append(top100Details.toString()).append("。");
|
||
}
|
||
|
||
if (!forHistoryTop.isEmpty() && !selectedByHistoryTop.isEmpty()) {
|
||
detailedInfo.append(" 历史排位筛选：").append(formatBallNumbers(forHistoryTop)).append("参与筛选，");
|
||
detailedInfo.append(formatBallNumbers(selectedByHistoryTop)).append("通过历史排位筛选出来。");
|
||
}
|
||
if (historyDetails.length() > 0) {
|
||
detailedInfo.append(" 历史排位详情：").append(historyDetails.toString()).append("。");
|
||
}
|
||
|
||
return new FollowBallTop100HistoryFilteringResult(finalResult, detailedInfo.toString());
|
||
}
|
||
|
||
/**
|
||
* 构建跟随球号筛选步骤描述
|
||
*/
|
||
private String buildFollowBallStepsDescription(List<String> completedSteps, List<String> skippedSteps) {
|
||
StringBuilder sb = new StringBuilder();
|
||
if (!completedSteps.isEmpty()) {
|
||
if (completedSteps.size() == 1) {
|
||
sb.append("通过频率筛选确定部分球号，通过").append(completedSteps.get(0)).append("确定剩余球号");
|
||
} else {
|
||
sb.append("通过频率筛选确定部分球号，经过");
|
||
for (int i = 0; i < completedSteps.size(); i++) {
|
||
if (i > 0) sb.append("、");
|
||
sb.append(completedSteps.get(i));
|
||
}
|
||
sb.append("最终确定剩余球号");
|
||
}
|
||
}
|
||
if (!skippedSteps.isEmpty()) {
|
||
if (sb.length() > 0) sb.append("，");
|
||
sb.append("无需进行").append(String.join("、", skippedSteps));
|
||
}
|
||
return sb.append("。").toString();
|
||
}
|
||
|
||
/**
|
||
* 蓝球多级筛选（带详细过程说明）
|
||
* @param candidateBalls 候选蓝球号码
|
||
* @param selectCount 需要选择的数量
|
||
* @param step2BlueT8Coefficients 第二步T8面系数数据
|
||
* @return 筛选结果和详细说明
|
||
*/
|
||
private BlueBallMultiLevelFilteringResult performBlueBallMultiLevelFilteringWithDetails(List<Integer> candidateBalls, int selectCount, List<BallWithCoefficient> step2BlueT8Coefficients) {
|
||
List<String> completedSteps = new ArrayList<>();
|
||
List<String> skippedSteps = new ArrayList<>();
|
||
|
||
// 统计同频候选在step2BlueT8Coefficients中的面系数和（找不到视为0）
|
||
Map<Integer, Double> sumMap = new HashMap<>();
|
||
StringBuilder t8Details = new StringBuilder();
|
||
Map<Double, List<Integer>> t8Groups = new TreeMap<>(Collections.reverseOrder());
|
||
|
||
for (Integer ball : candidateBalls) {
|
||
double sum = 0.0;
|
||
if (step2BlueT8Coefficients != null) {
|
||
for (BallWithCoefficient bwc : step2BlueT8Coefficients) {
|
||
if (ball.equals(bwc.getBallNumber())) {
|
||
sum += bwc.getCoefficient();
|
||
}
|
||
}
|
||
}
|
||
sumMap.put(ball, sum);
|
||
t8Groups.computeIfAbsent(sum, k -> new ArrayList<>()).add(ball);
|
||
}
|
||
|
||
// 记录所有候选球号的T8面系数和详情
|
||
for (Map.Entry<Double, List<Integer>> entry : t8Groups.entrySet()) {
|
||
List<Integer> balls = entry.getValue();
|
||
Collections.sort(balls);
|
||
if (t8Details.length() > 0) t8Details.append("，");
|
||
t8Details.append(formatBallNumbers(balls)).append("（T8面系数和").append(String.format("%.2f", entry.getKey())).append("）");
|
||
}
|
||
|
||
// 按"系数和降序、球号升序"排序，取前selectCount个
|
||
List<Integer> sortedCandidates = new ArrayList<>(candidateBalls);
|
||
sortedCandidates.sort((a, b) -> {
|
||
int cmp = Double.compare(sumMap.getOrDefault(b, 0.0), sumMap.getOrDefault(a, 0.0));
|
||
if (cmp != 0) return cmp;
|
||
return Integer.compare(a, b);
|
||
});
|
||
|
||
List<Integer> result = sortedCandidates.subList(0, Math.min(selectCount, sortedCandidates.size()));
|
||
|
||
completedSteps.add("通过T8面系数和筛选确定");
|
||
skippedSteps.add("百期排位");
|
||
skippedSteps.add("历史排位");
|
||
|
||
String stepsDesc = buildBlueBallStepsDescription(completedSteps, skippedSteps);
|
||
String detailInfo = "T8面系数和筛选：" + formatBallNumbers(candidateBalls) + "参与筛选，" +
|
||
formatBallNumbers(result) + "通过T8面系数和筛选出来。" +
|
||
"T8面系数和详情：" + t8Details.toString() + "。";
|
||
|
||
return new BlueBallMultiLevelFilteringResult(result, stepsDesc, detailInfo);
|
||
}
|
||
|
||
/**
|
||
* 构建蓝球筛选步骤描述
|
||
*/
|
||
private String buildBlueBallStepsDescription(List<String> completedSteps, List<String> skippedSteps) {
|
||
StringBuilder sb = new StringBuilder();
|
||
if (!completedSteps.isEmpty()) {
|
||
if (completedSteps.size() == 1) {
|
||
sb.append("通过频率筛选确定部分球号，通过").append(completedSteps.get(0)).append("确定剩余球号");
|
||
} else {
|
||
sb.append("通过频率筛选确定部分球号，经过");
|
||
for (int i = 0; i < completedSteps.size(); i++) {
|
||
if (i > 0) sb.append("、");
|
||
sb.append(completedSteps.get(i));
|
||
}
|
||
sb.append("最终确定剩余球号");
|
||
}
|
||
}
|
||
if (!skippedSteps.isEmpty()) {
|
||
if (sb.length() > 0) sb.append("，");
|
||
sb.append("无需进行").append(String.join("、", skippedSteps));
|
||
}
|
||
return sb.append("。").toString();
|
||
}
|
||
|
||
/**
|
||
* 格式化球号列表为字符串
|
||
*/
|
||
private String formatBallNumbers(List<Integer> ballNumbers) {
|
||
if (ballNumbers == null || ballNumbers.isEmpty()) {
|
||
return "";
|
||
}
|
||
|
||
List<Integer> sortedBalls = new ArrayList<>(ballNumbers);
|
||
Collections.sort(sortedBalls);
|
||
|
||
if (sortedBalls.size() <= 10) {
|
||
return sortedBalls.toString().replace("[", "").replace("]", "");
|
||
} else {
|
||
// 如果球号太多，只显示前几个和后几个
|
||
List<Integer> displayBalls = new ArrayList<>();
|
||
displayBalls.addAll(sortedBalls.subList(0, 5));
|
||
displayBalls.addAll(sortedBalls.subList(sortedBalls.size() - 3, sortedBalls.size()));
|
||
return displayBalls.subList(0, 5).toString().replace("[", "").replace("]", "") +
|
||
"等" + sortedBalls.size() + "个";
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 格式化球号列表为字符串（完整显示，不使用"等"字简化）
|
||
*/
|
||
private String formatBallNumbersComplete(List<Integer> ballNumbers) {
|
||
if (ballNumbers == null || ballNumbers.isEmpty()) {
|
||
return "";
|
||
}
|
||
|
||
List<Integer> sortedBalls = new ArrayList<>(ballNumbers);
|
||
Collections.sort(sortedBalls);
|
||
|
||
return sortedBalls.toString().replace("[", "").replace("]", "");
|
||
}
|
||
|
||
/**
|
||
* 格式化带频率的球号列表为字符串
|
||
* @param frequencyGroups 按频率分组的球号，key为频率，value为球号列表
|
||
*/
|
||
private String formatBallNumbersWithFrequency(Map<Integer, List<Integer>> frequencyGroups) {
|
||
if (frequencyGroups == null || frequencyGroups.isEmpty()) {
|
||
return "";
|
||
}
|
||
|
||
StringBuilder result = new StringBuilder();
|
||
List<String> parts = new ArrayList<>();
|
||
|
||
// 按频率从高到低排序
|
||
List<Map.Entry<Integer, List<Integer>>> sortedEntries = frequencyGroups.entrySet().stream()
|
||
.sorted(Map.Entry.<Integer, List<Integer>>comparingByKey().reversed())
|
||
.collect(Collectors.toList());
|
||
|
||
for (Map.Entry<Integer, List<Integer>> entry : sortedEntries) {
|
||
Integer frequency = entry.getKey();
|
||
List<Integer> balls = entry.getValue();
|
||
|
||
// 对球号排序
|
||
Collections.sort(balls);
|
||
|
||
// 始终显示所有球号，不使用省略
|
||
String ballsStr = balls.toString().replace("[", "").replace("]", "");
|
||
parts.add(ballsStr + "（出现" + frequency + "次）");
|
||
}
|
||
|
||
// 组合所有部分，显示完整的频率分布信息
|
||
for (int i = 0; i < parts.size(); i++) {
|
||
if (i > 0) {
|
||
result.append("，");
|
||
}
|
||
result.append(parts.get(i));
|
||
}
|
||
|
||
return result.toString();
|
||
}
|
||
|
||
/**
|
||
* 执行多层筛选并返回详细的步骤信息
|
||
* @param candidateBalls 候选球号列表
|
||
* @param selectCount 需要选择的数量
|
||
* @param ballsWithCoefficients 系数数据
|
||
* @return 筛选结果和步骤描述
|
||
*/
|
||
private MultiLevelFilteringResult performMultiLevelFilteringWithDetails(List<Integer> candidateBalls,
|
||
int selectCount, List<BallWithCoefficient> ballsWithCoefficients) {
|
||
log.debug("开始详细多层筛选，候选球号：{}，需要选择：{}个", candidateBalls, selectCount);
|
||
|
||
if (candidateBalls.size() <= selectCount) {
|
||
return new MultiLevelFilteringResult(new ArrayList<>(candidateBalls), "直接选择，无需进一步筛选。");
|
||
}
|
||
|
||
List<Integer> currentCandidates = new ArrayList<>(candidateBalls);
|
||
List<String> completedSteps = new ArrayList<>();
|
||
List<String> skippedSteps = new ArrayList<>();
|
||
StringBuilder detailedInfo = new StringBuilder();
|
||
|
||
// 第一层：ballNumbersWithCoefficients系数和筛选
|
||
log.debug("=== 第一层：T3系数和筛选 ===");
|
||
FilteringDetailResult t3Result = selectBallsByBallNumbersWithCoefficientsWithDetails(currentCandidates, selectCount, ballsWithCoefficients);
|
||
List<Integer> ballNumbersFiltered = t3Result.getFilteredBalls();
|
||
log.debug("T3系数和筛选结果：{}", ballNumbersFiltered);
|
||
|
||
if (ballNumbersFiltered.size() < currentCandidates.size()) {
|
||
completedSteps.add("T3系数和筛选");
|
||
if (!t3Result.getDetailInfo().isEmpty()) {
|
||
detailedInfo.append("T3系数和详情：").append(t3Result.getDetailInfo()).append("。");
|
||
}
|
||
}
|
||
|
||
if (ballNumbersFiltered.size() == selectCount) {
|
||
log.debug("T3系数和筛选完成，选择：{}", ballNumbersFiltered);
|
||
skippedSteps.add("百期排位");
|
||
skippedSteps.add("历史排位");
|
||
return new MultiLevelFilteringResult(ballNumbersFiltered, buildStepsDescription(completedSteps, skippedSteps), detailedInfo.toString());
|
||
}
|
||
|
||
currentCandidates = ballNumbersFiltered;
|
||
|
||
// 第二层：history_top_100表排名筛选（百期排位）
|
||
log.debug("=== 第二层：百期排位筛选 ===");
|
||
FilteringDetailResult top100Result = selectBallsByHistoryTop100RankingWithDetails(currentCandidates, selectCount);
|
||
List<Integer> historyTop100Filtered = top100Result.getFilteredBalls();
|
||
log.debug("百期排位筛选结果：{}", historyTop100Filtered);
|
||
|
||
if (historyTop100Filtered.size() < currentCandidates.size()) {
|
||
completedSteps.add("百期排位");
|
||
if (!top100Result.getDetailInfo().isEmpty()) {
|
||
if (detailedInfo.length() > 0) detailedInfo.append(" ");
|
||
detailedInfo.append("百期排位详情：").append(top100Result.getDetailInfo()).append("。");
|
||
}
|
||
}
|
||
|
||
if (historyTop100Filtered.size() == selectCount) {
|
||
log.debug("百期排位筛选完成，选择：{}", historyTop100Filtered);
|
||
skippedSteps.add("历史排位");
|
||
return new MultiLevelFilteringResult(historyTop100Filtered, buildStepsDescription(completedSteps, skippedSteps), detailedInfo.toString());
|
||
}
|
||
currentCandidates = historyTop100Filtered;
|
||
|
||
// 第三层：history_top表点系数筛选（历史排位）
|
||
log.debug("=== 第三层：历史排位筛选 ===");
|
||
FilteringDetailResult historyTopResult = selectBallsByHistoryTopPointCoefficientWithDetails(currentCandidates, selectCount);
|
||
List<Integer> historyTopFiltered = historyTopResult.getFilteredBalls();
|
||
log.debug("历史排位筛选结果：{}", historyTopFiltered);
|
||
|
||
if (historyTopFiltered.size() < currentCandidates.size()) {
|
||
completedSteps.add("历史排位");
|
||
if (!historyTopResult.getDetailInfo().isEmpty()) {
|
||
if (detailedInfo.length() > 0) detailedInfo.append(" ");
|
||
detailedInfo.append("历史排位详情：").append(historyTopResult.getDetailInfo()).append("。");
|
||
}
|
||
}
|
||
|
||
if (historyTopFiltered.size() == selectCount) {
|
||
log.debug("历史排位筛选完成，选择：{}", historyTopFiltered);
|
||
return new MultiLevelFilteringResult(historyTopFiltered, buildStepsDescription(completedSteps, skippedSteps), detailedInfo.toString());
|
||
}
|
||
currentCandidates = historyTopFiltered;
|
||
|
||
// 第四层：随机选择
|
||
log.debug("=== 第四层：随机选择 ===");
|
||
List<Integer> randomSelected = selectBallsRandomly(currentCandidates, selectCount);
|
||
log.debug("随机筛选完成，选择：{}", randomSelected);
|
||
|
||
if (currentCandidates.size() > selectCount) {
|
||
completedSteps.add("随机选择");
|
||
}
|
||
|
||
return new MultiLevelFilteringResult(randomSelected, buildStepsDescription(completedSteps, skippedSteps), detailedInfo.toString());
|
||
}
|
||
|
||
/**
|
||
* 构建筛选步骤描述
|
||
* @param completedSteps 已完成的步骤
|
||
* @param skippedSteps 跳过的步骤
|
||
* @return 步骤描述字符串
|
||
*/
|
||
private String buildStepsDescription(List<String> completedSteps, List<String> skippedSteps) {
|
||
StringBuilder description = new StringBuilder();
|
||
|
||
if (!completedSteps.isEmpty()) {
|
||
if (completedSteps.size() == 1) {
|
||
description.append("通过频率筛选确定部分球号，通过").append(completedSteps.get(0)).append("确定剩余球号");
|
||
} else {
|
||
description.append("通过频率筛选确定部分球号，经过");
|
||
for (int i = 0; i < completedSteps.size(); i++) {
|
||
if (i > 0) description.append("、");
|
||
description.append(completedSteps.get(i));
|
||
}
|
||
description.append("最终确定剩余球号");
|
||
}
|
||
}
|
||
|
||
if (!skippedSteps.isEmpty()) {
|
||
if (description.length() > 0) {
|
||
description.append("，无需进行");
|
||
} else {
|
||
description.append("无需进行");
|
||
}
|
||
for (int i = 0; i < skippedSteps.size(); i++) {
|
||
if (i > 0) description.append("、");
|
||
description.append(skippedSteps.get(i));
|
||
}
|
||
}
|
||
|
||
description.append("。");
|
||
return description.toString();
|
||
}
|
||
|
||
/**
|
||
* 根据ballNumbersWithCoefficients系数和进行筛选
|
||
* 当系数和相同时，返回所有相同系数和的球号，让下一层筛选来处理
|
||
*/
|
||
private List<Integer> selectBallsByBallNumbersWithCoefficients(List<Integer> candidateBalls, int selectCount, List<BallWithCoefficient> ballsWithCoefficients) {
|
||
log.debug("使用ballNumbersWithCoefficients系数和筛选{}个候选球号，需要选择{}个", candidateBalls.size(), selectCount);
|
||
|
||
if (candidateBalls.size() <= selectCount) {
|
||
return new ArrayList<>(candidateBalls);
|
||
}
|
||
|
||
// 计算每个球号的系数和
|
||
Map<Integer, Double> ballCoefficientSum = new HashMap<>();
|
||
for (Integer ballNumber : candidateBalls) {
|
||
double coefficientSum = calculateBallNumbersWithCoefficientsSum(ballNumber, ballsWithCoefficients);
|
||
ballCoefficientSum.put(ballNumber, coefficientSum);
|
||
log.debug("球号{}的ballNumbersWithCoefficients系数和：{}", ballNumber, coefficientSum);
|
||
}
|
||
|
||
// 按系数和分组（从高到低排序）
|
||
Map<Double, List<Integer>> coefficientGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (Integer ballNumber : candidateBalls) {
|
||
double coefficientSum = ballCoefficientSum.get(ballNumber);
|
||
coefficientGroups.computeIfAbsent(coefficientSum, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.debug("ballNumbersWithCoefficients系数分组：{}", coefficientGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
// 按系数和从高到低处理
|
||
for (Map.Entry<Double, List<Integer>> group : coefficientGroups.entrySet()) {
|
||
Double coefficientSum = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
log.debug("系数和{}的球号：{}", coefficientSum, balls);
|
||
|
||
// 检查加入这组球号后是否会超过selectCount个
|
||
if (result.size() + balls.size() <= selectCount) {
|
||
// 不会超过，直接添加所有球号（按球号升序排序）
|
||
Collections.sort(balls);
|
||
result.addAll(balls);
|
||
log.debug("直接添加{}个球号，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过，返回所有相同系数和的球号，让下一层筛选来处理
|
||
result.addAll(balls);
|
||
log.debug("系数和相同，返回所有相同系数和的球号：{}，让下一层筛选处理", balls);
|
||
break;
|
||
}
|
||
|
||
// 如果已经有selectCount个，结束
|
||
if (result.size() >= selectCount) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
log.debug("ballNumbersWithCoefficients筛选结果：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 计算指定球号在ballNumbersWithCoefficients中的系数和
|
||
* 从ballsWithCoefficients列表中找到所有匹配的球号，计算系数和
|
||
*/
|
||
private double calculateBallNumbersWithCoefficientsSum(Integer ballNumber, List<BallWithCoefficient> ballsWithCoefficients) {
|
||
try {
|
||
// 从ballsWithCoefficients中找到所有匹配的球号，计算系数和
|
||
double sum = ballsWithCoefficients.stream()
|
||
.filter(ball -> ball.getBallNumber().equals(ballNumber))
|
||
.mapToDouble(BallWithCoefficient::getCoefficient)
|
||
.sum();
|
||
|
||
log.debug("球号{}在ballsWithCoefficients中的系数和：{}", ballNumber, sum);
|
||
return sum;
|
||
} catch (Exception e) {
|
||
log.error("计算ballNumbersWithCoefficients系数和时出错，球号：{}", ballNumber, e);
|
||
return 0.0;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 根据ballNumbersWithCoefficients系数和进行筛选（包含详细信息）
|
||
* @param candidateBalls 候选球号列表
|
||
* @param selectCount 需要选择的数量
|
||
* @param ballsWithCoefficients 系数数据
|
||
* @return 筛选结果和详细信息
|
||
*/
|
||
private FilteringDetailResult selectBallsByBallNumbersWithCoefficientsWithDetails(List<Integer> candidateBalls,
|
||
int selectCount, List<BallWithCoefficient> ballsWithCoefficients) {
|
||
log.debug("使用ballNumbersWithCoefficients系数和筛选{}个候选球号，需要选择{}个", candidateBalls.size(), selectCount);
|
||
|
||
if (candidateBalls.size() <= selectCount) {
|
||
return new FilteringDetailResult(new ArrayList<>(candidateBalls), "");
|
||
}
|
||
|
||
// 计算每个球号的系数和
|
||
Map<Integer, Double> ballCoefficientSum = new HashMap<>();
|
||
for (Integer ballNumber : candidateBalls) {
|
||
double coefficientSum = calculateBallNumbersWithCoefficientsSum(ballNumber, ballsWithCoefficients);
|
||
ballCoefficientSum.put(ballNumber, coefficientSum);
|
||
log.debug("球号{}的ballNumbersWithCoefficients系数和：{}", ballNumber, coefficientSum);
|
||
}
|
||
|
||
// 按系数和分组（从高到低排序）
|
||
Map<Double, List<Integer>> coefficientGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (Integer ballNumber : candidateBalls) {
|
||
double coefficientSum = ballCoefficientSum.get(ballNumber);
|
||
coefficientGroups.computeIfAbsent(coefficientSum, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.debug("ballNumbersWithCoefficients系数分组：{}", coefficientGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
StringBuilder detailInfo = new StringBuilder();
|
||
|
||
// 先记录所有球号的系数和详细信息
|
||
for (Map.Entry<Double, List<Integer>> group : coefficientGroups.entrySet()) {
|
||
Double coefficientSum = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
Collections.sort(balls); // 按球号升序排序
|
||
|
||
// 记录详细信息（显示所有参与筛选的球号）
|
||
if (detailInfo.length() > 0) detailInfo.append("，");
|
||
detailInfo.append(formatBallNumbers(balls)).append("（系数和").append(String.format("%.2f", coefficientSum)).append("）");
|
||
}
|
||
|
||
// 再按系数和从高到低筛选球号
|
||
for (Map.Entry<Double, List<Integer>> group : coefficientGroups.entrySet()) {
|
||
Double coefficientSum = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
log.debug("系数和{}的球号：{}", coefficientSum, balls);
|
||
|
||
// 检查加入这组球号后是否会超过selectCount个
|
||
if (result.size() + balls.size() <= selectCount) {
|
||
// 不会超过，直接添加所有球号（按球号升序排序）
|
||
Collections.sort(balls);
|
||
result.addAll(balls);
|
||
log.debug("直接添加{}个球号，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过，返回所有相同系数和的球号，让下一层筛选来处理
|
||
result.addAll(balls);
|
||
log.debug("系数和相同，返回所有相同系数的球号：{}，让下一层筛选处理", balls);
|
||
break;
|
||
}
|
||
|
||
// 如果已经有selectCount个，结束
|
||
if (result.size() >= selectCount) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
log.debug("ballNumbersWithCoefficients筛选结果：{}", result);
|
||
return new FilteringDetailResult(result, detailInfo.toString());
|
||
}
|
||
|
||
/**
|
||
* 根据T3表线系数之和进行筛选
|
||
* 当线系数之和相同时，返回所有相同线系数之和的球号，让下一层筛选来处理
|
||
*/
|
||
private List<Integer> selectBallsByT3LineCoefficientSum(List<Integer> candidateBalls, int selectCount) {
|
||
log.debug("使用T3表线系数之和筛选{}个候选球号，需要选择{}个", candidateBalls.size(), selectCount);
|
||
|
||
if (candidateBalls.size() <= selectCount) {
|
||
return new ArrayList<>(candidateBalls);
|
||
}
|
||
|
||
// 计算每个球号作为主球号时的线系数之和
|
||
Map<Integer, Double> ballCoefficientSum = new HashMap<>();
|
||
for (Integer ballNumber : candidateBalls) {
|
||
double coefficientSum = calculateT3LineCoefficientSum(ballNumber);
|
||
ballCoefficientSum.put(ballNumber, coefficientSum);
|
||
log.debug("球号{}的T3线系数之和：{}", ballNumber, coefficientSum);
|
||
}
|
||
|
||
// 按线系数之和降序排序
|
||
List<Integer> sortedBalls = candidateBalls.stream()
|
||
.sorted((a, b) -> Double.compare(ballCoefficientSum.get(b), ballCoefficientSum.get(a)))
|
||
.collect(Collectors.toList());
|
||
|
||
log.debug("按T3线系数之和排序后的球号：{}", sortedBalls);
|
||
|
||
// 按线系数之和分组
|
||
Map<Double, List<Integer>> coefficientGroups = new LinkedHashMap<>();
|
||
for (Integer ballNumber : sortedBalls) {
|
||
double coefficientSum = ballCoefficientSum.get(ballNumber);
|
||
coefficientGroups.computeIfAbsent(coefficientSum, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.debug("T3表线系数分组：{}", coefficientGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
// 按线系数之和从高到低处理
|
||
for (Map.Entry<Double, List<Integer>> group : coefficientGroups.entrySet()) {
|
||
Double coefficientSum = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
log.debug("线系数之和{}的球号：{}", coefficientSum, balls);
|
||
|
||
// 检查加入这组球号后是否会超过selectCount个
|
||
if (result.size() + balls.size() <= selectCount) {
|
||
// 不会超过，直接添加所有球号（按球号升序排序）
|
||
Collections.sort(balls);
|
||
result.addAll(balls);
|
||
log.debug("直接添加{}个球号，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过，返回所有相同线系数之和的球号，让下一层筛选来处理
|
||
result.addAll(balls);
|
||
log.debug("线系数之和相同，返回所有相同线系数的球号：{}，让下一层筛选处理", balls);
|
||
break;
|
||
}
|
||
|
||
// 如果已经有selectCount个，结束
|
||
if (result.size() >= selectCount) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
log.debug("T3表线系数筛选结果：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 计算指定球号作为主球号时的T3表线系数之和
|
||
*/
|
||
private double calculateT3LineCoefficientSum(Integer masterBallNumber) {
|
||
try {
|
||
// 查询T3表中该主球号的所有记录
|
||
QueryWrapper<T3> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", masterBallNumber)
|
||
.orderByDesc("lineCoefficient");
|
||
|
||
List<T3> t3List = t3Mapper.selectList(queryWrapper);
|
||
|
||
if (t3List.isEmpty()) {
|
||
log.debug("T3表中主球{}没有数据，线系数之和为0", masterBallNumber);
|
||
return 0.0;
|
||
}
|
||
|
||
// 计算线系数之和
|
||
double sum = t3List.stream()
|
||
.mapToDouble(T3::getLineCoefficient)
|
||
.sum();
|
||
|
||
log.debug("T3表主球{}的线系数之和：{}", masterBallNumber, sum);
|
||
return sum;
|
||
|
||
} catch (Exception e) {
|
||
log.error("计算T3表线系数之和时出错，主球号：{}", masterBallNumber, e);
|
||
return 0.0;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 跟随球号分析算法
|
||
* @param level 高位/中位/低位标识 (H/M/L)
|
||
* @param firstThreeRedBalls 前3个红球号码（独立的）
|
||
* @param lastSixRedBalls 后6个红球号码（独立的）
|
||
* @param blueBall 1个蓝球号码
|
||
* @return 分析结果：出现频率最高的前10位数字
|
||
*/
|
||
public List<Integer> fallowBallAnalysis(String level, List<Integer> firstThreeRedBalls,
|
||
List<Integer> lastSixRedBalls, Integer blueBall) {
|
||
log.info("开始跟随球号分析算法，级别：{}，前3个红球：{}，后6个红球：{}，蓝球：{}",
|
||
level, firstThreeRedBalls, lastSixRedBalls, blueBall);
|
||
|
||
// 验证输入参数
|
||
if (firstThreeRedBalls == null || firstThreeRedBalls.size() != 3) {
|
||
throw new IllegalArgumentException("前3个红球数量必须为3个");
|
||
}
|
||
if (lastSixRedBalls == null || lastSixRedBalls.size() != 6) {
|
||
throw new IllegalArgumentException("后6个红球数量必须为6个");
|
||
}
|
||
if (blueBall == null) {
|
||
throw new IllegalArgumentException("蓝球不能为空");
|
||
}
|
||
if (!Arrays.asList("H", "M", "L").contains(level)) {
|
||
throw new IllegalArgumentException("级别必须为H、M或L");
|
||
}
|
||
|
||
// 验证球号范围和重复性
|
||
validateBallNumbers(firstThreeRedBalls, lastSixRedBalls, blueBall);
|
||
|
||
List<Integer> allNumbers = new ArrayList<>();
|
||
|
||
// 第一步：处理第1个红球，从T7表获取10个数字（同时记录系数）
|
||
log.info("第一步：处理第1个红球{}，从T7表获取10个数字，使用{}级别算法", firstThreeRedBalls.get(0), level);
|
||
List<Integer> firstRedBallNumbers = getTop10FromT7(firstThreeRedBalls.get(0), level);
|
||
allNumbers.addAll(firstRedBallNumbers);
|
||
log.info("第1个红球{}获取到{}个数字：{}", firstThreeRedBalls.get(0), firstRedBallNumbers.size(), firstRedBallNumbers);
|
||
|
||
// 同步记录上述10个数字在T7表中的面系数，记录格式与analyzeBalls一致
|
||
List<BallWithCoefficient> step1BallsWithCoefficients = getT7CoefficientsFor(firstThreeRedBalls.get(0), firstRedBallNumbers);
|
||
log.info("=== 第一步（T7）球号和系数统计（共{}个） ===", step1BallsWithCoefficients.size());
|
||
for (int i = 0; i < step1BallsWithCoefficients.size(); i++) {
|
||
BallWithCoefficient ballWithCoeff = step1BallsWithCoefficients.get(i);
|
||
log.info("第{}个：{}", i + 1, ballWithCoeff.toString());
|
||
}
|
||
log.info("=== 第一步统计结束 ===");
|
||
|
||
// 第二步：处理后6个红球，每个红球从T3表获取26个数字
|
||
log.info("第二步：处理后6个红球，每个红球从T3表获取26个数字");
|
||
for (int i = 0; i < lastSixRedBalls.size(); i++) {
|
||
Integer redBall = lastSixRedBalls.get(i);
|
||
log.info("处理第{}个红球：{}", i + 1, redBall);
|
||
|
||
List<Integer> ballNumbers = getTop26FromT3(redBall);
|
||
allNumbers.addAll(ballNumbers);
|
||
|
||
log.info("红球{}获取到{}个数字：{}", redBall, ballNumbers.size(), ballNumbers);
|
||
}
|
||
|
||
// 第三步：从history_top_100获取前3个球号
|
||
log.info("第三步：从history_top_100获取前3个球号");
|
||
List<Integer> top3Numbers = getTop3FromHistoryTop100();
|
||
allNumbers.addAll(top3Numbers);
|
||
log.info("从history_top_100获取到{}个数字：{}", top3Numbers.size(), top3Numbers);
|
||
|
||
// 第四步：取出前3个红球号码的后两个
|
||
log.info("第四步：取出前3个红球号码的后两个");
|
||
List<Integer> lastTwoOfFirstThree = Arrays.asList(firstThreeRedBalls.get(1), firstThreeRedBalls.get(2));
|
||
allNumbers.addAll(lastTwoOfFirstThree);
|
||
log.info("前3个红球的后两个：{}", lastTwoOfFirstThree);
|
||
|
||
// 第五步：用上期蓝球从T4表获取26个蓝球号码
|
||
log.info("第五步：用上期蓝球{}从T4表获取26个蓝球号码", blueBall);
|
||
List<Integer> blueNumbers = getTop26FromT4(blueBall);
|
||
allNumbers.addAll(blueNumbers);
|
||
log.info("蓝球{}获取到{}个数字：{}", blueBall, blueNumbers.size(), blueNumbers);
|
||
|
||
log.info("总共收集到{}个数字", allNumbers.size());
|
||
|
||
// 第六步：统计频率并获取前10个（若同频超过10个，用第一步T7面系数作为二次筛选依据）
|
||
List<Integer> result = getTop10ByFrequency(allNumbers, step1BallsWithCoefficients);
|
||
|
||
log.info("跟随球号分析算法完成，结果：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 跟随球号分析算法（带筛选过程说明）
|
||
* @param level 级别：H-高，M-中，L-低
|
||
* @param firstThreeRedBalls 前3个红球
|
||
* @param lastSixRedBalls 后6个红球
|
||
* @param blueBall 蓝球
|
||
* @return 分析结果VO，包含前10个数字和筛选过程说明
|
||
*/
|
||
public FollowBallAnalysisResultVO fallowBallAnalysisWithProcess(String level, List<Integer> firstThreeRedBalls,
|
||
List<Integer> lastSixRedBalls, Integer blueBall) {
|
||
log.info("开始跟随球号分析算法（带过程说明），级别：{}，前3个红球：{}，后6个红球：{}，蓝球：{}",
|
||
level, firstThreeRedBalls, lastSixRedBalls, blueBall);
|
||
|
||
// 验证输入参数
|
||
if (firstThreeRedBalls == null || firstThreeRedBalls.size() != 3) {
|
||
throw new IllegalArgumentException("前3个红球数量必须为3个");
|
||
}
|
||
if (lastSixRedBalls == null || lastSixRedBalls.size() != 6) {
|
||
throw new IllegalArgumentException("后6个红球数量必须为6个");
|
||
}
|
||
if (blueBall == null) {
|
||
throw new IllegalArgumentException("蓝球不能为空");
|
||
}
|
||
if (!Arrays.asList("H", "M", "L").contains(level)) {
|
||
throw new IllegalArgumentException("级别必须为H、M或L");
|
||
}
|
||
|
||
// 验证球号范围和重复性
|
||
validateBallNumbers(firstThreeRedBalls, lastSixRedBalls, blueBall);
|
||
|
||
List<Integer> allNumbers = new ArrayList<>();
|
||
|
||
// 第一步：处理第1个红球，从T7表获取10个数字（同时记录系数）
|
||
log.info("第一步：处理第1个红球{}，从T7表获取10个数字，使用{}级别算法", firstThreeRedBalls.get(0), level);
|
||
List<Integer> firstRedBallNumbers = getTop10FromT7(firstThreeRedBalls.get(0), level);
|
||
allNumbers.addAll(firstRedBallNumbers);
|
||
log.info("第1个红球{}获取到{}个数字：{}", firstThreeRedBalls.get(0), firstRedBallNumbers.size(), firstRedBallNumbers);
|
||
|
||
// 同步记录上述10个数字在T7表中的面系数，记录格式与analyzeBalls一致
|
||
List<BallWithCoefficient> step1BallsWithCoefficients = getT7CoefficientsFor(firstThreeRedBalls.get(0), firstRedBallNumbers);
|
||
log.info("=== 第一步（T7）球号和系数统计（共{}个） ===", step1BallsWithCoefficients.size());
|
||
for (int i = 0; i < step1BallsWithCoefficients.size(); i++) {
|
||
BallWithCoefficient ballWithCoeff = step1BallsWithCoefficients.get(i);
|
||
log.info("第{}个：{}", i + 1, ballWithCoeff.toString());
|
||
}
|
||
log.info("=== 第一步统计结束 ===");
|
||
|
||
// 第二步：处理后6个红球，每个红球从T3表获取26个数字
|
||
log.info("第二步：处理后6个红球，每个红球从T3表获取26个数字");
|
||
for (int i = 0; i < lastSixRedBalls.size(); i++) {
|
||
Integer redBall = lastSixRedBalls.get(i);
|
||
log.info("处理第{}个红球：{}", i + 1, redBall);
|
||
|
||
List<Integer> ballNumbers = getTop26FromT3(redBall);
|
||
allNumbers.addAll(ballNumbers);
|
||
|
||
log.info("红球{}获取到{}个数字：{}", redBall, ballNumbers.size(), ballNumbers);
|
||
}
|
||
|
||
// 第三步：从history_top_100获取前3个球号
|
||
log.info("第三步：从history_top_100获取前3个球号");
|
||
List<Integer> top3Numbers = getTop3FromHistoryTop100();
|
||
allNumbers.addAll(top3Numbers);
|
||
log.info("从history_top_100获取到{}个数字：{}", top3Numbers.size(), top3Numbers);
|
||
|
||
// 第四步：取出前3个红球号码的后两个
|
||
log.info("第四步：取出前3个红球号码的后两个");
|
||
List<Integer> lastTwoOfFirstThree = Arrays.asList(firstThreeRedBalls.get(1), firstThreeRedBalls.get(2));
|
||
allNumbers.addAll(lastTwoOfFirstThree);
|
||
log.info("前3个红球的后两个：{}", lastTwoOfFirstThree);
|
||
|
||
// 第五步：用上期蓝球从T4表获取26个蓝球号码
|
||
log.info("第五步：用上期蓝球{}从T4表获取26个蓝球号码", blueBall);
|
||
List<Integer> blueNumbers = getTop26FromT4(blueBall);
|
||
allNumbers.addAll(blueNumbers);
|
||
log.info("蓝球{}获取到{}个数字：{}", blueBall, blueNumbers.size(), blueNumbers);
|
||
|
||
log.info("总共收集到{}个数字", allNumbers.size());
|
||
|
||
// 第六步：统计频率并获取前10个（带筛选过程说明）
|
||
FollowBallAnalysisResultVO result = getTop10ByFrequencyWithProcess(allNumbers, step1BallsWithCoefficients);
|
||
|
||
log.info("跟随球号分析算法（带过程说明）完成，结果：{}，过程说明：{}", result.getResult(), result.getFilteringProcess());
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 验证球号的有效性和唯一性
|
||
*/
|
||
private void validateBallNumbers(List<Integer> firstThreeRedBalls, List<Integer> lastSixRedBalls, Integer blueBall) {
|
||
// 验证红球范围
|
||
for (Integer ball : firstThreeRedBalls) {
|
||
if (ball == null || ball < 1 || ball > 33) {
|
||
throw new IllegalArgumentException("前3个红球号码必须在1-33范围内");
|
||
}
|
||
}
|
||
for (Integer ball : lastSixRedBalls) {
|
||
if (ball == null || ball < 1 || ball > 33) {
|
||
throw new IllegalArgumentException("后6个红球号码必须在1-33范围内");
|
||
}
|
||
}
|
||
|
||
// 验证蓝球范围
|
||
if (blueBall < 1 || blueBall > 16) {
|
||
throw new IllegalArgumentException("蓝球号码必须在1-16范围内");
|
||
}
|
||
|
||
// 验证前3个红球不重复
|
||
Set<Integer> firstThreeSet = new HashSet<>(firstThreeRedBalls);
|
||
if (firstThreeSet.size() != 3) {
|
||
throw new IllegalArgumentException("前3个红球号码不能重复");
|
||
}
|
||
|
||
// 验证后6个红球不重复
|
||
Set<Integer> lastSixSet = new HashSet<>(lastSixRedBalls);
|
||
if (lastSixSet.size() != 6) {
|
||
throw new IllegalArgumentException("后6个红球号码不能重复");
|
||
}
|
||
|
||
log.debug("球号验证通过");
|
||
}
|
||
|
||
/**
|
||
* 从T7表获取指定主球的10个从球号
|
||
* 根据不同级别使用不同的选择策略
|
||
* @param masterBallNumber 主球号
|
||
* @param level 级别：H-高位，M-中位，L-低位
|
||
*/
|
||
private List<Integer> getTop10FromT7(Integer masterBallNumber, String level) {
|
||
log.debug("从T7表查询主球{}的面系数数据，级别：{}", masterBallNumber, level);
|
||
|
||
// 查询指定主球的所有数据，按面系数降序排列
|
||
QueryWrapper<T7> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", masterBallNumber)
|
||
.orderByDesc("faceCoefficient")
|
||
.orderByAsc("slaveBallNumber"); // 面系数相同时按从球号升序
|
||
|
||
List<T7> t7List = t7Mapper.selectList(queryWrapper);
|
||
|
||
if (t7List.isEmpty()) {
|
||
log.warn("T7表中主球{}没有数据", masterBallNumber);
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
switch (level) {
|
||
case "H":
|
||
// 高位：取面系数最大的前10个
|
||
result = getHighLevelBallsFromT7(t7List);
|
||
break;
|
||
case "M":
|
||
// 中位：取面系数平均值向上5个、向下4个，共10个球号
|
||
result = getMiddleLevelBallsFromT7(t7List);
|
||
break;
|
||
case "L":
|
||
// 低位：取面系数最小值向上第3-13个球共10个球号
|
||
result = getLowLevelBallsFromT7(t7List);
|
||
break;
|
||
}
|
||
|
||
log.debug("T7表主球{}{}级别最终选择的{}个从球：{}", masterBallNumber, level, result.size(), result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 高位算法：从T7表取面系数最大的前10个
|
||
*/
|
||
private List<Integer> getHighLevelBallsFromT7(List<T7> t7List) {
|
||
if (t7List.size() < 10) {
|
||
log.warn("T7表数据不足10条，实际{}条", t7List.size());
|
||
return t7List.stream().map(T7::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 获取前9个
|
||
List<Integer> result = new ArrayList<>();
|
||
for (int i = 0; i < 9; i++) {
|
||
result.add(t7List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理第10个位置：检查是否有相同的面系数
|
||
Double targetCoefficient = t7List.get(9).getFaceCoefficient();
|
||
List<T7> candidatesFor10th = new ArrayList<>();
|
||
|
||
// 找出所有面系数等于第10个位置面系数的记录
|
||
for (int i = 9; i < t7List.size(); i++) {
|
||
if (t7List.get(i).getFaceCoefficient().equals(targetCoefficient)) {
|
||
candidatesFor10th.add(t7List.get(i));
|
||
} else {
|
||
break; // 面系数不同，停止查找
|
||
}
|
||
}
|
||
|
||
if (candidatesFor10th.size() == 1) {
|
||
// 只有一个候选，直接添加
|
||
result.add(candidatesFor10th.get(0).getSlaveBallNumber());
|
||
} else {
|
||
// 有多个候选，通过history_top_100表的点系数排序
|
||
log.debug("第10位有{}个相同面系数的候选：{}", candidatesFor10th.size(),
|
||
candidatesFor10th.stream().map(T7::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallFromHistoryTop100(
|
||
candidatesFor10th.stream().map(T7::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.add(bestBall);
|
||
}
|
||
|
||
log.debug("T7高位算法最终选择的10个球：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 中位算法：从T7表取面系数平均值向上5个、向下4个，共10个球号。
|
||
* 毛边处理要求：
|
||
* - 向上边界包含边界本身（或其上方/下方的同系数项）一起参与比较；
|
||
* - 向下边界包含边界本身（或其下方的同系数项）一起参与比较；
|
||
* - 当边界存在多个相同面系数的候选时，按 history_top_100 → history_top → 随机 的顺序筛选。
|
||
*/
|
||
private List<Integer> getMiddleLevelBallsFromT7(List<T7> t7List) {
|
||
if (t7List.size() < 10) {
|
||
log.warn("T7表数据不足10条，实际{}条", t7List.size());
|
||
return t7List.stream().map(T7::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 计算面系数平均值
|
||
double avgCoefficient = t7List.stream()
|
||
.mapToDouble(T7::getFaceCoefficient)
|
||
.average()
|
||
.orElse(0.0);
|
||
|
||
log.debug("T7表面系数平均值：{}", avgCoefficient);
|
||
|
||
// 找到大于平均值且最接近的位置（如果有多个相同值，选择最后一个）
|
||
int avgIndex = -1;
|
||
double minDiff = Double.MAX_VALUE;
|
||
for (int i = 0; i < t7List.size(); i++) {
|
||
double coefficient = t7List.get(i).getFaceCoefficient();
|
||
// 只考虑大于平均值的值
|
||
if (coefficient > avgCoefficient) {
|
||
double diff = coefficient - avgCoefficient;
|
||
if (diff <= minDiff) { // 使用 <= 来选择最后一个相同值
|
||
minDiff = diff;
|
||
avgIndex = i;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 如果没有找到大于平均值的，则取最大值
|
||
if (avgIndex == -1) {
|
||
avgIndex = 0; // T7表按面系数降序排列，第一个就是最大值
|
||
log.debug("未找到大于平均值的位置，使用最大值位置：{}，面系数：{}", avgIndex, t7List.get(avgIndex).getFaceCoefficient());
|
||
} else {
|
||
log.debug("找到大于平均值且最接近的位置：{}，面系数：{}", avgIndex, t7List.get(avgIndex).getFaceCoefficient());
|
||
}
|
||
|
||
// 向上5个，向下4个，共10个
|
||
int startIndex = Math.max(0, avgIndex - 5);
|
||
int endIndex = Math.min(t7List.size() - 1, avgIndex + 4);
|
||
|
||
// 确保总共10个数字
|
||
while (endIndex - startIndex + 1 < 10 && (startIndex > 0 || endIndex < t7List.size() - 1)) {
|
||
if (startIndex > 0) {
|
||
startIndex--;
|
||
}
|
||
if (endIndex < t7List.size() - 1 && endIndex - startIndex + 1 < 10) {
|
||
endIndex++;
|
||
}
|
||
}
|
||
|
||
List<Integer> candidates = new ArrayList<>();
|
||
for (int i = startIndex; i <= endIndex && candidates.size() < 10; i++) {
|
||
candidates.add(t7List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理边界位置的相同面系数情况（包含边界本身参与比较，并带回退规则）
|
||
List<Integer> result = handleT7BoundaryConflicts(t7List, candidates, startIndex, endIndex);
|
||
|
||
log.debug("T7中位算法选择范围：[{}, {}]，共{}个球", startIndex, endIndex, result.size());
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 低位算法：从T7表取面系数最小值向上第3-13个球共10个球号
|
||
*/
|
||
private List<Integer> getLowLevelBallsFromT7(List<T7> t7List) {
|
||
if (t7List.size() < 13) {
|
||
log.warn("T7表数据不足13条，实际{}条", t7List.size());
|
||
return t7List.stream().map(T7::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 从最后13个开始，取第3-13个（即倒数第12到倒数第2个）
|
||
int startIndex = Math.max(0, t7List.size() - 12);
|
||
int endIndex = t7List.size() - 2;
|
||
|
||
List<Integer> candidates = new ArrayList<>();
|
||
for (int i = startIndex; i <= endIndex; i++) {
|
||
candidates.add(t7List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理边界位置的相同面系数情况
|
||
List<Integer> result = handleT7BoundaryConflicts(t7List, candidates, startIndex, endIndex);
|
||
|
||
log.debug("T7低位算法选择范围：[{}, {}]，共{}个球", startIndex, endIndex, result.size());
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 处理T7表边界位置的面系数冲突
|
||
*/
|
||
private List<Integer> handleT7BoundaryConflicts(List<T7> t7List, List<Integer> candidates,
|
||
int startIndex, int endIndex) {
|
||
List<Integer> result = new ArrayList<>(candidates);
|
||
|
||
if (result.size() >= 10) {
|
||
// 检查第1个位置（最大面系数）的冲突：包含边界本身
|
||
Double firstCoefficient = t7List.get(startIndex).getFaceCoefficient();
|
||
List<T7> candidatesForFirst = new ArrayList<>();
|
||
candidatesForFirst.add(t7List.get(startIndex)); // 边界本身
|
||
|
||
// 找出第一个位置上面（如果存在）的所有相同面系数的记录
|
||
for (int i = 0; i < startIndex; i++) {
|
||
if (t7List.get(i).getFaceCoefficient().equals(firstCoefficient)) {
|
||
candidatesForFirst.add(t7List.get(i));
|
||
}
|
||
}
|
||
|
||
if (candidatesForFirst.size() > 1) {
|
||
log.debug("第1位及其上面有{}个相同面系数的候选：{}", candidatesForFirst.size(),
|
||
candidatesForFirst.stream().map(T7::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallWithFallback(
|
||
candidatesForFirst.stream().map(T7::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.set(0, bestBall);
|
||
}
|
||
|
||
// 检查第10个位置（最小面系数）的冲突：包含边界本身
|
||
Double lastCoefficient = t7List.get(endIndex).getFaceCoefficient();
|
||
List<T7> candidatesForLast = new ArrayList<>();
|
||
candidatesForLast.add(t7List.get(endIndex)); // 边界本身
|
||
|
||
// 找出第10个位置下面（如果存在）的所有相同面系数的记录
|
||
for (int i = endIndex + 1; i < t7List.size(); i++) {
|
||
if (t7List.get(i).getFaceCoefficient().equals(lastCoefficient)) {
|
||
candidatesForLast.add(t7List.get(i));
|
||
}
|
||
}
|
||
|
||
if (candidatesForLast.size() > 1) {
|
||
log.debug("第10位及其下面有{}个相同面系数的候选：{}", candidatesForLast.size(),
|
||
candidatesForLast.stream().map(T7::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallWithFallback(
|
||
candidatesForLast.stream().map(T7::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.set(result.size() - 1, bestBall);
|
||
}
|
||
}
|
||
|
||
return result.subList(0, Math.min(10, result.size()));
|
||
}
|
||
|
||
/**
|
||
* 从T3表获取指定主球的26个从球号（按线系数从大到小排列）
|
||
*/
|
||
private List<Integer> getTop26FromT3(Integer masterBallNumber) {
|
||
log.debug("从T3表查询主球{}的线系数数据，取前26个", masterBallNumber);
|
||
|
||
// 查询指定主球的所有数据，按线系数降序排列
|
||
QueryWrapper<T3> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", masterBallNumber)
|
||
.orderByDesc("lineCoefficient")
|
||
.orderByAsc("slaveBallNumber"); // 线系数相同时按从球号升序
|
||
|
||
List<T3> t3List = t3Mapper.selectList(queryWrapper);
|
||
|
||
if (t3List.isEmpty()) {
|
||
log.warn("T3表中主球{}没有数据", masterBallNumber);
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
if (t3List.size() < 26) {
|
||
log.warn("T3表数据不足26条，实际{}条", t3List.size());
|
||
return t3List.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 获取前25个
|
||
List<Integer> result = new ArrayList<>();
|
||
for (int i = 0; i < 25; i++) {
|
||
result.add(t3List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理第26个位置：检查是否有相同的线系数
|
||
Double targetCoefficient = t3List.get(25).getLineCoefficient();
|
||
List<T3> candidatesFor26th = new ArrayList<>();
|
||
|
||
// 找出所有线系数等于第26个位置线系数的记录
|
||
for (int i = 25; i < t3List.size(); i++) {
|
||
if (t3List.get(i).getLineCoefficient().equals(targetCoefficient)) {
|
||
candidatesFor26th.add(t3List.get(i));
|
||
} else {
|
||
break; // 线系数不同，停止查找
|
||
}
|
||
}
|
||
|
||
if (candidatesFor26th.size() == 1) {
|
||
// 只有一个候选，直接添加
|
||
result.add(candidatesFor26th.get(0).getSlaveBallNumber());
|
||
} else {
|
||
// 有多个候选，通过history_top_100表的点系数排序
|
||
log.debug("第26位有{}个相同线系数的候选：{}", candidatesFor26th.size(),
|
||
candidatesFor26th.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallFromHistoryTop100(
|
||
candidatesFor26th.stream().map(T3::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.add(bestBall);
|
||
}
|
||
|
||
log.debug("T3表主球{}最终选择的26个从球：{}", masterBallNumber, result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 从history_top_100表获取前3个球号（按点系数排序）
|
||
*/
|
||
private List<Integer> getTop3FromHistoryTop100() {
|
||
log.debug("从history_top_100表获取前3个球号");
|
||
|
||
// 查询前3个点系数最高的球号
|
||
QueryWrapper<HistoryTop100> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber") // 点系数相同时按球号升序
|
||
.last("LIMIT 3"); // 限制只返回前3条记录
|
||
|
||
List<HistoryTop100> top100List = historyTop100Mapper.selectList(queryWrapper);
|
||
|
||
if (top100List.size() < 3) {
|
||
log.warn("history_top_100表数据不足3条，实际{}条", top100List.size());
|
||
}
|
||
|
||
List<Integer> result = top100List.stream()
|
||
.map(HistoryTop100::getBallNumber)
|
||
.collect(Collectors.toList());
|
||
|
||
log.debug("history_top_100表前3个球号：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 从T4表获取指定主球的10个从球号
|
||
* 根据不同级别使用不同的选择策略
|
||
* @param masterBallNumber 主球号
|
||
* @param level 级别：H-高位，M-中位，L-低位
|
||
*/
|
||
private List<Integer> getTop10FromT4(Integer masterBallNumber, String level) {
|
||
log.debug("从T4表查询主球{}的线系数数据，级别：{}", masterBallNumber, level);
|
||
|
||
// 查询指定主球的所有数据，按线系数降序排列
|
||
QueryWrapper<T4> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", masterBallNumber)
|
||
.orderByDesc("lineCoefficient")
|
||
.orderByAsc("slaveBallNumber"); // 线系数相同时按从球号升序
|
||
|
||
List<T4> t4List = t4Mapper.selectList(queryWrapper);
|
||
|
||
if (t4List.isEmpty()) {
|
||
log.warn("T4表中主球{}没有数据", masterBallNumber);
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
switch (level) {
|
||
case "H":
|
||
// 高位：取线系数最大的前10个
|
||
result = getHighLevelBallsFromT4For10(t4List);
|
||
break;
|
||
case "M":
|
||
// 中位：取线系数平均值向上6个向下4个的10个球号
|
||
result = getMiddleLevelBallsFromT4For10(t4List);
|
||
break;
|
||
case "L":
|
||
// 低位：取线系数最小值向上第4-14个球的10个球号
|
||
result = getLowLevelBallsFromT4For10(t4List);
|
||
break;
|
||
}
|
||
|
||
log.debug("T4表主球{}{}级别最终选择的{}个从球：{}", masterBallNumber, level, result.size(), result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 高位算法：从T4表取线系数最大的前10个
|
||
*/
|
||
private List<Integer> getHighLevelBallsFromT4For10(List<T4> t4List) {
|
||
if (t4List.size() < 10) {
|
||
log.warn("T4表数据不足10条，实际{}条", t4List.size());
|
||
return t4List.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 获取前9个
|
||
List<Integer> result = new ArrayList<>();
|
||
for (int i = 0; i < 9; i++) {
|
||
result.add(t4List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理第10个位置：检查是否有相同的线系数
|
||
Double targetCoefficient = t4List.get(9).getLineCoefficient();
|
||
List<T4> candidatesFor10th = new ArrayList<>();
|
||
|
||
// 找出所有线系数等于第10个位置线系数的记录
|
||
for (int i = 9; i < t4List.size(); i++) {
|
||
if (t4List.get(i).getLineCoefficient().equals(targetCoefficient)) {
|
||
candidatesFor10th.add(t4List.get(i));
|
||
} else {
|
||
break; // 线系数不同，停止查找
|
||
}
|
||
}
|
||
|
||
if (candidatesFor10th.size() == 1) {
|
||
// 只有一个候选，直接添加
|
||
result.add(candidatesFor10th.get(0).getSlaveBallNumber());
|
||
} else {
|
||
// 有多个候选，通过history_top_100表的点系数排序
|
||
log.debug("第10位有{}个相同线系数的候选：{}", candidatesFor10th.size(),
|
||
candidatesFor10th.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallFromHistoryTop100(
|
||
candidatesFor10th.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.add(bestBall);
|
||
}
|
||
|
||
log.debug("T4高位算法最终选择的10个球：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 中位算法：从T4表取线系数平均值向上5个向下5个的10个球号
|
||
*/
|
||
private List<Integer> getMiddleLevelBallsFromT4For10(List<T4> t4List) {
|
||
if (t4List.size() < 10) {
|
||
log.warn("T4表数据不足10条，实际{}条", t4List.size());
|
||
return t4List.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 计算线系数平均值
|
||
double avgCoefficient = t4List.stream()
|
||
.mapToDouble(T4::getLineCoefficient)
|
||
.average()
|
||
.orElse(0.0);
|
||
|
||
log.debug("T4表线系数平均值：{}", avgCoefficient);
|
||
|
||
// 找到大于平均值且最接近的位置（如果有多个相同值，选择最后一个）
|
||
int avgIndex = -1;
|
||
double minDiff = Double.MAX_VALUE;
|
||
for (int i = 0; i < t4List.size(); i++) {
|
||
double coefficient = t4List.get(i).getLineCoefficient();
|
||
// 只考虑大于平均值的值
|
||
if (coefficient > avgCoefficient) {
|
||
double diff = coefficient - avgCoefficient;
|
||
if (diff <= minDiff) { // 使用 <= 来选择最后一个相同值
|
||
minDiff = diff;
|
||
avgIndex = i;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 如果没有找到大于平均值的，则取最大值
|
||
if (avgIndex == -1) {
|
||
avgIndex = 0; // T4表按线系数降序排列，第一个就是最大值
|
||
log.debug("未找到大于平均值的位置，使用最大值位置：{}，线系数：{}", avgIndex, t4List.get(avgIndex).getLineCoefficient());
|
||
} else {
|
||
log.debug("找到大于平均值且最接近的位置：{}，线系数：{}", avgIndex, t4List.get(avgIndex).getLineCoefficient());
|
||
}
|
||
|
||
// 向上5个，向下5个，共10个
|
||
int startIndex = Math.max(0, avgIndex - 5);
|
||
int endIndex = Math.min(t4List.size() - 1, avgIndex + 4);
|
||
|
||
// 确保总共10个数字
|
||
while (endIndex - startIndex + 1 < 10 && (startIndex > 0 || endIndex < t4List.size() - 1)) {
|
||
if (startIndex > 0) {
|
||
startIndex--;
|
||
}
|
||
if (endIndex < t4List.size() - 1 && endIndex - startIndex + 1 < 10) {
|
||
endIndex++;
|
||
}
|
||
}
|
||
|
||
List<Integer> candidates = new ArrayList<>();
|
||
for (int i = startIndex; i <= endIndex && candidates.size() < 10; i++) {
|
||
candidates.add(t4List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理边界位置的相同线系数情况
|
||
List<Integer> result = handleT4BoundaryConflictsFor10(t4List, candidates, startIndex, endIndex);
|
||
|
||
log.debug("T4中位算法选择范围：[{}, {}]，共{}个球", startIndex, endIndex, result.size());
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 低位算法：从T4表取线系数最小值向上第4-14个球的10个球号
|
||
*/
|
||
private List<Integer> getLowLevelBallsFromT4For10(List<T4> t4List) {
|
||
if (t4List.size() < 14) {
|
||
log.warn("T4表数据不足14条，实际{}条", t4List.size());
|
||
return t4List.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 从最后14个开始，取第4-14个（即倒数第11到倒数第1个）
|
||
int startIndex = Math.max(0, t4List.size() - 11);
|
||
int endIndex = t4List.size() - 1;
|
||
|
||
List<Integer> candidates = new ArrayList<>();
|
||
for (int i = startIndex; i <= endIndex; i++) {
|
||
candidates.add(t4List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理边界位置的相同线系数情况
|
||
List<Integer> result = handleT4BoundaryConflictsFor10(t4List, candidates, startIndex, endIndex);
|
||
|
||
log.debug("T4低位算法选择范围：[{}, {}]，共{}个球", startIndex, endIndex, result.size());
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 统计数字出现频率，返回频率最高的前10个数字
|
||
* 如果频次相同的球号超过10个，使用T7表面系数进行二次筛选
|
||
*/
|
||
private List<Integer> getTop10ByFrequency(List<Integer> allNumbers, List<BallWithCoefficient> step1BallsWithCoefficients) {
|
||
log.debug("统计{}个数字的出现频率", allNumbers.size());
|
||
|
||
// 统计频率
|
||
Map<Integer, Integer> frequencyMap = new HashMap<>();
|
||
for (Integer number : allNumbers) {
|
||
frequencyMap.put(number, frequencyMap.getOrDefault(number, 0) + 1);
|
||
}
|
||
|
||
log.debug("数字频率统计：{}", frequencyMap);
|
||
|
||
// 按频率分组
|
||
Map<Integer, List<Integer>> frequencyGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
|
||
Integer frequency = entry.getValue();
|
||
Integer ballNumber = entry.getKey();
|
||
|
||
frequencyGroups.computeIfAbsent(frequency, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.debug("按频率分组：{}", frequencyGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
// 按频率从高到低处理
|
||
for (Map.Entry<Integer, List<Integer>> group : frequencyGroups.entrySet()) {
|
||
Integer frequency = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
// 对同频率的球号按数字升序排序
|
||
Collections.sort(balls);
|
||
|
||
log.info("频率{}的球号：{}", frequency, balls);
|
||
|
||
// 检查加入这组球号后是否会超过10个
|
||
if (result.size() + balls.size() <= 10) {
|
||
// 不会超过10个，直接添加所有球号
|
||
result.addAll(balls);
|
||
log.info("直接添加{}个球号，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过10个：先按第一步T7面系数排序；如仍有边界相同面系数，继续按 100期 → 历史 → 随机 的回退规则，只在边界同系数的集合内决策
|
||
int remainingSlots = 10 - result.size();
|
||
log.info("需要从{}个频率相同的球号中选择{}个，先按第一步T7面系数进行筛选（找不到则按0处理）", balls.size(), remainingSlots);
|
||
|
||
// 构建 step1 球号->面系数 映射（找不到则为0）
|
||
Map<Integer, Double> num2Coeff = new HashMap<>();
|
||
if (step1BallsWithCoefficients != null) {
|
||
for (BallWithCoefficient bwc : step1BallsWithCoefficients) {
|
||
num2Coeff.put(bwc.getBallNumber(), bwc.getCoefficient());
|
||
}
|
||
}
|
||
|
||
// 先按面系数降序，再按球号升序
|
||
List<Integer> sortedByT7 = new ArrayList<>(balls);
|
||
sortedByT7.sort((a, b) -> {
|
||
double ca = num2Coeff.getOrDefault(a, 0.0);
|
||
double cb = num2Coeff.getOrDefault(b, 0.0);
|
||
if (Double.compare(cb, ca) != 0) {
|
||
return Double.compare(cb, ca);
|
||
}
|
||
return Integer.compare(a, b);
|
||
});
|
||
|
||
// 如果正好能取齐，直接取
|
||
if (sortedByT7.size() <= remainingSlots) {
|
||
result.addAll(sortedByT7);
|
||
log.info("按T7面系数后正好取齐，选择：{}", sortedByT7);
|
||
break;
|
||
}
|
||
|
||
// 存在边界相同面系数：提取阈值、拆分高于阈值与阈值相等的集合
|
||
double thresholdCoeff = num2Coeff.getOrDefault(sortedByT7.get(remainingSlots - 1), 0.0);
|
||
List<Integer> higherThanThreshold = new ArrayList<>();
|
||
List<Integer> equalThresholdGroup = new ArrayList<>();
|
||
for (Integer bn : sortedByT7) {
|
||
double c = num2Coeff.getOrDefault(bn, 0.0);
|
||
if (c > thresholdCoeff) {
|
||
higherThanThreshold.add(bn);
|
||
} else if (Double.compare(c, thresholdCoeff) == 0) {
|
||
equalThresholdGroup.add(bn);
|
||
}
|
||
}
|
||
|
||
// 先无条件加入高于阈值的
|
||
result.addAll(higherThanThreshold);
|
||
|
||
int stillNeed = remainingSlots - higherThanThreshold.size();
|
||
if (stillNeed > 0) {
|
||
// 仅在阈值相同的集合内，先用100期取该组的最高点系数组（可能少于需要的数量则直接全部加入），
|
||
// 若仍未满足，再对剩余候选使用history_top精筛；仍无法区分则随机补齐。
|
||
List<Integer> tieResolved = selectByTop100ThenHistoryTop(equalThresholdGroup, stillNeed);
|
||
result.addAll(tieResolved);
|
||
log.info("边界同面系数通过100期→历史→随机补齐：{}", tieResolved);
|
||
}
|
||
|
||
// 已达到8个，结束
|
||
break;
|
||
}
|
||
|
||
// 如果已经有8个，结束
|
||
if (result.size() >= 8) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
log.info("频率统计最终结果（共{}个）：{}", result.size(), result);
|
||
|
||
// 打印详细的频率信息
|
||
for (int i = 0; i < result.size(); i++) {
|
||
Integer ballNumber = result.get(i);
|
||
Integer frequency = frequencyMap.get(ballNumber);
|
||
log.info("第{}位：数字{}，出现{}次", i + 1, ballNumber, frequency);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 统计频率并获取前10个（带筛选过程说明）
|
||
* @param allNumbers 所有数字
|
||
* @param step1BallsWithCoefficients 第一步T7面系数数据
|
||
* @return 包含结果和筛选过程说明的VO对象
|
||
*/
|
||
private FollowBallAnalysisResultVO getTop10ByFrequencyWithProcess(List<Integer> allNumbers, List<BallWithCoefficient> step1BallsWithCoefficients) {
|
||
log.debug("统计{}个数字的出现频率", allNumbers.size());
|
||
|
||
// 统计频率
|
||
Map<Integer, Integer> frequencyMap = new HashMap<>();
|
||
for (Integer number : allNumbers) {
|
||
frequencyMap.put(number, frequencyMap.getOrDefault(number, 0) + 1);
|
||
}
|
||
|
||
log.debug("数字频率统计：{}", frequencyMap);
|
||
|
||
// 按频率分组
|
||
Map<Integer, List<Integer>> frequencyGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
|
||
Integer frequency = entry.getValue();
|
||
Integer ballNumber = entry.getKey();
|
||
|
||
frequencyGroups.computeIfAbsent(frequency, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.debug("按频率分组：{}", frequencyGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
List<Integer> directlySelectedBalls = new ArrayList<>();
|
||
List<Integer> multiLevelCandidates = new ArrayList<>();
|
||
List<Integer> secondaryFilteredBalls = new ArrayList<>();
|
||
boolean needMultiLevelFiltering = false;
|
||
StringBuilder processDescription = new StringBuilder();
|
||
String detailedStepsInfo = "";
|
||
|
||
// 按频率从高到低处理
|
||
for (Map.Entry<Integer, List<Integer>> group : frequencyGroups.entrySet()) {
|
||
Integer frequency = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
// 对同频率的球号按数字升序排序
|
||
Collections.sort(balls);
|
||
|
||
log.info("频率{}的球号：{}", frequency, balls);
|
||
|
||
// 检查加入这组球号后是否会超过10个
|
||
if (result.size() + balls.size() <= 10) {
|
||
// 不会超过10个，直接添加所有球号
|
||
result.addAll(balls);
|
||
directlySelectedBalls.addAll(balls);
|
||
log.info("直接添加{}个球号，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过10个，需要多级筛选
|
||
needMultiLevelFiltering = true;
|
||
multiLevelCandidates.addAll(balls);
|
||
|
||
int remainingSlots = 10 - result.size();
|
||
log.info("需要从{}个频率相同的球号中选择{}个，先按第一步T7面系数进行筛选", balls.size(), remainingSlots);
|
||
|
||
// 进行多级筛选
|
||
FollowBallMultiLevelFilteringResult filteringResult = performFollowBallMultiLevelFilteringWithDetails(balls, remainingSlots, step1BallsWithCoefficients);
|
||
result.addAll(filteringResult.getSelectedBalls());
|
||
secondaryFilteredBalls = new ArrayList<>(filteringResult.getSelectedBalls());
|
||
processDescription.append("筛选步骤：").append(filteringResult.getStepsDescription());
|
||
detailedStepsInfo = filteringResult.getDetailedStepsInfo();
|
||
|
||
// 已达到10个，结束
|
||
break;
|
||
}
|
||
|
||
// 如果已经有10个，结束
|
||
if (result.size() >= 10) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 构建详细的过程描述
|
||
StringBuilder detailedDescription = new StringBuilder();
|
||
|
||
// 1. 频率分布描述 - 只包含实际参与筛选的球号
|
||
List<Integer> allParticipatedBalls = new ArrayList<>();
|
||
allParticipatedBalls.addAll(directlySelectedBalls);
|
||
allParticipatedBalls.addAll(multiLevelCandidates);
|
||
|
||
Map<Integer, List<Integer>> participatedFrequencyGroups = new LinkedHashMap<>();
|
||
for (Integer ball : allParticipatedBalls) {
|
||
Integer frequency = frequencyMap.get(ball);
|
||
participatedFrequencyGroups.computeIfAbsent(frequency, k -> new ArrayList<>()).add(ball);
|
||
}
|
||
|
||
// 按频率从高到低排序
|
||
Map<Integer, List<Integer>> sortedParticipatedFrequencyGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (Map.Entry<Integer, List<Integer>> entry : participatedFrequencyGroups.entrySet()) {
|
||
Integer frequency = entry.getKey();
|
||
List<Integer> balls = new ArrayList<>(entry.getValue());
|
||
Collections.sort(balls); // 球号按升序排序
|
||
sortedParticipatedFrequencyGroups.put(frequency, balls);
|
||
}
|
||
|
||
detailedDescription.append("参与筛选的候选球号按频率分布为");
|
||
detailedDescription.append(formatBallNumbersWithFrequency(sortedParticipatedFrequencyGroups));
|
||
|
||
// 2. 筛选结果描述
|
||
if (needMultiLevelFiltering) {
|
||
detailedDescription.append("；无法直接筛选出前10个，其中");
|
||
detailedDescription.append(formatBallNumbers(directlySelectedBalls));
|
||
detailedDescription.append("直接入选，");
|
||
detailedDescription.append(formatBallNumbers(multiLevelCandidates));
|
||
detailedDescription.append("需要进行二次筛选，最终筛选出");
|
||
detailedDescription.append(formatBallNumbers(secondaryFilteredBalls));
|
||
detailedDescription.append("，组成前10个球号：");
|
||
detailedDescription.append(formatBallNumbers(result));
|
||
detailedDescription.append("。");
|
||
detailedDescription.append(processDescription.toString());
|
||
if (!detailedStepsInfo.isEmpty()) {
|
||
detailedDescription.append(" ").append(detailedStepsInfo);
|
||
}
|
||
} else {
|
||
detailedDescription.append("；直接按频率筛选出前10个球号：");
|
||
detailedDescription.append(formatBallNumbers(result));
|
||
detailedDescription.append("。筛选步骤：通过频率筛选确定所有球号，无需进行T7面系数筛选、百期排位、历史排位。");
|
||
}
|
||
|
||
return FollowBallAnalysisResultVO.builder()
|
||
.result(result)
|
||
.filteringProcess(detailedDescription.toString())
|
||
.build();
|
||
}
|
||
|
||
/**
|
||
* 根据T7表的面系数总和选择球号，支持多级筛选
|
||
* @param candidateBalls 候选球号列表
|
||
* @param selectCount 需要选择的数量
|
||
* @return 选择的球号列表
|
||
*/
|
||
private List<Integer> selectBallsByT7FaceCoefficient(List<Integer> candidateBalls, int selectCount) {
|
||
log.info("开始根据T7表面系数总和选择球号，候选：{}，需要选择：{}", candidateBalls, selectCount);
|
||
|
||
if (candidateBalls.size() <= selectCount) {
|
||
log.info("候选球号数量不超过需要选择的数量，直接返回所有候选球号");
|
||
return new ArrayList<>(candidateBalls);
|
||
}
|
||
|
||
// 第一级：计算每个球号作为主球时的面系数总和
|
||
Map<Integer, Double> faceCoefficientSumMap = new HashMap<>();
|
||
|
||
for (Integer ballNumber : candidateBalls) {
|
||
QueryWrapper<T7> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", ballNumber);
|
||
|
||
List<T7> t7List = t7Mapper.selectList(queryWrapper);
|
||
|
||
double sum = t7List.stream()
|
||
.mapToDouble(T7::getFaceCoefficient)
|
||
.sum();
|
||
|
||
faceCoefficientSumMap.put(ballNumber, sum);
|
||
log.debug("球号{}作为主球的面系数总和：{}", ballNumber, sum);
|
||
}
|
||
|
||
// 按面系数总和分组
|
||
Map<Double, List<Integer>> faceCoefficientGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (Map.Entry<Integer, Double> entry : faceCoefficientSumMap.entrySet()) {
|
||
Double sum = entry.getValue();
|
||
Integer ballNumber = entry.getKey();
|
||
faceCoefficientGroups.computeIfAbsent(sum, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.info("T7表面系数总和分组：{}", faceCoefficientGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
// 按面系数总和从高到低处理
|
||
for (Map.Entry<Double, List<Integer>> group : faceCoefficientGroups.entrySet()) {
|
||
Double faceSum = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
log.info("面系数总和{}的球号：{}", faceSum, balls);
|
||
|
||
// 检查加入这组球号后是否会超过selectCount个
|
||
if (result.size() + balls.size() <= selectCount) {
|
||
// 不会超过，直接添加所有球号（按球号升序排序）
|
||
Collections.sort(balls);
|
||
result.addAll(balls);
|
||
log.info("直接添加{}个球号，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过，需要进一步筛选
|
||
int remainingSlots = selectCount - result.size();
|
||
log.info("需要从{}个面系数总和相同的球号中选择{}个，开始多级筛选", balls.size(), remainingSlots);
|
||
|
||
List<Integer> selectedBalls = selectBallsByMultiLevelFilteringFor8(balls, remainingSlots);
|
||
result.addAll(selectedBalls);
|
||
|
||
log.info("通过多级筛选完成，最终选择：{}", selectedBalls);
|
||
break; // 已经达到selectCount个，结束
|
||
}
|
||
|
||
// 如果已经有selectCount个，结束
|
||
if (result.size() >= selectCount) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
log.info("T7表面系数筛选最终结果（共{}个）：{}", result.size(), result);
|
||
|
||
// 打印详细的面系数信息
|
||
for (int i = 0; i < result.size(); i++) {
|
||
Integer ballNumber = result.get(i);
|
||
Double sum = faceCoefficientSumMap.get(ballNumber);
|
||
log.info("第{}位：球号{}，面系数总和：{}", i + 1, ballNumber, sum);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 多级筛选球号（8个球版本）：history_top_100 -> history_top -> 随机选择
|
||
* @param candidateBalls 候选球号列表
|
||
* @param selectCount 需要选择的数量
|
||
* @return 选择的球号列表
|
||
*/
|
||
private List<Integer> selectBallsByMultiLevelFilteringFor8(List<Integer> candidateBalls, int selectCount) {
|
||
log.info("开始多级筛选（8个球版本），候选：{}，需要选择：{}", candidateBalls, selectCount);
|
||
|
||
if (candidateBalls.size() <= selectCount) {
|
||
log.info("候选球号数量不超过需要选择的数量，直接返回所有候选球号");
|
||
return new ArrayList<>(candidateBalls);
|
||
}
|
||
|
||
// 第二级：使用history_top_100表的排名进行筛选
|
||
List<Integer> filteredByTop100 = selectBallsByHistoryTop100Ranking(candidateBalls, selectCount);
|
||
|
||
if (filteredByTop100.size() == selectCount) {
|
||
log.info("通过history_top_100表筛选成功，结果：{}", filteredByTop100);
|
||
return filteredByTop100;
|
||
}
|
||
|
||
// 第三级：使用history_top表的点系数进行筛选
|
||
log.info("history_top_100表筛选后仍有{}个球号，继续使用history_top表筛选", filteredByTop100.size());
|
||
List<Integer> filteredByTop = selectBallsByHistoryTopPointCoefficient(filteredByTop100, selectCount);
|
||
|
||
if (filteredByTop.size() == selectCount) {
|
||
log.info("通过history_top表筛选成功，结果：{}", filteredByTop);
|
||
return filteredByTop;
|
||
}
|
||
|
||
// 第四级：随机选择
|
||
log.info("history_top表筛选后仍有{}个球号，进行随机选择", filteredByTop.size());
|
||
List<Integer> finalResult = selectBallsRandomly(filteredByTop, selectCount);
|
||
|
||
log.info("随机选择完成，最终结果：{}", finalResult);
|
||
return finalResult;
|
||
}
|
||
|
||
/**
|
||
* 根据history_top_100表的排名筛选球号
|
||
* @param candidateBalls 候选球号列表
|
||
* @param selectCount 需要选择的数量
|
||
* @return 筛选后的球号列表
|
||
*/
|
||
private List<Integer> selectBallsByHistoryTop100Ranking(List<Integer> candidateBalls, int selectCount) {
|
||
log.info("使用history_top_100表排名筛选球号，候选：{}，需要选择：{}", candidateBalls, selectCount);
|
||
|
||
// 查询这些球号在history_top_100表中的点系数
|
||
QueryWrapper<HistoryTop100> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.in("ballNumber", candidateBalls)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber"); // 点系数相同时按球号升序
|
||
|
||
List<HistoryTop100> top100List = historyTop100Mapper.selectList(queryWrapper);
|
||
|
||
if (top100List.isEmpty()) {
|
||
log.warn("候选球号{}在history_top_100表中未找到数据，按球号升序返回", candidateBalls);
|
||
Collections.sort(candidateBalls);
|
||
return candidateBalls.subList(0, Math.min(selectCount, candidateBalls.size()));
|
||
}
|
||
|
||
// 按点系数分组
|
||
Map<Double, List<Integer>> pointCoefficientGroups = new LinkedHashMap<>();
|
||
for (HistoryTop100 item : top100List) {
|
||
Double pointCoefficient = item.getPointCoefficient();
|
||
Integer ballNumber = item.getBallNumber();
|
||
pointCoefficientGroups.computeIfAbsent(pointCoefficient, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.info("history_top_100表点系数分组：{}", pointCoefficientGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
// 按点系数从高到低处理
|
||
for (Map.Entry<Double, List<Integer>> group : pointCoefficientGroups.entrySet()) {
|
||
Double pointCoefficient = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
log.info("点系数{}的球号：{}", pointCoefficient, balls);
|
||
|
||
// 检查加入这组球号后是否会超过selectCount个
|
||
if (result.size() + balls.size() <= selectCount) {
|
||
// 不会超过，直接添加所有球号（按球号升序排序）
|
||
Collections.sort(balls);
|
||
result.addAll(balls);
|
||
log.info("直接添加{}个球号，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过，返回所有相同点系数的球号，让下一层筛选来处理
|
||
result.addAll(balls);
|
||
log.info("点系数相同，返回所有相同点系数的球号：{}，让下一层筛选处理", balls);
|
||
break;
|
||
}
|
||
|
||
// 如果已经有selectCount个，结束
|
||
if (result.size() >= selectCount) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 处理不在history_top_100表中的球号
|
||
List<Integer> notInTop100 = new ArrayList<>(candidateBalls);
|
||
notInTop100.removeAll(result);
|
||
if (!notInTop100.isEmpty() && result.size() < selectCount) {
|
||
int remainingSlots = selectCount - result.size();
|
||
Collections.sort(notInTop100);
|
||
int addCount = Math.min(remainingSlots, notInTop100.size());
|
||
result.addAll(notInTop100.subList(0, addCount));
|
||
log.info("添加不在history_top_100表中的{}个球号：{}", addCount, notInTop100.subList(0, addCount));
|
||
}
|
||
|
||
log.info("history_top_100表筛选结果：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 根据history_top_100表的排名筛选球号（包含详细信息）
|
||
* @param candidateBalls 候选球号列表
|
||
* @param selectCount 需要选择的数量
|
||
* @return 筛选结果和详细信息
|
||
*/
|
||
private FilteringDetailResult selectBallsByHistoryTop100RankingWithDetails(List<Integer> candidateBalls, int selectCount) {
|
||
log.info("使用history_top_100表排名筛选球号，候选：{}，需要选择：{}", candidateBalls, selectCount);
|
||
|
||
// 查询这些球号在history_top_100表中的点系数
|
||
QueryWrapper<HistoryTop100> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.in("ballNumber", candidateBalls)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber"); // 点系数相同时按球号升序
|
||
|
||
List<HistoryTop100> top100List = historyTop100Mapper.selectList(queryWrapper);
|
||
|
||
if (top100List.isEmpty()) {
|
||
log.warn("候选球号{}在history_top_100表中未找到数据，按球号升序返回", candidateBalls);
|
||
Collections.sort(candidateBalls);
|
||
return new FilteringDetailResult(candidateBalls.subList(0, Math.min(selectCount, candidateBalls.size())), "");
|
||
}
|
||
|
||
// 按点系数分组
|
||
Map<Double, List<Integer>> pointCoefficientGroups = new LinkedHashMap<>();
|
||
for (HistoryTop100 item : top100List) {
|
||
Double pointCoefficient = item.getPointCoefficient();
|
||
Integer ballNumber = item.getBallNumber();
|
||
pointCoefficientGroups.computeIfAbsent(pointCoefficient, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.info("history_top_100表点系数分组：{}", pointCoefficientGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
StringBuilder detailInfo = new StringBuilder();
|
||
|
||
// 先记录所有球号的排位详细信息
|
||
for (Map.Entry<Double, List<Integer>> group : pointCoefficientGroups.entrySet()) {
|
||
Double pointCoefficient = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
Collections.sort(balls); // 按球号升序排序
|
||
|
||
// 记录详细信息（显示所有参与筛选的球号）
|
||
if (detailInfo.length() > 0) detailInfo.append("，");
|
||
detailInfo.append(formatBallNumbers(balls)).append("（排位").append(String.format("%.2f", pointCoefficient)).append("）");
|
||
}
|
||
|
||
// 再按点系数从高到低筛选球号
|
||
for (Map.Entry<Double, List<Integer>> group : pointCoefficientGroups.entrySet()) {
|
||
Double pointCoefficient = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
log.info("点系数{}的球号：{}", pointCoefficient, balls);
|
||
|
||
// 检查加入这组球号后是否会超过selectCount个
|
||
if (result.size() + balls.size() <= selectCount) {
|
||
// 不会超过，直接添加所有球号（按球号升序排序）
|
||
Collections.sort(balls);
|
||
result.addAll(balls);
|
||
log.info("直接添加{}个球号，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过，返回所有相同点系数的球号，让下一层筛选来处理
|
||
result.addAll(balls);
|
||
log.info("点系数相同，返回所有相同点系数的球号：{}，让下一层筛选处理", balls);
|
||
break;
|
||
}
|
||
|
||
// 如果已经有selectCount个，结束
|
||
if (result.size() >= selectCount) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 处理不在history_top_100表中的球号
|
||
List<Integer> notInTop100 = new ArrayList<>(candidateBalls);
|
||
List<Integer> inTop100 = new ArrayList<>();
|
||
for (HistoryTop100 item : top100List) {
|
||
inTop100.add(item.getBallNumber());
|
||
}
|
||
notInTop100.removeAll(inTop100);
|
||
|
||
// 先记录所有不在表中的球号的详细信息
|
||
if (!notInTop100.isEmpty()) {
|
||
Collections.sort(notInTop100);
|
||
if (detailInfo.length() > 0) detailInfo.append("，");
|
||
detailInfo.append(formatBallNumbers(notInTop100)).append("（无排位）");
|
||
}
|
||
|
||
// 再选择需要的球号加入结果
|
||
if (!notInTop100.isEmpty() && result.size() < selectCount) {
|
||
int remainingSlots = selectCount - result.size();
|
||
int addCount = Math.min(remainingSlots, notInTop100.size());
|
||
result.addAll(notInTop100.subList(0, addCount));
|
||
|
||
log.info("添加不在history_top_100表中的{}个球号：{}", addCount, notInTop100.subList(0, addCount));
|
||
}
|
||
|
||
log.info("history_top_100表筛选结果：{}", result);
|
||
return new FilteringDetailResult(result, detailInfo.toString());
|
||
}
|
||
|
||
/**
|
||
* 根据history_top表的点系数筛选球号
|
||
* 当点系数相同时，返回所有相同点系数的球号，让下一层筛选来处理
|
||
*/
|
||
private List<Integer> selectBallsByHistoryTopPointCoefficient(List<Integer> candidateBalls, int selectCount) {
|
||
log.info("使用history_top表点系数筛选球号，候选：{}，需要选择：{}", candidateBalls, selectCount);
|
||
|
||
// 查询这些球号在history_top表中的点系数
|
||
QueryWrapper<HistoryTop> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.in("ballNumber", candidateBalls)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber"); // 点系数相同时按球号升序
|
||
|
||
List<HistoryTop> historyTopList = historyTopMapper.selectList(queryWrapper);
|
||
|
||
if (historyTopList.isEmpty()) {
|
||
log.warn("候选球号{}在history_top表中未找到数据，按球号升序返回", candidateBalls);
|
||
Collections.sort(candidateBalls);
|
||
return candidateBalls.subList(0, Math.min(selectCount, candidateBalls.size()));
|
||
}
|
||
|
||
// 按点系数分组
|
||
Map<Double, List<Integer>> pointCoefficientGroups = new LinkedHashMap<>();
|
||
for (HistoryTop item : historyTopList) {
|
||
Double pointCoefficient = item.getPointCoefficient();
|
||
Integer ballNumber = item.getBallNumber();
|
||
pointCoefficientGroups.computeIfAbsent(pointCoefficient, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.info("history_top表点系数分组：{}", pointCoefficientGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
// 按点系数从高到低处理
|
||
for (Map.Entry<Double, List<Integer>> group : pointCoefficientGroups.entrySet()) {
|
||
Double pointCoefficient = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
log.info("点系数{}的球号：{}", pointCoefficient, balls);
|
||
|
||
// 检查加入这组球号后是否会超过selectCount个
|
||
if (result.size() + balls.size() <= selectCount) {
|
||
// 不会超过，直接添加所有球号（按球号升序排序）
|
||
Collections.sort(balls);
|
||
result.addAll(balls);
|
||
log.info("直接添加{}个球号，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过，返回所有相同点系数的球号，让下一层筛选来处理
|
||
result.addAll(balls);
|
||
log.info("点系数相同，返回所有相同点系数的球号：{}，让下一层筛选处理", balls);
|
||
break;
|
||
}
|
||
|
||
// 如果已经有selectCount个，结束
|
||
if (result.size() >= selectCount) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 处理不在history_top表中的球号
|
||
List<Integer> notInHistoryTop = new ArrayList<>(candidateBalls);
|
||
notInHistoryTop.removeAll(result);
|
||
if (!notInHistoryTop.isEmpty() && result.size() < selectCount) {
|
||
int remainingSlots = selectCount - result.size();
|
||
Collections.sort(notInHistoryTop);
|
||
int addCount = Math.min(remainingSlots, notInHistoryTop.size());
|
||
result.addAll(notInHistoryTop.subList(0, addCount));
|
||
log.info("添加不在history_top表中的{}个球号：{}", addCount, notInHistoryTop.subList(0, addCount));
|
||
}
|
||
|
||
log.info("history_top表筛选结果：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 根据history_top表的点系数筛选球号（包含详细信息）
|
||
* @param candidateBalls 候选球号列表
|
||
* @param selectCount 需要选择的数量
|
||
* @return 筛选结果和详细信息
|
||
*/
|
||
private FilteringDetailResult selectBallsByHistoryTopPointCoefficientWithDetails(List<Integer> candidateBalls, int selectCount) {
|
||
log.info("使用history_top表点系数筛选球号，候选：{}，需要选择：{}", candidateBalls, selectCount);
|
||
|
||
// 查询这些球号在history_top表中的点系数
|
||
QueryWrapper<HistoryTop> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.in("ballNumber", candidateBalls)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber"); // 点系数相同时按球号升序
|
||
|
||
List<HistoryTop> historyTopList = historyTopMapper.selectList(queryWrapper);
|
||
|
||
if (historyTopList.isEmpty()) {
|
||
log.warn("候选球号{}在history_top表中未找到数据，按球号升序返回", candidateBalls);
|
||
Collections.sort(candidateBalls);
|
||
return new FilteringDetailResult(candidateBalls.subList(0, Math.min(selectCount, candidateBalls.size())), "");
|
||
}
|
||
|
||
// 按点系数分组
|
||
Map<Double, List<Integer>> pointCoefficientGroups = new LinkedHashMap<>();
|
||
for (HistoryTop item : historyTopList) {
|
||
Double pointCoefficient = item.getPointCoefficient();
|
||
Integer ballNumber = item.getBallNumber();
|
||
pointCoefficientGroups.computeIfAbsent(pointCoefficient, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.info("history_top表点系数分组：{}", pointCoefficientGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
StringBuilder detailInfo = new StringBuilder();
|
||
|
||
// 先记录所有球号的点系数详细信息
|
||
for (Map.Entry<Double, List<Integer>> group : pointCoefficientGroups.entrySet()) {
|
||
Double pointCoefficient = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
Collections.sort(balls); // 按球号升序排序
|
||
|
||
// 记录详细信息（显示所有参与筛选的球号）
|
||
if (detailInfo.length() > 0) detailInfo.append("，");
|
||
detailInfo.append(formatBallNumbers(balls)).append("（点系数").append(String.format("%.2f", pointCoefficient)).append("）");
|
||
}
|
||
|
||
// 处理不在history_top表中的球号的详细信息
|
||
List<Integer> notInHistoryTop = new ArrayList<>(candidateBalls);
|
||
List<Integer> inHistoryTop = new ArrayList<>();
|
||
for (HistoryTop item : historyTopList) {
|
||
inHistoryTop.add(item.getBallNumber());
|
||
}
|
||
notInHistoryTop.removeAll(inHistoryTop);
|
||
|
||
// 先记录所有不在表中的球号的详细信息
|
||
if (!notInHistoryTop.isEmpty()) {
|
||
Collections.sort(notInHistoryTop);
|
||
if (detailInfo.length() > 0) detailInfo.append("，");
|
||
detailInfo.append(formatBallNumbers(notInHistoryTop)).append("（无历史数据）");
|
||
}
|
||
|
||
// 再按点系数从高到低筛选球号
|
||
for (Map.Entry<Double, List<Integer>> group : pointCoefficientGroups.entrySet()) {
|
||
Double pointCoefficient = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
log.info("点系数{}的球号：{}", pointCoefficient, balls);
|
||
|
||
// 检查加入这组球号后是否会超过selectCount个
|
||
if (result.size() + balls.size() <= selectCount) {
|
||
// 不会超过，直接添加所有球号（按球号升序排序）
|
||
Collections.sort(balls);
|
||
result.addAll(balls);
|
||
log.info("直接添加{}个球号，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过，返回所有相同点系数的球号，让下一层筛选来处理
|
||
result.addAll(balls);
|
||
log.info("点系数相同，返回所有相同点系数的球号：{}，让下一层筛选处理", balls);
|
||
break;
|
||
}
|
||
|
||
// 如果已经有selectCount个，结束
|
||
if (result.size() >= selectCount) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 再选择需要的不在表中的球号加入结果
|
||
if (!notInHistoryTop.isEmpty() && result.size() < selectCount) {
|
||
int remainingSlots = selectCount - result.size();
|
||
int addCount = Math.min(remainingSlots, notInHistoryTop.size());
|
||
result.addAll(notInHistoryTop.subList(0, addCount));
|
||
|
||
log.info("添加不在history_top表中的{}个球号：{}", addCount, notInHistoryTop.subList(0, addCount));
|
||
}
|
||
|
||
log.info("history_top表筛选结果：{}", result);
|
||
return new FilteringDetailResult(result, detailInfo.toString());
|
||
}
|
||
|
||
/**
|
||
* 随机选择球号
|
||
* @param candidateBalls 候选球号列表
|
||
* @param selectCount 需要选择的数量
|
||
* @return 随机选择的球号列表
|
||
*/
|
||
private List<Integer> selectBallsRandomly(List<Integer> candidateBalls, int selectCount) {
|
||
log.info("随机选择球号，候选：{}，需要选择：{}", candidateBalls, selectCount);
|
||
|
||
if (candidateBalls.size() <= selectCount) {
|
||
log.info("候选球号数量不超过需要选择的数量，直接返回所有候选球号");
|
||
return new ArrayList<>(candidateBalls);
|
||
}
|
||
|
||
// 创建候选球号的副本并打乱顺序
|
||
List<Integer> shuffledBalls = new ArrayList<>(candidateBalls);
|
||
Collections.shuffle(shuffledBalls, new Random(System.currentTimeMillis()));
|
||
|
||
// 选择前selectCount个
|
||
List<Integer> result = shuffledBalls.subList(0, selectCount);
|
||
|
||
// 按球号升序排序结果
|
||
Collections.sort(result);
|
||
|
||
log.info("随机选择结果：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 仅在一组同T7系数的并列候选中，按“先100期再历史最后随机”的规则补齐目标数量。
|
||
* 行为符合“100期先拿能拿的直接加入；不足时再从剩余里用history_top补齐；仍不足再随机补齐”。
|
||
*/
|
||
private List<Integer> selectByTop100ThenHistoryTop(List<Integer> candidateBalls, int needCount) {
|
||
if (candidateBalls == null || candidateBalls.isEmpty() || needCount <= 0) {
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
// 在同T7系数的候选中，先用100期逐组加入；若某组加入会超出，则该组整体作为未决集合，交给下一层(history_top)
|
||
QueryWrapper<HistoryTop100> query = new QueryWrapper<>();
|
||
query.in("ballNumber", candidateBalls)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber");
|
||
List<HistoryTop100> top100List = historyTop100Mapper.selectList(query);
|
||
|
||
List<Integer> selectedByTop100 = new ArrayList<>();
|
||
List<Integer> undecidedGroup = new ArrayList<>();
|
||
|
||
if (top100List != null && !top100List.isEmpty()) {
|
||
// 分组（保持顺序）
|
||
Map<Double, List<Integer>> groups = new LinkedHashMap<>();
|
||
for (HistoryTop100 item : top100List) {
|
||
groups.computeIfAbsent(item.getPointCoefficient(), k -> new ArrayList<>())
|
||
.add(item.getBallNumber());
|
||
}
|
||
for (Map.Entry<Double, List<Integer>> entry : groups.entrySet()) {
|
||
List<Integer> groupBalls = entry.getValue();
|
||
if (selectedByTop100.size() + groupBalls.size() <= needCount) {
|
||
selectedByTop100.addAll(groupBalls);
|
||
} else {
|
||
undecidedGroup.addAll(groupBalls);
|
||
break; // 只把“超出的那一组”交给下一层
|
||
}
|
||
if (selectedByTop100.size() == needCount) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (selectedByTop100.size() >= needCount) {
|
||
return selectedByTop100.subList(0, needCount);
|
||
}
|
||
|
||
// 还有缺口：仅对未决集合使用 history_top；若100期没有数据，则把所有候选作为未决集合
|
||
int stillNeed = needCount - selectedByTop100.size();
|
||
List<Integer> forHistoryTop;
|
||
if (!undecidedGroup.isEmpty()) {
|
||
forHistoryTop = new ArrayList<>(undecidedGroup);
|
||
} else if (top100List == null || top100List.isEmpty()) {
|
||
// 100期没有任何记录，则全部交给历史表
|
||
forHistoryTop = new ArrayList<>(candidateBalls);
|
||
} else {
|
||
// 100期记录不足但没有触发未决组（例如所有组总和仍小于needCount），则用剩余候选补齐
|
||
forHistoryTop = new ArrayList<>(candidateBalls);
|
||
forHistoryTop.removeAll(selectedByTop100);
|
||
}
|
||
|
||
List<Integer> byTop = forHistoryTop.isEmpty() ? new ArrayList<>()
|
||
: selectBallsByHistoryTopPointCoefficient(forHistoryTop, stillNeed);
|
||
|
||
List<Integer> collected = new ArrayList<>();
|
||
collected.addAll(selectedByTop100);
|
||
if (!byTop.isEmpty()) {
|
||
if (byTop.size() > stillNeed) {
|
||
byTop = byTop.subList(0, stillNeed);
|
||
}
|
||
collected.addAll(byTop);
|
||
}
|
||
|
||
// 仍不足则在“未被选中的集合”中随机补齐
|
||
int gap = needCount - collected.size();
|
||
if (gap > 0) {
|
||
List<Integer> left = new ArrayList<>(candidateBalls);
|
||
left.removeAll(collected);
|
||
if (!left.isEmpty()) {
|
||
List<Integer> rnd = selectBallsRandomly(left, Math.min(gap, left.size()));
|
||
collected.addAll(rnd);
|
||
}
|
||
}
|
||
|
||
return collected;
|
||
}
|
||
|
||
/**
|
||
* 蓝球分析算法主方法
|
||
* @param level 高位/中位/低位标识 (H/M/L)
|
||
* @param predictedRedBalls 6个预测的红球号码
|
||
* @param predictedBlueBalls 2个预测的蓝球号码
|
||
* @param lastRedBalls 6个上期红球号码
|
||
* @param lastBlueBall 1个上期蓝球号码
|
||
* @return 分析结果：出现频率最高的前4个蓝球号码
|
||
*/
|
||
public List<Integer> blueBallAnalysis(String level, List<Integer> predictedRedBalls,
|
||
List<Integer> predictedBlueBalls, List<Integer> lastRedBalls,
|
||
Integer lastBlueBall) {
|
||
log.info("开始蓝球分析算法，级别：{}，预测红球：{}，预测蓝球：{}，上期红球：{}，上期蓝球：{}",
|
||
level, predictedRedBalls, predictedBlueBalls, lastRedBalls, lastBlueBall);
|
||
|
||
// 验证输入参数
|
||
validateBlueBallAnalysisParams(level, predictedRedBalls, predictedBlueBalls, lastRedBalls, lastBlueBall);
|
||
|
||
List<Integer> allNumbers = new ArrayList<>();
|
||
|
||
// 第一步：处理上期6个红球，每个红球从T6表获取12个蓝球号码
|
||
log.info("第一步：处理上期6个红球，从T6表获取蓝球号码");
|
||
for (int i = 0; i < lastRedBalls.size(); i++) {
|
||
Integer redBall = lastRedBalls.get(i);
|
||
log.info("处理第{}个上期红球：{}", i + 1, redBall);
|
||
|
||
List<Integer> ballNumbers = getTop12FromT6(redBall);
|
||
allNumbers.addAll(ballNumbers);
|
||
|
||
log.info("上期红球{}从T6表获取到{}个蓝球号码：{}", redBall, ballNumbers.size(), ballNumbers);
|
||
}
|
||
|
||
// 第二步：处理预测的6个红球，每个红球从T8表获取5个蓝球号码
|
||
log.info("第二步：处理预测的6个红球，从T8表获取蓝球号码，使用{}级别算法", level);
|
||
for (int i = 0; i < predictedRedBalls.size(); i++) {
|
||
Integer redBall = predictedRedBalls.get(i);
|
||
log.info("处理第{}个预测红球：{}", i + 1, redBall);
|
||
|
||
List<Integer> ballNumbers = getSimpleTop5FromT8ByLevel(redBall, level);
|
||
allNumbers.addAll(ballNumbers);
|
||
|
||
// 额外记录这5个蓝球的面系数（与 fallowBallAnalysis 第一步风格一致）
|
||
List<BallWithCoefficient> t8Coeffs = getT8CoefficientsFor(redBall, ballNumbers);
|
||
log.info("=== 预测红球{} 对应T8面系数（共{}个） ===", redBall, t8Coeffs.size());
|
||
for (int k = 0; k < t8Coeffs.size(); k++) {
|
||
log.info("第{}个：{}", k + 1, t8Coeffs.get(k).toString());
|
||
}
|
||
log.info("=== 记录结束 ===");
|
||
|
||
log.info("预测红球{}从T8表获取到{}个蓝球号码：{}", redBall, ballNumbers.size(), ballNumbers);
|
||
}
|
||
|
||
// 第三步：从blue_history_top_100获取前2个蓝球号码
|
||
log.info("第三步：从blue_history_top_100获取前2个蓝球号码");
|
||
List<Integer> top2BlueNumbers = getTop2FromBlueHistoryTop100();
|
||
allNumbers.addAll(top2BlueNumbers);
|
||
log.info("从blue_history_top_100获取到{}个蓝球号码：{}", top2BlueNumbers.size(), top2BlueNumbers);
|
||
|
||
// 第四步：添加预测的2个蓝球号码
|
||
log.info("第四步：添加预测的2个蓝球号码：{}", predictedBlueBalls);
|
||
allNumbers.addAll(predictedBlueBalls);
|
||
|
||
// 第五步：用上期蓝球从T5表获取12个蓝球号码（含毛边处理）
|
||
log.info("第五步：用上期蓝球{}从T5表获取12个蓝球号码", lastBlueBall);
|
||
List<Integer> blueNumbers = getTop12FromT5(lastBlueBall);
|
||
allNumbers.addAll(blueNumbers);
|
||
log.info("蓝球{}获取到{}个数字：{}", lastBlueBall, blueNumbers.size(), blueNumbers);
|
||
|
||
log.info("总共收集到{}个蓝球号码", allNumbers.size());
|
||
|
||
// 汇总第二步收集的T8面系数，供第六步同频二次筛选使用
|
||
List<BallWithCoefficient> step2BlueT8Coefficients = new ArrayList<>();
|
||
// 由于上面的循环内使用了临时变量 t8Coeffs，这里重新按预测红球聚合一次，确保完整
|
||
for (Integer redBall : predictedRedBalls) {
|
||
List<Integer> tmpBalls = getSimpleTop5FromT8ByLevel(redBall, level);
|
||
step2BlueT8Coefficients.addAll(getT8CoefficientsFor(redBall, tmpBalls));
|
||
}
|
||
|
||
// 第六步：统计频率并获取前4个（同频时使用第2步收集的T8系数求和作为第一级筛选）
|
||
List<Integer> result = getSimpleTop4ByFrequency(allNumbers, step2BlueT8Coefficients);
|
||
|
||
log.info("蓝球分析算法完成，结果：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 蓝球分析算法主方法（带筛选过程说明）
|
||
* @param level 高位/中位/低位标识 (H/M/L)
|
||
* @param predictedRedBalls 6个预测的红球号码
|
||
* @param predictedBlueBalls 2个预测的蓝球号码
|
||
* @param lastRedBalls 6个上期红球号码
|
||
* @param lastBlueBall 1个上期蓝球号码
|
||
* @return 分析结果：出现频率最高的前4个蓝球号码及筛选过程说明
|
||
*/
|
||
public BlueBallAnalysisResultVO blueBallAnalysisWithProcess(String level, List<Integer> predictedRedBalls,
|
||
List<Integer> predictedBlueBalls, List<Integer> lastRedBalls,
|
||
Integer lastBlueBall) {
|
||
log.info("开始蓝球分析算法（带过程说明），级别：{}，预测红球：{}，预测蓝球：{}，上期红球：{}，上期蓝球：{}",
|
||
level, predictedRedBalls, predictedBlueBalls, lastRedBalls, lastBlueBall);
|
||
|
||
// 验证输入参数
|
||
validateBlueBallAnalysisParams(level, predictedRedBalls, predictedBlueBalls, lastRedBalls, lastBlueBall);
|
||
|
||
List<Integer> allNumbers = new ArrayList<>();
|
||
|
||
// 第一步：处理上期6个红球，每个红球从T6表获取12个蓝球号码
|
||
log.info("第一步：处理上期6个红球，从T6表获取蓝球号码");
|
||
for (int i = 0; i < lastRedBalls.size(); i++) {
|
||
Integer redBall = lastRedBalls.get(i);
|
||
log.info("处理第{}个上期红球：{}", i + 1, redBall);
|
||
|
||
List<Integer> ballNumbers = getTop12FromT6(redBall);
|
||
allNumbers.addAll(ballNumbers);
|
||
|
||
log.info("上期红球{}从T6表获取到{}个蓝球号码：{}", redBall, ballNumbers.size(), ballNumbers);
|
||
}
|
||
|
||
// 第二步：处理预测的6个红球，每个红球从T8表获取5个蓝球号码
|
||
log.info("第二步：处理预测的6个红球，从T8表获取蓝球号码，使用{}级别算法", level);
|
||
for (int i = 0; i < predictedRedBalls.size(); i++) {
|
||
Integer redBall = predictedRedBalls.get(i);
|
||
log.info("处理第{}个预测红球：{}", i + 1, redBall);
|
||
|
||
List<Integer> ballNumbers = getSimpleTop5FromT8ByLevel(redBall, level);
|
||
allNumbers.addAll(ballNumbers);
|
||
|
||
// 额外记录这5个蓝球的面系数（与 fallowBallAnalysis 第一步风格一致）
|
||
List<BallWithCoefficient> t8Coeffs = getT8CoefficientsFor(redBall, ballNumbers);
|
||
log.info("=== 预测红球{} 对应T8面系数（共{}个） ===", redBall, t8Coeffs.size());
|
||
for (int k = 0; k < t8Coeffs.size(); k++) {
|
||
log.info("第{}个：{}", k + 1, t8Coeffs.get(k).toString());
|
||
}
|
||
log.info("=== 记录结束 ===");
|
||
|
||
log.info("预测红球{}从T8表获取到{}个蓝球号码：{}", redBall, ballNumbers.size(), ballNumbers);
|
||
}
|
||
|
||
// 第三步：从blue_history_top_100获取前2个蓝球号码
|
||
log.info("第三步：从blue_history_top_100获取前2个蓝球号码");
|
||
List<Integer> top2BlueNumbers = getTop2FromBlueHistoryTop100();
|
||
allNumbers.addAll(top2BlueNumbers);
|
||
log.info("从blue_history_top_100获取到{}个蓝球号码：{}", top2BlueNumbers.size(), top2BlueNumbers);
|
||
|
||
// 第四步：添加预测的2个蓝球号码
|
||
log.info("第四步：添加预测的2个蓝球号码：{}", predictedBlueBalls);
|
||
allNumbers.addAll(predictedBlueBalls);
|
||
|
||
// 第五步：用上期蓝球从T5表获取12个蓝球号码（含毛边处理）
|
||
log.info("第五步：用上期蓝球{}从T5表获取12个蓝球号码", lastBlueBall);
|
||
List<Integer> blueNumbers = getTop12FromT5(lastBlueBall);
|
||
allNumbers.addAll(blueNumbers);
|
||
log.info("蓝球{}获取到{}个数字：{}", lastBlueBall, blueNumbers.size(), blueNumbers);
|
||
|
||
log.info("总共收集到{}个蓝球号码", allNumbers.size());
|
||
|
||
// 汇总第二步收集的T8面系数，供第六步同频二次筛选使用
|
||
List<BallWithCoefficient> step2BlueT8Coefficients = new ArrayList<>();
|
||
// 由于上面的循环内使用了临时变量 t8Coeffs，这里重新按预测红球聚合一次，确保完整
|
||
for (Integer redBall : predictedRedBalls) {
|
||
List<Integer> tmpBalls = getSimpleTop5FromT8ByLevel(redBall, level);
|
||
step2BlueT8Coefficients.addAll(getT8CoefficientsFor(redBall, tmpBalls));
|
||
}
|
||
|
||
// 第六步：统计频率并获取前4个（带筛选过程说明）
|
||
BlueBallAnalysisResultVO result = getSimpleTop4ByFrequencyWithProcess(allNumbers, step2BlueT8Coefficients);
|
||
|
||
log.info("蓝球分析算法（带过程说明）完成，结果：{}，过程说明：{}", result.getResult(), result.getFilteringProcess());
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 验证蓝球分析算法的输入参数
|
||
*/
|
||
private void validateBlueBallAnalysisParams(String level, List<Integer> predictedRedBalls,
|
||
List<Integer> predictedBlueBalls, List<Integer> lastRedBalls,
|
||
Integer lastBlueBall) {
|
||
// 验证级别
|
||
if (!Arrays.asList("H", "M", "L").contains(level)) {
|
||
throw new IllegalArgumentException("级别必须为H、M或L");
|
||
}
|
||
|
||
// 验证预测红球
|
||
if (predictedRedBalls == null || predictedRedBalls.size() != 6) {
|
||
throw new IllegalArgumentException("预测红球数量必须为6个");
|
||
}
|
||
for (Integer ball : predictedRedBalls) {
|
||
if (ball == null || ball < 1 || ball > 33) {
|
||
throw new IllegalArgumentException("预测红球号码必须在1-33范围内，实际：" + ball);
|
||
}
|
||
}
|
||
if (predictedRedBalls.stream().distinct().count() != predictedRedBalls.size()) {
|
||
throw new IllegalArgumentException("预测红球号码不能重复");
|
||
}
|
||
|
||
// 验证预测蓝球
|
||
if (predictedBlueBalls == null || predictedBlueBalls.size() != 2) {
|
||
throw new IllegalArgumentException("预测蓝球数量必须为2个");
|
||
}
|
||
for (Integer ball : predictedBlueBalls) {
|
||
if (ball == null || ball < 1 || ball > 16) {
|
||
throw new IllegalArgumentException("预测蓝球号码必须在1-16范围内，实际：" + ball);
|
||
}
|
||
}
|
||
if (predictedBlueBalls.stream().distinct().count() != predictedBlueBalls.size()) {
|
||
throw new IllegalArgumentException("预测蓝球号码不能重复");
|
||
}
|
||
|
||
// 验证上期红球
|
||
if (lastRedBalls == null || lastRedBalls.size() != 6) {
|
||
throw new IllegalArgumentException("上期红球数量必须为6个");
|
||
}
|
||
for (Integer ball : lastRedBalls) {
|
||
if (ball == null || ball < 1 || ball > 33) {
|
||
throw new IllegalArgumentException("上期红球号码必须在1-33范围内，实际：" + ball);
|
||
}
|
||
}
|
||
if (lastRedBalls.stream().distinct().count() != lastRedBalls.size()) {
|
||
throw new IllegalArgumentException("上期红球号码不能重复");
|
||
}
|
||
|
||
// 验证上期蓝球
|
||
if (lastBlueBall == null || lastBlueBall < 1 || lastBlueBall > 16) {
|
||
throw new IllegalArgumentException("上期蓝球号码必须在1-16范围内，实际：" + lastBlueBall);
|
||
}
|
||
|
||
log.debug("蓝球分析算法参数验证通过");
|
||
}
|
||
|
||
/**
|
||
* 从T6表获取指定红球对应的12个蓝球号码（线系数最大的12个）
|
||
* @param masterBallNumber 主球号（红球）
|
||
* @return 12个蓝球号码列表
|
||
*/
|
||
private List<Integer> getTop12FromT6(Integer masterBallNumber) {
|
||
log.debug("从T6表查询主球{}的线系数数据", masterBallNumber);
|
||
|
||
// 查询指定主球的所有数据，按线系数降序排列
|
||
QueryWrapper<T6> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", masterBallNumber)
|
||
.orderByDesc("lineCoefficient")
|
||
.orderByAsc("slaveBallNumber"); // 线系数相同时按从球号升序
|
||
|
||
List<T6> t6List = t6Mapper.selectList(queryWrapper);
|
||
|
||
if (t6List.isEmpty()) {
|
||
log.warn("T6表中主球{}没有数据", masterBallNumber);
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
if (t6List.size() < 12) {
|
||
log.warn("T6表数据不足12条，实际{}条", t6List.size());
|
||
return t6List.stream().map(T6::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 获取前11个
|
||
List<Integer> result = new ArrayList<>();
|
||
for (int i = 0; i < 11; i++) {
|
||
result.add(t6List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理第12个位置：检查是否有相同的线系数
|
||
Double targetCoefficient = t6List.get(11).getLineCoefficient();
|
||
List<T6> candidatesFor12th = new ArrayList<>();
|
||
|
||
// 找出所有线系数等于第12个位置线系数的记录
|
||
for (int i = 11; i < t6List.size(); i++) {
|
||
if (t6List.get(i).getLineCoefficient().equals(targetCoefficient)) {
|
||
candidatesFor12th.add(t6List.get(i));
|
||
} else {
|
||
break; // 线系数不同，停止查找
|
||
}
|
||
}
|
||
|
||
if (candidatesFor12th.size() == 1) {
|
||
// 只有一个候选，直接添加
|
||
result.add(candidatesFor12th.get(0).getSlaveBallNumber());
|
||
} else {
|
||
// 有多个候选，通过blue_history_top_100表的点系数排序
|
||
log.debug("第12位有{}个相同线系数的候选：{}", candidatesFor12th.size(),
|
||
candidatesFor12th.stream().map(T6::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallFromBlueHistoryTop100(
|
||
candidatesFor12th.stream().map(T6::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.add(bestBall);
|
||
}
|
||
|
||
log.debug("T6表主球{}最终选择的{}个从球：{}", masterBallNumber, result.size(), result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 从blue_history_top_100表中选择点系数最高的球号
|
||
* @param candidates 候选球号列表
|
||
* @return 点系数最高的球号
|
||
*/
|
||
private Integer selectBestBallFromBlueHistoryTop100(List<Integer> candidates) {
|
||
log.debug("从blue_history_top_100表中选择最佳球号，候选：{}", candidates);
|
||
|
||
if (candidates.isEmpty()) {
|
||
throw new IllegalArgumentException("候选球号列表不能为空");
|
||
}
|
||
|
||
if (candidates.size() == 1) {
|
||
return candidates.get(0);
|
||
}
|
||
|
||
// 查询这些球号在blue_history_top_100表中的点系数
|
||
QueryWrapper<BlueHistoryTop100> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.in("ballNumber", candidates)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber"); // 点系数相同时按球号升序
|
||
|
||
List<BlueHistoryTop100> top100List = blueHistoryTop100Mapper.selectList(queryWrapper);
|
||
|
||
if (top100List.isEmpty()) {
|
||
log.warn("候选球号{}在blue_history_top_100表中未找到数据，返回最小球号", candidates);
|
||
return Collections.min(candidates);
|
||
}
|
||
|
||
// 返回点系数最高的球号
|
||
Integer bestBall = top100List.get(0).getBallNumber();
|
||
log.debug("选择的最佳球号：{}，点系数：{}", bestBall, top100List.get(0).getPointCoefficient());
|
||
|
||
return bestBall;
|
||
}
|
||
|
||
/**
|
||
* 蓝球多级回退选择：先用 blue_history_top_100，再用 blue_history_top，最后随机
|
||
*/
|
||
private List<Integer> selectBlueBallsWithFallback(List<Integer> candidates, int needCount) {
|
||
if (candidates == null || candidates.isEmpty() || needCount <= 0) {
|
||
return new ArrayList<>();
|
||
}
|
||
if (candidates.size() <= needCount) {
|
||
return new ArrayList<>(candidates);
|
||
}
|
||
|
||
// 先用 blue_history_top_100
|
||
QueryWrapper<BlueHistoryTop100> top100Query = new QueryWrapper<>();
|
||
top100Query.in("ballNumber", candidates)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber");
|
||
List<BlueHistoryTop100> top100List = blueHistoryTop100Mapper.selectList(top100Query);
|
||
|
||
if (top100List != null && top100List.size() >= needCount) {
|
||
return top100List.subList(0, needCount).stream()
|
||
.map(BlueHistoryTop100::getBallNumber)
|
||
.collect(Collectors.toList());
|
||
}
|
||
|
||
// 不足，继续用 blue_history_top
|
||
List<Integer> selectedBy100 = top100List == null ? new ArrayList<>()
|
||
: top100List.stream().map(BlueHistoryTop100::getBallNumber).collect(Collectors.toList());
|
||
List<Integer> remaining = new ArrayList<>(candidates);
|
||
remaining.removeAll(selectedBy100);
|
||
int stillNeed = needCount - selectedBy100.size();
|
||
|
||
QueryWrapper<BlueHistoryTop> topQuery = new QueryWrapper<>();
|
||
topQuery.in("ballNumber", remaining)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber");
|
||
List<BlueHistoryTop> topList = blueHistoryTopMapper.selectList(topQuery);
|
||
|
||
List<Integer> selectedByTop = topList == null ? new ArrayList<>()
|
||
: topList.stream().limit(stillNeed).map(BlueHistoryTop::getBallNumber).collect(Collectors.toList());
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
result.addAll(selectedBy100);
|
||
result.addAll(selectedByTop);
|
||
|
||
// 仍不足则随机补齐
|
||
int gap = needCount - result.size();
|
||
if (gap > 0) {
|
||
List<Integer> left = new ArrayList<>(candidates);
|
||
left.removeAll(result);
|
||
if (!left.isEmpty()) {
|
||
Collections.shuffle(left);
|
||
result.addAll(left.subList(0, Math.min(gap, left.size())));
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 从T8表获取指定红球对应的5个蓝球号码（简化版本）
|
||
* @param masterBallNumber 主球号（红球）
|
||
* @param level 级别：H-高位，M-中位，L-低位
|
||
* @return 5个蓝球号码列表
|
||
*/
|
||
private List<Integer> getSimpleTop5FromT8ByLevel(Integer masterBallNumber, String level) {
|
||
log.debug("从T8表查询主球{}的面系数数据，级别：{}", masterBallNumber, level);
|
||
|
||
// 查询指定主球的所有数据，按面系数降序排列
|
||
QueryWrapper<T8> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", masterBallNumber)
|
||
.orderByDesc("faceCoefficient")
|
||
.orderByAsc("slaveBallNumber"); // 面系数相同时按从球号升序
|
||
|
||
List<T8> t8List = t8Mapper.selectList(queryWrapper);
|
||
|
||
if (t8List.isEmpty()) {
|
||
log.warn("T8表中主球{}没有数据", masterBallNumber);
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
int size = t8List.size();
|
||
|
||
switch (level) {
|
||
case "H": {
|
||
// 高位：系数最大值向下5个；第5个位置毛边：向下查找相同面系数，使用blue_history_top_100比较
|
||
if (size < 5) {
|
||
log.warn("T8表数据不足5条，实际{}条", size);
|
||
return t8List.stream().map(T8::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 前4个直接取
|
||
for (int i = 0; i < 4; i++) {
|
||
result.add(t8List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理第5个位置的毛边
|
||
Double fifthCoeff = t8List.get(4).getFaceCoefficient();
|
||
List<T8> candidatesFor5th = new ArrayList<>();
|
||
candidatesFor5th.add(t8List.get(4));
|
||
for (int i = 5; i < size; i++) {
|
||
if (t8List.get(i).getFaceCoefficient().equals(fifthCoeff)) {
|
||
candidatesFor5th.add(t8List.get(i));
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (candidatesFor5th.size() == 1) {
|
||
result.add(candidatesFor5th.get(0).getSlaveBallNumber());
|
||
} else {
|
||
log.debug("高位第5位有{}个相同面系数的候选：{}", candidatesFor5th.size(),
|
||
candidatesFor5th.stream().map(T8::getSlaveBallNumber).collect(Collectors.toList()));
|
||
Integer bestBall = selectBestBallFromBlueHistoryTop100(
|
||
candidatesFor5th.stream().map(T8::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.add(bestBall);
|
||
}
|
||
break;
|
||
}
|
||
case "M": {
|
||
// 中位：取比平均值大的、且最近的一个为中心，向上2个、向下2个，共5个；
|
||
// 上面两个的第一个(中心上方最近的)毛边向上查找；下面两个的第二个(更小的)毛边向下查找；均用blue_history_top_100比较
|
||
if (size < 5) {
|
||
log.warn("T8表数据不足5条，实际{}条", size);
|
||
return t8List.stream().map(T8::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
double avg = t8List.stream().mapToDouble(T8::getFaceCoefficient).average().orElse(0.0);
|
||
int avgIndex = -1;
|
||
double minDiff = Double.MAX_VALUE;
|
||
for (int i = 0; i < size; i++) {
|
||
double c = t8List.get(i).getFaceCoefficient();
|
||
if (c > avg) {
|
||
double diff = c - avg;
|
||
if (diff <= minDiff) { // 取最后一个最接近的
|
||
minDiff = diff;
|
||
avgIndex = i;
|
||
}
|
||
}
|
||
}
|
||
if (avgIndex == -1) {
|
||
avgIndex = 0;
|
||
}
|
||
|
||
int startIndex = Math.max(0, avgIndex - 2);
|
||
int endIndex = Math.min(size - 1, avgIndex + 2);
|
||
while (endIndex - startIndex + 1 < 5 && (startIndex > 0 || endIndex < size - 1)) {
|
||
if (startIndex > 0) startIndex--;
|
||
if (endIndex < size - 1 && endIndex - startIndex + 1 < 5) endIndex++;
|
||
}
|
||
|
||
for (int i = startIndex; i <= endIndex; i++) {
|
||
result.add(t8List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 上面两个中的第一个（系数更大的那个）：索引 startIndex（即 avgIndex-2）
|
||
int upFirstIndex = startIndex;
|
||
if (upFirstIndex >= 0) {
|
||
Double coeff = t8List.get(upFirstIndex).getFaceCoefficient();
|
||
List<T8> candidatesUp = new ArrayList<>();
|
||
// 包含窗口内的这个位置本身
|
||
candidatesUp.add(t8List.get(upFirstIndex));
|
||
// 只向上（窗口之外）查找相同面系数，避免与窗口内其它位置重复
|
||
for (int i = upFirstIndex - 1; i >= 0; i--) {
|
||
if (t8List.get(i).getFaceCoefficient().equals(coeff)) {
|
||
candidatesUp.add(t8List.get(i));
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
if (candidatesUp.size() > 1) {
|
||
log.debug("中位上方第一个位置存在{}个相同面系数候选：{}", candidatesUp.size(),
|
||
candidatesUp.stream().map(T8::getSlaveBallNumber).collect(Collectors.toList()));
|
||
Integer best = selectBestBallFromBlueHistoryTop100(
|
||
candidatesUp.stream().map(T8::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
// 替换窗口内的第一个位置
|
||
result.set(0, best);
|
||
}
|
||
}
|
||
|
||
// 下面两个中的第二个（系数更小的那个）：索引 endIndex（即 avgIndex+2）
|
||
int downSecondIndex = endIndex;
|
||
if (downSecondIndex < size) {
|
||
Double coeff = t8List.get(downSecondIndex).getFaceCoefficient();
|
||
List<T8> candidatesDown = new ArrayList<>();
|
||
// 包含窗口内该位置
|
||
candidatesDown.add(t8List.get(downSecondIndex));
|
||
// 只向下（窗口之外）查找相同系数，避免与窗口内其它位置重复
|
||
for (int i = downSecondIndex + 1; i < size; i++) {
|
||
if (t8List.get(i).getFaceCoefficient().equals(coeff)) {
|
||
candidatesDown.add(t8List.get(i));
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
if (candidatesDown.size() > 1) {
|
||
log.debug("中位下方第二个位置存在{}个相同面系数候选：{}", candidatesDown.size(),
|
||
candidatesDown.stream().map(T8::getSlaveBallNumber).collect(Collectors.toList()));
|
||
Integer best = selectBestBallFromBlueHistoryTop100(
|
||
candidatesDown.stream().map(T8::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
// 替换窗口内的最后一个位置
|
||
result.set(result.size() - 1, best);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case "L": {
|
||
// 低位：取系数倒数第二个向上5个；窗口顶部和底部位置均有毛边：使用blue_history_top_100/blue_history_top多级回退比较
|
||
if (size < 5) {
|
||
log.warn("T8表数据不足5条，实际{}条", size);
|
||
return t8List.stream().map(T8::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
int endIndex = size - 2; // 倒数第二
|
||
int startIndex = Math.max(0, endIndex - 4);
|
||
|
||
// 先按基本规则选出5个位置的球号
|
||
List<Integer> baseResult = new ArrayList<>();
|
||
for (int i = startIndex; i <= endIndex; i++) {
|
||
baseResult.add(t8List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理顶部位置（系数最大的）毛边：向上查找相同面系数
|
||
Double topCoeff = t8List.get(startIndex).getFaceCoefficient();
|
||
List<T8> candidatesTop = new ArrayList<>();
|
||
candidatesTop.add(t8List.get(startIndex));
|
||
for (int i = startIndex - 1; i >= 0; i--) {
|
||
if (t8List.get(i).getFaceCoefficient().equals(topCoeff)) {
|
||
candidatesTop.add(t8List.get(i));
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
if (candidatesTop.size() > 1) {
|
||
log.debug("低位顶部位置存在{}个相同面系数候选：{}", candidatesTop.size(),
|
||
candidatesTop.stream().map(T8::getSlaveBallNumber).collect(Collectors.toList()));
|
||
List<Integer> topSelected = selectBlueBallsWithFallback(
|
||
candidatesTop.stream().map(T8::getSlaveBallNumber).collect(Collectors.toList()), 1
|
||
);
|
||
if (!topSelected.isEmpty()) {
|
||
baseResult.set(0, topSelected.get(0));
|
||
}
|
||
}
|
||
|
||
// 处理底部位置（系数最小的）毛边：向下查找相同面系数
|
||
Double bottomCoeff = t8List.get(endIndex).getFaceCoefficient();
|
||
List<T8> candidatesBottom = new ArrayList<>();
|
||
candidatesBottom.add(t8List.get(endIndex));
|
||
for (int i = endIndex + 1; i < size; i++) {
|
||
if (t8List.get(i).getFaceCoefficient().equals(bottomCoeff)) {
|
||
candidatesBottom.add(t8List.get(i));
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
if (candidatesBottom.size() > 1) {
|
||
log.debug("低位底部位置存在{}个相同面系数候选：{}", candidatesBottom.size(),
|
||
candidatesBottom.stream().map(T8::getSlaveBallNumber).collect(Collectors.toList()));
|
||
List<Integer> bottomSelected = selectBlueBallsWithFallback(
|
||
candidatesBottom.stream().map(T8::getSlaveBallNumber).collect(Collectors.toList()), 1
|
||
);
|
||
if (!bottomSelected.isEmpty()) {
|
||
baseResult.set(baseResult.size() - 1, bottomSelected.get(0));
|
||
}
|
||
}
|
||
|
||
result = baseResult;
|
||
break;
|
||
}
|
||
}
|
||
|
||
log.debug("T8表主球{}{}级别最终选择的{}个从球：{}", masterBallNumber, level, result.size(), result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 从blue_history_top_100表获取点系数最高的前2个蓝球号码
|
||
* 如果第2个点系数不唯一，使用blue_history_top表进行二级筛选
|
||
* @return 前2个蓝球号码列表
|
||
*/
|
||
private List<Integer> getTop2FromBlueHistoryTop100() {
|
||
log.debug("从blue_history_top_100表获取前2个蓝球号码");
|
||
|
||
// 查询所有数据，按点系数降序排列
|
||
QueryWrapper<BlueHistoryTop100> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber"); // 点系数相同时按球号升序
|
||
|
||
List<BlueHistoryTop100> top100List = blueHistoryTop100Mapper.selectList(queryWrapper);
|
||
|
||
if (top100List.isEmpty()) {
|
||
log.warn("blue_history_top_100表中没有数据");
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
if (top100List.size() == 1) {
|
||
List<Integer> result = Arrays.asList(top100List.get(0).getBallNumber());
|
||
log.debug("blue_history_top_100表只有1条数据：{}", result);
|
||
return result;
|
||
}
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
// 第1个直接取点系数最高的
|
||
result.add(top100List.get(0).getBallNumber());
|
||
log.debug("第1个蓝球号码：{}，点系数：{}", top100List.get(0).getBallNumber(), top100List.get(0).getPointCoefficient());
|
||
|
||
// 处理第2个位置：检查是否有相同的点系数
|
||
Double targetCoefficient = top100List.get(1).getPointCoefficient();
|
||
List<BlueHistoryTop100> candidatesFor2nd = new ArrayList<>();
|
||
|
||
// 找出所有点系数等于第2个位置点系数的记录
|
||
for (int i = 1; i < top100List.size(); i++) {
|
||
if (top100List.get(i).getPointCoefficient().equals(targetCoefficient)) {
|
||
candidatesFor2nd.add(top100List.get(i));
|
||
} else {
|
||
break; // 点系数不同，停止查找
|
||
}
|
||
}
|
||
|
||
if (candidatesFor2nd.size() == 1) {
|
||
// 只有一个候选，直接添加
|
||
result.add(candidatesFor2nd.get(0).getBallNumber());
|
||
log.debug("第2个蓝球号码：{}，点系数：{}", candidatesFor2nd.get(0).getBallNumber(), candidatesFor2nd.get(0).getPointCoefficient());
|
||
} else {
|
||
// 有多个候选，通过blue_history_top表的点系数排序
|
||
log.debug("第2位有{}个相同点系数的候选：{}", candidatesFor2nd.size(),
|
||
candidatesFor2nd.stream().map(BlueHistoryTop100::getBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallFromBlueHistoryTop(
|
||
candidatesFor2nd.stream().map(BlueHistoryTop100::getBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.add(bestBall);
|
||
log.debug("通过blue_history_top表筛选的第2个蓝球号码：{}", bestBall);
|
||
}
|
||
|
||
log.debug("从blue_history_top_100表最终获取到{}个蓝球号码：{}", result.size(), result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 从T5表获取指定蓝球对应的5个蓝球号码（简化版本）
|
||
* @param masterBallNumber 主球号（蓝球）
|
||
* @param level 级别：H-高位，M-中位，L-低位
|
||
* @return 5个蓝球号码列表
|
||
*/
|
||
private List<Integer> getSimpleTop5FromT5ByLevel(Integer masterBallNumber, String level) {
|
||
log.debug("从T5表查询主球{}的线系数数据，级别：{}", masterBallNumber, level);
|
||
|
||
// 查询指定主球的所有数据，按线系数降序排列
|
||
QueryWrapper<T5> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", masterBallNumber)
|
||
.orderByDesc("lineCoefficient")
|
||
.orderByAsc("slaveBallNumber"); // 线系数相同时按从球号升序
|
||
|
||
List<T5> t5List = t5Mapper.selectList(queryWrapper);
|
||
|
||
if (t5List.isEmpty()) {
|
||
log.warn("T5表中主球{}没有数据", masterBallNumber);
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
int size = t5List.size();
|
||
|
||
switch (level) {
|
||
case "H":
|
||
// 高位：取线系数最大的5个
|
||
for (int i = 0; i < Math.min(5, size); i++) {
|
||
result.add(t5List.get(i).getSlaveBallNumber());
|
||
}
|
||
break;
|
||
case "M":
|
||
// 中位：取中间的5个
|
||
int start = Math.max(0, (size - 5) / 2);
|
||
for (int i = start; i < Math.min(start + 5, size); i++) {
|
||
result.add(t5List.get(i).getSlaveBallNumber());
|
||
}
|
||
break;
|
||
case "L":
|
||
// 低位：取最后5个（线系数最小的）
|
||
int startLow = Math.max(0, size - 5);
|
||
for (int i = startLow; i < size; i++) {
|
||
result.add(t5List.get(i).getSlaveBallNumber());
|
||
}
|
||
break;
|
||
}
|
||
|
||
log.debug("T5表主球{}{}级别最终选择的{}个从球：{}", masterBallNumber, level, result.size(), result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 统计数字出现频率，返回频率最高的前4个蓝球号码
|
||
* 如果频次相同的球号超过4个，使用多级筛选机制
|
||
*/
|
||
private List<Integer> getSimpleTop4ByFrequency(List<Integer> allNumbers, List<BallWithCoefficient> step2BlueT8Coefficients) {
|
||
log.debug("统计{}个蓝球号码的出现频率", allNumbers.size());
|
||
|
||
// 统计频率
|
||
Map<Integer, Integer> frequencyMap = new HashMap<>();
|
||
for (Integer number : allNumbers) {
|
||
frequencyMap.put(number, frequencyMap.getOrDefault(number, 0) + 1);
|
||
}
|
||
|
||
log.debug("蓝球号码频率统计：{}", frequencyMap);
|
||
|
||
// 按频率分组
|
||
Map<Integer, List<Integer>> frequencyGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
|
||
Integer frequency = entry.getValue();
|
||
Integer ballNumber = entry.getKey();
|
||
|
||
frequencyGroups.computeIfAbsent(frequency, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.debug("按频率分组：{}", frequencyGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
// 按频率从高到低处理
|
||
for (Map.Entry<Integer, List<Integer>> group : frequencyGroups.entrySet()) {
|
||
Integer frequency = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
// 对同频率的球号按数字升序排序
|
||
Collections.sort(balls);
|
||
|
||
log.info("频率{}的蓝球号码：{}", frequency, balls);
|
||
|
||
// 检查加入这组球号后是否会超过4个
|
||
if (result.size() + balls.size() <= 4) {
|
||
// 不会超过4个，直接添加所有球号
|
||
result.addAll(balls);
|
||
log.info("直接添加{}个蓝球号码，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过4个：第一级直接用“第二步收集的T8面系数求和”进行筛选
|
||
int remainingSlots = 4 - result.size();
|
||
log.info("需要从{}个频率相同的蓝球号码中选择{}个，使用第二步T8面系数求和进行筛选", balls.size(), remainingSlots);
|
||
|
||
// 统计同频候选在step2BlueT8Coefficients中的面系数和（找不到视为0）
|
||
Map<Integer, Double> sumMap = new HashMap<>();
|
||
for (Integer b : balls) {
|
||
double sum = 0.0;
|
||
if (step2BlueT8Coefficients != null) {
|
||
for (BallWithCoefficient bwc : step2BlueT8Coefficients) {
|
||
if (b.equals(bwc.getBallNumber())) {
|
||
sum += bwc.getCoefficient();
|
||
}
|
||
}
|
||
}
|
||
sumMap.put(b, sum);
|
||
}
|
||
|
||
// 按“系数和降序、球号升序”排序，取前remainingSlots
|
||
balls.sort((a, b) -> {
|
||
int cmp = Double.compare(sumMap.getOrDefault(b, 0.0), sumMap.getOrDefault(a, 0.0));
|
||
if (cmp != 0) return cmp;
|
||
return Integer.compare(a, b);
|
||
});
|
||
|
||
List<Integer> selectedBalls = balls.subList(0, Math.min(remainingSlots, balls.size()));
|
||
result.addAll(selectedBalls);
|
||
|
||
log.info("通过第二步T8面系数和筛选完成，最终选择：{}", selectedBalls);
|
||
break; // 已经达到4个，结束
|
||
}
|
||
|
||
// 如果已经有4个，结束
|
||
if (result.size() >= 4) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
log.info("频率统计最终结果（共{}个）：{}", result.size(), result);
|
||
|
||
// 打印详细的频率信息
|
||
for (int i = 0; i < result.size(); i++) {
|
||
Integer ballNumber = result.get(i);
|
||
Integer frequency = frequencyMap.get(ballNumber);
|
||
log.info("第{}位：蓝球号码{}，出现{}次", i + 1, ballNumber, frequency);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 统计频率并获取前4个蓝球号码（带筛选过程说明）
|
||
* @param allNumbers 所有蓝球号码
|
||
* @param step2BlueT8Coefficients 第二步T8面系数数据
|
||
* @return 包含结果和筛选过程说明的VO对象
|
||
*/
|
||
private BlueBallAnalysisResultVO getSimpleTop4ByFrequencyWithProcess(List<Integer> allNumbers, List<BallWithCoefficient> step2BlueT8Coefficients) {
|
||
log.debug("统计{}个蓝球号码的出现频率", allNumbers.size());
|
||
|
||
// 统计频率
|
||
Map<Integer, Integer> frequencyMap = new HashMap<>();
|
||
for (Integer number : allNumbers) {
|
||
frequencyMap.put(number, frequencyMap.getOrDefault(number, 0) + 1);
|
||
}
|
||
|
||
log.debug("蓝球号码频率统计：{}", frequencyMap);
|
||
|
||
// 按频率分组
|
||
Map<Integer, List<Integer>> frequencyGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
|
||
Integer frequency = entry.getValue();
|
||
Integer ballNumber = entry.getKey();
|
||
|
||
frequencyGroups.computeIfAbsent(frequency, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.debug("按频率分组：{}", frequencyGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
List<Integer> directlySelectedBalls = new ArrayList<>();
|
||
List<Integer> multiLevelCandidates = new ArrayList<>();
|
||
List<Integer> secondaryFilteredBalls = new ArrayList<>();
|
||
boolean needMultiLevelFiltering = false;
|
||
StringBuilder processDescription = new StringBuilder();
|
||
String detailedStepsInfo = "";
|
||
|
||
// 构建参与筛选的球号频率分布描述
|
||
List<Integer> allParticipatedBalls = new ArrayList<>();
|
||
Map<Integer, List<Integer>> participatedFrequencyGroups = new LinkedHashMap<>();
|
||
|
||
// 按频率从高到低处理
|
||
for (Map.Entry<Integer, List<Integer>> group : frequencyGroups.entrySet()) {
|
||
Integer frequency = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
// 对同频率的球号按数字升序排序
|
||
Collections.sort(balls);
|
||
|
||
log.info("频率{}的蓝球号码：{}", frequency, balls);
|
||
|
||
// 检查加入这组球号后是否会超过4个
|
||
if (result.size() + balls.size() <= 4) {
|
||
// 不会超过4个，直接添加所有球号
|
||
result.addAll(balls);
|
||
directlySelectedBalls.addAll(balls);
|
||
allParticipatedBalls.addAll(balls);
|
||
log.info("直接添加{}个蓝球号码，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过4个，需要多级筛选
|
||
needMultiLevelFiltering = true;
|
||
multiLevelCandidates.addAll(balls);
|
||
allParticipatedBalls.addAll(balls);
|
||
|
||
int remainingSlots = 4 - result.size();
|
||
log.info("需要从{}个频率相同的蓝球号码中选择{}个，使用第二步T8面系数求和进行筛选", balls.size(), remainingSlots);
|
||
|
||
// 进行多级筛选
|
||
BlueBallMultiLevelFilteringResult filteringResult = performBlueBallMultiLevelFilteringWithDetails(balls, remainingSlots, step2BlueT8Coefficients);
|
||
result.addAll(filteringResult.getSelectedBalls());
|
||
secondaryFilteredBalls = new ArrayList<>(filteringResult.getSelectedBalls());
|
||
processDescription.append("筛选步骤：").append(filteringResult.getStepsDescription());
|
||
detailedStepsInfo = filteringResult.getDetailedStepsInfo();
|
||
|
||
// 已达到4个，结束
|
||
break;
|
||
}
|
||
|
||
// 如果已经有4个，结束
|
||
if (result.size() >= 4) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 构建参与筛选的频率分布
|
||
for (Integer ball : allParticipatedBalls) {
|
||
Integer frequency = frequencyMap.get(ball);
|
||
participatedFrequencyGroups.computeIfAbsent(frequency, k -> new ArrayList<>()).add(ball);
|
||
}
|
||
|
||
// 按频率从高到低排序
|
||
Map<Integer, List<Integer>> sortedParticipatedFrequencyGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (Map.Entry<Integer, List<Integer>> entry : participatedFrequencyGroups.entrySet()) {
|
||
Integer frequency = entry.getKey();
|
||
List<Integer> balls = new ArrayList<>(entry.getValue());
|
||
Collections.sort(balls); // 球号按升序排序
|
||
sortedParticipatedFrequencyGroups.put(frequency, balls);
|
||
}
|
||
|
||
// 构建详细的过程描述
|
||
StringBuilder detailedDescription = new StringBuilder();
|
||
|
||
// 1. 频率分布描述 - 只包含实际参与筛选的球号
|
||
detailedDescription.append("参与筛选的候选蓝球号码按频率分布为");
|
||
detailedDescription.append(formatBallNumbersWithFrequency(sortedParticipatedFrequencyGroups));
|
||
|
||
// 2. 筛选结果描述
|
||
if (needMultiLevelFiltering) {
|
||
detailedDescription.append("；无法直接筛选出前4个，其中");
|
||
detailedDescription.append(formatBallNumbersComplete(directlySelectedBalls));
|
||
detailedDescription.append("直接入选，");
|
||
detailedDescription.append(formatBallNumbersComplete(multiLevelCandidates));
|
||
detailedDescription.append("需要进行二次筛选，最终筛选出");
|
||
detailedDescription.append(formatBallNumbersComplete(secondaryFilteredBalls));
|
||
detailedDescription.append("，组成前4个蓝球号码：");
|
||
detailedDescription.append(formatBallNumbersComplete(result));
|
||
detailedDescription.append("。");
|
||
detailedDescription.append(processDescription.toString());
|
||
if (!detailedStepsInfo.isEmpty()) {
|
||
detailedDescription.append(" ").append(detailedStepsInfo);
|
||
}
|
||
} else {
|
||
detailedDescription.append("；直接按频率筛选出前4个蓝球号码：");
|
||
detailedDescription.append(formatBallNumbersComplete(result));
|
||
detailedDescription.append("。筛选步骤：通过频率筛选确定所有球号，无需进行T8面系数和筛选、百期排位、历史排位。");
|
||
}
|
||
|
||
return BlueBallAnalysisResultVO.builder()
|
||
.result(result)
|
||
.filteringProcess(detailedDescription.toString())
|
||
.build();
|
||
}
|
||
|
||
/**
|
||
* 从blue_history_top表中选择点系数最高的球号
|
||
* @param candidates 候选球号列表
|
||
* @return 点系数最高的球号
|
||
*/
|
||
private Integer selectBestBallFromBlueHistoryTop(List<Integer> candidates) {
|
||
log.debug("从blue_history_top表中选择最佳球号，候选：{}", candidates);
|
||
|
||
if (candidates.isEmpty()) {
|
||
throw new IllegalArgumentException("候选球号列表不能为空");
|
||
}
|
||
|
||
if (candidates.size() == 1) {
|
||
return candidates.get(0);
|
||
}
|
||
|
||
// 查询这些球号在blue_history_top表中的点系数
|
||
QueryWrapper<BlueHistoryTop> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.in("ballNumber", candidates)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber"); // 点系数相同时按球号升序
|
||
|
||
List<BlueHistoryTop> historyTopList = blueHistoryTopMapper.selectList(queryWrapper);
|
||
|
||
if (historyTopList.isEmpty()) {
|
||
log.warn("候选球号{}在blue_history_top表中未找到数据，返回最小球号", candidates);
|
||
return Collections.min(candidates);
|
||
}
|
||
|
||
// 返回点系数最高的球号
|
||
Integer bestBall = historyTopList.get(0).getBallNumber();
|
||
log.debug("选择的最佳球号：{}，点系数：{}", bestBall, historyTopList.get(0).getPointCoefficient());
|
||
|
||
return bestBall;
|
||
}
|
||
|
||
/**
|
||
* 四级筛选蓝球号码：T8面系数 -> blue_history_top_100排名 -> blue_history_top点系数 -> 随机选择
|
||
* @param candidateBalls 候选蓝球号码列表
|
||
* @param selectCount 需要选择的数量
|
||
* @return 选择的蓝球号码列表
|
||
*/
|
||
private List<Integer> selectBallsByMultiLevelFilteringForBlue4(List<Integer> candidateBalls, int selectCount) {
|
||
log.info("开始四级筛选蓝球号码，候选：{}，需要选择：{}", candidateBalls, selectCount);
|
||
|
||
if (candidateBalls.size() <= selectCount) {
|
||
log.info("候选蓝球号码数量不超过需要选择的数量，直接返回所有候选蓝球号码");
|
||
return new ArrayList<>(candidateBalls);
|
||
}
|
||
|
||
// 第一级：使用T8表的面系数总和进行筛选
|
||
List<Integer> filteredByT8 = selectBallsByT8FaceCoefficientSumForBlue4(candidateBalls, selectCount);
|
||
|
||
if (filteredByT8.size() == selectCount) {
|
||
log.info("通过T8表面系数筛选成功，结果：{}", filteredByT8);
|
||
return filteredByT8;
|
||
}
|
||
|
||
// 第二级：使用blue_history_top_100表的排名进行筛选
|
||
log.info("T8表筛选后仍有{}个蓝球号码，继续使用blue_history_top_100表筛选", filteredByT8.size());
|
||
List<Integer> filteredByTop100 = selectBallsByBlueHistoryTop100RankingForBlue4(filteredByT8, selectCount);
|
||
|
||
if (filteredByTop100.size() == selectCount) {
|
||
log.info("通过blue_history_top_100表筛选成功，结果：{}", filteredByTop100);
|
||
return filteredByTop100;
|
||
}
|
||
|
||
// 第三级：使用blue_history_top表的点系数进行筛选
|
||
log.info("blue_history_top_100表筛选后仍有{}个蓝球号码，继续使用blue_history_top表筛选", filteredByTop100.size());
|
||
List<Integer> filteredByTop = selectBallsByBlueHistoryTopPointCoefficientForBlue4(filteredByTop100, selectCount);
|
||
|
||
if (filteredByTop.size() == selectCount) {
|
||
log.info("通过blue_history_top表筛选成功，结果：{}", filteredByTop);
|
||
return filteredByTop;
|
||
}
|
||
|
||
// 第四级：随机选择
|
||
log.info("blue_history_top表筛选后仍有{}个蓝球号码，进行随机选择", filteredByTop.size());
|
||
List<Integer> finalResult = selectBallsRandomlyForBlue4(filteredByTop, selectCount);
|
||
|
||
log.info("随机选择完成，最终结果：{}", finalResult);
|
||
return finalResult;
|
||
}
|
||
|
||
/**
|
||
* 根据T8表的面系数总和选择蓝球号码（第一级筛选）
|
||
* @param candidateBalls 候选蓝球号码列表
|
||
* @param selectCount 需要选择的数量
|
||
* @return 选择的蓝球号码列表
|
||
*/
|
||
private List<Integer> selectBallsByT8FaceCoefficientSumForBlue4(List<Integer> candidateBalls, int selectCount) {
|
||
log.info("开始根据T8表面系数总和选择蓝球号码，候选：{}，需要选择：{}", candidateBalls, selectCount);
|
||
|
||
if (candidateBalls.size() <= selectCount) {
|
||
log.info("候选蓝球号码数量不超过需要选择的数量，直接返回所有候选蓝球号码");
|
||
return new ArrayList<>(candidateBalls);
|
||
}
|
||
|
||
// 计算每个蓝球号码作为主球时的面系数总和
|
||
Map<Integer, Double> faceCoefficientSumMap = new HashMap<>();
|
||
|
||
for (Integer ballNumber : candidateBalls) {
|
||
QueryWrapper<T8> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", ballNumber);
|
||
|
||
List<T8> t8List = t8Mapper.selectList(queryWrapper);
|
||
|
||
double sum = t8List.stream()
|
||
.mapToDouble(T8::getFaceCoefficient)
|
||
.sum();
|
||
|
||
faceCoefficientSumMap.put(ballNumber, sum);
|
||
log.debug("蓝球号码{}作为主球的面系数总和：{}", ballNumber, sum);
|
||
}
|
||
|
||
// 按面系数总和分组
|
||
Map<Double, List<Integer>> faceCoefficientGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (Map.Entry<Integer, Double> entry : faceCoefficientSumMap.entrySet()) {
|
||
Double sum = entry.getValue();
|
||
Integer ballNumber = entry.getKey();
|
||
faceCoefficientGroups.computeIfAbsent(sum, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.info("T8表面系数总和分组：{}", faceCoefficientGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
// 按面系数总和从高到低处理
|
||
for (Map.Entry<Double, List<Integer>> group : faceCoefficientGroups.entrySet()) {
|
||
Double faceSum = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
log.info("面系数总和{}的蓝球号码：{}", faceSum, balls);
|
||
|
||
// 检查加入这组球号后是否会超过selectCount个
|
||
if (result.size() + balls.size() <= selectCount) {
|
||
// 不会超过，直接添加所有球号（按球号升序排序）
|
||
Collections.sort(balls);
|
||
result.addAll(balls);
|
||
log.info("直接添加{}个蓝球号码，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过，按球号升序选择需要的数量
|
||
int remainingSlots = selectCount - result.size();
|
||
Collections.sort(balls);
|
||
result.addAll(balls.subList(0, remainingSlots));
|
||
log.info("选择前{}个蓝球号码：{}", remainingSlots, balls.subList(0, remainingSlots));
|
||
break;
|
||
}
|
||
|
||
// 如果已经有selectCount个，结束
|
||
if (result.size() >= selectCount) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
log.info("T8表面系数筛选结果：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 根据blue_history_top_100表的点系数选择蓝球号码（第二级筛选）
|
||
* @param candidateBalls 候选蓝球号码列表
|
||
* @param selectCount 需要选择的数量
|
||
* @return 选择的蓝球号码列表
|
||
*/
|
||
private List<Integer> selectBallsByBlueHistoryTop100RankingForBlue4(List<Integer> candidateBalls, int selectCount) {
|
||
log.info("使用blue_history_top_100表点系数筛选蓝球号码，候选：{}，需要选择：{}", candidateBalls, selectCount);
|
||
|
||
// 查询这些球号在blue_history_top_100表中的点系数
|
||
QueryWrapper<BlueHistoryTop100> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.in("ballNumber", candidateBalls)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber"); // 点系数相同时按球号升序
|
||
|
||
List<BlueHistoryTop100> top100List = blueHistoryTop100Mapper.selectList(queryWrapper);
|
||
|
||
if (top100List.isEmpty()) {
|
||
log.warn("候选球号{}在blue_history_top_100表中未找到数据，按球号升序返回", candidateBalls);
|
||
Collections.sort(candidateBalls);
|
||
return candidateBalls.subList(0, Math.min(selectCount, candidateBalls.size()));
|
||
}
|
||
|
||
// 按点系数分组
|
||
Map<Double, List<Integer>> pointCoefficientGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (BlueHistoryTop100 item : top100List) {
|
||
Double pointCoefficient = item.getPointCoefficient();
|
||
Integer ballNumber = item.getBallNumber();
|
||
pointCoefficientGroups.computeIfAbsent(pointCoefficient, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.info("blue_history_top_100表点系数分组：{}", pointCoefficientGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
// 按点系数从高到低处理
|
||
for (Map.Entry<Double, List<Integer>> group : pointCoefficientGroups.entrySet()) {
|
||
Double pointCoefficient = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
log.info("点系数{}的蓝球号码：{}", pointCoefficient, balls);
|
||
|
||
// 检查加入这组球号后是否会超过selectCount个
|
||
if (result.size() + balls.size() <= selectCount) {
|
||
// 不会超过，直接添加所有球号（按球号升序排序）
|
||
Collections.sort(balls);
|
||
result.addAll(balls);
|
||
log.info("直接添加{}个蓝球号码，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过，按球号升序选择需要的数量
|
||
int remainingSlots = selectCount - result.size();
|
||
Collections.sort(balls);
|
||
result.addAll(balls.subList(0, remainingSlots));
|
||
log.info("选择前{}个蓝球号码：{}", remainingSlots, balls.subList(0, remainingSlots));
|
||
break;
|
||
}
|
||
|
||
// 如果已经有selectCount个，结束
|
||
if (result.size() >= selectCount) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 处理不在blue_history_top_100表中的球号
|
||
List<Integer> notInTop100 = new ArrayList<>(candidateBalls);
|
||
notInTop100.removeAll(result);
|
||
if (!notInTop100.isEmpty() && result.size() < selectCount) {
|
||
int remainingSlots = selectCount - result.size();
|
||
Collections.sort(notInTop100);
|
||
int addCount = Math.min(remainingSlots, notInTop100.size());
|
||
result.addAll(notInTop100.subList(0, addCount));
|
||
log.info("添加不在blue_history_top_100表中的{}个蓝球号码：{}", addCount, notInTop100.subList(0, addCount));
|
||
}
|
||
|
||
log.info("blue_history_top_100表筛选结果：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 根据blue_history_top表的点系数选择蓝球号码（第三级筛选）
|
||
* @param candidateBalls 候选蓝球号码列表
|
||
* @param selectCount 需要选择的数量
|
||
* @return 选择的蓝球号码列表
|
||
*/
|
||
private List<Integer> selectBallsByBlueHistoryTopPointCoefficientForBlue4(List<Integer> candidateBalls, int selectCount) {
|
||
log.info("使用blue_history_top表点系数筛选蓝球号码，候选：{}，需要选择：{}", candidateBalls, selectCount);
|
||
|
||
// 查询这些球号在blue_history_top表中的点系数
|
||
QueryWrapper<BlueHistoryTop> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.in("ballNumber", candidateBalls)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber"); // 点系数相同时按球号升序
|
||
|
||
List<BlueHistoryTop> historyTopList = blueHistoryTopMapper.selectList(queryWrapper);
|
||
|
||
if (historyTopList.isEmpty()) {
|
||
log.warn("候选球号{}在blue_history_top表中未找到数据，按球号升序返回", candidateBalls);
|
||
Collections.sort(candidateBalls);
|
||
return candidateBalls.subList(0, Math.min(selectCount, candidateBalls.size()));
|
||
}
|
||
|
||
// 按点系数分组
|
||
Map<Double, List<Integer>> pointCoefficientGroups = new TreeMap<>(Collections.reverseOrder());
|
||
for (BlueHistoryTop item : historyTopList) {
|
||
Double pointCoefficient = item.getPointCoefficient();
|
||
Integer ballNumber = item.getBallNumber();
|
||
pointCoefficientGroups.computeIfAbsent(pointCoefficient, k -> new ArrayList<>()).add(ballNumber);
|
||
}
|
||
|
||
log.info("blue_history_top表点系数分组：{}", pointCoefficientGroups);
|
||
|
||
List<Integer> result = new ArrayList<>();
|
||
|
||
// 按点系数从高到低处理
|
||
for (Map.Entry<Double, List<Integer>> group : pointCoefficientGroups.entrySet()) {
|
||
Double pointCoefficient = group.getKey();
|
||
List<Integer> balls = group.getValue();
|
||
|
||
log.info("点系数{}的蓝球号码：{}", pointCoefficient, balls);
|
||
|
||
// 检查加入这组球号后是否会超过selectCount个
|
||
if (result.size() + balls.size() <= selectCount) {
|
||
// 不会超过，直接添加所有球号（按球号升序排序）
|
||
Collections.sort(balls);
|
||
result.addAll(balls);
|
||
log.info("直接添加{}个蓝球号码，当前总数：{}", balls.size(), result.size());
|
||
} else {
|
||
// 会超过，按球号升序选择需要的数量
|
||
int remainingSlots = selectCount - result.size();
|
||
Collections.sort(balls);
|
||
result.addAll(balls.subList(0, remainingSlots));
|
||
log.info("选择前{}个蓝球号码：{}", remainingSlots, balls.subList(0, remainingSlots));
|
||
break;
|
||
}
|
||
|
||
// 如果已经有selectCount个，结束
|
||
if (result.size() >= selectCount) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 处理不在blue_history_top表中的球号
|
||
List<Integer> notInHistoryTop = new ArrayList<>(candidateBalls);
|
||
notInHistoryTop.removeAll(result);
|
||
if (!notInHistoryTop.isEmpty() && result.size() < selectCount) {
|
||
int remainingSlots = selectCount - result.size();
|
||
Collections.sort(notInHistoryTop);
|
||
int addCount = Math.min(remainingSlots, notInHistoryTop.size());
|
||
result.addAll(notInHistoryTop.subList(0, addCount));
|
||
log.info("添加不在blue_history_top表中的{}个蓝球号码：{}", addCount, notInHistoryTop.subList(0, addCount));
|
||
}
|
||
|
||
log.info("blue_history_top表筛选结果：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 随机选择蓝球号码（第四级筛选）
|
||
* @param candidateBalls 候选蓝球号码列表
|
||
* @param selectCount 需要选择的数量
|
||
* @return 随机选择的蓝球号码列表
|
||
*/
|
||
private List<Integer> selectBallsRandomlyForBlue4(List<Integer> candidateBalls, int selectCount) {
|
||
log.info("随机选择蓝球号码，候选：{}，需要选择：{}", candidateBalls, selectCount);
|
||
|
||
if (candidateBalls.size() <= selectCount) {
|
||
log.info("候选蓝球号码数量不超过需要选择的数量，直接返回所有候选蓝球号码");
|
||
return new ArrayList<>(candidateBalls);
|
||
}
|
||
|
||
// 创建候选球号的副本并打乱顺序
|
||
List<Integer> shuffledBalls = new ArrayList<>(candidateBalls);
|
||
Collections.shuffle(shuffledBalls, new Random(System.currentTimeMillis()));
|
||
|
||
// 选择前selectCount个
|
||
List<Integer> result = shuffledBalls.subList(0, selectCount);
|
||
|
||
// 按球号升序排序结果
|
||
Collections.sort(result);
|
||
|
||
log.info("随机选择结果：{}", result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 首球命中率统计
|
||
* @param userId 用户ID
|
||
* @return 首球命中率统计信息
|
||
*/
|
||
public BallHitRateVO getFirstBallHitRate(Long userId) {
|
||
log.info("开始统计用户{}的首球命中率", userId);
|
||
|
||
// 查询用户的所有预测记录（除了"待开奖"状态的）
|
||
QueryWrapper<PredictRecord> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("userId", userId)
|
||
.ne("predictStatus", "待开奖");
|
||
|
||
List<PredictRecord> predictRecords = predictRecordMapper.selectList(queryWrapper);
|
||
|
||
// 总预测次数
|
||
int totalCount = predictRecords.size();
|
||
|
||
// 统计首球命中次数
|
||
int hitCount = 0;
|
||
|
||
for (PredictRecord record : predictRecords) {
|
||
// 获取该预测记录对应的开奖信息
|
||
LotteryDraws draw = lotteryDrawsService.getByDrawId(record.getDrawId());
|
||
|
||
if (draw != null && record.getRedBall1() != null) {
|
||
Integer predictedFirstBall = record.getRedBall1();
|
||
List<Integer> drawnRedBalls = Arrays.asList(
|
||
draw.getRedBall1(),
|
||
draw.getRedBall2(),
|
||
draw.getRedBall3(),
|
||
draw.getRedBall4(),
|
||
draw.getRedBall5(),
|
||
draw.getRedBall6()
|
||
);
|
||
// 比较预测的第一个红球是否在开奖的六个红球中
|
||
if (drawnRedBalls.contains(predictedFirstBall)) {
|
||
hitCount++;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 计算命中率
|
||
double hitRate = totalCount > 0 ? (double) hitCount / totalCount * 100 : 0;
|
||
|
||
BallHitRateVO result = BallHitRateVO.builder()
|
||
.hitCount(hitCount)
|
||
.totalCount(totalCount)
|
||
.hitRate(hitRate)
|
||
.build();
|
||
|
||
log.info("用户{}的首球命中率统计结果：命中{}次，总计{}次，命中率{}%",
|
||
userId, hitCount, totalCount, String.format("%.2f", hitRate));
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 蓝球命中率统计
|
||
* @param userId 用户ID
|
||
* @return 蓝球命中率统计信息
|
||
*/
|
||
public BallHitRateVO getBlueBallHitRate(Long userId) {
|
||
log.info("开始统计用户{}的蓝球命中率", userId);
|
||
|
||
// 查询用户的所有预测记录（除了"待开奖"状态的）
|
||
QueryWrapper<PredictRecord> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("userId", userId)
|
||
.ne("predictStatus", "待开奖");
|
||
|
||
List<PredictRecord> predictRecords = predictRecordMapper.selectList(queryWrapper);
|
||
|
||
// 总预测次数
|
||
int totalCount = predictRecords.size();
|
||
|
||
// 统计蓝球命中次数
|
||
int hitCount = 0;
|
||
|
||
for (PredictRecord record : predictRecords) {
|
||
// 获取该预测记录对应的开奖信息
|
||
LotteryDraws draw = lotteryDrawsService.getByDrawId(record.getDrawId());
|
||
|
||
if (draw != null && record.getBlueBall() != null) {
|
||
// 比较预测的蓝球与开奖的蓝球是否相等
|
||
if (record.getBlueBall().equals(draw.getBlueBall())) {
|
||
hitCount++;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 计算命中率
|
||
double hitRate = totalCount > 0 ? (double) hitCount / totalCount * 100 : 0;
|
||
|
||
BallHitRateVO result = BallHitRateVO.builder()
|
||
.hitCount(hitCount)
|
||
.totalCount(totalCount)
|
||
.hitRate(hitRate)
|
||
.build();
|
||
|
||
log.info("用户{}的蓝球命中率统计结果：命中{}次，总计{}次，命中率{}%",
|
||
userId, hitCount, totalCount, String.format("%.2f", hitRate));
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 奖金统计
|
||
* @param userId 用户ID
|
||
* @param predictId 预测记录ID，如果为null则统计所有记录
|
||
* @return 奖金统计信息
|
||
*/
|
||
public PrizeEstimateVO getPrizeStatistics(Long userId, Long predictId) {
|
||
log.info("开始为用户{}进行奖金统计，predictId={}", userId, predictId);
|
||
|
||
// 查询条件
|
||
QueryWrapper<PredictRecord> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("userId", userId);
|
||
// 排除待开奖状态
|
||
queryWrapper.ne("predictStatus", "待开奖");
|
||
// 如果指定了预测记录ID，则只查询该记录
|
||
if (predictId != null) {
|
||
queryWrapper.eq("id", predictId);
|
||
}
|
||
|
||
// 查询用户的预测记录
|
||
List<PredictRecord> records = predictRecordMapper.selectList(queryWrapper);
|
||
|
||
// 按中奖等级分组统计
|
||
Map<String, Integer> countByPrizeLevel = new HashMap<>();
|
||
Map<String, BigDecimal> totalBonusByPrizeLevel = new HashMap<>();
|
||
|
||
// 初始化所有等级
|
||
String[] prizeLevels = {"一等奖", "二等奖", "三等奖", "四等奖", "五等奖", "六等奖", "未中奖"};
|
||
for (String level : prizeLevels) {
|
||
countByPrizeLevel.put(level, 0);
|
||
totalBonusByPrizeLevel.put(level, BigDecimal.ZERO);
|
||
}
|
||
|
||
// 统计各等级数量和奖金
|
||
for (PredictRecord record : records) {
|
||
String prizeLevel = record.getPredictResult();
|
||
if (prizeLevel == null) {
|
||
prizeLevel = "未中奖";
|
||
}
|
||
|
||
// 更新计数
|
||
countByPrizeLevel.put(prizeLevel, countByPrizeLevel.getOrDefault(prizeLevel, 0) + 1);
|
||
|
||
// 累计奖金
|
||
if (record.getBonus() != null) {
|
||
BigDecimal bonus = new BigDecimal(record.getBonus().toString());
|
||
totalBonusByPrizeLevel.put(prizeLevel,
|
||
totalBonusByPrizeLevel.getOrDefault(prizeLevel, BigDecimal.ZERO).add(bonus));
|
||
}
|
||
}
|
||
|
||
// 构建返回结果
|
||
List<PrizeEstimateVO.PrizeDetailItem> prizeDetails = new ArrayList<>();
|
||
|
||
// 按顺序添加各等级的统计结果（从高到低）
|
||
for (String level : prizeLevels) {
|
||
// 跳过没有记录的等级
|
||
if (countByPrizeLevel.get(level) <= 0) {
|
||
continue;
|
||
}
|
||
|
||
int count = countByPrizeLevel.get(level);
|
||
BigDecimal totalBonus = totalBonusByPrizeLevel.get(level);
|
||
BigDecimal singlePrize = BigDecimal.ZERO;
|
||
if (count > 0) {
|
||
singlePrize = totalBonus.divide(new BigDecimal(count), 2, RoundingMode.HALF_UP);
|
||
}
|
||
|
||
prizeDetails.add(PrizeEstimateVO.PrizeDetailItem.builder()
|
||
.prizeLevel(level)
|
||
.winningCount(count)
|
||
.singlePrize(singlePrize)
|
||
.subtotal(totalBonus)
|
||
.build());
|
||
}
|
||
|
||
// 计算总奖金
|
||
BigDecimal totalPrize = prizeDetails.stream()
|
||
.map(PrizeEstimateVO.PrizeDetailItem::getSubtotal)
|
||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||
|
||
PrizeEstimateVO result = PrizeEstimateVO.builder()
|
||
.totalPrize(totalPrize)
|
||
.prizeDetails(prizeDetails)
|
||
.build();
|
||
|
||
log.info("用户{}的奖金统计结果：总奖金{}，各等级明细：{}",
|
||
userId, totalPrize, prizeDetails);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 红球命中率统计
|
||
* @param userId 用户ID
|
||
* @return 红球命中率统计信息
|
||
*/
|
||
public RedBallHitRateVO getRedBallHitRate(Long userId) {
|
||
log.info("开始统计用户{}的红球命中率", userId);
|
||
|
||
// 查询用户的所有预测记录（除了"待开奖"状态的）
|
||
QueryWrapper<PredictRecord> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("userId", userId)
|
||
.ne("predictStatus", "待开奖");
|
||
|
||
List<PredictRecord> predictRecords = predictRecordMapper.selectList(queryWrapper);
|
||
|
||
int totalHitCount = 0;
|
||
int totalRecords = predictRecords.size();
|
||
|
||
for (PredictRecord record : predictRecords) {
|
||
// 获取该预测记录对应的开奖信息
|
||
LotteryDraws draw = lotteryDrawsService.getByDrawId(record.getDrawId());
|
||
|
||
if (draw != null) {
|
||
List<Integer> predictedRedBalls = Arrays.asList(
|
||
record.getRedBall1(),
|
||
record.getRedBall2(),
|
||
record.getRedBall3(),
|
||
record.getRedBall4(),
|
||
record.getRedBall5(),
|
||
record.getRedBall6()
|
||
);
|
||
|
||
List<Integer> drawnRedBalls = Arrays.asList(
|
||
draw.getRedBall1(),
|
||
draw.getRedBall2(),
|
||
draw.getRedBall3(),
|
||
draw.getRedBall4(),
|
||
draw.getRedBall5(),
|
||
draw.getRedBall6()
|
||
);
|
||
|
||
// 计算当前记录命中的红球数
|
||
for (Integer predictedBall : predictedRedBalls) {
|
||
if (predictedBall != null && drawnRedBalls.contains(predictedBall)) {
|
||
totalHitCount++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
int totalPredictedCount = totalRecords * 6;
|
||
double hitRate = (totalPredictedCount > 0) ? ((double) totalHitCount / totalPredictedCount) * 100 : 0;
|
||
|
||
RedBallHitRateVO result = RedBallHitRateVO.builder()
|
||
.totalHitCount(totalHitCount)
|
||
.totalPredictedCount(totalPredictedCount)
|
||
.hitRate(hitRate)
|
||
.build();
|
||
|
||
log.info("用户{}的红球命中率统计结果：命中总数{}，预测总数{}，命中率{}%",
|
||
userId, totalHitCount, totalPredictedCount, String.format("%.2f", hitRate));
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 从T4表获取指定主球的26个从球号，取线系数最大值向下26个数字
|
||
* @param masterBallNumber 主球号
|
||
*/
|
||
private List<Integer> getTop26FromT4(Integer masterBallNumber) {
|
||
log.debug("从T4表查询主球{}的线系数数据，取前26个", masterBallNumber);
|
||
|
||
// 查询指定主球的所有数据，按线系数降序排列
|
||
QueryWrapper<T4> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", masterBallNumber)
|
||
.orderByDesc("lineCoefficient")
|
||
.orderByAsc("slaveBallNumber"); // 线系数相同时按从球号升序
|
||
|
||
List<T4> t4List = t4Mapper.selectList(queryWrapper);
|
||
|
||
if (t4List.isEmpty()) {
|
||
log.warn("T4表中主球{}没有数据", masterBallNumber);
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
if (t4List.size() < 26) {
|
||
log.warn("T4表数据不足26条，实际{}条", t4List.size());
|
||
return t4List.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 获取前25个
|
||
List<Integer> result = new ArrayList<>();
|
||
for (int i = 0; i < 25; i++) {
|
||
result.add(t4List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理第26个位置：检查是否有相同的线系数
|
||
Double targetCoefficient = t4List.get(25).getLineCoefficient();
|
||
List<T4> candidatesFor26th = new ArrayList<>();
|
||
|
||
// 找出所有线系数等于第26个位置线系数的记录
|
||
for (int i = 25; i < t4List.size(); i++) {
|
||
if (t4List.get(i).getLineCoefficient().equals(targetCoefficient)) {
|
||
candidatesFor26th.add(t4List.get(i));
|
||
} else {
|
||
break; // 线系数不同，停止查找
|
||
}
|
||
}
|
||
|
||
if (candidatesFor26th.size() == 1) {
|
||
// 只有一个候选，直接添加
|
||
result.add(candidatesFor26th.get(0).getSlaveBallNumber());
|
||
} else {
|
||
// 有多个候选，通过history_top_100表的点系数排序
|
||
log.debug("第26位有{}个相同线系数的候选：{}", candidatesFor26th.size(),
|
||
candidatesFor26th.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallFromHistoryTop100(
|
||
candidatesFor26th.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.add(bestBall);
|
||
}
|
||
|
||
log.debug("T4表主球{}最终选择的26个从球：{}", masterBallNumber, result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 从T5表获取指定主球的12个从球号，取线系数最大值向下12个数字
|
||
* @param masterBallNumber 主球号
|
||
*/
|
||
private List<Integer> getTop12FromT5(Integer masterBallNumber) {
|
||
log.debug("从T5表查询主球{}的线系数数据，取前12个（含毛边处理）", masterBallNumber);
|
||
|
||
// 查询指定主球的所有数据，按线系数降序排列
|
||
QueryWrapper<T5> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", masterBallNumber)
|
||
.orderByDesc("lineCoefficient")
|
||
.orderByAsc("slaveBallNumber"); // 线系数相同时按从球号升序
|
||
|
||
List<T5> t5List = t5Mapper.selectList(queryWrapper);
|
||
|
||
if (t5List.isEmpty()) {
|
||
log.warn("T5表中主球{}没有数据", masterBallNumber);
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
if (t5List.size() < 12) {
|
||
log.warn("T5表数据不足12条，实际{}条", t5List.size());
|
||
return t5List.stream().map(T5::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 完全复刻补齐策略：
|
||
// 1) 找到第12位的阈值系数 targetCoefficient
|
||
// 2) 统计 strictlyGreaterCount = 面系数 > targetCoefficient 的数量
|
||
// 3) 全部选入这 strictlyGreaterCount 个
|
||
// 4) 在“等于 targetCoefficient”的集合中，按 blue_history_top_100 点系数选择 (12 - strictlyGreaterCount) 个
|
||
// 5) 若等于集合不足，再从更小系数中按顺序补足
|
||
|
||
Double targetCoefficient = t5List.get(11).getLineCoefficient();
|
||
|
||
// 统计大于阈值的数量
|
||
int strictlyGreaterCount = 0;
|
||
while (strictlyGreaterCount < t5List.size() &&
|
||
t5List.get(strictlyGreaterCount).getLineCoefficient() > targetCoefficient) {
|
||
strictlyGreaterCount++;
|
||
}
|
||
|
||
// 先加入所有大于阈值的球号
|
||
List<Integer> result = new ArrayList<>();
|
||
for (int i = 0; i < Math.min(strictlyGreaterCount, 12); i++) {
|
||
result.add(t5List.get(i).getSlaveBallNumber());
|
||
}
|
||
if (result.size() >= 12) {
|
||
log.debug("T5表主球{}最终选择的{}个从球：{}", masterBallNumber, result.size(), result);
|
||
return result;
|
||
}
|
||
|
||
// 收集等于阈值的连续区间（紧随其后的相等区）
|
||
List<T5> equalsGroup = new ArrayList<>();
|
||
int idx = strictlyGreaterCount;
|
||
while (idx < t5List.size() && t5List.get(idx).getLineCoefficient().equals(targetCoefficient)) {
|
||
equalsGroup.add(t5List.get(idx));
|
||
idx++;
|
||
}
|
||
|
||
int needFromEquals = 12 - result.size();
|
||
if (!equalsGroup.isEmpty()) {
|
||
List<Integer> eqNums = equalsGroup.stream().map(T5::getSlaveBallNumber).collect(Collectors.toList());
|
||
if (eqNums.size() <= needFromEquals) {
|
||
result.addAll(eqNums);
|
||
} else {
|
||
// 在等于组中先用 blue_history_top_100 分组排序，若边界存在同分，再到 blue_history_top 打破平局
|
||
QueryWrapper<BlueHistoryTop100> qw = new QueryWrapper<>();
|
||
qw.in("ballNumber", eqNums)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber");
|
||
List<BlueHistoryTop100> top100 = blueHistoryTop100Mapper.selectList(qw);
|
||
|
||
List<Integer> picked = new ArrayList<>();
|
||
if (top100.isEmpty()) {
|
||
log.warn("等值候选{}在blue_history_top_100中未找到，按球号升序取前{}个", eqNums, needFromEquals);
|
||
Collections.sort(eqNums);
|
||
picked.addAll(eqNums.subList(0, Math.min(needFromEquals, eqNums.size())));
|
||
} else {
|
||
// 将top100结果按点系数分组（降序）
|
||
Map<Double, List<Integer>> pcGroups = new TreeMap<>(Collections.reverseOrder());
|
||
Set<Integer> inTop100 = new HashSet<>();
|
||
for (BlueHistoryTop100 row : top100) {
|
||
inTop100.add(row.getBallNumber());
|
||
pcGroups.computeIfAbsent(row.getPointCoefficient(), k -> new ArrayList<>())
|
||
.add(row.getBallNumber());
|
||
}
|
||
|
||
// 按组累加，遇到超额的组（边界同分）用 blue_history_top 打破平局
|
||
for (Map.Entry<Double, List<Integer>> e : pcGroups.entrySet()) {
|
||
if (picked.size() >= needFromEquals) break;
|
||
List<Integer> group = e.getValue();
|
||
int remaining = needFromEquals - picked.size();
|
||
if (group.size() <= remaining) {
|
||
// 整组加入
|
||
for (Integer n : group) {
|
||
if (!picked.contains(n)) picked.add(n);
|
||
}
|
||
} else {
|
||
// 边界同分：到 blue_history_top 进行最终排序
|
||
QueryWrapper<BlueHistoryTop> qwTop = new QueryWrapper<>();
|
||
qwTop.in("ballNumber", group)
|
||
.orderByDesc("pointCoefficient")
|
||
.orderByAsc("ballNumber");
|
||
List<BlueHistoryTop> topRows = blueHistoryTopMapper.selectList(qwTop);
|
||
if (!topRows.isEmpty()) {
|
||
List<Integer> ordered = topRows.stream()
|
||
.map(BlueHistoryTop::getBallNumber)
|
||
.collect(Collectors.toList());
|
||
picked.addAll(ordered.subList(0, Math.min(remaining, ordered.size())));
|
||
} else {
|
||
// 若blue_history_top也没有，按球号升序取
|
||
List<Integer> ordered = new ArrayList<>(group);
|
||
Collections.sort(ordered);
|
||
picked.addAll(ordered.subList(0, Math.min(remaining, ordered.size())));
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 若top100覆盖的候选仍不足needFromEquals，再从不在top100中的等值候选补齐（球号升序）
|
||
if (picked.size() < needFromEquals) {
|
||
List<Integer> notInTop100 = eqNums.stream()
|
||
.filter(n -> !inTop100.contains(n))
|
||
.sorted()
|
||
.collect(Collectors.toList());
|
||
int remain = needFromEquals - picked.size();
|
||
picked.addAll(notInTop100.subList(0, Math.min(remain, notInTop100.size())));
|
||
}
|
||
}
|
||
result.addAll(picked);
|
||
}
|
||
}
|
||
|
||
// 若仍不足12，从更小系数的条目继续顺序补足
|
||
idx = strictlyGreaterCount + equalsGroup.size();
|
||
while (result.size() < 12 && idx < t5List.size()) {
|
||
result.add(t5List.get(idx).getSlaveBallNumber());
|
||
idx++;
|
||
}
|
||
|
||
log.debug("T5表主球{}最终选择的{}个从球：{}", masterBallNumber, result.size(), result);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 从T4表获取指定主球的17个从球号，取线系数最大值向下17个数字
|
||
* @param masterBallNumber 主球号
|
||
*/
|
||
private List<Integer> getTop17FromT4(Integer masterBallNumber) {
|
||
log.debug("从T4表查询主球{}的线系数数据，取前17个", masterBallNumber);
|
||
|
||
// 查询指定主球的所有数据，按线系数降序排列
|
||
QueryWrapper<T4> queryWrapper = new QueryWrapper<>();
|
||
queryWrapper.eq("masterBallNumber", masterBallNumber)
|
||
.orderByDesc("lineCoefficient")
|
||
.orderByAsc("slaveBallNumber"); // 线系数相同时按从球号升序
|
||
|
||
List<T4> t4List = t4Mapper.selectList(queryWrapper);
|
||
|
||
if (t4List.isEmpty()) {
|
||
log.warn("T4表中主球{}没有数据", masterBallNumber);
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
if (t4List.size() < 17) {
|
||
log.warn("T4表数据不足17条，实际{}条", t4List.size());
|
||
return t4List.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList());
|
||
}
|
||
|
||
// 获取前16个
|
||
List<Integer> result = new ArrayList<>();
|
||
for (int i = 0; i < 16; i++) {
|
||
result.add(t4List.get(i).getSlaveBallNumber());
|
||
}
|
||
|
||
// 处理第17个位置：检查是否有相同的线系数
|
||
Double targetCoefficient = t4List.get(16).getLineCoefficient();
|
||
List<T4> candidatesFor17th = new ArrayList<>();
|
||
|
||
// 找出所有线系数等于第17个位置线系数的记录
|
||
for (int i = 16; i < t4List.size(); i++) {
|
||
if (t4List.get(i).getLineCoefficient().equals(targetCoefficient)) {
|
||
candidatesFor17th.add(t4List.get(i));
|
||
} else {
|
||
break; // 线系数不同，停止查找
|
||
}
|
||
}
|
||
|
||
if (candidatesFor17th.size() == 1) {
|
||
// 只有一个候选，直接添加
|
||
result.add(candidatesFor17th.get(0).getSlaveBallNumber());
|
||
} else {
|
||
// 有多个候选，通过history_top_100表的点系数排序
|
||
log.debug("第17位有{}个相同线系数的候选：{}", candidatesFor17th.size(),
|
||
candidatesFor17th.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList()));
|
||
|
||
Integer bestBall = selectBestBallFromHistoryTop100(
|
||
candidatesFor17th.stream().map(T4::getSlaveBallNumber).collect(Collectors.toList())
|
||
);
|
||
result.add(bestBall);
|
||
}
|
||
|
||
log.debug("T4表主球{}最终选择的17个从球：{}", masterBallNumber, result);
|
||
return result;
|
||
}
|
||
} |