Elenco permutazioni

Question

Sto cercando di elencare tutte le tre permutazioni delle lettere e questo è il codice che ho -

window.permute = function(){ 
    var alphabet = "abcdefghijklmnopqrstuvwxyz"; 
    var searchTerm ="aaa"; 
    var position = 2; 
    changeString(searchTerm, position); 
} 

window.changeString = function(searchTerm, position){ 
    if (position <0){ 
     alert(newString); 

    return; 
    } 
    var alphabet = "abcdefghijklmnopqrstuvwxyz" 
    for (j=0; j < 26;j++){ 
     var newString = searchTerm.substr(0, position) + alphabet[j] + searchTerm.substr(position+1); 
     var newPosition = position -1; 
     changeString(newString,newPosition); 
    } 
    return; 
} 

Non funziona e non sono sicuro perché- chiunque può aiutare?

Answer 1

alert(newString); 

newString non è definito proprio lì. Invece, è necessario utilizzare l'argomento passato:

alert(searchTerm); 

---

Edit: Io non sono del tutto sicuro del vostro approccio. Sembra troppo complicato. Questo sembra funzionare. Capisco che preferisci che il tuo codice funzioni, ma forse questo ti aiuta a risolvere. Non ho abbastanza la tua parte substr.

http://jsfiddle.net/NUG2A/2/

var alphabet = "abc"; // shortened to save time 

function permute(text) { 
    if(text.length === 3) { // if length is 3, combination is valid; alert 
     console.log(text); // or alert 
    } else { 
     var newalphabet = alphabet.split("").filter(function(v) { 
      return text.indexOf(v) === -1; 
     }); // construct a new alphabet of characters that are not used yet 
      // because each letter may only occur once in each combination 

     for(var i = 0; i < newalphabet.length; i++) { 
      permute(text + newalphabet[i]); // call permute with current text + new 
              // letter from filtered alphabet 
     } 
    } 
} 

permute(""); 

Ciò risulterà nel seguente essere chiamato:

permute(""); 
permute("a"); 
permute("ab"); 
permute("abc"); // alert 
permute("ac"); 
permute("acb"); // alert 
permute("b"); 
// ... 

Answer 2

for (j=0; j < 26;j++){ 

dovrebbe essere

for (var j=0; j<26; j++) { 

Senza la dichiarazione, j è una variabile globale, quindi richiede solo una iterazione per arrivare a 26 e quindi tutti i loop terminano.

Answer 3

Non sono sicuro dalla tua domanda che intendi "permutazioni" perché solitamente le permutazioni non includono elementi ripetuti in cui sembra che tu voglia includere "aaa".

Qui ci sono several algorithms per la quotazione delle permutazioni che puoi controllare. Se si scopre che si intende avere ripetizioni, sembra che pimvdb abbiate coperto.

Edit: modo da sapere cosa si sta entrando in fase di esecuzione saggio:

• con la ripetizione (AAA, AAB, ...): n^k = 26^3 = 17.576
• Senza ripetizione (abc, bac, ...): n!/(Nk)! = 26!/(26-3)! = 15.600

Answer 4

Per permutazioni un algoritmo ricorsivo come pimvd mostrato è sempre bello, ma non dimenticare è possibile forzare solo bruta con per-loops quando N è piccolo:

for(int x1=0; x1 < 26; x1++) 
for(int x2=0; x2 < 26; x2++) 
for(int x3=0; x3 < 26; x3++){ 
    //do something with x1, x2, x3 
} 

Answer 5

var permutate = (function() { 
    var results = [];  
    function doPermute(input, output, used, size, level) {   
     if (size == level) { 
      var word = output.join(''); 
      results.push(word); 
      return; 
     } 
     level++; 
     for (var i = 0; i < input.length; i++) { 
      if (used[i]) { 
       continue; 
      }    
      used[i] = true; 
      output.push(input[i]); 
      doPermute(input, output, used, size, level); 
      used[i] = false; 
      output.pop(); 
     } 
    } 

    return { 
     getPermutations: function(input, size) { 
      var chars = input.split(''); 
      var output = []; 
      var used = new Array(chars.length);  
      doPermute(chars, output, used, size, 0);   
      return results;  
     } 
    } 
})(); 

per ulteriori informazioni, visitare http://jinwolf.tumblr.com/post/26476479113/draw-something-cheat per un esempio di lavoro, controllare questo jsfiddle http://jsfiddle.net/jinwolf/Ek4N5/31/

Answer 6

In C#:

0.123.

void DoPermuation(string s) 
    { 
     var pool = new HashSet<string>(); 
     //Permute("", , pool); 
     pool = Permute(new List<char>(s)); 
     int i = 0; 
     foreach (var item in pool) Console.WriteLine("{0:D2}: {1}", ++i, item);  
    } 

    HashSet<string> Permute(List<char> range) 
    { 
     if (range.Count == 1) return new HashSet<string>(new string[] { range[0].ToString() }); 

     var pool = new HashSet<string>(); 
     foreach (var c in range) 
     {    
      var list = new List<char>(range); 
      list.Remove(c); 
      foreach (var item in Permute(list)) pool.Add(c + item);     
     } 

     return pool; 
    }