List Permutations

I'm trying to list all three letter permutations and this is the code I have -

  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 = "abcdefghijklmnopq开发者_如何学Crstuvwxyz"
    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;
}

It's not working and I'm not sure why- can anyone help?

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

for more information, visit http://jinwolf.tumblr.com/post/26476479113/draw-something-cheat for an working example, check this jsfiddle http://jsfiddle.net/jinwolf/Ek4N5/31/

alert(newString);

newString is not defined right there. Instead, you should use the argument passed:

alert(searchTerm);

Edit: I'm not entirely sure of your approach. It seems overly complicated. This seems to work. I understand that you rather have your own code working, but perhaps this helps you in solving. I don't quite get your substr part.

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

This will result in the following being called:

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

I'm not sure from your question that you mean "permutations" because usually permutations do not include repeated elements where it looks like you want to include "aaa".

Here are several algorithms for listing permutations you can go check out. If it turns out you mean to have repetitions, it looks like pimvdb has you covered.

Edit: So you know what you are getting into run-time wise:

• With repetition (aaa,aab,...): n^k = 26^3 = 17,576
• Without repetition (abc,bac,...): n!/(n-k)! = 26!/(26-3)! = 15,600

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

should be

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

Without the declaration, j is a global variable, so it only takes one iteration to get to 26 and then all the loops terminate.

For permutations a recursive algorith as pimvd showed is always nice but don't forget you can just brute force it with for-loops when N is small:

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
}

In C#:

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