Javascript 1D->；二维阵列W/法向曲线子阵列长度

我试图将一维数组分解为二维数组，其中子数组的长度不同。这种差异应该遵循高斯曲线[或土丘形状]。假设我们制作的2D数组变量名为gaussianCurve。gaussianCurve[0]&gaussianCurve[n]中的数组长度为1，gaussianCurve[n/2]是参数“maxArrayLength”提供的最大值。这将强制高斯曲线索引的数量变为变量

假设我有以下psuedo代码：

function (oneDimentionalArray, maxArrayLength) {
// oneDimentionalArray is ["A","B","C","D","E","F","G","H","I","J","K"]
// maxArrayLength is 5
// Currently working like this (i.e. "batches"):
// return [["A","B","C","D","E"],["F","G","H","I","J"],["K"]]
// would LIKE it to work like this
    gaussianCurve = []
    gaussianCurve.push(["A"])
    gaussianCurve.push(["B", "C"])
    gaussianCurve.push(["D", "E", "F", "G", "H"])
    gaussianCurve.push(["I", "J"])
    gaussianCurve.push(["K"])

    return  gaussianCurve
}

我为什么想要这样的东西？进度条

他们没有显示我正在立即取得进展

这是因为第一个作业必须在杆移动之前完成

它们在95%以上时减速，有时甚至保持在100%

真烦人

欢迎提出任何建议。我只是在脑海里看不到答案

编辑：我觉得它的措辞很糟糕，所以我正在重新编写它

…高斯曲线[0]。长度&gaussianCurve[gaussianCurve.length-1]。长度将为1，而高斯曲线[gaussianCurve.length/2]。长度将达到“maxArrayLength”

输入：

function gaussianRefactor(["A","B","C","D","E","F","G","H","I","J","K"], 1)
function gaussianRefactor(["A","B","C","D","E","F","G","H","I","J","K"], 2)
function gaussianRefactor(["A","B","C","D","E","F","G","H","I","J","K"], 4)
function gaussianRefactor(["A","B","C","D","E","F","G","H","I","J","K"], 8)
function gaussianRefactor(["A","B","C","D","E","F","G","H","I","J","K"], 16)

输出：

[["A"],["B"],["C"],["D"],["E"],["F"],["G"],["H"],["I"],["J"],["K"]]
[["A"],["B","C"],["D","E"],["F","G"],["H","I"],["J"],["K"]]
[["A"],["B","C","D"],["E","F","G","H"],["I","J","K"]]
[["A"],["B","C","D","E","F","G","H","I"],["J","K"]]
[["A","B","C","D","E","F","G","H","I","J","K"]]

---

没有任何内部阵列可以超过maxArrayLength的长度

我快速尝试了一下，它似乎可以工作。一些潜在的改进：

• 函数的输入检查
• 它会将任何可能的剩余值放入中间的容器中。对于偶数编号的总箱，它将受益于一些平衡。在那之后，最好尝试根据输入数据中的原始索引对每个箱子进行排序，因为现在事情可能会乱序。但是，如果这只是为了让进度条具有非线性分布的作业，那么顺序可能并不重要

函数概率（s，m，x）{
var eExp=-Math.pow（x-m，2）/
（2*数学功率（s，2））；
返回1/（数学sqrt（2*Math.PI）*s）*
Math.pow（Math.E，eExp）；
}
函数数组（输入，nBins）{
//首先，尝试确定s的合理值，以便外部箱子有一个值
var s=0.1；
var sMax=10；
var m=（nBins-1）/2.0；
var outerBinMinimum=1/input.length；
var p=0；
while（true&&s=outerBinMinimum）{
打破
}否则{
s+=0.1；
}
}
//容纳数组
var输出=[]；
//保存所需的数组大小
var OutputLength=[]；
//根据概率密度填充这些
对于（var b=0；b非常有趣的挑战：）

我打了一些比赛，以下是我的想法：


功能块（arr，start，n）{
如果（arr.length长度）{
返回[arr]；
}
常数曲线=[]；
//提取中间部分。
const mid=数学层（len/2）；
常数startIndex=mid-（max/2）+1；
常数最高=阵列拼接（起始索引，最大值）；
曲线推力（最高）；
//将其余部分拆分为2个数组；左侧和右侧，中间已排除。
常量leftArr=arr.slice（0，startIndex）；
常数rightArr=arr.slice（startIndex，len）；
设leftMax=max；
设rightMax=max；
//从左侧添加块。
while（leftArr.length）{
const leftChunk=chunk（leftArr，leftArr.length-leftMax，leftMax）；
if（leftChunk）{
曲线。取消移位（左块）；
}否则{
左最大--；
}
}
//从右侧添加块。
while（右端长度）{
const rightChunk=chunk（rightArr，0，rightMax）；
如果（右块）{
曲线推（右块）；
}否则{
rightMax--；
}
}
回归曲线；
}
log（JSON.stringify（gaussianArray（[“A”、“B”、“C”、“D”、“E”、“F”、“G”、“H”、“I”、“J”、“K”]），1））；
log（JSON.stringify（gaussianArray（[“A”、“B”、“C”、“D”、“E”、“F”、“G”、“H”、“I”、“J”、“K”]），2））；
log（JSON.stringify（gaussianArray（[“A”、“B”、“C”、“D”、“E”、“F”、“G”、“H”、“I”、“J”、“K”]），4））；
log（JSON.stringify（gaussianArray（[“A”、“B”、“C”、“D”、“E”、“F”、“G”、“H”、“I”、“J”、“K”]），8））；
log（JSON.stringify（gaussianArray（[“A”、“B”、“C”、“D”、“E”、“F”、“G”、“H”、“I”、“J”、“K”]），16））这更符合我的想法。我非常不喜欢我找到西格玛的方式。我知道我应该重新排列公式来计算它，但我还没有让它起作用。无论如何，这里有一个“答案”，虽然对于我在问题中作为示例提供的较小阵列，它失败了，但它成功地完成了我需要做的事情。如果有人有什么改进，请告诉我

var gaussianRefactor = function(srcOneDimentionalArray, srcMaxArrayLength) {
  var finalArray = [];
  if (srcOneDimentionalArray.length <= srcMaxArrayLength) {
    finalArray.push(srcOneDimentionalArray);
    return finalArray;
  }
  if (srcMaxArrayLength === 1) {
  for(var lengthOne = 0; lengthOne < srcOneDimentionalArray.length; lengthOne++)
    finalArray.push([srcOneDimentionalArray[lengthOne]]);
    return finalArray;
  }
  var maxArrayLength = srcMaxArrayLength;
  var oneDimentionalArray = srcOneDimentionalArray.slice(0);
  for (var x = srcMaxArrayLength; x > 1 && maxArrayLength / oneDimentionalArray.length > 0.3333; x--) {
    maxArrayLength--;
  }
  var standardChunkSize = srcOneDimentionalArray.length / maxArrayLength;
  var predictedSize = (3 * Math.floor(standardChunkSize)) % 2 === 0 ? 3 * Math.floor(standardChunkSize) + 1 : 3 * Math.floor(standardChunkSize);
  var predictedSizeCenter = Math.ceil(predictedSize / 2);
  var sigma = 0.2034185 * Math.pow(standardChunkSize, 1.963449);
  var multiplicand = 1 / (Math.sqrt(sigma) * Math.sqrt(2 * Math.PI));
  var centerGauss = maxArrayLength / multiplicand;
  var mu = 0;
  var delta;
  var fraction;
  var exponent;
  var full;
  var subArrayLength;
  var subArray;
  var notWideEnough = true;
  var maxElements;
  var maxAttempts = Math.max(Math.ceil(sigma), 100);
  var currentAttempts = 0;
  while (notWideEnough && currentAttempts < maxAttempts) {
    maxElements = 0;
    for (var j = 0; j < predictedSize; j++) {
      delta = (j - predictedSizeCenter) - mu;
      fraction = delta / Math.sqrt(sigma);
      exponent = -0.5 * Math.pow(fraction, 2);
      full = multiplicand * Math.exp(exponent);
      subArrayLength = Math.floor(full * centerGauss);
      maxElements += subArrayLength;
    }
    if (maxElements >= srcOneDimentionalArray.length) {
      notWideEnough = false;
    } else {
      sigma = sigma + sigma * 0.05;
    }
    currentAttempts++;
  }
  if (currentAttempts === maxAttempts) {
    return false;
  }

  for (var i = 0; i < predictedSize; i++) {
    delta = (i - predictedSizeCenter) - mu;
    fraction = delta / Math.sqrt(sigma);
    exponent = -0.5 * Math.pow(fraction, 2);
    full = multiplicand * Math.exp(exponent);
    subArrayLength = Math.floor(full * centerGauss);
    if (subArrayLength < 1 || oneDimentionalArray.length < 1) {
      continue;
    }
    subArray = oneDimentionalArray.slice(0, subArrayLength);
    oneDimentionalArray = oneDimentionalArray.slice(subArrayLength, oneDimentionalArray.length);
    finalArray.push(subArray);
  }
  return finalArray;
}

输出

[["A"],["B"],["C"],["D"],["E"],["F"],["G"],["H"],["I"],["J"],["K"]]
[["A"],["B"],["C"],["D"],["E"],["F","G"],["H"],["I"],["J"],["K"]]
[["A"],["B"],["C","D"],["E","F","G"],["H","I"],["J"],["K"]]
[["A"],["B"],["C","D"],["E","F","G"],["H","I"],["J"],["K"]]
[["A","B","C","D","E","F","G","H","I","J","K"]]

如果上面的数组包含两个以上的字母，即
L，M
，那么输出将是什么？我将变量命名为“maxArrayLength”，表示它只提供一个上限。如果数组中的元素数量小于maxArrayLength参数，那么它基本上是没有意义的。然后，可以将类似于您提供的数组插入mike.k提供的答案，以获得[[L]、[M]]或[[L，M]]。两者都可以。但是，我会在生产代码中对此进行短路，以说明……[0]&……[n-1]中的数组的长度是否为1，并且……[n/2]是否为参数“n”提供的最大值您提供的是任何数组的最大值。如果GET在超出最大字符数之前最多可以处理50个值，则您可以将数组“分块”到X@brightmatter谢谢你的反馈。可能已经晚了（在这里），但我不确定我是否完全遵循了所有的原则。你介意发布一个“非琐碎”的例子吗与示例输入和所需输出分开？我将在上面的问题中间插入一个JSF。这不是问题的答案。这只是我尝试的一种方法，先用三角形来解决它。不确定这是否会对您有所帮助。更现实的数字是数组中的10000个元素“分块”成不超过75个el的数组你想让他们沉迷于等待的想法，感觉被投资了，这样他们就不会放弃这个请求
[["A"],["B"],["C"],["D"],["E"],["F"],["G"],["H"],["I"],["J"],["K"]]
[["A"],["B"],["C"],["D"],["E"],["F","G"],["H"],["I"],["J"],["K"]]
[["A"],["B"],["C","D"],["E","F","G"],["H","I"],["J"],["K"]]
[["A"],["B"],["C","D"],["E","F","G"],["H","I"],["J"],["K"]]
[["A","B","C","D","E","F","G","H","I","J","K"]]