如何优化我的javascript程序？

我试图解决这个javascript问题，并提出了这个解决方案，它给出了正确的解决方案，但在线法官显示超出了时间限制。我想优化算法。我可以在算法中更改什么

问题描述：整数数组的特殊分数（ssc）将是每个整数与其对应索引的乘积加上数组中的一

例如：使用

array [6, 12, -1]

arr =   [6,      12,       -1 ]
ssc =   1*6  +  2* 12 +  3.(*1) = 6 + 24 - 3 = 27

示例中给出的阵列有六（6）个排列，并与相应的ssc一起排列：

排列特殊分数（ssc） [6, 12, -1] 1*6 + 2*12 + 3*(-1) = 27 [6, -1, 12] 1*6 + 2*(-1) + 3*12 = 40 [-1, 6, 12] 1*(-1) + 2*6 + 3*12 = 47 [-1, 12, 6] 1*(-1) + 2*12 + 3*6 = 41 [12, -1, 6] 1*12 + 2*(-1) + 3*6 = 28 [12, 6, -1] 1*12 + 2*6 + 3*(-1) = 21 所有可能排列的ssc的总和为：27+40+47+41+28+21=204

ssc的最大值为47

ssc的最小值为21

我们需要一个特殊函数ssc_forperm（），该函数接收数量不确定的元素数组（这些元素可能出现多次），并输出包含以下数据的字典列表：

[{"total perm":__}, {"total ssc": ___}, {"max ssc": __}, {"min ssc":__}]

我的解决方案：

function permute(input) {
    var permArr = [],
        usedChars = [];
    return (function main() {
        for (var i = 0; i < input.length; i++) {
            var ch = input.splice(i, 1)[0];
            usedChars.push(ch);
            if (input.length === 0) {
                permArr.push(usedChars.slice());
            }
            main();
            input.splice(i, 0, ch);
            usedChars.pop();
        }
        return permArr;
    })();
}

function sscForperm(arr){
  var perm=permute(arr);
  var perm_arr=[];
  var temp_arr=[];
  var j=0;
  while(j<perm.length)
  {
      if(temp_arr.indexOf(perm[j].toString())===-1)
      {
          perm_arr.push(perm[j]);
          temp_arr.push(perm[j].toString());
      }
      j++;
  }
  var total_perm=perm_arr.length;

  var total=0;
  var max= 0;
  var k=0;
  while(k<perm_arr[0].length)
  {
      max+=perm_arr[0][k]*(k+1);
      k++;
  }
  var min=max;
  total+=max;

  var i=1;
  while(i<total_perm)
  {
      var l=0;
      var temp=0;
      while(l<perm_arr[0].length)
      {
          temp+=perm_arr[i][l]*(l+1);
          l++;
      }
      total+=temp;
      if(temp>max)
      {
          max=temp;
      }
      if(temp<min)
      {
          min=temp;
      }
      i++;
  }
  var dict1 = {"total perm":total_perm};
  var dict2 = {"total ssc":total};
  var dict3 = {"max ssc":max};
  var dict4 = {"min ssc":min};
  var ans=[];
  ans.push(dict1);
  ans.push(dict2);
  ans.push(dict3);
  ans.push(dict4);
  return ans;
}

函数排列（输入）{
var permArr=[]，
usedChars=[]；
返回（函数main（）{
对于（变量i=0；i而（j优化代码的一个简单方法是使用googleclosure编译器


我预先编译了你的代码，我得到的代码在


这很快也很简单。它现在应该运行得更快一些。
total perm=n！

总ssc
可以从公式中导出，因为每个数组元素都出现在每个索引的总和
（n-1）！
时间中：

total ssc = array sum * (n - 1)! * index sum
(6 + 12 - 1) * 2! * 3 * (3 + 1) / 2 = 204

max-ssc
和
min-ssc
可以通过简单地对数组排序并在任意方向应用索引倍数来计算：升序产生最大值，降序产生最小值。
您能添加一个指向原始问题的链接吗？