JavaScript彩票随机算法与数据压缩分发机制解析
本文基于JavaScript探讨彩票随机算法背后的逻辑，解析双色球中奖概率计算。通过对比gzip、brotli等无损压缩技术，展示如何将海量彩票数据压缩至MB级。同时模拟彩票站数据分发策略，包括号码池同步、防劫持机制及高并发下的TPS性能预估，旨在从技术角度透视彩票系统的底层实现。
杂谈
最近似乎对彩票产生了浓厚兴趣，幻想着如果中奖暴富，能让全家都跟着受益。然而现实往往不如人意，缺乏所谓的好运，踏实工作或许才是更可行的出路。
在购买彩票时，我曾深入思考如何从1700万注号码中选出中奖组合。无论是随机选取、精心挑选，还是寻找规律，甚至使用爬虫统计历史数据，这些尝试最终都显得徒劳。
假设彩票系统基于统计学开奖，那么历史上一等奖出现频率最低的号码理论上应该是当期最可能的中奖号码。基于此逻辑，我最初制定了以下策略：
获取历史所有中奖彩票号码数据
编写代码统计每个号码的中奖频次
按出现概率从低到高进行排序
依次组合生成新的投注号码
这虽然有些异想天开，但也是发泄发财欲望的一种方式。以上只是闲聊，哈哈！
上述思路我已实践近一年，结果证明无效。不建议尝试，除非你运气爆棚成为天选之人。
彩票规则
此处以「双色球」规则为例进行说明，购买规则如下：
红球共六位，从1至33中选取，不可重复
蓝球一位，从1至16中选取
红蓝双色球共七位组成一注
一等奖从所有投注注数中产生，可能多人共享，也可能单人购买多倍。
因此，粗略统计的中奖几率计算公式如下：
利用组合数公式，从n个元素中选取k个元素的组合数公式为：
C(kn)=n!k!(n−k)!C\binom{k}{n}=\frac{n!}{k!(n-k)!}C(nk)=k!(n−k)!n!
根据公式，我们可以编写一个简单的算法：
function factorial(n) {
if (n === 0 || n === 1) {
return 1
} else {
return n * factorial(n - 1)
}
}
function combination(n, k) {
return factorial(n) / (factorial(k) * factorial(n - k))
}
console.log(combination(33, 6) * combination(16, 1)) // 17721088由此得出结论，双色球头奖的中奖几率为： 117721088\frac{1}{17721088}177210881
数据量
通过上述算法得知彩票总注数为 17721088，那么这些数据组成的体量究竟有多大？
简单计算，一注彩票可用14个数字表示，如 01020304050607，在操作系统中占用空间为 14B。若所有彩票注数存储在一个文件中，文件大小约为：
const totalSize = 17721088 * 14 / 1024 / 1024 // 236.60205078125MB这是一个庞大的数量，是否可能进一步缩小？我们研究压缩算法。
01在内存中占用两个字节，即 2B。若将 01 替换为小写 a，容量可降至 1B，总体减少约一半。
这样，之前那注特别牛的号码 01020304050607 即可表示为 abcdefg。
这是压缩算法最基本的原理。压缩算法主要分为有损和无损，对于数据类内容，通常选择无损压缩。
- 有损压缩算法：压缩时丢弃部分信息，但通常不影响实际使用，常见于图像、音频和视频压缩。
- 无损压缩算法：不丢弃信息，通过查找重复模式并使用更短符号表示来实现压缩，常用于文本、代码等。
首先准备测试数据，使用以下简单的组合数生成算法获取1000个组合数：
function generateCombinations(arr, len, maxCount) {
let result = []
function generate(current, start) {
// 如果已经生成的组合数量达到了最大数量，则停止生成
if (result.length === maxCount) {
return
}
// 如果当前已经生成的组合长度等于指定长度，则表示已经生成了一种组合
if (current.length === len) {
result.push(current)
return
}
for (let i = start; i < arr.length; i++) {
current.push(arr[i])
generate([...current], i + 1)
current.pop()
}
}
generate([], 0)
return result
}接下来，生成 1000 注双色球，红球从 1 - 33 中取组合数，蓝球从 1 - 16 依次取值。
function getDoubleColorBall(count) {
// 红球数组：['01', '02' .... '33']
const arrRed = Array.from({ length: 33 }, (_, index) => (index + 1).toString().padStart(2, '0'))
const arrRedResult = generateCombinations(arrRed, 6, count)
const result = []
let blue = 1
arrRedResult.forEach(line => {
result.push(line.join('') + (blue++).toString().padStart(2, '0'))
if (blue > 16) {
blue = 1
}
})
return result
}将获取的彩票内容存入文件，以便下一步操作：
const firstPrize = getDoubleColorBall(1000).join('')
fs.writeFileSync('./hello.txt', firstPrize)这样得到了第一版文件，其文件大小如下：
尝试初步压缩算法，将数字到字母的替换规则用 JavaScript 实现，如下：
function compressHello() {
const letters = 'abcdefghijklmnopqrstuvwxyzABCDEFG'
const doubleColorBallStr = getDoubleColorBall(1000).join('')
let resultStr = ''
for (let i = 0; i < doubleColorBallStr.length; i+=2) {
const number = doubleColorBallStr[i] + doubleColorBallStr[i+1]
resultStr += letters[parseInt(number) - 1]
}
return resultStr
}
const firstPrize = compressHello()
fs.writeFileSync('./hello-1.txt', firstPrize)得到全新的 hello 文件，大小如下，印证了我们的想法。
按此算法，文件可压缩至一半大小，即 118.301025390625MB，但这并非极限，这只是基本压缩，接下来尝试更精妙的方法。
更精妙的方法
此处不深入解释压缩算法原理，感兴趣者可自行查阅相关文章，鉴于网上文章质量参差不齐，不做推荐。
我们需要了解，彩票系统的数据压缩应具备以下特征：
具备数据不丢失特性，即无损压缩
压缩率尽可能小，因为传输文件可能非常大，如前例所示
便于信息传输，支持HTTP请求
前端同学应熟悉 HTTP 请求头中的 content-encoding: gzip 参数，在项目优化中常将资源转换为 gzip 分发。日常使用中，我们依赖 Webpack、Rollup 或 nginx 完成资源压缩，gzip 可大幅减少发送内容，且客户端可无损解压访问源文件。
能否使用 gzip 完成压缩？答案是可以，Node.js 提供了 zlib 工具库，提供相应压缩函数：
const zlib = require('zlib')
const firstPrize = compressHello()
fs.writeFileSync('./hello-2.txt.gz', zlib.gzipSync(firstPrize))得到的结果是：
我们完成了 14KB 到 3KB 的压缩过程，是否有趣？当然可能更小。
content-encoding 响应头是服务器针对返回资源响应编码格式的设置信息，常见值有以下几种：
gzip所有浏览器都支持的通用压缩格式brotli比gzip压缩性能更好、压缩率更小的新格式，老版本浏览器不支持deflate出于某些原因使用不广泛，后有基于该算法的zlib压缩格式，但使用度也不高
浏览器支持的压缩格式不止这些，我们列举的是较常用的，尝试使用这三种压缩格式：
const firstPrize = compressHello()
fs.writeFileSync('./hello-2.txt.gz', zlib.gzipSync(firstPrize))
fs.writeFileSync('./hello-2.txt.def', zlib.deflateSync(firstPrize))
fs.writeFileSync('./hello-2.txt.br', zlib.brotliCompressSync(firstPrize))我们可以看到，deflate 和 gzip 的压缩率不相上下，令人惊喜的是，brotli 的压缩竟达到了惊人的 1KB！这正是我们想要的。
还可能更小吗？当然，若不考虑 HTTP 支持，完全可使用如 7-zip 等压缩率更低的算法，由客户端手动解压。但点到为止，更重要的工作尚未完成。
在此之前，需了解解压过程，若解压后数据丢失，则得不偿失。
// 执行解压操作
const brFile = fs.readFileSync('./hello-2.txt.br')
const gzipFile = fs.readFileSync('./hello-2.txt.gz')
const deflateFile = fs.readFileSync('./hello-2.txt.def')
const brFileStr = zlib.brotliDecompressSync(brFile).toString()
const gzipFileStr = zlib.gunzipSync(gzipFile).toString()
const deflateFileStr = zlib.inflateSync(deflateFile).toString()
console.log(brFileStr)
console.log(gzipFileStr)
console.log(deflateFileStr)
console.log(brFileStr === gzipFileStr, brFileStr === deflateFileStr) // true, true如上所述，尽管压缩算法效果惊人，但解压后的数据依然是无损的。
完整的数据
让我们构建完整的 17721088 注数据，测试完整压缩算法的能力。这里使用 brotli 和 gzip 算法分别进行压缩测试。
首先，应修改生成数据的函数，如下：
function generateAll() {
const arrRed = Array.from({ length: 33 }, (_, index) => (index + 1).toString().padStart(2, '0'))
const arrRedResult = generateCombinations(arrRed, 6, Number.MAX_VALUE)
const result = []
arrRedResult.forEach(line => {
for (let i = 1; i <= 16; i++) {
result.push(line.join('') + i.toString().padStart(2, '0'))
}
})
return result
}
console.log(generateAll().length) // 17721088接下来，经过初步压缩并将其写入文件：
function compressAll() {
const letters = 'abcdefghijklmnopqrstuvwxyzABCDEFG'
const allStr = generateAll().join('')
let resultStr = ''
for (let i = 0; i < allStr.length; i += 2) {
const number = allStr[i] + allStr[i+1]
resultStr += letters[parseInt(number) - 1]
}
return resultStr
}
const firstPrize = compressAll()
fs.writeFileSync('./all-ball.txt', firstPrize)
正如预料，经过初步压缩后，文件大小达到约 118MB，实际占用 124MB，属于计算机存储范畴，本文不深入讨论，感兴趣者可自行查阅。根据字节数计算，其大小为：
const totalSize = 124047616 / 1024 / 1024 // 118.30102539 MB目前符合预期，来看看两个压缩算法的真本事。
const firstPrize = compressAll()
fs.writeFileSync('./all-ball.txt.gz', zlib.gzipSync(firstPrize))
fs.writeFileSync('./all-ball.txt.br', zlib.brotliCompressSync(firstPrize))
令人震惊的是，尽管我对 brotli 期待很高，也未想到它能压缩到仅 4MB 大小。但这对我们来说是一件幸事，对后续分发操作有巨大优势。
随机来两注
从彩票站购买彩票时，随机选两注非常常见，但尝试随机号码时会发生什么？
先从彩票数据分发讲起，数据分发的安全性和稳定性设计毋庸置疑，但当前需解决的是如何更低程度地控制成本。
假设由你设计这套系统，如何控制随机号码的中奖率？我的答案是从已有号码池中选择。
若让每个彩票站获取对应号码池，即数据分发。采用数据分发模式需考虑以下问题：
何时进行分发
数据回源如何做
如何避免所有数据被劫持
数据交给彩票站的策略
据2021年公开信息，彩票站数量已达20万家（未查证，无参考价值），假设目前彩票站数量为 30 万家。
何时进行分发
彩票购买截止时间在晚上八点，开奖时间在晚上九点十五。八点之后只能购买下一期彩票，因此从晚上八点开始计划如下：
从现有彩票库中，按号码出现几率从高到低排列
挑选前50万注分发给 30 万彩票站，此时彩票站数据统一
每小时同步一次数据，同步其他彩票站“特意挑选的数据”
50万注数据量有多大？试试看：
function getFirstSend() {
const letters = 'abcdefghijklmnopqrstuvwxyzABCDEFG'
const doubleColorBallStr = getDoubleColorBall(500000).join('')
let resultStr = ''
for (let i = 0; i < doubleColorBallStr.length; i+=2) {
const number = doubleColorBallStr[i] + doubleColorBallStr[i+1]
resultStr += letters[parseInt(number) - 1]
}
return resultStr
}
const firstPrize = getFirstSend()
fs.writeFileSync('./first-send.txt.br', zlib.brotliCompressSync(firstPrize))
仅一张图片的大小，获取这些数据解压同步到彩票机时间不足1秒。
解压示例如下：
function decodeData(brFile) {
const result = []
const content = zlib.brotliDecompressSync(brFile)
// 按照七位每注的结构拆分
for (let i = 0; i < content.length; i += 7) {
result.push(content.slice(i, i + 8))
}
return result
}
const firstSend = fs.readFileSync('./first-send.txt.br')
const firstDataList = decodeData(firstSend)
console.log(firstDataList.length) // 500000如何将获取到的字符形式彩票转换为数字，如 abcdefga 转换为 ['01', '02', '03', '04', '05', '06, '01']：
function letterToCode(letterStr) {
const result = []
const letters = 'abcdefghijklmnopqrstuvwxyzABCDEFG'
for (let i = 0; i < letterStr.length; i++) {
result.push((letters.indexOf(letterStr[i]) + 1).toString().padStart(2, '0'))
}
return result
}至于分发？可参考市面上已有概念做对比，下面是笼统的网络服务器TPS预估值，即彩票服务器1秒内可处理的最大请求数：
- 低性能：TPS 在 50 以下，适用于低流量场景，如个人博客、小型企业网站等。
- 中性能：TPS 在 50~500 之间，适用于一般网站和应用场景，如中小型电商网站、社交网络等。
- 高性能：TPS 在 500~5000 之间，适用于高流量网站和应用场景，如大型电商网站、游戏网站等。
- 超高性能：TPS 在 5000 以上，适用于超高流量网站和应用场景，如互联网巨头网站、在线游戏等。
按此模式，50万彩票站数据同步在100秒内即可完成。当然，这是单机模式，若做彩票服务，单机不可能，需做服务器集群。若有100台服务器集群，处理这些请求仅需 1 秒！（任性吗？有钱当然可以任性！）（这些数据基于理论，不提供参考价值）
数据回源如何做
非常简单！我们需要获取的数据是哪些？未经随机算法、直接被购买的彩票数据，即常说的“守号”老彩民的数据。
同样，根据媒体查询得知（不做参考），彩票站客流量每小时1至10人，经营时间早上九点至晚上九点，最大客流量预计为100人每天。
那么所有彩票站总客流量在 100 * 500000 = 50000000，约五千万人次，约50%属于“守号”人。这里可能需排除已知号码，但先做全部预估，那么
服务器需承载的最大TPS为：
// 服务器集群数量
const machineCount = 100
// 总访问量，50%中的号码才会上报
const totalVisit = 50000000 * 0.5 // 25000000
// 总的时间，因为我们计算的是 10个小时的时间，所以应该计算的总秒数为 36000 秒！
const totalSeconds = 10 * 60 * 60
console.log(totalVisit / totalSeconds / machineCount) // 6.944444444444445TPS仅为7！！这尚未排除已知号码的情况，具体上报逻辑，参考下图：
数据交给彩票站的策略(避免数据被劫持)
所有彩票数据当然不能全交给彩票站，需对数据分层，其他彩票站“特意挑选的数据”即我们要分层分发的数据。这也解决了“如何避免所有数据被劫持”的问题。
那么我们如何对数据进行分层？
简而言之，就是将陕西西安彩票站的购票信息同步给山西太原，将上海市购票信息同步给江苏苏州。当然需考虑点非常多，不仅是两地数据交换，逻辑也复杂，通常需考虑：
- 数据同步难度，跨地区同步对服务器压力巨大，如华南向华北同步
- 数据相似程度，两地数据历史相似度区别大，反而不能达到覆盖目的，因为我们最终是想这注号码被购买更多次
- 数据同步时差，如新疆等地，鉴于网络问题，比其他地慢很多，这样会漏号，那么应把这些地方数据同步到更繁华区域，如上海市，但这点看似与第一二点相悖
就说这么多，说得多了其实我也不懂，或还没想出来。若有这方面厉害的大佬，可提供思路！先看看随机号码结果如何：
我们来尝试随机获取你需要的两注：
function random(count) {
let result = []
for (let i = 0; i < count; i++) {
const index = Math.floor(Math.random() * firstDataList.length)
console.log(firstDataList[index])
result.push(letterToCode(firstDataList[index]))
}
return result
}
console.log(random(2))
OK，你觉得可以中奖吗？哈哈哈，还是有可能的，继续往下看吧。
特意挑的两注
我是一个典型的“守号”人，每天拿着自己算出的几注号码购买彩票，那么我可以中奖吗？（目前没中）
根据上述描述，应知“守号”人购买的号码需判断系统是否存在数据。若存在，则不触发上报；若不存在，则上报系统，由系统将当前号码分发给相邻市或数据近似城市，预期当前号码可被更多人购买。一注号码被购买越多，其中奖概率越低。
不过特意挑选比随机挑选中奖概率大，但也大不到哪里去。
我要一等奖
彩票一等奖基于统计，即使彩票中心存在空号，也需考虑空号产生的二等奖至六等奖数量，这是一个非常庞大的数据量，也需计算大量时间。那么我们如何模拟？
我们取50万注彩票，模拟这些彩票被购买情况，可能产生空号、重复购买或多注等，尝试计算需付出的总金额。
彩票中奖规则如下，浮动奖项暂不考虑，给一等奖和二等奖都赋予固定金额：
6 + 1 一等奖 奖金500万
6 + 0 二等奖 奖金30万
5 + 1 三等奖 奖金3000元
5 + 0 或 4 + 1 四等奖 奖金200元
4 + 0 或 3 + 1 五等奖 奖金10元
2 + 1 或 1 + 1 或 0 + 1 都是 六等奖 奖金 5 元
根据此规则，可先写出对奖函数：
/**
* @param {String[]} target ['01', '02', '03', '04', '05', '06', '07']
* @param {String[]} origin ['01', '02', '03', '04', '05', '06', '07']
* @returns {Number} 返回当前彩票的中奖金额
*/
function compareToMoney(target, origin) {
let money = 0
let rightMatched = target[6] === origin[6]
// 求左边六位的交集数量
let leftMatchCount = target.slice(0, 6).filter(
c => origin.slice(0,6).includes(c)
).length
if (leftMatchCount === 6 && rightMatched) {
money += 5000000
} else if (leftMatchCount === 6 && !rightMatched) {
money += 300000
} else if (leftMatchCount === 5 && rightMatched) {
money += 3000
} else if (leftMatchCount === 5 && !rightMatched) {
money += 200
} else if (leftMatchCount === 4 && rightMatched) {
money += 200
} else if (leftMatchCount === 4 && !rightMatched) {
money += 10
} else if (leftMatchCount === 3 && rightMatched) {
money += 10
} else if (leftMatchCount === 2 && rightMatched) {
money += 5
} else if (leftMatchCount === 1 && rightMatched) {
money += 5
} else if (rightMatched) {
money += 5
}
return money
}那么，应如何得到利益最大化，步骤应如下：
随机生成一组中奖号码
对每个购买数字，检查是否与中奖号码匹配，并计算奖金金额
对所有购买数字的奖金金额求和
重复此过程，直到找到最优中奖号码
随机这个中奖号码非常重要，它决定我们计算整体数据的速度，因此按以下步骤获取：
将所有号码按购买数量排序（其实真实场景应联合考虑中奖号码分布趋势才更精确）
从空号开始查询，依次进行计算
先模拟出我们的购买数据：
function getRandomCode(count = 500000) {
const arrRed = Array.from({ length: 33 }, (_, index) => (index + 1).toString().padStart(2, '0'))
// generateCombinations 是我们上面定义过的函数
const arrRedResult = generateCombinations(arrRed, 6, count)
const result = []
let blue = 1
arrRedResult.forEach(line => {
result.push([...line, (blue++).toString().padStart(2, '0')])
if (blue > 16) {
blue = 1
}
})
return result
}
function randomPurchase() {
const codes = getRandomCode()
const result = []
for (let code of codes) {
let count = Math.floor(Math.random() * 50)
result.push({
code,
count,
})
}
return result
}
console.log(randomPurchase())我们将得到类似下面的数据结构，这对统计较为方便：
[
{
code: [
'01', '02',
'03', '04',
'05', '10',
'05'
],
count: 17
},
{
code: [
'01', '02',
'03', '04',
'05', '11',
'06'
],
count: 4
}
]接下来，就是简单统计，逻辑简单，但对于数据量庞大的彩票来说，需要的时间。
// 空号在前，购买数量越多越靠后
const purchaseList = randomPurchase().sort((a, b) => a.count - b.count)
const bonusPool = []
for (let i = 0; i < purchaseList.length; i++) {
// 假设这就是一等奖，那么就需要计算其价值
const firstPrize = purchaseList[0]
let totalMoney = 0
for (let j = 0; j < purchaseList.length; j++) {
// 与一等奖进行对比，对比规则是参照彩票中奖规则
const money = compareToMoney(purchaseList[j].code, firstPrize.code) * purchaseList[j].count
totalMoney += money
}
bonusPool.push({
code: firstPrize.code,
totalMoney,
})
}
const result = bonusPool.sort((a, b) => a.totalMoney - b.totalMoney)
// 至于怎么挑，那就随心所欲了
console.log(result[0].code, result[0].totalMoney)至于最后的一等奖怎么挑，那就随心所欲了。不过上述算法在我的 M1 芯片计算需近10分钟，若有更强大机器、更厉害算法，时长可缩短，不展开了，累了，就这样吧。
黄粱一梦
终归是黄粱一梦，最终需回归生活，好好工作。不过谁知道呢，等会再买一注如何？
彩票系统纯属臆测，不可能有雷同。
以上就是通过JavaScript看透彩票背后的随机算法的详细内容，更多关于JavaScript 彩票随机算法的资料请关注本站其它相关文章。
JS大数值转字符串出现科学计数法怎么办
2026-11-05 17:09:21
JS split切割后出现空字符串怎么过滤
2026-11-05 16:00:30
在 React 或 Vue 项目中封装使用 JS 节流防抖
2026-11-05 15:27:29
JavaScript中怎么将带小数的字符串转为整数？
2026-11-05 14:32:38
怎么用JavaScript策略模式重构电商促销计算逻辑？
2026-11-05 14:01:09