生成具有增加/减少连续值之间差异的整数序列

Question

我正在尝试生成 2 个整数序列：一个是相邻值的差异稳定增加，另一个是差异稳定减少。

所需输出示例：

递增递增：[1, 3, 6, 10, 15]

随着差异的增加而下降：[15, 13, 10, 6, 1]

递增递减差值：[1, 6, 10, 13, 15]

递减差值：[15, 10, 6, 3, 1]

下面的代码 sn-p 生成一个数组，其中相邻值的差异稳步增加（但尚未考虑停止值输入）。我坚持使用正确的数学方法来创建一个类似的数组，其中相邻值的差异稳步减小。

const ranger = (start = 0, stop = 0, len = 1) => {
  const d = (start <= stop) ? 1 : -1;
  const step = Math.round(Math.abs(stop - start) / len);
  const arr = Array.from(Array(len), (x, i) => i + 1)
    .map((x) => (x !== 1) ? Math.round(start + d * x * step * (x / len)) : start);
    
  return arr;
};

console.log('asc', ranger(5, 100, 10));
console.log('desc', ranger(100, 5, 10));

Answer 1

您确定步数的方法似乎有点偏离。

让我们先看看如何确定正确的步骤。

这是我们的测试范围： [1,3,6,10,15]。 数字之间的差异是 [2,3,4,5] 我们可以将差异表示为：x + 1, x + 2, x + 3, x + 4。所以我们可以将它们组合成 4x + 10。这是我们的总数增加了，它等于我们的停止 - 开始 (15 - 1)，即 14。

所以我们修改后的方程是 14 = 4x + 10 求解后得到 x = 1；

这里的4代表步数，10是步数的总和。 我们可以使用卡尔高斯公式来确定总和。 公式为 (n / 2)(第一个数字 + 最后一个数字) = sum

这里n是步数。在我们的等式中，步数将始终为 len - 1。而最后一个数字将始终为 1。

所以我们翻译的高斯公式是 (len - 1) / 2 * (len - 1 + 1)

然后我们将其代入公式以确定步骤： 步= (Math.abs(stop - start) - (len - 1)/2 * (len - 1 + 1))/(len - 1)

如果您对数学不感兴趣，请跳至此处查找步骤

好的。现在我们正确地找到了步骤。让我们看看一些代码。

   

 function ranger(start = 0, stop = 0, len = 1) {
      let incArray = [];
      let step = (Math.abs(stop - start) - (len - 1)/2*(len - 1 + 1))/(len - 1);
      console.log('step is', step);

      if(start < stop){
        for(var i = 0, currentValue = start; currentValue < stop; i++){
          //use default value on our first iteration of the loop
           if(i> 0){
             //we are grabbing the previous item in the array and adding 
             //the step plus i to it
             //for ranger(1, 15, 5)) when i = 1, step = 1, incArray[1], so   
             // current value = 1 + 1 + 1 = 3;
             currentValue = (i + step + incArray[incArray.length -1])
           }
           incArray.push(currentValue)    
        }
      }
      else{
        for(var i = len, currentValue = start; currentValue > stop; i--){
          if(i< len ){
            currentValue = (-(i + step) + incArray[incArray.length -1]) 
          }
          incArray.push(currentValue)
          prevValue = currentValue;     
        } 
      }
      return incArray;
    }

console.log('asc', ranger(1, 15, 5));
console.log('asc', ranger(1, 21, 6));
console.log('desc', ranger(15, 1, 5));
//now try a range with a step of 2:
console.log('asc', ranger(1, 19, 5));

// asc (5) [1, 3, 6, 10, 15]
// desc (5) [15, 10, 6, 3, 1]

这只是一个粗略的草案，因此您可以使用 map 进行干净的重构，并使其在升序和降序时更加动态地工作。

Answer 2

我最初的解决方案比它需要的更复杂，并且无法处理零值和负值（有关详细信息，请参阅编辑历史记录）。以下是一种更好的方法来生成整数序列数组，其中连续数字之间的差异增加或减少（尽管它仍然效率低下）。

// requires non-negative value for len
const georange = (start, stop, len, rev = false) => {
  const shift = (() => {
    if (start < 1 || stop < 1) {
      return start < stop ? 1 - start : 1 - stop;
    }
    
    return 0;
  })();

  const gstart = start + shift;
  const gstop = stop + shift;
  const gstep = Math.pow(gstop / gstart, 1 / (len - 1));
  let range = Array(len).fill(gstart).map((x, i) => Math.round(x * Math.pow(gstep, i)));
  if (rev) {
    const steps = range.map((x, i, arr) => (i === 0) ? 0 : x - arr[i - 1]).reverse();
    range = steps.map((_, i, arr) => arr.slice(0, i).reduce((acc, x) => acc + x, gstart));
  }
  
  if (shift) {
    range = range.map((x) => x - shift);
  }
  
  return range;
};

const ascincr = georange(1, 15, 5);
console.log(ascincr);
// [1, 2, 4, 8, 15]

const ascdecr = georange(1, 15, 5, true);
console.log(ascdecr);
// [1, 8, 12, 14, 15]

const descincr = georange(15, 1, 5, true);
console.log(descincr);
// [15, 14, 12, 8, 1]

const descdecr = georange(15, 1, 5);
console.log(descdecr);
// [15, 8, 4, 2, 1]

这种方法使用geometric sequences 背后的基本数学运算并稍微扭曲它以生成具有增加差异的升序序列或具有减小差异的降序序列（无论输入值是正数还是负数 - 背离了正常行为几何序列）。将rev 标志设置为true 获取由普通几何序列产生的连续项的差异，并将它们反转以生成差异减小的升序序列或差异增加的降序序列。

这次修订源于查看了一种简单的范围生成方法，如下面的方法和this question 中的其他类似方法，然后测试了从定义的长度导出动态步长值的方法（而不是通过定义的步长来确定长度）。

const range = (start, stop, step) => {
  // requires positive step for ascending ranges and negative step for descending ranges
  return Array(Math.ceil((stop - start) / step)).fill(start).map((x, i) => x + i * step);
};

const result = range(1, 15, 3);
console.log(result);
// [1, 4, 7, 10, 13]