大概有个思路：
生成一组m个随机数，并只有一个最大数
取得这组数的和sum，然后n/sum得到比例s
再把这组数都乘以s并取整

问题在取整后总和可能会小于n，或者是最大值和次大值差值很小时取整后可能会相等
对这两个情况特殊处理一下就可以了

因为生成随机数时不用考虑n，在生成完成后再用比例去缩放数值，所以随机性应该还可以
代码晚点看情况补上

最大数max = n - m + 1，剩下的都为1，这样分可以吗？

function foo(n, m) { // 名字就不起了，就叫这个吧
    var average = Math.floor(n / m); // average >= 1
    var max = 0;
    var left = n;
    var arr = [];
    for (var i = 0; i < m; i++) {
        // 这里是关键，每次随机得到一个大于0的值，但必须确保余下的数足够剩下的元素分配
        // 一开始我使用的是 Math.random() * (left - (m - i - 1))，但是效果不好
        // 会导致随机性很差，大数都集中在前面的元素中，而后面的元素往往都是1
        // 这是由于最初的算法在开始时的随机空间很大，所以也容易得到较大的数的原因，而越到后面，剩下的可分配的值越小
        // 后来我改进了算法，加了一个average，用来平均每次的随机空间，测试下来效果挺不错
        arr[i] = i == m - 1 ? left
            : Math.floor(Math.random() * (left - (m - i - 1) * average)) + 1;
        left -= arr[i];
        if (arr[i] > arr[max]) {
            max = i;
        } else if (arr[i] == arr[max] && arr[i] >= average) { // 这里用来修正最大值，确保最大值的元素只有一个
            arr[i]--;
            arr[max]++;
        }
    }
    console.log(arr);
    return arr;
}

测试代码：

foo(4, 2);
foo(4, 2);
foo(4, 2);
foo(8, 3);
foo(8, 3);
foo(8, 3);
foo(8, 3);
foo(20, 7);
foo(20, 7);
foo(20, 7);
foo(20, 7);
foo(20, 7);
foo(20, 7);
foo(20, 7);

下面是某一次测试的结果：

[3, 1]
[1, 3]
[1, 3]
[4, 2, 2]
[3, 1, 4]
[4, 2, 2]
[4, 2, 2]
[1, 2, 4, 2, 6, 1, 4]
[3, 6, 1, 4, 2, 1, 3]
[1, 1, 6, 5, 1, 2, 4]
[3, 4, 5, 1, 2, 3, 2]
[2, 8, 1, 3, 2, 2, 2]
[4, 1, 7, 1, 2, 2, 3]
[3, 1, 2, 4, 5, 2, 3]

function ran(nNum, mNum) {
  var n = nNum - mNum;
  var maxNum = 1;
  var maxNumIndex = 0;
  var numArray = [];
  if (n > 0) {
    for (var i = 0; i < mNum - 1; i++) {
      numArray.push(getNum(i) + 1);
    }
    if (n === maxNum) numArray[maxNumIndex]--;
    numArray.push(n + 1);
    console.log(numArray);
  } else {
    console.log("unsolvable");
  }

  function getNum(i) {
    var m = Math.ceil(Math.random() * n);
    if (m === maxNum) {
      m = getNum(i);
    } else {
      n -= m;
      if (m > maxNum) {
        maxNum = m;
        maxNumIndex = i;
      }
    }
    return m;
  }
}

先将n-1分隔成m个随机数，然后取其中最大值进行+1