随机数工具箱：全方位随机化解决方案2025

输入：无
输出：0-1之间的随机小数

应用场景：硬币投掷、游戏抽签

// 示例：生成指定范围的整数
function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}
 
// 使用示例
const dice = randomInt(1, 6); // 模拟掷骰子
const day = randomInt(1, 31); // 生成月份中的随机一天

// 生成指定精度的小数
function randomFloat(min, max, precision = 2) {
  const factor = Math.pow(10, precision);
  return Math.round((Math.random() * (max - min) + min) * factor) / factor;
}
 
// 使用示例
const price = randomFloat(10.00, 99.99, 2); // 生成随机价格
const temperature = randomFloat(-10, 40, 1); // 生成随机温度

function weightedRandom(items) {
  const totalWeight = items.reduce((sum, item) => sum + item.weight, 0);
  let random = Math.random() * totalWeight;
 
  for (let item of items) {
    random -= item.weight;
    if (random <= 0) {
      return item;
    }
  }
  return items[items.length - 1]; // 兜底返回
}
 
// 使用示例
const rewards = [
  { name: "金币 x100", weight: 50 },
  { name: "钻石 x10", weight: 20 },
  { name: "传说装备", weight: 5 },
  { name: "谢谢参与", weight: 25 }
];
 
const reward = weightedRandom(rewards);
console.log(`恭喜获得：${reward.name}`);

// Fisher-Yates 洗牌算法
function shuffleArray(array) {
  const shuffled = [...array];
  for (let i = shuffled.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
  }
  return shuffled;
}
 
// 使用示例
const teamMembers = ["张三", "李四", "王五", "赵六"];
const shuffled = shuffleArray(teamMembers);
console.log("随机分配的任务顺序：", shuffled);

function randomGrouping(items, groupCount) {
  const shuffled = shuffleArray(items);
  const groups = Array.from({ length: groupCount }, () => []);
 
  shuffled.forEach((item, index) => {
    groups[index % groupCount].push(item);
  });
 
  return groups;
}
 
// 使用示例
const students = Array.from({ length: 30 }, (_, i) => `学生${i + 1}`);
const groups = randomGrouping(students, 6);
groups.forEach((group, index) => {
  console.log(`第${index + 1}组：`, group);
});

# Python示例：从总体中随机抽取样本
import random
 
def simple_random_sampling(population, sample_size):
    """简单随机抽样"""
    return random.sample(population, sample_size)
 
# 使用示例
all_customers = list(range(1, 10001))  # 10000个客户
survey_sample = simple_random_sampling(all_customers, 100)
print(f"已随机抽取100个客户进行调研")

def stratified_random_sampling(data, strata_col, sample_ratio=0.1):
    """分层随机抽样"""
    from collections import defaultdict
 
    # 按层分组
    strata = defaultdict(list)
    for item in data:
        strata[item[strata_col]].append(item)
 
    # 每层按比例抽样
    sample = []
    for stratum_items in strata.values():
        stratum_sample = random.sample(
            stratum_items,
            max(1, int(len(stratum_items) * sample_ratio))
        )
        sample.extend(stratum_sample)
 
    return sample

选项：[日式料理, 意大利菜, 川菜, 韩料, 泰餐]
输出：随机推荐一家餐厅
节省时间：平均15分钟决策时间

输入：已搭配方案列表
功能：随机选择一套搭配
应用：打破选择困难症
效果：节省早晨准备时间40%

输入：备选活动列表
输出：随机推荐活动
特点：支持权重（天气、心情、预算）

function meetingAgenda(order) {
  const topics = [
    "项目进展汇报",
    "问题讨论",
    "下周计划",
    "资源配置",
    "其他事项"
  ];
 
  // 使用随机排序确定议题顺序
  const shuffledTopics = shuffleArray(topics);
 
  console.log("=== 会议议程 ===");
  shuffledTopics.forEach((topic, index) => {
    console.log(`${index + 1}. ${topic}`);
  });
}
 
meetingAgenda();

# 估算π值
import random
import math
 
def estimate_pi(num_samples=1000000):
    """使用蒙特卡洛方法估算π"""
    inside_circle = 0
    total_samples = num_samples
 
    for _ in range(total_samples):
        x = random.uniform(-1, 1)
        y = random.uniform(-1, 1)
        if x*x + y*y <= 1:
            inside_circle += 1
 
    return 4 * inside_circle / total_samples
 
# 运行估算
pi_estimate = estimate_pi(1000000)
print(f"估算的π值：{pi_estimate}")
print(f"误差：{abs(pi_estimate - math.pi):.6f}")

# 简化版A/B测试
import random
 
class ABTest:
    def __init__(self, test_name, variants):
        self.test_name = test_name
        self.variants = variants  # [{name: "A", weight: 0.5}, {name: "B", weight: 0.5}]
        self.assignments = {}
 
    def assign_user(self, user_id):
        """为用户分配测试组"""
        if user_id in self.assignments:
            return self.assignments[user_id]
 
        # 基于权重随机分配
        random_value = random.random()
        cumulative = 0
 
        for variant in self.variants:
            cumulative += variant['weight']
            if random_value <= cumulative:
                self.assignments[user_id] = variant['name']
                return variant['name']
 
        return self.variants[-1]['name']  # 兜底
 
# 使用示例
test = ABTest("按钮颜色测试", [
    {"name": "红色", "weight": 0.5},
    {"name": "蓝色", "weight": 0.5}
])
 
# 模拟用户分配
for i in range(1000):
    variant = test.assign_user(f"user_{i}")
    print(f"用户{i}被分配到：{variant}组")

// 个人书单管理工具
const myBooks = [
  { title: "《深度学习》", category: "技术", weight: 3, unread: true },
  { title: "《人类简史》", category: "历史", weight: 2, unread: true },
  { title: "《设计心理学》", category: "设计", weight: 2, unread: true },
  { title: "《随机漫步的傻瓜》", category: "投资", weight: 1, unread: true }
];
 
function pickNextBook(books) {
  const unreadBooks = books.filter(book => book.unread);
  return weightedRandom(unreadBooks);
}
 
// 每月制定读书计划
function planMonthlyReading() {
  const selectedBooks = [];
  let remainingSlots = 4; // 每月4本书
 
  while (remainingSlots > 0) {
    const nextBook = pickNextBook(myBooks);
    if (!selectedBooks.find(b => b.title === nextBook.title)) {
      selectedBooks.push(nextBook);
      remainingSlots--;
    }
  }
 
  return selectedBooks;
}

// 课堂提问系统
class ClassroomPicker {
  constructor(students) {
    this.students = students;
    this.pickHistory = [];
  }
 
  pickNextStudent() {
    // 排除最近提问过的学生
    const recentPicked = this.pickHistory.slice(-10);
    const available = this.students.filter(s =>
      !recentPicked.includes(s.id)
    );
 
    const selected = available[Math.floor(Math.random() * available.length)];
    this.pickHistory.push(selected.id);
 
    return selected;
  }
 
  getStats() {
    const pickedCount = {};
    this.students.forEach(s => {
      pickedCount[s.id] = this.pickHistory.filter(id => id === s.id).length;
    });
    return pickedCount;
  }
}
 
// 使用示例
const class5A = new ClassroomPicker(
  Array.from({ length: 45 }, (_, i) => ({ id: i + 1, name: `学生${i + 1}` }))
);
 
// 一学期后统计

def balanced_grouping(students, group_size=6):
    """平衡分组算法"""
    groups = []
    remaining = students.copy()
 
    while remaining:
        group = []
        for _ in range(min(group_size, len(remaining))):
            # 选择与当前组最互补的学生
            candidate = select_best_match(group, remaining)
            group.append(candidate)
            remaining.remove(candidate)
        groups.append(group)
 
    return groups
 
def select_best_match(group, candidates):
    """选择与组内成员最互补的候选人"""
    best_candidate = None
    best_score = float('-inf')
 
    for candidate in candidates:
        score = calculate_complementarity(group, candidate)
        if score > best_score:
            best_score = score
            best_candidate = candidate
 
    return best_candidate

class CustomerServiceAssigner {
  constructor(agents) {
    this.agents = agents; // [{id, status, current_load, skill_level}]
    this.customerQueue = [];
  }
 
  assignCustomer(customer) {
    const availableAgents = this.agents.filter(a => a.status === 'available');
 
    if (availableAgents.length === 0) {
      this.customerQueue.push(customer);
      return null;
    }
 
    // 使用权重分配：负载低、技能高的客服优先级高
    const weights = availableAgents.map(agent => {
      let weight = 100;
 
      // 负载权重：当前负载越低权重越高
      weight -= agent.current_load * 10;
 
      // 技能权重：技能等级越高权重越高
      weight += agent.skill_level * 5;
 
      return weight;
    });
 
    const selectedAgent = weightedRandomByWeights(availableAgents, weights);
    selectedAgent.current_load++;
    selectedAgent.status = 'busy';
 
    return selectedAgent;
  }
 
  weightedRandomByWeights(items, weights) {
    const totalWeight = weights.reduce((sum, w) => sum + w, 0);
    let random = Math.random() * totalWeight;
 
    for (let i = 0; i < items.length; i++) {
      random -= weights[i];
      if (random <= 0) {
        return items[i];
      }
    }
 
    return items[items.length - 1];
  }
}

import random
 
class LotterySystem:
    def __init__(self):
        self.prizes = {
            "特等奖": {"count": 1, "value": 50000, "probability": 0.00001 },
            "一等奖": {"count": 10, "value": 5000, "probability": 0.0001 },
            "二等奖": {"count": 100, "value": 500, "probability": 0.001 },
            "三等奖": {"count": 1000, "value": 50, "probability": 0.01 },
            "参与奖": {"count": 50000, "value": 5, "probability": 0.1 }
        }
 
    def draw_lottery(self, user_id):
        """抽奖算法"""
        # 用户已经中过高级奖项？降级处理
        user_history = self.get_user_history(user_id)
 
        if user_history.get("特等奖"):
            return self.draw_with_restrictions("参与奖")
        elif user_history.get("一等奖"):
            return self.draw_with_restrictions(["二等奖", "三等奖", "参与奖"])
 
        return self.draw_with_restrictions(list(self.prizes.keys()))
 
    def draw_with_restrictions(self, allowed_prizes):
        """带限制的抽奖"""
        weights = [self.prizes[prize]["probability"] for prize in allowed_prizes]
        selected = weighted_random_choice(allowed_prizes, weights)
 
        # 减少奖品库存
        self.prizes[selected]["count"] -= 1
 
        return selected
 
def weighted_random_choice(choices, weights):
    """加权随机选择"""
    total = sum(weights)
    r = random.uniform(0, total)
    upto = 0
    for choice, weight in zip(choices, weights):
        if upto + weight >= r:
            return choice
        upto += weight
    return choices[-1]

前端界面 → 随机算法 → 结果输出

负载均衡器 → 多个随机服务实例 → 分布式缓存 → 数据库

API网关 → 随机数服务 → 用户服务 → 审计服务 → 通知服务

// 基础随机数（不适合安全场景）
const basic = Math.random();
 
// 密码学安全随机数（推荐用于安全场景）
const secure = crypto.getRandomValues(new Uint32Array(1))[0] / 0xFFFFFFFF;

# 使用卡方检验测试随机数分布
import random
from scipy import stats
 
def test_randomness(n=10000, k=10):
    """测试随机数分布的均匀性"""
    counts = [0] * k
 
    for _ in range(n):
        value = random.randint(0, k-1)
        counts[value] += 1
 
    expected = n / k
    chi2, p_value = stats.chisquare(counts)
 
    print(f"卡方统计量: {chi2:.4f}")
    print(f"p值: {p_value:.4f}")
    print(f"分布均匀性: {'通过' if p_value > 0.05 else '不通过'}")
 
test_randomness()

import random
from queue import Queue
 
class RandomNumberPool:
    def __init__(self, pool_size=10000):
        self.pool = Queue(maxsize=pool_size)
        self._fill_pool()
 
    def _fill_pool(self):
        """预填充随机数池"""
        while not self.pool.full():
            self.pool.put(random.random())
 
    def get_random(self):
        """获取随机数（带补充机制）"""
        if self.pool.empty():
            self._fill_pool()
        return self.pool.get()

// 批量生成比单个生成更高效
function generateBatch(count) {
  const batch = [];
  const randomArray = new Uint32Array(count);
  crypto.getRandomValues(randomArray);
 
  for (let i = 0; i < count; i++) {
    batch.push(randomArray[i] / 0xFFFFFFFF);
  }
 
  return batch;
}
 
// 性能对比测试
console.time('单个生成10000个');
for (let i = 0; i < 10000; i++) {
  Math.random();
}
console.timeEnd('单个生成10000个');
 
console.time('批量生成10000个');
generateBatch(10000);
console.timeEnd('批量生成10000个');

class RandomDecisionLogger {
  constructor() {
    this.decisions = [];
  }
 
  logDecision(category, input, output, algorithm, timestamp = Date.now()) {
    this.decisions.push({
      category,      // 决策类别
      input,         // 输入参数
      output,        // 输出结果
      algorithm,     // 使用的算法
      timestamp,     // 时间戳
      hash: this._calculateHash(category, input, output) // 结果哈希
    });
  }
 
  _calculateHash(...args) {
    // 简化版哈希计算
    return args.join('|').split('').reduce((acc, char) => {
      return ((acc << 5) - acc) + char.charCodeAt(0);
    }, 0);
  }
 
  getDecisionHistory(filter = {}) {
    return this.decisions.filter(decision => {
      for (let key in filter) {
        if (decision[key] !== filter[key]) {
          return false;
        }
      }
      return true;
    });
  }
}
 
// 使用示例
const logger = new RandomDecisionLogger();
 
// 记录一次随机决策
logger.logDecision(
  "餐厅推荐",
  { options: ["川菜", "粤菜", "西餐"] },
  "川菜",
  "weighted_random",
  Date.now()
);

<!DOCTYPE html>
<html>
<head>
  <style>
    .spinning-wheel {
      width: 200px;
      height: 200px;
      border-radius: 50%;
      border: 10px solid #333;
      position: relative;
      animation: spin 3s cubic-bezier(0.23, 1, 0.32, 1);
    }
 
    @keyframes spin {
      from { transform: rotate(0deg); }
      to { transform: rotate(1440deg); }
    }
 
    .result-display {
      margin-top: 20px;
      font-size: 24px;
      font-weight: bold;
      color: #2c3e50;
    }
  </style>
</head>
<body>
  <div class="spinning-wheel"></div>
  <div class="result-display" id="result"></div>
 
  <script>
    // 随机选择动画效果
    function spinAndSelect(options) {
      const wheel = document.querySelector('.spinning-wheel');
      const result = document.getElementById('result');
 
      setTimeout(() => {
        const selected = options[Math.floor(Math.random() * options.length)];
        result.textContent = `结果：${selected}`;
      }, 3000);
    }
  </script>
</body>
</html>

# ❌ 错误示例
random.seed(time.time())  # 可预测
 
# ✅ 正确示例
import secrets
random.seed(secrets.randbits(256))  # 密码学安全

// ❌ 错误示例：未处理边界
function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min)) + min;
}
// 当min > max时会出错
 
// ✅ 正确示例
function randomInt(min, max) {
  if (min > max) {
    [min, max] = [max, min]; // 交换
  }
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

// ❌ 错误示例：可能产生重复
const samples = [];
for (let i = 0; i < 10; i++) {
  samples.push(Math.floor(Math.random() * 100));
}
 
// ✅ 正确示例：保证唯一性
const samples = new Set();
while (samples.size < 10) {
  samples.add(Math.floor(Math.random() * 100));
}

// POST /api/v1/random/generate
app.post('/api/v1/random/generate', (req, res) => {
  const { min, max, count, type, weights } = req.body;
 
  let results = [];
 
  switch (type) {
    case 'integer':
      results = generateRandomIntegers(min, max, count);
      break;
    case 'float':
      results = generateRandomFloats(min, max, count);
      break;
    case 'weighted':
      results = generateWeightedRandom(weights, count);
      break;
    default:
      return res.status(400).json({ error: 'Invalid type' });
  }
 
  // 记录审计日志
  logAuditEvent({
    user: req.user.id,
    operation: 'generate',
    type,
    count: results.length,
    timestamp: Date.now()
  });
 
  res.json({
    success: true,
    data: results,
    meta: {
      count: results.length,
      timestamp: Date.now()
    }
  });
});

type Query {
  randomInt(min: Int!, max: Int!): Int!
  randomFloat(min: Float!, max: Float!, precision: Int = 2): Float!
  randomFromList(list: [String!]!, weights: [Float]): String!
  randomBatch(count: Int!, min: Int, max: Int): [Int!]!
}
 
type Mutation {
  generateSeeded(seed: String!, min: Int!, max: Int!): Int!
}
 
type Subscription {
  randomStream(min: Int!, max: Int!): Int!
}

import matplotlib.pyplot as plt
import numpy as np
import random
 
# 生成随机数据
data = [random.randint(1, 100) for _ in range(1000)]
 
# 绘制直方图
plt.hist(data, bins=20, alpha=0.7, color='skyblue')
plt.title('随机数分布直方图')
plt.xlabel('数值')
plt.ylabel('频次')
plt.show()
 
# 绘制散点图
x = [random.random() for _ in range(100)]
y = [random.random() for _ in range(100)]
 
plt.figure(figsize=(10, 6))
plt.scatter(x, y, alpha=0.6)
plt.title('随机数散点图 (x vs y)')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

// D3.js 可视化
const width = 400;
const height = 400;
const radius = Math.min(width, height) / 2;
 
const svg = d3.select("#chart")
  .append("svg")
  .attr("width", width)
  .attr("height", height);
 
const g = svg.append("g")
  .attr("transform", `translate(${width / 2}, ${height / 2})`);
 
// 创建饼图
const pie = d3.pie().value(d => d.value);
const arc = d3.arc().innerRadius(0).outerRadius(radius);
 
// 随机数据
const data = [
  { label: "选项A", value: 30 },
  { label: "选项B", value: 20 },
  { label: "选项C", value: 40 },
  { label: "选项D", value: 10 }
];
 
// 绘制
const arcs = g.selectAll(".arc")
  .data(pie(data))
  .enter()
  .append("g")
  .attr("class", "arc");
 
arcs.append("path")
  .attr("d", arc)
  .attr("fill", (d, i) => d3.schemeCategory10[i]);
 
arcs.append("text")
  .attr("transform", d => `translate(${arc.centroid(d)})`)
  .attr("text-anchor", "middle")
  .text(d => d.data.label);

import numpy as np
import pandas as pd
 
def monte_carlo_risk_assessment(portfolio_value, volatility, time_horizon=252, num_simulations=10000):
    """
    使用蒙特卡洛模拟评估投资组合风险
    """
    results = []
 
    for _ in range(num_simulations):
        # 生成随机收益率序列
        returns = np.random.normal(0, volatility/np.sqrt(252), time_horizon)
 
        # 计算累计收益
        cumulative_returns = np.cumprod(1 + returns)
 
        # 计算最终价值
        final_value = portfolio_value * cumulative_returns[-1]
 
        results.append(final_value)
 
    return np.array(results)
 
# 使用示例
portfolio_value = 1000000  # 100万投资组合
volatility = 0.15  # 15%年化波动率
 
simulation_results = monte_carlo_risk_assessment(portfolio_value, volatility)
 
# 计算风险指标
var_95 = np.percentile(simulation_results, 5)  # 95% VaR
var_99 = np.percentile(simulation_results, 1)  # 99% VaR
expected_value = np.mean(simulation_results)
 
print(f"95% VaR: ${portfolio_value - var_95:,.2f}")
print(f"99% VaR: ${portfolio_value - var_99:,.2f}")
print(f"预期价值: ${expected_value:,.2f}")
 
# 绘制风险分布图
import matplotlib.pyplot as plt
 
plt.hist(simulation_results, bins=50, alpha=0.7)
plt.axvline(portfolio_value, color='green', linestyle='--', label='初始价值')
plt.axvline(var_95, color='red', linestyle='--', label='95% VaR')
plt.xlabel('最终投资组合价值 ($)')
plt.ylabel('频次')
plt.title('蒙特卡洛风险模拟结果')
plt.legend()
plt.show()

class LootDropSystem {
  constructor(dropTable) {
    this.dropTable = dropTable; // 掉落表
  }
 
  rollDrop() {
    const rand = Math.random();
    let cumulative = 0;
 
    for (const item of this.dropTable) {
      cumulative += item.probability;
      if (rand <= cumulative) {
        return {
          item: item.name,
          rarity: item.rarity,
          isRare: item.probability < 0.01
        };
      }
    }
 
    return { item: "空气", rarity: "common", isRare: false };
  }
 
  simulateDrops(numRolls = 10000) {
    const results = {};
    const rareCount = { count: 0, total: 0 };
 
    for (let i = 0; i < numRolls; i++) {
      const drop = this.rollDrop();
      results[drop.item] = (results[drop.item] || 0) + 1;
 
      if (drop.isRare) {
        rareCount.count++;
      }
      rareCount.total++;
    }
 
    return {
      distribution: results,
      rareDropRate: rareCount.count / rareCount.total
    };
  }
}
 
// 使用示例：MMORPG装备掉落表
const lootTable = [
  { name: "普通武器", rarity: "common", probability: 0.70 },
  { name: "精良武器", rarity: "uncommon", probability: 0.20 },
  { name: "稀有武器", rarity: "rare", probability: 0.08 },
  { name: "史诗武器", rarity: "epic", probability: 0.019 },
  { name: "传说武器", rarity: "legendary", probability: 0.001 }
];
 
const lootSystem = new LootDropSystem(lootTable);
 
// 模拟10000次掉落
const simulation = lootSystem.simulateDrops(10000);
console.log("掉落分布:", simulation.distribution);
console.log("稀有物品掉率:", (simulation.rareDropRate * 100).toFixed(2) + "%");

import random
from collections import Counter
 
class ClinicalTrialRandomizer:
    def __init__(self, participants):
        self.participants = participants
        self.assignments = {}
        self.blocks = []  # 区组大小
 
    def stratified_randomization(self, strata_col, treatment_ratio=1):
        """
        分层随机分组
        """
        strata = {}
 
        # 按层分组
        for participant in self.participants:
            stratum = participant[strata_col]
            if stratum not in strata:
                strata[stratum] = []
            strata[stratum].append(participant)
 
        # 每层内随机分配
        for stratum, members in strata.items():
            # 随机打乱
            random.shuffle(members)
 
            # 计算分组数量
            treatment_count = int(len(members) * treatment_ratio / (1 + treatment_ratio))
            control_count = len(members) - treatment_count
 
            # 分配治疗组和对照组
            for i, member in enumerate(members):
                if i < treatment_count:
                    self.assignments[member['id']] = 'treatment'
                else:
                    self.assignments[member['id']] = 'control'
 
        return self.assignments
 
    def block_randomization(self, block_size=4):
        """
        区组随机分组
        """
        self.blocks = []
        ids = list(self.assignments.keys())
 
        while len(ids) >= block_size:
            block = ids[:block_size]
            ids = ids[block_size:]
            self.blocks.append(block)
 
            # 随机分配区组内治疗/对照组
            random.shuffle(block)
            treatment_count = block_size // 2
 
            for i, participant_id in enumerate(block):
                if i < treatment_count:
                    self.assignments[participant_id] = 'treatment'
                else:
                    self.assignments[participant_id] = 'control'
 
        # 处理剩余参与者
        for participant_id in ids:
            self.assignments[participant_id] = random.choice(['treatment', 'control'])
 
        return self.assignments
 
# 使用示例
participants = [
    {'id': f'P{i:03d}', 'age_group': '18-35', 'gender': random.choice(['M', 'F'])}
    for i in range(1, 201)  # 200名参与者
]
 
randomizer = ClinicalTrialRandomizer(participants)
randomizer.stratified_randomization('age_group')
randomizer.block_randomization()
 
# 统计分析
assignment_counter = Counter(randomizer.assignments.values())
print(f"治疗组: {assignment_counter['treatment']}")
print(f"对照组: {assignment_counter['control']}")
 
# 验证分组平衡性
from scipy import stats
 
treatment_ages = [
    next(p['age_group'] for p in participants if p['id'] == pid)
    for pid, group in randomizer.assignments.items()
    if group == 'treatment'
]
control_ages = [
    next(p['age_group'] for p in participants if p['id'] == pid)
    for pid, group in randomizer.assignments.items()
    if group == 'control'
]
 
# 卡方检验年龄分布
chi2, p_value = stats.chi2_contingency([
    Counter(treatment_ages),
    Counter(control_ages)
])[:2]
 
print(f"年龄分布平衡性检验 p值: {p_value:.4f}")

# 使用统计测试验证随机性
def test_random_quality():
    values = [random.random() for _ in range(10000)]
 
    # 1. 均匀性检验
    bins = np.histogram(values, bins=10)[0]
    chi2, p = stats.chisquare(bins)
    print(f"均匀性检验 p值: {p:.4f}")
 
    # 2. 序列相关性检验
    x = values[:-1]
    y = values[1:]
    correlation = np.corrcoef(x, y)[0, 1]
    print(f"序列相关系数: {correlation:.6f}")
 
test_random_quality()

# Python示例
import secrets
 
# 生成安全随机数
secure_random = secrets.randbelow(100)
print(f"安全随机数: {secure_random}")
 
# 生成安全随机字节
secure_bytes = secrets.token_bytes(16)
print(f"安全随机字节: {secure_bytes.hex()}")
 
# 生成安全随机十六进制字符串
secure_hex = secrets.token_hex(32)
print(f"安全随机十六进制: {secure_hex}")

import random
sample = random.sample(population, 1000)

import random
sample = random.sample(population, 10000)

import numpy as np
# 使用蓄水池抽样
def reservoir_sampling(stream, k):
    reservoir = stream[:k]
    for i in range(k, len(stream)):
        j = random.randint(0, i)
        if j < k:
            reservoir[j] = stream[i]
    return reservoir

import pandas as pd
# 使用采样函数
sample = population.sample(n=100000, random_state=42)

class CrossPlatformRandom {
  constructor(seed = Date.now()) {
    this.seed = seed;
    this.mt = this.createMersenneTwister(seed);
  }
 
  createMersenneTwister(seed) {
    // 梅森旋转算法实现
    return {
      state: new Uint32Array(624),
      index: 0,
      initialize(seed) {
        this.state[0] = seed >>> 0;
        for (let i = 1; i < 624; i++) {
          this.state[i] = (1812433253 * (this.state[i - 1] ^ (this.state[i - 1] >>> 30)) + i) >>> 0;
        }
      },
      // ... 更多实现
    };
  }
 
  next() {
    return this.mt.next();
  }
 
  // 确保不同平台相同种子产生相同结果
  static create(seed) {
    return new CrossPlatformRandom(seed);
  }
}

// 性能测试
function benchmark() {
  const iterations = 1000000;
 
  // 测试单个生成
  console.time('单个生成100万次');
  for (let i = 0; i < iterations; i++) {
    Math.random();
  }
  console.timeEnd('单个生成100万次');
 
  // 测试批量生成
  console.time('批量生成100万次');
  const batch = new Uint32Array(iterations);
  crypto.getRandomValues(batch);
  console.timeEnd('批量生成100万次');
 
  // 测试加权随机
  console.time('加权随机10万次');
  const weights = [1, 2, 3, 4, 5];
  for (let i = 0; i < 100000; i++) {
    weightedRandom(weights);
  }
  console.timeEnd('加权随机10万次');
}

import random
 
# 实验A：使用固定种子
random.seed(42)
result_a = [random.randint(1, 100) for _ in range(10)]
print("实验A结果:", result_a)
 
# 实验B：使用相同种子，相同结果
random.seed(42)
result_b = [random.randint(1, 100) for _ in range(10)]
print("实验B结果:", result_b)
 
# 实验C：使用不同种子，不同结果
random.seed(43)
result_c = [random.randint(1, 100) for _ in range(10)]
print("实验C结果:", result_c)
 
# 结论
assert result_a == result_b, "相同种子应产生相同结果"
assert result_a != result_c, "不同种子应产生不同结果"