Javascript 尽可能多地使用重复值存储数组的子集

我遇到了一个问题，我必须处理一个给定的值，并检查该值是否大于我的值数组，如果大于，则使用我的数组合并输出。我已经在这里问了一个类似的问题：

重要提示，我想尽可能多地重复这些子集。我的解决方案仅提供具有不同编号的子集的组合。

比如说

我的阵列始终是：

const ArrayPrimitive = [100,50,20,10];

例如，输入中的给定值：

• 条目：30.00结果：[20.00,10.00]
• 条目：80.00结果：[50.00,20.00,10.00]
• 条目：125.00结果：抛出NoteUnavailableException
• 条目：-130.00结果：抛出InvalidArgumentException
• 条目：空结果：[空集]
  
• Entry:200预期结果：[100.00，100.00]*这里是我被绊倒的地方，我想组合子集的相同值（我的数组
  原语）在使用较小的数字之前尽可能多地使用。
  在这种情况下，我的子集中需要2个100的值，当我测试这个值时，这些函数会抛出一个错误

     const ArrayPrimitive = [100, 50, 20, 10]; // Assuming presorted     array(descending)
  
  function findChange(m) {
    return ArrayPrimitive.reduce((mm, c) => {
      if (mm.rest >= c) {
        mm.change.push(c);
        mm.rest -= c
      }
      return mm
    }, {
      change: [],
      rest: m
    });
  }
  
  function findChangeOld(m) {
    var retval = {
        change: [],
        rest: m
      },
      i = ArrayPrimitive.length;
  
    for (var x = 0; x < i; x++) {
      if (retval.rest >= ArrayPrimitive[x]) {
        retval.change.push(ArrayPrimitive[x])
        retval.rest -= ArrayPrimitive[x];
      }
    }
    return retval;
  }
  
  function calcChange(v) {
    var c = findChangeOld(v);
  
    if (v < 0 || isNaN(v)) {
      console.log('${v}: throw InvalidArgumentException');
      return;
    }
  
    if (c.rest > 0)
      console.log('${v}: throw NoteUnavailableException');
    else
      console.log('${v}: ${c.change}');
  }
  
  calcChange(30);
  calcChange(80);
  calcChange(105);
  calcChange(125);
  calcChange(-130);
  calcChange(null);
  

  const ArrayPrimitive=[100,50,20,10]；//假设预排序数组（降序）
  函数findChange（m）{
  返回ArrayPrimitive.reduce（（mm，c）=>{
  如果（mm.rest>=c）{
  mm.更换.推送（c）；
  mm.rest-=c
  }
  返回mm
  }, {
  更改：[]，
  其余：m
  });
  }
  函数findChangeOld（m）{
  变量retval={
  更改：[]，
  其余：m
  },
  i=阵列基本长度；
  对于（var x=0；x=ArrayPrimitive[x]）{
  retval.change.push（ArrayPrimitive[x]）
  retval.rest-=ArrayPrimitive[x]；
  }
  }
  返回返回；
  }
  功能计算变更（v）{
  var c=findChangeOld（v）；
  if（v<0 | | isNaN（v））{
  log（'${v}：抛出InvalidArgumentException'）；
  返回；
  }
  如果（c.rest>0）
  log（'${v}:throw NoteUnavailableException'）；
  其他的
  log（'${v}:${c.change}'）；
  }
  calcChange（30）；
  calcChange（80）；
  calcChange（105）；
  calcChange（125）；
  钙变化（-130）；
  calcChange（空）；
  

我希望我说得很清楚。

当你向这个提交“270”时，你会得到一个数组[1001005020]

我将把例外情况和边缘案例留给你来设置守卫。但这似乎满足了你所有直截了当的情况

        let arr = [100,50,20,10];

        let factors = [];
        let total = 270;

        arr.forEach ( d => {
            while ( total >= d ) {
                factors.push ( d );
                total -= d;
            }
        } );

        // [100, 100, 50, 20]
        console.log ( factors );

---

如果（mm.rest>=c）可能会将

更改为
，而（mm.rest>=c）
@Pointy感谢您的帮助，但它不起作用。可能会有一个解决方案：如果您提交的数字超过数组总和（事实上，该点可能会帮助您查看解决方案），请执行检查。例如，您的数组总计为190。因此，任何数值>190（或者更确切地说，任何数值>arraysum+largestnum），您将查看是否将该数组中的最大数值组合N次后，会留下一个可以由较小数值实现的剩余值（模数）。若并没有，那个么你们就知道你们必须使用较小的数字。对如果它不仅仅是最大的数字，那么你会用每个较小的数字递归mod结果。听起来像是标准，有标准的解决方案。