java和python写抢红包算法代码

原创

疯狂的KK

发布于 2023-03-18 12:03:38

9270

Java实现：

普通红包算法

javaCopy codeimport java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class RedPacket {
    public static List<BigDecimal> divideRedPacket(BigDecimal totalAmount, int totalPeople) {
        List<BigDecimal> amounts = new ArrayList<>();
        BigDecimal remainAmount = totalAmount;
        int remainPeople = totalPeople;
        Random random = new Random();
        for (int i = 0; i < totalPeople - 1; i++) {
            BigDecimal amount = new BigDecimal(random.nextDouble()).multiply(remainAmount).setScale(2, BigDecimal.ROUND_HALF_UP);
            amounts.add(amount);
            remainAmount = remainAmount.subtract(amount);
            remainPeople--;
        }
        amounts.add(remainAmount.divide(new BigDecimal(remainPeople), 2, BigDecimal.ROUND_HALF_UP));
        return amounts;
    }
}

这种算法是普通的红包算法，每个人的红包金额是随机分配的。分配过程中，每个人的红包金额的上限是当前红包总金额除以当前剩余人数，这样能够保证每个人最终都能获得一定的红包金额。 2. 普通红包平均算法

javaCopy codeimport java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
public class RedPacket {
    public static List<BigDecimal> divideRedPacket(BigDecimal totalAmount, int totalPeople) {
        List<BigDecimal> amounts = new ArrayList<>();
        BigDecimal remainAmount = totalAmount;
        BigDecimal averageAmount = totalAmount.divide(new BigDecimal(totalPeople), 2, BigDecimal.ROUND_HALF_UP);
        for (int i = 0; i < totalPeople - 1; i++) {
            amounts.add(averageAmount);
            remainAmount = remainAmount.subtract(averageAmount);
        }
        amounts.add(remainAmount);
        return amounts;
    }
}

这种算法是普通的红包平均算法，每个人的红包金额是平均分配的。分配过程中，每个人的红包金额都是当前红包总金额除以总人数，这样能够保证每个人最终获得相同的红包金额。 3. 带权红包平均算法

javaCopy codeimport java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class RedPacket {
    public static List<BigDecimal> divideRedPacket(BigDecimal totalAmount, int totalPeople, List<Double> weights) {
        List<BigDecimal> amounts = new ArrayList<>();
        BigDecimal remainAmount = totalAmount;
        double totalWeight = 0.0;
        for (double weight : weights) {
            totalWeight += weight;
        }
        BigDecimal averageAmount = totalAmount.divide(new BigDecimal(totalPeople), 2, BigDecimal.ROUND_HALF_UP);
        for (int i = 0; i < totalPeople - 1; i++) {
            BigDecimal amount = new BigDecimal(weights.get(i) / totalWeight).multiply(totalAmount).setScale(2, BigDecimal.ROUND_HALF_UP);
            if (amount.compareTo(averageAmount.multiply(new BigDecimal(2))) > 0) {
                amount = averageAmount.multiply(new BigDecimal(2));
            }
            amounts.add(amount);
            remainAmount = remainAmount.subtract(amount);
        }
        amounts.add(remainAmount);
        return amounts;
    }
}

这种算法是带权红包平均算法，每个人的红包金额是根据权重分配的。分配过程中，每个人的红包金额是当前红包总金额乘以该人的权重除以所有人的权重之和，这样能够保证权重大的人获得的红包金额更多。同时，为了保证每个人获得的红包金额不会过大，当某个人获得的红包金额超过平均值的两倍时，将其红包金额设置为平均值的两倍。 Python实现：

普通红包算法

pythonCopy codeimport random
from decimal import Decimal, ROUND_HALF_UP
def divide_red_packet(total_amount, total_people):
    amounts = []
    remain_amount = total_amount
    remain_people = total_people
    for i in range(total_people - 1):
        amount = Decimal(str(random.uniform(0, remain_amount))).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
        amounts.append(amount)
        remain_amount -= amount
        remain_people -= 1
    amounts.append((remain_amount / remain_people).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
    return amounts

这种算法是普通的红包算法，每个人的红包金额是随机分配的。分配过程中，每个人的红包金额的上限是当前红包总金额除以当前剩余人数

抢红包算法是一种常见的随机分配算法，常用于红包等奖励的随机分配。以下是使用Java和Python编写的三种抢红包算法及其实现。

均值法

Java实现：

public static double[] divideRedPacketByAverage(int totalAmount, int totalPeople) {
    double[] amounts = new double[totalPeople];
    double average = (double) totalAmount / totalPeople;
    for (int i = 0; i < totalPeople; i++) {
        amounts[i] = average;
    }
    return amounts;
}

Python实现：

def divide_red_packet_by_average(total_amount, total_people):
    amounts = [0] * total_people
    average = total_amount / total_people
    for i in range(total_people):
        amounts[i] = average
    return amounts

分析：均值法是最简单、最公平的分配方式，每个人分得的金额相等。但是，由于每个人分得的金额相同，可能会导致某些人分得的金额过少或过多，缺乏趣味性。

随机法

Java实现：

public static double[] divideRedPacketByRandom(int totalAmount, int totalPeople) {
    double[] amounts = new double[totalPeople];
    Random random = new Random();
    for (int i = 0; i < totalPeople; i++) {
        amounts[i] = random.nextDouble() * totalAmount / totalPeople * 2;
    }
    Arrays.sort(amounts);
    for (int i = 0; i < totalPeople - 1; i++) {
        amounts[i] = amounts[i + 1] - amounts[i];
    }
    amounts[totalPeople - 1] = totalAmount - amounts[totalPeople - 1];
    return amounts;
}

Python实现：

import random


def divide_red_packet_by_random(total_amount, total_people):
    amounts = [0] * total_people
    for i in range(total_people):
        amounts[i] = random.random() * total_amount / total_people * 2
    amounts.sort()
    for i in range(total_people - 1):
        amounts[i] = amounts[i + 1] - amounts[i]
    amounts[total_people - 1] = total_amount - amounts[total_people - 1]
    return amounts

分析：随机法是一种更有趣的分配方式，每个人分得的金额不同。但是，由于随机分配，可能会导致某些人分得的金额过少或过多，缺乏公平性。

拼手气法

Java实现：

public static double[] divideRedPacketByLuck(int totalAmount, int totalPeople) {
    double[] amounts = new double[totalPeople];
    Random random = new Random();
    int remainAmount = totalAmount;
    int remainPeople = totalPeople;
    for (int i = 0; i < totalPeople - 1; i++) {
        int amount = random.nextInt(remainAmount / remainPeople * 2 - 1) + 1;
        amounts[i] = amount;
        remainAmount -= amount;
        remainPeople--;
    }
    amounts[totalPeople - 1] = remainAmount;
    return amounts;
}

Python实现：

import random


def divide_red_packet_by_luck(total_amount, total_people):
    amounts = [0] * total_people
    remain_amount = total_amount
    remain_people = total_people
    for i in range(total_people - 1):
        amount = random.randint(1, remain_amount / remain_people * 2 - 1)
        amounts[i] = amount
        remain_amount -= amount
        remain_people -= 1
    amounts[total_people - 1] = remain_amount
    return amounts

分析：拼手气法是一种更有趣的分配方式，每个人分得的金额不同，同时保证了公平性。但是，由于随机分配，可能会导致某些人分得的金额过少或过多，缺乏稳定性。

综上所述，三种抢红包算法各有优缺点，根据实际需求选择合适的算法。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

java