C'è un metodo pre-costruito per trovare tutte le permutazioni di una string in JavaScript?

Sono un principiante al mondo JavaScript. Come indica il titolo, voglio sapere se esiste un metodo pre-costruito in JavaScript per trovare tutte le permute possibili di una determinata string.

Ad esempio , dato l'input:

the 

Uscita desiderata:

 the teh eht eth het hte 

Nessun pre-costruito, ma la scrittura di tale function è ansible. Ecco un modo relativamente semplice usando due funzioni:

 function FindAllPermutations(str, index, buffer) { if (typeof str == "string") str = str.split(""); if (typeof index == "undefined") index = 0; if (typeof buffer == "undefined") buffer = []; if (index >= str.length) return buffer; for (var i = index; i < str.length; i++) buffer.push(ToggleLetters(str, index, i)); return FindAllPermutations(str, index + 1, buffer); } function ToggleLetters(str, index1, index2) { if (index1 != index2) { var temp = str[index1]; str[index1] = str[index2]; str[index2] = temp; } return str.join(""); } 

Uso:

 var arrAllPermutations = FindAllPermutations("the"); 

Caso di prova live: http://jsfiddle.net/yahavbr/X79vz/1/

Questa è solo l'implementazione di base, non rimuove i duplicati e non ha ottimizzazione. Tuttavia per piccole stringhe non avrai alcun problema, aggiungi misura del tempo come nel caso di prova di cui sopra e vedi quale sia il tuo ragionevole limite.

 //string permutation function permutation(start, string) { //base case if ( string.length == 1 ) { return [ start + string ]; } else { var returnResult = []; for (var i=0; i < string.length; i++) { var result = permutation (string[i], string.substr(0, i) + string.substr(i+1)); for (var j=0; j<result.length; j++) { returnResult.push(start + result[j]); } } return returnResult; } } 

la permutazione ('', '123') restituirà

["123", "132", "213", "231", "312", "321"]

Assumendo una grande string per la ricerca, è ansible utilizzare un'espressione regolare

esaminare una serie di possibili che corrispondono innanzitutto alle lettere e al numero totale di lettere,

e restituire le partite che utilizzano la stessa lettera impostata come il model.

// (case-insensitive)

 function lettersets(str, pat){ var A= [], M, tem, rx= RegExp('\\b(['+pat+']{'+pat.length+'})\\b', 'gi'), pattern= pat.toLowerCase().split('').sort().join(''); while((M= rx.exec(str))!= null){ tem= M[1].toLowerCase().split('').sort(); if(tem.join('')=== pattern) A.push(M[1]); }; return A; } 

lettere (s, 'il'). sort ();

 function permutations(str){ if (str.length === 1){ return str; } var permut = []; for (var i=0; i<str.length; i++){ var s = str[0]; var _new = permutations(str.slice(1, str.length)); for(var j=0; j<_new.length; j++){ permut.push(s + _new[j]); } str = str.substr(1, str.length -1) + s; } return permut; } 

permutazioni ( 'il');
// output restituisce: ['the', 'teh', 'het', 'hte', 'eth', 'eht']

Questo è simile ma trova tutti gli anagrammi / permutazioni da una serie di parole. Ho avuto questa domanda in un'intervista. Dato una serie di parole ['cat', 'cane', 'tac', 'dio', 'act'], restituisce un arrays con tutti gli anagrammi raggruppati. Fa in modo che gli anagrammi siano unici.

 var arr = ['cat', 'dog', 'tac', 'god', 'act']; var allAnagrams = function(arr) { var anagrams = {}; arr.forEach(function(str) { var recurse = function(ana, str) { if (str === '') anagrams[ana] = 1; for (var i = 0; i < str.length; i++) recurse(ana + str[i], str.slice(0, i) + str.slice(i + 1)); }; recurse('', str); }); return Object.keys(anagrams); } console.log(allAnagrams(arr)); //["cat", "cta", "act", "atc", "tca", "tac", "dog", "dgo", "odg", "ogd", "gdo", "god"] 
 function swap(a, b, str) { if (a == b) str = str; else { str = str.split(""); var temp = str[a]; str[a] = str[b]; str[b] = temp; str = str.join(""); } } function anagram(a1, b1, ar) { if (a1 == b1) document.write(ar + "<br/>"); else for (i = a1; i < b1; i++) { swap(a1, b1, ar); anagram((a1) ++, b1, ar); swap(a1, b1, ar); } } 

Beh non c'è nessun built-in function in js (non credo che sia in qualsiasi linguaggio di codifica) …… e comunque questo è il programma completamente funzionante, ometta tutte le ripetizioni e mostra anche il numero di permutazioni … ..

 var n=0; var counter=0; var storarr=new Array(); function swap(a,b,str) { //swaps the terms str[a] and str[b] and returns the final str str = str.split(""); var temp = str[a]; str[a] = str[b]; str[b] = temp; return str.join(""); } function anagram(_a,_b,ar) { //actual function which produces the anagrams if(_a == _b) { storarr[n]=ar; n++; counter++; } else { for(var i= _a;i<= _b;i++) { ar=swap(_a,i,ar); anagram(_a+1,_b,ar); ar=swap(_a,i,ar); } } } function factorial(a) { //return a! var x=1; for(var i=1;i<=a;i++) x=x*i; return x; } var strl=prompt("Enter String:",""); var l=strl.length; anagram(0,l-1,strl); storarr.sort(); //sorts the storarr alphabetically var storlen=storarr.length; var cai=0; var counterarr = new Array(); strl.split(""); for(var i=0;i<l;i=i+c) { //determines the number of times a term is repeating var c=1; for(var j=i+1;j<l;j++) { if(strl[i]==strl[j]) c++; } counterarr[cai]=c; cai++; } var yellow=1; for(var i=0;i<counterarr.length;i++) { //multiplies the terms of the counter arrays yellow=yellow*factorial(counterarr[i]); } counter=counter/yellow; document.write("Count : " + counter + "<br />"); for(var i=0;i<storlen;i=i+yellow) { //prints the non-flagged terms in storarr document.write(storarr[i] + "<br />"); } strl.join(""); 
 <pre> <script> var count = 0; var duplicate = false; function FindAllPermutations(str, index) { for (var i = index; i < str.length; i++) { var newstr; if (index == i) newstr = str; else newstr = SwapLetters(str, index, i); if (!duplicate) { count++; document.write(newstr + "\n"); if (i == index) duplicate = true; } else if (i != index) duplicate = false; FindAllPermutations(newstr, index + 1); } } function SwapLetters(str, index1, index2) { if (index1 == index2) return str; str = str.split(""); var temp = str[index1]; str[index1] = str[index2]; str[index2] = temp; return str.join(""); } FindAllPermutations("ABCD", 0); // will output all 24 permutations with no duplicates document.write("Count: " + count); </script>