如何将数字转换为价格范围

Question

我想计算在客户购买我的产品许可证时向他们收取的费用。

我以不同的许可证出售它：

• 1-10：50 美元/用户
• 11-20 : $40/用户
• 21-30 : $30/用户
• 31-50 : $20/用户

所以当有人购买 136 个许可证时，我会向他收费：

50 x 2 x $20 = $2000
30 x 1 x $30 = $900
     6 x $50 = $300

我正在寻找一种关于如何处理给定数字并将其分解为一个范围内出现次数的算法.. 如何在纯 C# 或 LINQ 中做到这一点？

------------ 编辑 ----------------

我提出了一个不那么令人困惑的问题 (Algorithm for Fogbugz pricing scheme)，我得到了我一直在寻找的答案。

谢谢大家..

Answer 1

如果采用这种价格结构，我认为通过购买最适合他们需要的套餐来最小化成本符合客户的最大利益。以下算法使用动态规划来计算准确购买一定数量许可证的最低可能价格（您可以通过购买超出需要的数量来省钱，尽管我没有实现）：

int getPrice(int n)
{
    if (n >= 1 && n <= 10) return 50 * n;
    if (n >= 11 && n <= 20) return 40 * n;
    if (n >= 21 && n <= 30) return 30 * n;
    if (n >= 31 && n <= 50) return 20 * n;
    throw new Exception("Impossible");
}

int minimizePrice(int n)
{
    int[] minimumPrice = new int[n + 1];
    for (int i = 1; i <= n; ++i)
    {
        minimumPrice[i] = int.MaxValue;
        for (int j = Math.Max(0, i - 50); j < i; ++j)
        {
            minimumPrice[i] = Math.Min(minimumPrice[i],
                minimumPrice[j] + getPrice(i - j));
        }
    }
    return minimumPrice[n];
}

对于 70 个许可证，最低价格为 1400 美元，可通过购买 2 个 35 个许可证的块获得。你在建议一个贪心算法。这会让您的客户感到困惑。聪明的顾客会下两单而不是大单，这样可以节省 400 美元。

我建议您更改价格，以便您可以以每个 20 美元购买的许可证数量没有上限。

Answer 2

这看起来与为购买进行找零的算法（选择哪些硬币）非常相似。唯一的区别是您要与一个范围而不是单个数字进行比较。

代码可能如下所示：

var val = 136;
var price = 0;
while (val > 0) 
{
  var range = FindMatchingRange(val); // Use a dictionary, list, or array.
  var number = Math.Min(val, range.Max);
  price += range.CostPerUser * number;
  val -= number;
}

Answer 3

如果我是一个需要 10 个许可证的人，根据您建议的定价计划，我为什么只购买 10 个许可证？

10 个许可证 * 50 美元/许可证 = 500 美元

11 个许可证 * 40 美元/许可证 = 440 美元

您想要的是降低最近购买的许可证成本的计划。因此，对于想要 11 个许可证的人，他们会支付：

（10 个许可证 * 50 美元/许可证）+（1 个许可证 * 40 美元/许可证）= 540 美元

一个可能的计划如下所示：

first 10 licenses (1-10): $50/user
next 10 licenses (11-20): $40/user
next 10 licenses (21-30): $30/user
all licenses after that (31+) : $20/user

编写代码来计算任意数量用户的最终成本是一项简单的练习。购买 136 个许可证的计算如下：

(10 个许可 * 50 美元/许可) + (10 个许可 * 40 美元/许可) + (10 个许可 * 30 美元/许可) + (106 个许可 * 20 美元/许可) = 500 美元 + 400 美元 + 300 美元 + 2120 美元 = 3,220 美元。

在我看来，最初的定价计划很古怪。以去年购买了 130 个许可证的客户为例，该客户回来后还想要 10 个许可证。有什么理由向他们收取最高费率？他们是大批量客户，您想以最低的“边际”价格向他们出售（并且他们有理由期望收到）额外的许可证。

Answer 4

我为你做了一个计算课……只是更以客户为导向。 它会根据您定义的价格范围计算最便宜的价格。

示例：136 个许可证

50 个许可证，每个 20 美元（因为：31-50 ：20 美元/用户）

50 个许可证，每个 20 美元（因为：31-50 ：20 美元/用户）

36 个许可证，每个 20 美元（因为：31-50 ：20 美元/用户）

总计：1720

---

示例 130 许可证

50 个许可证，每个 20 美元

50 个许可证，每个 20 美元

30 个许可证，每个 30 美元

总计：1900

---

课程代码：

   public class PriceCalculator
    {
        public List<OrderPackage> CalculateCheapestPrice(Int32 AmountOfLicenses, 
            List<PriceRange> PriceRanges, out Double Total)
        {
            List<OrderPackage> result = new List<OrderPackage>();
            Total = 0;

            Int32 AmountsOfLicensesleft = AmountOfLicenses;

            PriceRanges.Sort(ComparePrice);

            for (int i = 0; i < PriceRanges.Count; i++)
            {
                for (int j = PriceRanges[i].MaxAmount; j >= PriceRanges[i].MinAmount; j--)
                {
                    if (j <= AmountsOfLicensesleft)
                    {
                        OrderPackage Order = new OrderPackage();
                        Int32 AmountOfThisPackage = AmountsOfLicensesleft / j;
                        //Int32 AmountForThisPrice = Convert.ToInt32(Math.Floor(tmp));

                        Order.PriceRange = PriceRanges[i];
                        Order.AmountOfLicenses = j;

                        Total += Order.AmountOfLicenses * Order.PriceRange.PricePerLicense;

                        for (int k = 0; k < AmountOfThisPackage; k++)
                        {
                            result.Add(Order);
                        }

                        AmountsOfLicensesleft = AmountsOfLicensesleft - (AmountOfThisPackage * j);
                    }
                }
            }

            return result;
        }

        private static int ComparePrice(PriceRange x, PriceRange y)
        {
            if (x.PricePerLicense == y.PricePerLicense)
                return 0;

            if (x.PricePerLicense > y.PricePerLicense)
                return 1;

            if (x.PricePerLicense < y.PricePerLicense)
                return -1;

            return 0;
        }

        public class OrderPackage
        {
            public PriceRange PriceRange { get; set; }
            public Int32 AmountOfLicenses { get; set; }
        }

        public class PriceRange
        {
            public int MinAmount { get; set; }
            public int MaxAmount { get; set; }

            public Double PricePerLicense { get; set; }
        }
    }

用法示例：

private void button1_Click(object sender, EventArgs e)
{
    // Preparing PriceRangeDefinitions
    List<PriceCalculator.PriceRange> PriceRangeDefinitions = new List<PriceCalculator.PriceRange>();
    PriceRangeDefinitions.Add(new PriceCalculator.PriceRange() { MinAmount = 1, MaxAmount = 10, PricePerLicense = 50 });
    PriceRangeDefinitions.Add(new PriceCalculator.PriceRange() { MinAmount = 11, MaxAmount = 20, PricePerLicense = 40 });
    PriceRangeDefinitions.Add(new PriceCalculator.PriceRange() { MinAmount = 21, MaxAmount = 30, PricePerLicense = 30 });
    PriceRangeDefinitions.Add(new PriceCalculator.PriceRange() { MinAmount = 31, MaxAmount = 50, PricePerLicense = 20 });

    // Start the Calculation
    PriceCalculator calculator = new PriceCalculator();
    Double Total;
    List<PriceCalculator.OrderPackage> Packages =
        calculator.CalculateCheapestPrice(130, PriceRangeDefinitions, out Total);

    // Show Proof of Concept
    String ProofOfConcept = String.Empty;
    for (int i = 0; i < Packages.Count; i++)
    {
        ProofOfConcept += Packages[i].AmountOfLicenses.ToString() + " Licenses " +
            Packages[i].PriceRange.PricePerLicense.ToString() + "$ each" + Environment.NewLine;
    }
    ProofOfConcept += Environment.NewLine + "TOTAL: " + Total.ToString();

    MessageBox.Show(ProofOfConcept);
}

Answer 5

可能是 KeyValuePair 集合或字典？