CLEAR
lnSize = 20

DIMENSION aA(m.lnSize)
FOR ln1 = 1 TO m.lnSize
aA[m.ln1] = m.ln1
ENDFOR

lnSec = SECONDS()
FOR ln1 = 0 TO 2^m.lnSize-1
lcS = ""
FOR ln2 = 1 TO m.lnSize
  lcS = lcS + IIF(BITTEST(m.ln1, m.ln2 - 1), "," + TRANSFORM(aA[m.ln2]), "")
ENDFOR
lcS = SUBSTR(m.lcS, 2)
IF m.ln1 % 2^(m.lnSize-4) = 0
? INT(m.ln1), m.lcS, "sum is", EVALUATE(EVL(CHRTRAN(m.lcS,",","+"),"0"))
ENDIF
ENDFOR
? "time:", SECONDS() - m.lnSec

1) Сортирую элементы массива значений по убыванию.
2) Берем первые A элементов и записываем их в массив результатов R
3) Вычисляем сумму массива S и ошибку (разницу между S и B)
4) Перебираем элементы массива значений начиная с A+1 элемента = x
   а) Для каждого элемента R пытаемся вместо него подставить x
   б) Если замена элемента R(i) на х дает лучшую сумму (в смысле ошибки), то запомним его индекс i
   в) Если после мы нашли i, то R(i) = x, S = S - R(i) + x
5) Возвращаем R

RAND(1) && Всегда генерим одинаковые последовательности
lnSize = 200
lnSum = 5000 && От величины искомой суммы очень сильно зависит время
lnC = 0.01 && от заданной "точности поиска" очень сильно зависит время
lnDelta = m.lnC * m.lnSum / m.lnSize

CREATE CURSOR cA (a B(0))
FOR ln1 = 1 TO m.lnSize
 INSERT INTO cA (a) VALUES (1+INT(RAND() * 1000))
ENDFOR
SET TALK OFF
SET NOTIFY OFF
SET NOTIFY CURSOR OFF

lnSec = SECONDS()
* От способа упорядочения исходных данных
* зависит результат - либо "много мелких", либо "мало крупных"
* но формально алгоритму упорядочение этого массива вообще не нужно
* на скорость оно влияет в зависимости от искомой суммы
* и того какие элементы в массиве - мелкие или крупные
* т.е. в общем случае сказать будет ли быстрее работать
* с индексом по возрастанию, или по убыванию, или вовсе без индекса нельзя
INDEX ON a TAG a &&DESCENDING

CREATE CURSOR cS (s B(0), c M)
INSERT INTO cS (s, c) VALUES (0, "")

SELECT cA
SCAN ALL FOR cA.a <= m.lnSum
 SELECT cS.s u, cS.c FROM cS ;
  UNION ALL ;
  SELECT cA.a + cS.s, cS.c + "," + TRANSFORM(cA.a) FROM cS ;
  INTO CURSOR cU
  INDEX ON u TAG u
 CREATE CURSOR cS (s B(0), c M)
 GO TOP IN cU
 lnY = cU.u
 INSERT INTO cS (s, c) VALUES (m.lnY, cU.c)
 SELECT cU
 SCAN ALL FOR cU.u > m.lnY + m.lnDelta WHILE cU.u <= m.lnSum
  lnY = cU.u
  INSERT INTO cS (s, c) VALUES (m.lnY, cU.c)
* Эти "ранные выходы" формально не предусмотрены алгоритмом,
* но могут очень хорошо помочь, если в процессе перебора
* таки будет найдена "точно" искомая сумма.
* IF m.lnY = m.lnSum
*  EXIT
* ENDIF
 ENDSCAN
*IF m.lnY = m.lnSum
* EXIT
*ENDIF
ENDSCAN
* Просто для наглядности считаем из скольких элементов
* составлена каждая сумма
SELECT Cs.s, Cs.c, OCCURS(",",Cs.c) FROM cS ;
 WHERE s BETWEEN (1 - m.lnC) * m.lnSum AND m.lnSum ;
 INTO CURSOR res
? SECONDS() - m.lnSec
* Собственно "самое лучшее" будет в последней записи
* для этого примера находит "точную сумму", но при смене параметров
* может не находить точную, но найдёт приближённую
BROWSE LAST

* А вот и теория из википедии

*for each i from 1 to N do
*   let T be a list consisting of xi + y, for all y in S
*   let U be the union of T and S
*   sort U
*   make S empty
*   let y be the smallest element of U
*   add y to S
*   for each element z of U in increasing order do
*      //trim the list by eliminating numbers close to one another
*      //and throw out elements greater than s
*     if y + cs/N < z <= s, set y = z and add z to S
* if S contains a number between (1 - c)s and s, output yes, otherwise no

 SCAN ALL FOR cA.a <= m.lnSum

predelSuma=VAL(alltrim(ThisForm.Text2.Value))
STORE 1000000 TO predel_old
DIMENSION y[100]

SELECT masiv.num_ber FROM masiv WHERE masiv.num_ber<predelSuma+1 ORDER BY num_ber DESC INTO ARRAY x
razmerMasiva = ALEN(x)

FOR counter=1 TO razmerMasiva
    STORE predelSuma TO predel
    STORE 1 TO j
    FOR i=counter TO razmerMasiva
        IF x>predel
            LOOP
        ELSE 
            y[j]=x[i]
            predel=predel-x[i]
            j=j+1
        ENDIF
        IF predel<=predel_old
            ACOPY(y, res)
            predel_old=predel
        ENDIF        
    ENDFOR
ENDFOR