Question

我编写了一个非常慢的函数来生成从AA000到ZZ999的代码（按顺序而非随机）。我已经得出结论，必须有一个更好的方法来做到这一点。关于如何加快速度的任何建议？

function generateAlphaNumeric(){

theAlphabet = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'];
resultArrray = [];
resultArrray2 = [];
teller = 0;

for(i in theAlphabet){
    for(x in theAlphabet){
        resultArrray[teller] = theAlphabet[i] + theAlphabet[x];
        teller++;
    }
}
teller = 0;
for(x = 0; x<10; x++){
    for(y = 0; y<10; y++){
        for(z = 0; z<10; z++){
            resultArrray2[teller] = x.toString() + y.toString() +z.toString();
            teller++;
        }
    }
}
teller = 0;
finalArray = [];
for(index in resultArrray){
    for(i in resultArrray2){
        finalArray[teller] = resultArrray[index] + resultArrray2[i];
        teller++;
    }
}
//console.log(resultArrray);
//console.log(resultArrray2);
console.log(finalArray);
}

Answer 1

这应该快得多：

var theAlphabet = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
'P','Q','R','S','T','U','V','W','X','Y','Z'];
var theDigits = ['0','1','2','3','4','5','6','7','8','9'];

var result = [];
for (var i=0 ; i<26 ; i++) {
    var prefix1 = theAlphabet[i];
    for (var j=0 ; j<26; j++) {
        var prefix2 = prefix1 + theAlphabet[j];
        for(var x = 0; x<10; x++){
            var prefix3 = prefix2 + theDigits[x];
            for(var y = 0; y<10; y++){
                var prefix4 = prefix3 + theDigits[y];
                for(var z = 0; z<10; z++){
                   result.push(prefix4 + theDigits[z]);
                }
            }       
        }
    }
}

主要观点：

一次生成所有内容
尽可能重用部分字符串

但是，我没有看到这样详尽的清单是如何有用的。正好有26 * 26 * 1000个不同的代码。因此，不是使用所有代码维护数组，而是简单地构建一个生成所请求的特定代码的函数是有意义的：

function getCode(number) {
    var z = number % 10;
    number -= z; number /= 10;
    var y = number % 10;
    number -= y; number /= 10;
    var x = number % 10;
    number -= x; number /= 10;
    var a = number % 26;
    number -= a; number /= 26;
    var b = number;

    return theAlphabet[a] + theAlphabet[b] + theDigits[x] + theDigits[y] + theDigits[z];
}

Answer 2

试试这个解决方案：

  function generate() {
    var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        ar = [];
    for (var index1 = 0; index1 < str.length; index1++) {
      for (var index2 = 0; index2 < str.length; index2++) {
        for (var index3 = 0; index3 < 1000; index3++) {
          ar.push(str[index1] + str[index2] + ('000' + index3).slice(-3));
        }
      }
    }
    return ar;
  }
  console.log(generate());

Answer 3

function generate() {
    var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        array = [];
    for (var i = 0; i < str.length; i++) {
      for (var j = 0; j < str.length; j++) {
        for (var k = 0; k < 10; k++) {
          for (var l = 0; l < 10; l++) {
            for (var m = 0; m < 10; m++) {
              ar.push(str[i] + str[j] + k + l + m);
            }
          }
        }
      }
    }
    return array;
  }
  console.log(generate());

这将生成所有代码的数组.U可以保存该数组并使用循环轻松解析它。

Answer 4

我没有测试它，但它应该做的伎俩

function generateAlphaNumeric()
{

   var theAlphabet = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'];
   var result = [];

   // Will take a random letter inside theAlphabet
   // Math.floor(Math.random() * theAlphabet.length) will  generate a random number between 0 and 25
   var i = 0;
   while(i<2)
   {
      var letter = theAlphabet[Math.floor(Math.random() * theAlphabet.length)];
      result.push(letter);
      i++;
   }

   i = 0;
   while(i<3)
   {
      // Adds a random number between 0 and 9
      result.push(Math.floor(Math.random() * 10));
      i++;
   }
   return result;
}

Answer 5

从计算复杂性的角度来看，遗憾的是这是你能做的最好的事情。从大量的指令角度来看，你可以做得更好（正如其他人指出的那样），但它仍然是复杂的相同顺序（请记住，常数/乘数与大O复杂性无关）。您还可以优化存储。

想一想。你的阵列需要有26 * 26 * 10 * 10 * 10个成员。这意味着您至少需要触摸那么多元素。

设N =字母表中的元素数设M =您的数字队列中的元素数

最佳案例顺序复杂度= O（N * N * M * M * M）（如果您只需要分配值）

最佳案例存储复杂性=与上述相同（您必须存储所有代码）

目前您正在使用以下操作：

for(i in theAlphabet){ // *O(N)*
  for(x in theAlphabet){ // *O(N)*
    resultArrray[teller] = theAlphabet[i] + theAlphabet[x];// *(O(1))*
  }
}



for(x = 0; x<10; x++){ // O(M)
    for(y = 0; y<10; y++){ // O(M)
        for(z = 0; z<10; z++){ // O(M)
            resultArrray2[teller] = x.toString() + y.toString() +z.toString(); // O(1) (technically this is O(length of x + y + z)
            teller++;
        }
    }
}


for(index in resultArrray){ // O(N * N)
    for(i in resultArrray2){ // O(M * M * M(
        finalArray[teller] = resultArrray[index] + resultArrray2[i]; //O(1)
        teller++;
    }
}

因此，在一天结束时，您的订单复杂度为O（N * N * M * M * M），这是您可以做的最好的。

更大的问题是你想要生成所有代码的原因。如果你想要的只是为每个订单号或其他东西创建一个唯一的代码，你可以创建一个状态机，如：

function getNextCode(previousCode) {
   // in here, just increment the previous code
}

如果您只想要一个随机标识符，请考虑使用时间戳的哈希值+关于请求的内容。

如果您不关心唯一性，您可以随时生成随机代码。

以上所有都是O（1）。

生成字母数字序列javascript

5 个答案: