Generazione di una sequenza alfanumerica javascript

Question

Ho scritto una funzione terribilmente lenta per generare codici che vanno da AA000 a ZZ999 (in sequenza non casuale). E ho concluso che deve esserci un modo migliore per farlo. Qualche suggerimento su come rendere questo più veloce?

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

Questo dovrebbe essere notevolmente più veloce:

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

idee fondamentali:

• Genera tutto in una corsa
• riutilizzo stringhe parziali, per quanto possibile

Come mai, non vedo come sia utile una lista così esaustiva. Esistono esattamente 26 * 26 * 1000 codici diversi. Così, invece di mantenere un array con tutti i codici che potrebbe avere senso per costruire semplicemente una funzione che genera il codice specifico richiesto:

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

provare questa soluzione:

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()); 

Questo genererà un array di tutti i codici .. U può salvare quell'array e analizzarlo facilmente usando un loop.

Answer 4

Non ho prove, ma dovrebbe fare il trucco

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

Dal punto di vista della complessità computazionale, purtroppo questo è il meglio che si può fare. Dal punto di vista del numero di istruzioni, puoi fare un po 'meglio (come altri hanno sottolineato), ma sarà sempre lo stesso ordine di complessità (ricorda che costanti/moltiplicatori sono irrilevanti nella complessità del Big-O). Puoi anche ottimizzare lo spazio di archiviazione.

Pensaci. Il tuo array deve avere 26 * 26 * 10 * 10 * 10 membri. Ciò significa che devi almeno toccare molti elementi.

Sia N = numero di elementi in alfabeto Sia M = numero di elementi in coda cifre

Caso migliore Ordinare Complessità = O (N * N * M * M * M) (se tutto quello che doveva fare era valori assegnare)

Miglior complessità dello storage caso = come sopra (è necessario memorizzare tutti i codici)

in questo momento si sta utilizzando le seguenti operazioni:

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

Quindi alla fine della giornata la complessità dell'ordine è O (N * N * M * M * M), che è il meglio che puoi fare.

La domanda più grande è perché si desidera generare tutti i codici.Se tutto quello che volete è quello di creare un codice univoco per ogni numero d'ordine o qualcosa, si può fare una macchina a stati come:

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

Se quello che cercate è un identificatore casuale, considerare l'utilizzo di un hash del timestamp + qualcosa su la richiesta invece.

Se non ti interessa l'univocità, puoi sempre generare un codice casuale.

Tutti i precedenti sono O (1).