Генерация буквенно-цифровой последовательности javascript

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).