Question

Mathematics/algorithms was never my strong point (!) so requesting help on this one.

What is the most efficient implementation for a method with the following signature:

/*
 * pairParts.size() > 0
 * pairParts.size() is always an even number
 */
private Set<StringPairGroup> getAllPossibleStringPairGroups(Set<String> pairParts) {
    Set<StringPairGroup> groups = new HashSet<StringPairGroup>();           
    // logic that adds all possible StringPairGroups            
`   return groups;
}

/*
 * StringPair object: first and second values cannot be null.
 * StringPair object: first != second
 * StringPair object: is equal to another if both the first values and both the second values are equal.
 */
public class StringPair {       
    private final String first;
    private final String second;    
    ...
}

/*
 * StringPairGroup object: is equal to another if their StringPair sets exactly match.
 */
public class StringPairGroup {      
   Set<StringPair> stringPairs  
   ...   
}

As an example an input of {‘A’, ‘B’} would return {[AB],[BA]}.
An input of {‘A’, ‘B’, ‘C’, ‘D’} would return
{[AB],[BA],[AC],[CA],[AD],[DA][…], [AB,CD],[BA,CD],[AB,DC],[BA,DC],[AC,DB],[…]}.

I am really just interested in the logic that creates all the possible StringPairGroups
for any set of input Strings. I could probably come up with some sort of brute force implementation but would rather know how to do something a lot ‘cleverer’.

So any hints as to how I would implement that would be useful.

Edit:

Sorry guys I think I may have missed off something quite important. I am really beggining to confuse myself. This is it:

A StringPairGroup cannot contain a repeated ‘pair part’ across all of its StringPairs. Does that make sense?

Answer 1

I understand the question as follows. There is a collection of N different strings (N is even),
e.g. A, B, C, D.
A pair is any concatenation of two different strings from this collection.
So, AB, BA are pairs, but AA is not a pair. A pair is different from another pair
if the corresponding concatenated strings are different strings. So, AB is different from BA,
and AB equals AB (obiously). There are N*N – N different pairs that can be built from
N different strings.

A group of order k is a set of k different pairs. So, [AB], [CD] are groups of order 1
because they both contain 1 pair.
[AB, CD], [BA, CD] are groups of order 2, because they both contain 2 pairs.
Two groups are equal if and only if they are equal as two sets. So, two equal
groups have exactly the same pairs; the order of the pairs does not matter. E.g.,
[AB, CD] and [BA, CD] are different groups because not all pairs in them are equal.
[AB, CD] and [CD, AB] are two equal groups.

All groups of order k can be constructed recursively:

1. Select any pair P of strings
2. If k = 1 return the groups built from all these pairs
3. If k > 1:
   3.1 Remove this pair from the collection C(N) of N strings, leaving a collection C(N-2)
   of the remaining strings.
   3.2 Construct all groups of order k-1 from C(N-2) and combine them with the pair P.

Here is a Java program (the complete code is on github:gist). An executable program in on ideone.

public static class Pair {
    public String s1, s2;
    public Pair(String s1, String s2) {
        this.s1 = s1; this.s2 = s2;
    }
    public String toString() {
        return s1 + s2;
    }
}

public static class Group {
    public List<Pair> pairs = new ArrayList<Pair>();
    public Group(Pair p) {pairs.add(p);}
}

public static List<Group> getGroups(String[] strings, int order) {
    List<Group> groups = new ArrayList<Group>();
    for (int i = 0; i < strings.length; ++i) {
        for (int j = 0; j < strings.length; ++j) {
            if (i != j) {
                Pair p = new Pair(strings[i], strings[j]);
                if (order == 1) {
                    groups.add(new Group(p));
                }
                else {
                    String[] strings2 = new String[strings.length - 2];
                    for (int k = 0, k2 = 0; k < strings.length; ++k) {
                        if (k != i && k != j) {
                            strings2[k2++] = strings[k];
                        }
                    }
                    List<Group> groups2 = getGroups(strings2, order - 1);
                    for (int k = 0; k < groups2.size(); ++k) {
                        Group g = new Group(p);
                        groups.add(g);
                        Group g2 = groups2.get(k);
                        g.pairs.addAll(g2.pairs);
                    }
                }
            }
        }            
    }
    return groups;
}

There are N/2 possible orders. Contruct the groups for all these orders and append them.

String strings[] = {"A", "B", "C", "D", "E", "F"};
List<Group> groups = new ArrayList<Group>();
for (int order = 1; order <= strings.length/2; ++order) {
    List<Group> groups2 = getGroups(strings, order); 
    groups.addAll(groups2);
}           

The recursive solution is well understandable but less efficient. If your N is large
then you would need a faster iterative solution. The iterative solution is less
illustrative than the recursive one and would not be suitable for the presentation here.
You can consult e.g. Knuth: The Art of Computer Programming, Vol. 4A: Combinatorial Algorithms.