Question

我是JavaScript世界的新手。正如标题所提到的，我想知道JavaScript中是否有任何预先构建的方法来查找给定字符串的所有可能排列。

例如，给定输入：

the

期望的输出：

the
teh
eht
eth
het
hte

Answer 1

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

排列（''，'123'）将返回

[“123”，“132”，“213”，“231”，“312”，“321”]

Answer 2

没有预先构建，但是可以编写这样的函数。这是使用两个函数的一种相对简单的方法：

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

用法：

var arrAllPermutations = FindAllPermutations("the");

实时测试案例：http://jsfiddle.net/yahavbr/X79vz/1/

这只是基本的实现，它不会删除重复项，也没有优化。但是对于小字符串，你不会有任何问题，可以像上面的测试用例一样添加时间测量，看看你的合理限制是什么。

Answer 3

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

排列（ '的'）;
//输出返回：['the'，'teh'，'het'，'hte'，'eth'，'eht']

Answer 4

假设要搜索大字符串，您可以使用正则表达式

检查一组首先匹配字母和字母总数的可能性，

并返回使用相同字母设置的匹配项。

//（不区分大小写）

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

lettersets（s，'the'）。sort（）;

Answer 5

这是类似的但是从一个单词数组中找到所有的字谜/排列。我在接受采访时有这个问题。鉴于一系列词语[＆＃39; cat＆＃39;，＆＃39; dog＆＃39;，＆＃39; tac＆＃39;，＆＃39; god＆＃39;，＆＃39; act＆＃39; ]，返回一个数组，所有的字谜组合在一起。确保字谜是独一无二的。

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"]

Answer 6

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

Answer 7

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

是否有任何预先构建的方法可以在JavaScript中查找给定字符串的所有排列？

7 个答案: