迭代解方程

Question

我想知道如何用下面的等式优化问题：

R=A/B*C/D

其中R是输入值，A、B、C和{}是整数列表中的一个值，例如[20,21,22,23,24,24,25,25,26,28,28,28,36,36,37,38,38,39,40,40,41,42,42,43]

目标是找到最接近A、B、C和{}的值。在

我用Cython来加快运行速度，但仍然需要几分钟才能解决。在

我不是在寻求解决方案，只是一些帮助，用正确的语言指引我正确的方向。在

编辑：回答一些问题

• 我是野蛮的强迫，因为我不知道其他的方法来做这件事，我接受建议。在
• 列表中有意重复，一个可能的解决方案是A=21，B=38，C=28，D=28。在

• 列表可能长达150个元素

  以下是我目前对赛顿的看法：

  def __init__ (self, **kwargs) :
      self._arr           = (20,20,21,22,24,25,27,30,34,35,36,38,40,44,45,46,46,47,48,50,51,52,54,55,56,58,60,62,65,68,70,75,80,85,90,95,100,120,127) 
      self._desiredNumber = kwargs.get('desiredNumber', None)
  
  
  def doesFit(self, *set):
      # check values of A, B, C and D agains harcodded limits, 
      # if conditions met return true, else return false
      return true
  
  def solver(self, float desiredError = 0.00001):
      cdef float computedNumber, computedError
      computedNumber = 0
      computedError = 0
  
      cdef int arrSize, a, b, c, d
      a = 0
      b = 0
      c = 0
      d = 0
      arrSize = len (self._arr)
  
      cdef vector[float] arr = self._arr
  
      result = []
  
      for a from 0 <= a < arrSize:
          for b from 0 <= b < arrSize:
              for c from 0 <= c < arrSize:
                  for d from 0 <= d < arrSize:
                      computedNumber=arr[a]/arr[b]*arr[c]/arr[d]
                      computedError = fabs (self._desiredNumber - computedNumber)
                      if computedError<=desiredError and (a!=b and a!=c and a!=d and b!=c and b!=d and c!=d):
                          if self.doesFit(arr[a], arr[b], arr[c], arr[d]):
                              result.append(dict (A=arr[a], B=arr[b], C=arr[c], D=arr[d], desiredError=computedError, computedNumber=computedNumber))
  
      # remove results with duplicated values of A, B, C and D. 
      # A/B*C/D is the same as C/D*A/B, etc
      keyfunc = lambda d: (d['A'], d['B'], d['C'], d['D'])
      giter = groupby(sorted(result, key=keyfunc), keyfunc)
      result = [next(g[1]) for g in giter]
  
      # sort results by desiredError
      result = sorted(result, key=itemgetter('desiredError'))
  
      # returns just the 12 best results
      if len(result) > 12:    
          result = result[0:12]    
  
      return result
  

Answer 1

我相信你所要求的，特别是一个蛮力函数。正如评论中所建议的，我确实实施了一个唯一的数组来加速算法。在

arr = [20,21,22,23,24,24,25,25,26,28,28,28,36,36,37,38,38,39,40,40,41,42,42,43]

def iterSolvePython(arr, desiredNumber):
    arr = list(sorted(set(arr)))
    best = {'a':arr[0],'b':arr[0],'c':arr[0],'d':arr[0], 'r': 1}
    for a in arr:
        for b in arr:
            for c in arr:
                for d in arr:
                    r = float(a)/b*c/d
                    if abs(desiredNumber-r) < abs(desiredNumber-best['r']):
                        best = {
                            'a':a,
                            'b':b,
                            'c':c,
                            'd':d,
                            'r':r
                        }
    return best

print(iterSolvePython(arr, 25))