如何优化我的JavaScript程序？

Question

I am trying to solve this javascript problem and came up with this solution which gives the correct solution but the online judge is showing time limit exceeded. I want to optimize the algorithm. What can I change in my algorithm?

Problem Description: The special score(ssc) of an array of integers will be the sum of each integer multiplied by its corresponding index plus one in the array.

Eg: with the

array [6, 12, -1]

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

The array given in the example has six(6) permutations and are with the corresponding ssc:

Permutations Special Score (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 The total sum of the ssc's of all the possible permutations is: 27 + 40 + 47 + 41 + 28 + 21 = 204

The maximum value for the ssc is 47.

The minimum value for the ssc is 21.

We need a special function ssc_forperm() that receives an array of uncertain number of elements (the elements may occur more than once) and may output a list of dictionaries with the following data:

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

My Solution:

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;
}

Answer 1

A simple way to optimize your code is using Google Closure Compiler.

Google Closure Compiler

I pre-Compiled your code and the code I got is at

http://closure-compiler.appspot.com/code/jsc23712967d5b5fa4f457b1638ec432b22/default.js

this was fast and easy. It should now run somewhat faster

Answer 2

total perm = n!

total ssc can be derived from a formula since each array element appears in the total sum (n - 1)! times for each index:

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

max ssc and min ssc can be computed by simply sorting the array and applying the index multiples in either direction: ascending yields the max, descending the min.