python系统测算

import numpy as np

# 参数设置
days = 30  # 模拟天数
init_users = 5  # 初始用户数
order_amounts = [1000, 2000, 5000]  # 报单金额选项
order_probs = [0.4, 0.35, 0.25]  # 报单金额概率
p_order = 0.2  # 每天报单概率
p_promote = 0.1  # 每天推广新用户概率
base_release_rate = 0.001  # 基础释放率0.1%
accel_release_rate = 0.005  # 加速释放率0.5%


# 开奖率场景（外部输入）
def blind_box_draw(scenario):
    if scenario == 'A':  # 均匀
        return np.random.choice([1, 2, 3, 4], p=[0.25, 0.25, 0.25, 0.25])
    elif scenario == 'B':  # 低倍率
        return np.random.choice([1, 2, 3, 4], p=[0.4, 0.3, 0.2, 0.1])
    elif scenario == 'C':  # 高倍率
        return np.random.choice([1, 2, 3, 4], p=[0.1, 0.2, 0.3, 0.4])


# 用户类
class User:
    def __init__(self, user_id, referrer=None, leg=None):
        self.id = user_id
        self.referrer = referrer  # 推广者
        self.leg = leg  # 'left' 或 'right'，表示在推广者市场中的位置
        self.pending = 0  # 待释放积分
        self.available = 0  # 可用积分
        self.total_orders = 0  # 累计报单总额（用于50,000限额）
        self.left_team = []  # 左区下线
        self.right_team = []  # 右区下线
        self.orders = []  # 报单记录

    def add_order(self, amount, scenario):
        # 检查限额: 新报单 + 正在返还订单总额 <= 50,000
        if self.available >= amount and (self.total_orders + amount) <= 50000:
            multiplier = blind_box_draw(scenario)  # 抽取盲盒
            points_gained = amount * multiplier
            self.pending += points_gained  # 积分加至待释放
            self.total_orders += amount
            self.orders.append(amount)
            return True
        return False

    def release_points(self, rate):
        release_amount = self.pending * rate
        self.available += release_amount
        self.pending -= release_amount
        return release_amount


# 模拟函数
def simulate(scenario):
    users = [User(i) for i in range(init_users)]  # 初始化用户
    # 初始报单: 每个用户报单1000
    for user in users:
        user.add_order(1000, scenario)

    # 记录指标
    metrics = {
        'day': [], 'total_pending': [], 'total_available': [], 'num_users': [],
        'num_orders': [], 'team_growth': [], 'release_rate': [], 'total_team_points': []
    }
    zero_growth_streak = 0  # 连续零增长天数

    for day in range(1, days + 1):
        # 新增用户: 推广
        new_users = []
        for user in list(users):  # 遍历现有用户
            if np.random.rand() < p_promote:
                new_id = len(users)
                leg = 'left' if np.random.rand() < 0.5 else 'right'  # 随机分配市场
                new_user = User(new_id, referrer=user, leg=leg)
                users.append(new_user)
                new_users.append(new_user)
                # 新用户报单1000
                new_user.add_order(1000, scenario)
                # 推广者获得1000可用积分
                user.available += 1000
                # 添加到推广者市场
                if leg == 'left':
                    user.left_team.append(new_user)
                else:
                    user.right_team.append(new_user)

        # 现有用户报单
        num_orders = 0
        for user in users:
            if np.random.rand() < p_order:
                amount = np.random.choice(order_amounts, p=order_probs)
                if user.add_order(amount, scenario):
                    num_orders += 1

        # 团队加速: 计算每个推广者的有效团队积分并赠送
        for user in users:
            if user.left_team or user.right_team:  # 如果是推广人员
                L = sum(u.total_orders for u in user.left_team)  # 左区总报单金额
                R = sum(u.total_orders for u in user.right_team)  # 右区总报单金额
                min_R = min(R, L / 10)  # 有效小市场
                effective_team_points = 11 * min_R  # 有效团队积分
                user.pending += effective_team_points  # 赠送积分加至待释放

        # 计算全局团队总积分和增长
        total_team_points = 0
        for user in users:
            L = sum(u.total_orders for u in user.left_team)
            R = sum(u.total_orders for u in user.right_team)
            total_team_points += L + R
            
        if day == 1:
            team_growth = total_team_points  # 第1天增长为初始值
        else:
            team_growth = total_team_points - metrics['total_team_points'][-1]

        # 释放率管理
        if team_growth == 0:
            zero_growth_streak += 1
            if zero_growth_streak >= 3:
                release_rate = base_release_rate  # 连续3天增长0, 释放率0.1%
            elif zero_growth_streak >= 4:
                release_rate = 0.0049  # 第4天增长0, 释放0.49%
            else:
                release_rate = accel_release_rate
        else:
            zero_growth_streak = 0
            release_rate = accel_release_rate  # 团队加速日, 释放率0.5%

        # 积分释放
        total_release = 0
        for user in users:
            total_release += user.release_points(release_rate)

        # 记录指标
        total_pending = sum(user.pending for user in users)
        total_available = sum(user.available for user in users)
        metrics['day'].append(day)
        metrics['total_pending'].append(total_pending)
        metrics['total_available'].append(total_available)
        metrics['num_users'].append(len(users))
        metrics['num_orders'].append(num_orders)
        metrics['team_growth'].append(team_growth)
        metrics['release_rate'].append(release_rate)
        metrics['total_team_points'].append(total_team_points)

    return metrics

if __name__ == '__main__':
    # 运行模拟 for each scenario
    metrics_A = simulate('A')  # 场景A
    metrics_B = simulate('B')  # 场景B
    metrics_C = simulate('C')  # 场景C

    print(metrics_A)
    print(metrics_B)
    print(metrics_C)