鼓励金算法--Go语言实现

什么是鼓励金?我想大家应该都有用过,例如今早我买包子时,就抵扣了部分金额。 用支付宝或者微信支付,支付成功后会返还一小笔钱,从周日到周四累计5天,然后在周五和周六抵现金使用, 这笔钱就是鼓励金(当然支付宝称作奖励金)。 我们现在几乎每天都在使用支付宝或者微信,每天都会接触鼓励金,但是你知道鼓励金发放的一般逻辑嘛, 或者说如果让你来做一个类似鼓励金一样的产品,你会怎样来实现发放逻辑呢。

问题描述

问题描述,洋气一点,可以称作产品需求,需求如下:

  • 根据订单金额分阶段发放,金额越高,得到的鼓励金要相应升高
  • 每个金额阶段中再分层,每个层次指定发放金额的最小值和最大值,并指定百分比
  • 商家可以根据上述两条规则自定义自己的发放逻辑
  • 商家可分时段自定义发放倍率(放大或者缩小发放的金额)
  • 平台可自定义全平台的发放倍率

解决思路与数据结构设计

数据结构如下:

type Ecrg_fee_dura struct {
  Upper float64
  Lower float64
}

type Ecrg_fee_item struct {
  Num  int
  Dura *Ecgr_fee_dura
}

type Ecrg_fee struct {
  Amount   float64
  Item_arr []*Ecgr_fee_item
}

Ecrg_fee_arr []*Ecrg_fee = []*Ecrg_fee{
  &Ecrg_fee{
    Amount: 99.99,
    Item_arr: []*Ecrg_fee_item{
      &Ecrg_fee_item{Num: 700, Dura: &Ecrg_fee_dura{Upper: 1.1, Lower: 0.8}},
      &Ecrg_fee_item{Num: 900, Dura: &Ecrg_fee_dura{Upper: 2.0, Lower: 1.0}},
      &Ecrg_fee_item{Num: 1000, Dura: &Ecrg_fee_dura{Upper: 5.0, Lower: 1.8}},
    },
  },
  &Ecrg_fee{
    Amount: 49.99,
    Item_arr: []*Ecrg_fee_item{
      &Ecrg_fee_item{Num: 700, Dura: &Ecrg_fee_dura{Upper: 0.6, Lower: 0.25}},
      &Ecrg_fee_item{Num: 900, Dura: &Ecrg_fee_dura{Upper: 1.25, Lower: 0.5}},
      &Ecrg_fee_item{Num: 1000, Dura: &Ecrg_fee_dura{Upper: 2.0, Lower: 1.0}},
    },
  },
  &Ecrg_fee{
    Amount: 29.99,
    Item_arr: []*Ecrg_fee_item{
      &Ecrg_fee_item{Num: 700, Dura: &Ecrg_fee_dura{Upper: 0.4, Lower: 0.25}},
      &Ecrg_fee_item{Num: 900, Dura: &Ecrg_fee_dura{Upper: 0.6, Lower: 0.3}},
      &Ecrg_fee_item{Num: 1000, Dura: &Ecrg_fee_dura{Upper: 1.0, Lower: 0.5}},
    },
  },
  &Ecrg_fee{
    Amount: 9.99,
    Item_arr: []*Ecrg_fee_item{
      &Ecrg_fee_item{Num: 700, Dura: &Ecrg_fee_dura{Upper: 0.25, Lower: 0.1}},
      &Ecrg_fee_item{Num: 900, Dura: &Ecrg_fee_dura{Upper: 0.5, Lower: 0.2}},
      &Ecrg_fee_item{Num: 1000, Dura: &Ecrg_fee_dura{Upper: 0.8, Lower: 0.4}},
    },
  },
}

给出数据结构和规则列表示例,应该就明白一半了,另一半的说明如下:

  • Ecrg_fee_arr 数组金额是从高到底,这里使用有序的列表来表示区间:
    • 第一项代表区间99.99到无限大,
    • 第二项代表49.99到99.99…
  • Ecrg_fee_item 定义了发放规则,由一个整数 Num 和一个区间 Dura 组成, Dura 代表发放金额的上限和下限, Num 就要放到数组中来理解, 同样这里也使用了有序数组来表示区间,只不过这里使用的是递增数组。 Item_arr 解析如下:
    • 第一项表示1-700,代表的含义是随机1-1000,命中1-700的概率,也就是说这里使用此项定义出70%的概率区间;
    • 第二项表示701-900,代表的含义是随机1-1000,命中701-900的概率,也就是说这里使用此项定义出20%的概率区间…
  • 数据结构和以上的解析基本映射出相应的算法执行步骤:
    1. 比对金额,定位金额区间
    2. 生成随机数,定位发放规则
    3. 生成随机数,生成鼓励金

编码实现

// 四舍五入
func FormatPrice(p float64) float64 {
  p = math.Floor((p+0.005)*100) / 100
  return math.Max(p, 0.01)
}

// 获取全平台倍率
func GetEcrgFactor() float64 {
  return 1.0
}

// 获取鼓励金发放订单最低金额
func GetEcrgThreshold() float64 {
  return 9.99
}

func CalcEcrgAmount(
  amount float64, // 订单金额
  factor float64, // 发放倍率
  ecrg_fee_arr []*Ecrg_fee, // 发放规则
) (
  ecrg_amount float64,
  code int, err error,
) {
  if amount < Ecrg_amount_threshold {
    return
  }

  // 添加鼓励金发放倍率
  factor = factor * GetEcrgFactor()

  // 规则未定义
  if len(ecrg_fee_arr) < 1 {
    ecrg_amount = amount * 0.01 * factor
    ecrg_amount = FormatPrice(ecrg_amount)
    return
  }

  rand.Seed(time.Now().UnixNano())
  // 遍历区间列表
  for index, _ := range ecrg_fee_arr {
    ecrg_fee := ecrg_fee_arr[index]

    // 定位金额区间
    if amount-ecrg_fee.Amount > 0.001 {
      // 生成随机数--用于定位发放规则
      rand_num := rand.Intn(1000) + 1
      for index, _ := range ecrg_fee.Item_arr {
        ecrg_item := ecrg_fee.Item_arr[index]
        // 定位中奖区间
        if rand_num <= ecrg_item.Num {
          fee_dura := ecrg_item.Dura
          // 生成随机数--用于生成发放金额
          rand_n := rand.Intn(100) + 1
          // 生成发放金额
          ecrg_amount = fee_dura.Lower + ((float64(rand_n)/100.00)*
            (fee_dura.Upper-fee_dura.Lower))*factor
          log.Printf("[CalcEcrgAmount] amount: %v, factor %v, "+
            "rand_num: %v, rand_n: %v, dura: %v, ecrg_amount: %v",
            amount, factor, rand_num, rand_n, *fee_dura, ecrg_amount,
          )

          // 发放金额格式化
          ecrg_amount = FormatPrice(ecrg_amount)
          return
        }
      }
    }
  }

  return
}

总结

以上给出了一个鼓励金或者奖励金一个粗糙的实现,欢迎大家,给出更好的设计方案,欢迎讨论。

推荐阅读更多精彩内容