0

我是一个完整的算法笨蛋，我有这个问题，我需要找到购买未知数量的小部件的最低成本，无论是按单价还是通过批量购买 x 小部件......我确信一个例子会有所帮助： -

1) 小部件每件价格为 0.05 美元 2) 小部件批次价格为每 100 个小部件 4.00 美元

假设我想购买 140 个小部件 -

a) 按单位计算成本是 140 x $0.05c => $7.00 b) 按批次计算成本是 2 批 100 @ $4.00 => $8.00（可以忽略多余的 60 个小部件）

所以在这种情况下按单位购买会便宜 1.00 美元

但是，如果我想购买 190 个小部件，那么 -

a) 按单位计算成本是 190 x $0.05c => $9.50 b) 按批次计算成本是 2 批 100 @ $4.00 => $8.00（可以忽略多余的 10 个小部件）

在这种情况下，批量购买价格会更便宜...

所以我需要找出如何以编程方式找出两种方法之间的“临界点”在哪里以获得最便宜的价格。

我希望我已经解释清楚了，我相信这是一个简单的答案，但我的大脑今天已经快速消退了！

TIA

编辑：：

好的，抱歉——我意识到我没有像我应该的那样清楚——因为有人指出批次和单位的混合也是可能的，因此对于 140 个小部件示例，它也可能是 1 个批次和 40 个单位。

我想要实现的是以编程方式找到购买 X 个小部件的最便宜方式，每个小部件的价格为 $XX，并且还给出了一批价格为 $YY 的 NN 个小部件。

购买批次的任何多余小部件都没有问题，即它可以超过购买的 X，但不能少于 X

因此，对于 140 个示例，1 批 @ 4.00 美元 + 40 个单位 @ 0.05 美元 => 6.00 美元，这是我认为最便宜的。对于 190 个示例，我认为 2 批仍然是最便宜的，因为 1 批 + 90 个单位是 8.50 美元...

我希望那里有一些简洁的方程式可以做到这一点:)

4

2 回答 2

1

这个问题的答案非常简单，如果你反过来想的话。您已经知道价格的“临界点”。它是 8.00 美元。您不知道的是该点以单位为单位，即 8.00 美元除以 0.05 美元（每单位）=> 160 个单位。

请注意，也有机会以 4.00 美元购买 100 个单位，以 0.05 美元购买 60 个单位，总计 7.00 美元。这是您可能考虑也可能不考虑的第三种可能性。

编辑：编辑后，事情变得更加简单：

您在 $XX 有 1 件商品，在 $YY 有一批 NN 商品。假设 $YY/NN < $XX （意思是批处理实际上省钱），你所要做的就是：

  1. 将您的目标数量除以 NN，然后向下取整。你将不得不购买这个数量的批次
  2. 将剩余数量乘以 $XX。如果超过 $YY，就多买一批，否则以 $XX 购买剩余数量
于 2013-04-12T15:55:16.420 回答
1

I wrote a basic brute-force style script in python to compare the prices of the two options (up to 1,000 elements). It's not the fastest nor most elegant approach but it appears to work.

The format on the output is: (<unit-count>, (<per-unit-cost>, <per-batch-cost>))

import math
import itertools
import pprint

unitList = range(1000)
pricePerUnit = .05
pricePerBatch = 4.0
numberPerBatch = 100.0

def calculatePerUnit(units):
  """ Calculate the price of buying per unit
  """
  return units * pricePerUnit

def calculatePerBatch(units):
  """ Calculate the price of buying per batch
  """
  return math.ceil(units / numberPerBatch) * pricePerBatch

def main():
  """ Execute the script
  """
  perUnit = map(calculatePerUnit, unitList)
  perBatch = map(calculatePerBatch, unitList)
  comparisonList = zip(perUnit, perBatch)
  perUnitCheaperPriceList = list(itertools.ifilter(lambda x: x[0] < x[1], comparisonList))
  perUnitCheaperUnitList = map(lambda x: int(x[0] / .05), perUnitCheaperPriceList)                                                                              
  pprint.pprint(zip(perUnitCheaperUnitList, perUnitCheaperPriceList))

if __name__=="__main__":
  main()

And the results:

[gizmo@test ~]$ python TippingPoint.py 
[(1, (0.050000000000000003, 4.0)),
 ... These are sequential values I left out for brevity ...
 (79, (3.9500000000000002, 4.0)),
 (101, (5.0500000000000007, 8.0)),
 ... These are sequential values I left out for brevity ...
 (159, (7.9500000000000002, 8.0)),
 (201, (10.050000000000001, 12.0)),
 ... These are sequential values I left out for brevity ...
 (239, (11.950000000000001, 12.0)),
 (301, (15.050000000000001, 16.0)),
 ... These are sequential values I left out for brevity ...
 (319, (15.950000000000001, 16.0))]
于 2013-04-12T16:22:53.990 回答