Update all new Tasks

Task/State-name-puzzle/00DESCRIPTION

@@ -0,0 +1,40 @@
+'''Background'''
+
+This task is inspired by [http://drdobbs.com/windows/198701685 Mark Nelson's DDJ Column "Wordplay"] and one of the weekly puzzle challenges from Will Shortz on NPR Weekend Edition [http://www.npr.org/templates/story/story.php?storyId=9264290] and originally attributed to David Edelheit.
+
+The challenge was to take the names of two U.S. States, mix them all together, then rearrange the letters to form the names of two ''different'' U.S. States (so that all four state names differ from one another). What states are these?
+
+The problem was reissued on  [https://tapestry.tucson.az.us/twiki/bin/view/Main/StateNamesPuzzle the Unicon Discussion Web] which includes several solutions with analysis.  Several techniques may be helpful and you may wish to refer to [[wp:Goedel_numbering|Gödel numbering]], [[wp:Equivalence_relation|equivalence relations]], and [[wp:Equivalence_classes|equivalence classes]].  The basic merits of these were discussed in the Unicon Discussion Web.
+
+A second challenge in the form of a set of fictitious new states was also presented.
+
+'''Task:'''<br>
+Write a program to solve the challenge using both the original list of states and the fictitious list.
+
+Caveats:
+* case and spacing isn't significant - just letters (harmonize case)
+* don't expect the names to be in any order - such as being sorted
+* don't rely on names to be unique (eliminate duplicates - meaning if Iowa appears twice you can only use it once)
+
+Comma separated list of state names used in the original puzzle:
+<pre>
+    "Alabama", "Alaska", "Arizona", "Arkansas",
+    "California", "Colorado", "Connecticut",
+    "Delaware",
+    "Florida", "Georgia", "Hawaii",
+    "Idaho", "Illinois", "Indiana", "Iowa",
+    "Kansas", "Kentucky", "Louisiana",
+    "Maine", "Maryland", "Massachusetts", "Michigan",
+    "Minnesota", "Mississippi", "Missouri", "Montana",
+    "Nebraska", "Nevada", "New Hampshire", "New Jersey",
+    "New Mexico", "New York", "North Carolina", "North Dakota",
+    "Ohio", "Oklahoma", "Oregon",
+    "Pennsylvania", "Rhode Island",
+    "South Carolina", "South Dakota", "Tennessee", "Texas",
+    "Utah", "Vermont", "Virginia",
+    "Washington", "West Virginia", "Wisconsin", "Wyoming"
+</pre>
+Comma separated list of additional fictitious state names to be added to the original (Includes a duplicate):
+<pre>
+"New Kory", "Wen Kory", "York New", "Kory New", "New Kory"
+</pre>

Task/State-name-puzzle/00META.yaml

@@ -0,0 +1,2 @@
+---
+note: Puzzles

Task/State-name-puzzle/Bracmat/state-name-puzzle.bracmat

@@ -0,0 +1,91 @@
+(     Alabama
+      Alaska
+      Arizona
+      Arkansas
+      California
+      Colorado
+      Connecticut
+      Delaware
+      Florida
+      Georgia
+      Hawaii
+      Idaho
+      Illinois
+      Indiana
+      Iowa
+      Kansas
+      Kentucky
+      Louisiana
+      Maine
+      Maryland
+      Massachusetts
+      Michigan
+      Minnesota
+      Mississippi
+      Missouri
+      Montana
+      Nebraska
+      Nevada
+      "New Hampshire"
+      "New Jersey"
+      "New Mexico"
+      "New York"
+      "North Carolina"
+      "North Dakota"
+      Ohio
+      Oklahoma
+      Oregon
+      Pennsylvania
+      "Rhode Island"
+      "South Carolina"
+      "South Dakota"
+      Tennessee
+      Texas
+      Utah
+      Vermont
+      Virginia
+      Washington
+      "West Virginia"
+      Wisconsin
+      Wyoming
+  : ?states
+& "New Kory" "Wen Kory" "York New" "Kory New" "New Kory":?extrastates
+& ( "State name puzzle"
+  =     allStates State state statechars char
+      , A Z S1 S2 S3 S4 L1 L2 L3 L4 L12
+    .   0:?allStates
+      &   whl
+        ' ( !arg:%?State ?arg
+          & low$!State:?state
+          & 0:?statechars
+          &   whl
+            ' ( @(!state:? (%@:~" ":?char) ?state)
+              & !char+!statechars:?statechars
+              )
+          & (!State.!statechars)+!allStates:?allStates
+          )
+      & (   !allStates
+          :   ?
+            + ?*(?S1.?L1)
+            + ?A
+            + ?*(?S2.?L2)
+            + ( ?Z
+              & !L1+!L2:?L12
+              &   !A+!Z
+                :   ?
+                  + ?*(?S3.?L3&!L12+-1*!L3:?L4)
+                  + ?
+                  +   ?
+                    * ( ?S4
+                      .   !L4
+                        & out$(!S1 "+" !S2 "=" !S3 "+" !S4)
+                        & ~
+                      )
+                  + ?
+              )
+        | out$"No more solutions"
+        )
+  )
+& "State name puzzle"$!states
+& "State name puzzle"$(!states !extrastates)
+);

Task/State-name-puzzle/C/state-name-puzzle.c

@@ -0,0 +1,106 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define USE_FAKES 1
+
+const char *states[] = {
+#if USE_FAKES
+	"New Kory", "Wen Kory", "York New", "Kory New", "New Kory",
+#endif
+	"Alabama", "Alaska", "Arizona", "Arkansas",
+	"California", "Colorado", "Connecticut",
+	"Delaware",
+	"Florida", "Georgia", "Hawaii",
+	"Idaho", "Illinois", "Indiana", "Iowa",
+	"Kansas", "Kentucky", "Louisiana",
+	"Maine", "Maryland", "Massachusetts", "Michigan",
+	"Minnesota", "Mississippi", "Missouri", "Montana",
+	"Nebraska", "Nevada", "New Hampshire", "New Jersey",
+	"New Mexico", "New York", "North Carolina", "North Dakota",
+	"Ohio", "Oklahoma", "Oregon",
+	"Pennsylvania", "Rhode Island",
+	"South Carolina", "South Dakota", "Tennessee", "Texas",
+	"Utah", "Vermont", "Virginia",
+	"Washington", "West Virginia", "Wisconsin", "Wyoming"
+};
+
+int n_states = sizeof(states)/sizeof(*states);
+typedef struct { unsigned char c[26]; const char *name[2]; } letters;
+
+void count_letters(letters *l, const char *s)
+{
+	int c;
+	if (!l->name[0]) l->name[0] = s;
+	else l->name[1] = s;
+
+	while ((c = *s++)) {
+		if (c >= 'a' && c <= 'z') l->c[c - 'a']++;
+		if (c >= 'A' && c <= 'Z') l->c[c - 'A']++;
+	}
+}
+
+int lcmp(const void *aa, const void *bb)
+{
+	int i;
+	const letters *a = aa, *b = bb;
+	for (i = 0; i < 26; i++)
+		if      (a->c[i] > b->c[i]) return  1;
+		else if (a->c[i] < b->c[i]) return -1;
+	return 0;
+}
+
+int scmp(const void *a, const void *b)
+{
+	return strcmp(*(const char *const *)a, *(const char *const *)b);
+}
+
+void no_dup()
+{
+	int i, j;
+
+	qsort(states, n_states, sizeof(const char*), scmp);
+
+	for (i = j = 0; i < n_states;) {
+		while (++i < n_states && !strcmp(states[i], states[j]));
+		if (i < n_states) states[++j] = states[i];
+	}
+
+	n_states = j + 1;
+}
+
+void find_mix()
+{
+	int i, j, n;
+	letters *l, *p;
+
+	no_dup();
+	n = n_states * (n_states - 1) / 2;
+	p = l = calloc(n, sizeof(letters));
+
+	for (i = 0; i < n_states; i++)
+		for (j = i + 1; j < n_states; j++, p++) {
+			count_letters(p, states[i]);
+			count_letters(p, states[j]);
+		}
+
+	qsort(l, n, sizeof(letters), lcmp);
+
+	for (j = 0; j < n; j++) {
+		for (i = j + 1; i < n && !lcmp(l + j, l + i); i++) {
+			if (l[j].name[0] == l[i].name[0]
+				|| l[j].name[1] == l[i].name[0]
+				|| l[j].name[1] == l[i].name[1])
+				continue;
+			printf("%s + %s => %s + %s\n",
+				l[j].name[0], l[j].name[1], l[i].name[0], l[i].name[1]);
+		}
+	}
+	free(l);
+}
+
+int main(void)
+{
+	find_mix();
+	return 0;
+}

Task/State-name-puzzle/D/state-name-puzzle.d

@@ -0,0 +1,28 @@
+import std.stdio, std.algorithm, std.string, std.exception;
+
+auto states = ["Alabama", "Alaska", "Arizona", "Arkansas",
+"California", "Colorado", "Connecticut", "Delaware", "Florida",
+"Georgia", "Hawaii", "Idaho", "Illinois", "Indiana", "Iowa", "Kansas",
+"Kentucky", "Louisiana", "Maine", "Maryland", "Massachusetts",
+"Michigan", "Minnesota", "Mississippi", "Missouri", "Montana",
+"Nebraska", "Nevada", "New Hampshire", "New Jersey", "New Mexico",
+"New York", "North Carolina", "North Dakota", "Ohio", "Oklahoma",
+"Oregon", "Pennsylvania", "Rhode Island", "South Carolina",
+"South Dakota", "Tennessee", "Texas", "Utah", "Vermont", "Virginia",
+"Washington", "West Virginia", "Wisconsin", "Wyoming",
+// Uncomment the next line for the fake states.
+// "New Kory", "Wen Kory", "York New", "Kory New", "New Kory"
+];
+
+void main() {
+  states.length -= states.sort().uniq.copy(states).length;
+
+  string[][const ubyte[]] smap;
+  foreach (immutable i, s1; states[0 .. $ - 1])
+    foreach (s2; states[i + 1 .. $])
+      smap[(s1 ~ s2).dup.representation.sort().release.assumeUnique]
+        ~= s1 ~ " + " ~ s2;
+
+  writefln("%-(%-(%s = %)\n%)",
+           smap.values.sort().filter!q{ a.length > 1 });
+}

Task/State-name-puzzle/Go/state-name-puzzle.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+    "fmt"
+    "unicode"
+)
+
+var states = []string{"Alabama", "Alaska", "Arizona", "Arkansas",
+    "California", "Colorado", "Connecticut",
+    "Delaware",
+    "Florida", "Georgia", "Hawaii",
+    "Idaho", "Illinois", "Indiana", "Iowa",
+    "Kansas", "Kentucky", "Louisiana",
+    "Maine", "Maryland", "Massachusetts", "Michigan",
+    "Minnesota", "Mississippi", "Missouri", "Montana",
+    "Nebraska", "Nevada", "New Hampshire", "New Jersey",
+    "New Mexico", "New York", "North Carolina", "North Dakota",
+    "Ohio", "Oklahoma", "Oregon",
+    "Pennsylvania", "Rhode Island",
+    "South Carolina", "South Dakota", "Tennessee", "Texas",
+    "Utah", "Vermont", "Virginia",
+    "Washington", "West Virginia", "Wisconsin", "Wyoming"}
+
+func main() {
+    play(states)
+    play(append(states,
+        "New Kory", "Wen Kory", "York New", "Kory New", "New Kory"))
+}
+
+func play(states []string) {
+    fmt.Println(len(states), "states:")
+    // get list of unique state names
+    set := make(map[string]bool, len(states))
+    for _, s := range states {
+        set[s] = true
+    }
+    // make parallel arrays for unique state names and letter histograms
+    s := make([]string, len(set))
+    h := make([][26]byte, len(set))
+    var i int
+    for us := range set {
+        s[i] = us
+        for _, c := range us {
+            if u := uint(unicode.ToLower(c)) - 'a'; u < 26 {
+                h[i][u]++
+            }
+        }
+        i++
+    }
+    // use map to find matches.  map key is sum of histograms of
+    // two different states.  map value is indexes of the two states.
+    type pair struct {
+        i1, i2 int
+    }
+    m := make(map[string][]pair)
+    b := make([]byte, 26) // buffer for summing histograms
+    for i1, h1 := range h {
+        for i2 := i1 + 1; i2 < len(h); i2++ {
+            // sum histograms
+            for i := range b {
+                b[i] = h1[i] + h[i2][i]
+            }
+            k := string(b) // make key from buffer.
+            // now loop over any existing pairs with the same key,
+            // printing any where both states of this pair are different
+            // than the states of the existing pair
+            for _, x := range m[k] {
+                if i1 != x.i1 && i1 != x.i2 && i2 != x.i1 && i2 != x.i2 {
+                    fmt.Printf("%s, %s = %s, %s\n", s[i1], s[i2],
+                        s[x.i1], s[x.i2])
+                }
+            }
+            // store this pair in the map whether printed or not.
+            m[k] = append(m[k], pair{i1, i2})
+        }
+    }
+}

Task/State-name-puzzle/Icon/state-name-puzzle-1.icon

@@ -0,0 +1,49 @@
+link strings                 # for csort and deletec
+
+procedure main(arglist)
+    ECsolve(S1 := getStates())     # original state names puzzle
+    ECsolve(S2 := getStates2())    # modified fictious names puzzle
+    GNsolve(S1)
+    GNsolve(S2)
+end
+
+procedure ECsolve(S)         # Solve challenge using equivalence classes
+    local T,x,y,z,i,t,s,l,m
+    st := &time              # mark runtime
+    /S := getStates()        # default
+    every insert(states := set(),deletec(map(!S),' \t'))  # ignore case & space
+
+    # Build a table containing sets of state name pairs
+    # keyed off of canonical form of the pair
+    # Use csort(s) rather than cset(s) to preserve the numbers of each letter
+    # Since we care not of X&Y .vs. Y&X keep only X&Y
+
+    T := table()
+    every (x := !states ) & ( y := !states ) do
+    if z := csort(x || (x << y)) then {
+        /T[z] := []
+        put(T[z],set(x,y))
+    }
+
+    # For each unique key (canonical pair) find intersection of all pairs
+    # Output is <current key matched> <key> <pairs>
+
+    i := m := 0       # keys (i) and pairs (m) matched
+    every z := key(T) do {
+        s := &null
+        every l := !T[z] do {
+            /s :=  l
+            s **:= l
+        }
+        if *s = 0 then {
+            i +:= 1
+            m +:= *T[z]
+            every x := !T[z] do {
+                #writes(i," ",z)  # uncomment for equiv class and match count
+                every writes(!x," ")
+                write()
+            }
+        }
+    }
+    write("... runtime ",(&time - st)/1000.,"\n",m," matches found.")
+end

Task/State-name-puzzle/Icon/state-name-puzzle-2.icon

@@ -0,0 +1,21 @@
+procedure getStates()   # return list of state names
+return ["Alabama", "Alaska", "Arizona", "Arkansas",
+       "California", "Colorado", "Connecticut",
+       "Delaware",
+       "Florida", "Georgia", "Hawaii",
+       "Idaho", "Illinois", "Indiana", "Iowa",
+       "Kansas", "Kentucky", "Louisiana",
+       "Maine", "Maryland", "Massachusetts", "Michigan",
+       "Minnesota", "Mississippi", "Missouri", "Montana",
+       "Nebraska", "Nevada", "New Hampshire", "New Jersey",
+       "New Mexico", "New York", "North Carolina", "North Dakota",
+       "Ohio", "Oklahoma", "Oregon",
+       "Pennsylvania", "Rhode Island",
+       "South Carolina", "South Dakota", "Tennessee", "Texas",
+       "Utah", "Vermont", "Virginia",
+       "Washington", "West Virginia", "Wisconsin", "Wyoming"]
+end
+
+procedure getStates2() # return list of state names + fictious states
+return getStates() ||| ["New Kory", "Wen Kory", "York New", "Kory New", "New Kory"]
+end

Task/State-name-puzzle/Icon/state-name-puzzle-3.icon

@@ -0,0 +1,58 @@
+link factors
+
+procedure GNsolve(S)
+    local min, max
+    st := &time
+    equivClasses := table()
+    statePairs := table()
+    /S := getStates()
+    every put(states := [], map(!S)) # Make case insignificant
+    min := proc("min",0)             # Link "factors" loses max/min functions
+    max := proc("max",0)             # ... these statements get them back
+
+    # Build a table of equivalence classes (all state pairs in the
+    #   same equivalence class have the same characters in them)
+    #   Output new pair couples *before* adding each state pair to class.
+
+    every (state1 := |get(states)) & (state2 := !states) do {
+        if state1 ~== state2 then {
+            statePair := min(state1, state2)||":"||max(state1,state2)
+            if /statePairs[statePair] := set(state1, state2) then {
+                signature := getClassSignature(state1, state2)
+                /equivClasses[signature] := set()
+                every *(statePairs[statePair] **   # require 4 distinct states
+                statePairs[pair := !equivClasses[signature]]) == 0 do {
+                    write(statePair, " and ", pair)
+                }
+                insert(equivClasses[signature], statePair)
+            }
+        }
+    }
+
+    write(&errout, "Time: ", (&time-st)/1000.0)
+end
+
+# Build a (Godel) signature identifying the equivalence class for state pair s.
+
+procedure getClassSignature(s1, s2)
+    static G
+    initial G := table()
+    /G[s1] := gn(s1)
+    /G[s2] := gn(s2)
+    return G[s1]*G[s2]
+end
+
+procedure gn(s)  # Compute the Godel number for a string (letters only)
+    static xlate
+    local p, i, z
+    initial {
+        xlate := table(1)
+        p := create prime()
+        every i := 1 to 26 do {
+            xlate[&lcase[i]] := xlate[&ucase[i]] := @p
+        }
+    }
+    z := 1
+    every z *:= xlate[!s]
+    return z
+end

Task/State-name-puzzle/J/state-name-puzzle-1.j

@@ -0,0 +1,21 @@
+require'strings stats'
+
+states=:<;._2]0 :0-.LF
+
+Alabama,Alaska,Arizona,Arkansas,California,Colorado,
+Connecticut,Delaware,Florida,Georgia,Hawaii,Idaho,
+Illinois,Indiana,Iowa,Kansas,Kentucky,Louisiana,
+Maine,Maryland,Massachusetts,Michigan,Minnesota,
+Mississippi,Missouri,Montana,Nebraska,Nevada,
+New Hampshire,New Jersey,New Mexico,New York,
+North Carolina,North Dakota,Ohio,Oklahoma,Oregon,
+Pennsylvania,Rhode Island,South Carolina,
+South Dakota,Tennessee,Texas,Utah,Vermont,Virginia,
+Washington,West Virginia,Wisconsin,Wyoming,
+Maine,Maine,Maine,Maine,Maine,Maine,Maine,Maine,
+
+)
+
+pairUp=: (#~ matchUp)@({~ 2 comb #)@~.
+matchUp=: (i.~ ~: i:~)@:(<@normalize@;"1)
+normalize=: /:~@tolower@-.&' '

Task/State-name-puzzle/J/state-name-puzzle-2.j

@@ -0,0 +1,6 @@
+   pairUp states
+┌──────────────┬──────────────┐
+│North Carolina│South Dakota  │
+├──────────────┼──────────────┤
+│North Dakota  │South Carolina│
+└──────────────┴──────────────┘

Task/State-name-puzzle/J/state-name-puzzle-3.j

@@ -0,0 +1,2 @@
+isolatePairs=: ~.@matchUp2@(#~ *./@matchUp"2)@({~ 2 comb #)
+matchUp2=: /:~"2@:(/:~"1)@(#~ 4=#@~.@,"2)

Task/State-name-puzzle/J/state-name-puzzle-4.j

@@ -0,0 +1,96 @@
+   isolatePairs pairUp 'New Kory';'Wen Kory';'York New';'Kory New';'New Kory';states
+┌──────────────┬──────────────┐
+│Kory New      │York New      │
+├──────────────┼──────────────┤
+│New Kory      │Wen Kory      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│New Kory      │Wen Kory      │
+├──────────────┼──────────────┤
+│New York      │York New      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│Kory New      │New York      │
+├──────────────┼──────────────┤
+│New Kory      │Wen Kory      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│Kory New      │Wen Kory      │
+├──────────────┼──────────────┤
+│New Kory      │York New      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│New Kory      │York New      │
+├──────────────┼──────────────┤
+│New York      │Wen Kory      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│Kory New      │New York      │
+├──────────────┼──────────────┤
+│New Kory      │York New      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│Kory New      │New Kory      │
+├──────────────┼──────────────┤
+│Wen Kory      │York New      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│Kory New      │New Kory      │
+├──────────────┼──────────────┤
+│New York      │Wen Kory      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│Kory New      │New Kory      │
+├──────────────┼──────────────┤
+│New York      │York New      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│New Kory      │New York      │
+├──────────────┼──────────────┤
+│Wen Kory      │York New      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│Kory New      │Wen Kory      │
+├──────────────┼──────────────┤
+│New Kory      │New York      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│Kory New      │York New      │
+├──────────────┼──────────────┤
+│New Kory      │New York      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│Kory New      │New York      │
+├──────────────┼──────────────┤
+│Wen Kory      │York New      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│Kory New      │Wen Kory      │
+├──────────────┼──────────────┤
+│New York      │York New      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│Kory New      │York New      │
+├──────────────┼──────────────┤
+│New York      │Wen Kory      │
+└──────────────┴──────────────┘
+
+┌──────────────┬──────────────┐
+│North Carolina│South Dakota  │
+├──────────────┼──────────────┤
+│North Dakota  │South Carolina│
+└──────────────┴──────────────┘

Task/State-name-puzzle/Java/state-name-puzzle.java

@@ -0,0 +1,60 @@
+import java.util.*;
+import java.util.stream.*;
+
+public class StateNamePuzzle {
+
+    static String[] states = {"Alabama", "Alaska", "Arizona", "Arkansas",
+        "California", "Colorado", "Connecticut", "Delaware", "Florida",
+        "Georgia", "hawaii", "Hawaii", "Idaho", "Illinois", "Indiana", "Iowa",
+        "Kansas", "Kentucky", "Louisiana", "Maine", "Maryland", "Massachusetts",
+        "Michigan", "Minnesota", "Mississippi", "Missouri", "Montana",
+        "Nebraska", "Nevada", "New Hampshire", "New Jersey", "New Mexico",
+        "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma",
+        "Oregon", "Pennsylvania", "Rhode Island", "South Carolina",
+        "South Dakota", "Tennessee", "Texas", "Utah", "Vermont", "Virginia",
+        "Washington", "West Virginia", "Wisconsin", "Wyoming",
+        "New Kory", "Wen Kory", "York New", "Kory New", "New Kory",};
+
+    public static void main(String[] args) {
+        solve(Arrays.asList(states));
+    }
+
+    static void solve(List<String> input) {
+        Map<String, String> orig = input.stream().collect(Collectors.toMap(
+                s -> s.replaceAll("\\s", "").toLowerCase(), s -> s, (s, a) -> s));
+
+        input = new ArrayList<>(orig.keySet());
+
+        Map<String, List<String[]>> map = new HashMap<>();
+        for (int i = 0; i < input.size() - 1; i++) {
+            String pair0 = input.get(i);
+            for (int j = i + 1; j < input.size(); j++) {
+
+                String[] pair = {pair0, input.get(j)};
+                String s = pair0 + pair[1];
+                String key = Arrays.toString(s.chars().sorted().toArray());
+
+                List<String[]> val;
+                if ((val = map.get(key)) == null)
+                    val = new ArrayList<>();
+                val.add(pair);
+                map.put(key, val);
+            }
+        }
+
+        map.forEach((key, list) -> {
+            for (int i = 0; i < list.size() - 1; i++) {
+                String[] a = list.get(i);
+                for (int j = i + 1; j < list.size(); j++) {
+                    String[] b = list.get(j);
+
+                    if (Stream.of(a[0], a[1], b[0], b[1]).distinct().count() < 4)
+                        continue;
+
+                    System.out.printf("%s + %s = %s + %s %n", orig.get(a[0]),
+                            orig.get(a[1]), orig.get(b[0]), orig.get(b[1]));
+                }
+            }
+        });
+    }
+}

Task/State-name-puzzle/Mathematica/state-name-puzzle.math

@@ -0,0 +1,13 @@
+letters[words_,n_] := Sort[Flatten[Characters /@ Take[words,n]]];
+groupSameQ[g1_, g2_] := Sort /@ Partition[g1, 2] === Sort /@ Partition[g2, 2];
+permutations[{a_, b_, c_, d_}] = Union[Permutations[{a, b, c, d}], SameTest -> groupSameQ];
+
+Select[Flatten[
+  permutations /@
+   Subsets[Union[ToLowerCase/@{"Alabama", "Alaska", "Arizona", "Arkansas", "California", "Colorado", "Connecticut", "Delaware", "Florida",
+      "Georgia", "Hawaii", "Idaho", "Illinois", "Indiana", "Iowa", "Kansas", "Kentucky", "Louisiana", "Maine", "Maryland",
+      "Massachusetts", "Michigan", "Minnesota", "Mississippi", "Missouri", "Montana", "Nebraska", "Nevada", "New Hampshire",
+      "New Jersey", "New Mexico", "New York", "North Carolina", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania",
+      "Rhode Island", "South Carolina", "South Dakota", "Tennessee", "Texas", "Utah", "Vermont", "Virginia", "Washington",
+      "West Virginia", "Wisconsin", "Wyoming"}], {4}], 1],
+ letters[#, 2] === letters[#, -2] &]

Task/State-name-puzzle/Perl-6/state-name-puzzle.pl6

@@ -0,0 +1,36 @@
+my @states = <
+    Alabama Alaska Arizona Arkansas California Colorado Connecticut Delaware
+    Florida Georgia Hawaii Idaho Illinois Indiana Iowa Kansas Kentucky
+    Louisiana Maine Maryland Massachusetts Michigan Minnesota Mississippi
+    Missouri Montana Nebraska Nevada New_Hampshire New_Jersey New_Mexico
+    New_York North_Carolina North_Dakota Ohio Oklahoma Oregon Pennsylvania
+    Rhode_Island South_Carolina South_Dakota Tennessee Texas Utah Vermont
+    Virginia Washington West_Virginia Wisconsin Wyoming
+>;
+
+say "50 states:";
+.say for anastates @states;
+
+say "\n54 states:";
+.say for anastates @states, < New_Kory Wen_Kory York_New Kory_New New_Kory >;
+
+sub anastates (*@states) {
+    my @s = @states.uniq».subst('_', ' ');
+
+    my @pairs = gather for ^@s -> $i {
+	for $i ^..^ @s -> $j {
+	    take [ @s[$i], @s[$j] ];
+	}
+    }
+
+    my $equivs = hash @pairs.classify: *.lc.comb.sort.join.trim;
+
+    gather for $equivs.values -> @c {
+	for ^@c -> $i {
+	    for $i ^..^ @c -> $j {
+		my $set = set @c[$i].list, @c[$j].list;
+		take $set.join(', ') if $set == 4;
+	    }
+	}
+    }
+}

Task/State-name-puzzle/Perl/state-name-puzzle.pl

@@ -0,0 +1,65 @@
+#!/usr/bin/perl
+use warnings;
+use strict;
+use feature qw{ say };
+
+
+sub uniq {
+    my %uniq;
+    undef @uniq{ @_ };
+    return keys %uniq
+}
+
+
+sub puzzle {
+    my @states = uniq(@_);
+
+    my %pairs;
+    for my $state1 (@states) {
+        for my $state2 (@states) {
+            next if $state1 le $state2;
+            my $both = join q(),
+                       grep ' ' ne $_,
+                       sort split //,
+                       lc "$state1$state2";
+            push @{ $pairs{$both} }, [ $state1, $state2 ];
+        }
+    }
+
+    for my $pair (keys %pairs) {
+        next if 2 > @{ $pairs{$pair} };
+
+        for my $pair1 (@{ $pairs{$pair} }) {
+            for my $pair2 (@{ $pairs{$pair} }) {
+                next if 4 > uniq(@$pair1, @$pair2)
+                     or $pair1->[0] lt $pair2->[0];
+
+                say join ' = ', map { join ' + ', @$_ } $pair1, $pair2;
+            }
+        }
+    }
+}
+
+my @states = ( 'Alabama', 'Alaska', 'Arizona', 'Arkansas',
+               'California', 'Colorado', 'Connecticut', 'Delaware',
+               'Florida', 'Georgia', 'Hawaii',
+               'Idaho', 'Illinois', 'Indiana', 'Iowa',
+               'Kansas', 'Kentucky', 'Louisiana',
+               'Maine', 'Maryland', 'Massachusetts', 'Michigan',
+               'Minnesota', 'Mississippi', 'Missouri', 'Montana',
+               'Nebraska', 'Nevada', 'New Hampshire', 'New Jersey',
+               'New Mexico', 'New York', 'North Carolina', 'North Dakota',
+               'Ohio', 'Oklahoma', 'Oregon',
+               'Pennsylvania', 'Rhode Island',
+               'South Carolina', 'South Dakota', 'Tennessee', 'Texas',
+               'Utah', 'Vermont', 'Virginia',
+               'Washington', 'West Virginia', 'Wisconsin', 'Wyoming',
+             );
+
+my @fictious = ( 'New Kory', 'Wen Kory', 'York New', 'Kory New', 'New Kory' );
+
+say scalar @states, ' states:';
+puzzle(@states);
+
+say @states + @fictious, ' states:';
+puzzle(@states, @fictious);

Task/State-name-puzzle/PicoLisp/state-name-puzzle.l

@@ -0,0 +1,41 @@
+(setq *States
+   (group
+      (mapcar '((Name) (cons (clip (sort (chop (lowc Name)))) Name))
+         (quote
+            "Alabama" "Alaska" "Arizona" "Arkansas"
+            "California" "Colorado" "Connecticut"
+            "Delaware"
+            "Florida" "Georgia" "Hawaii"
+            "Idaho" "Illinois" "Indiana" "Iowa"
+            "Kansas" "Kentucky" "Louisiana"
+            "Maine" "Maryland" "Massachusetts" "Michigan"
+            "Minnesota" "Mississippi" "Missouri" "Montana"
+            "Nebraska" "Nevada" "New Hampshire" "New Jersey"
+            "New Mexico" "New York" "North Carolina" "North Dakota"
+            "Ohio" "Oklahoma" "Oregon"
+            "Pennsylvania" "Rhode Island"
+            "South Carolina" "South Dakota" "Tennessee" "Texas"
+            "Utah" "Vermont" "Virginia"
+            "Washington" "West Virginia" "Wisconsin" "Wyoming"
+            "New Kory" "Wen Kory" "York New" "Kory New" "New Kory" ) ) ) )
+
+(extract
+   '((P)
+      (when (cddr P)
+         (mapcar
+            '((X)
+               (cons
+                  (cadr (assoc (car X) *States))
+                  (cadr (assoc (cdr X) *States)) ) )
+            (cdr P) ) ) )
+   (group
+      (mapcon
+         '((X)
+            (extract
+               '((Y)
+                  (cons
+                     (sort (conc (copy (caar X)) (copy (car Y))))
+                     (caar X)
+                     (car Y) ) )
+               (cdr X) ) )
+         *States ) ) )

Task/State-name-puzzle/Prolog/state-name-puzzle.pro

@@ -0,0 +1,70 @@
+state_name_puzzle :-
+	L = ["Alabama", "Alaska", "Arizona", "Arkansas",
+	     "California", "Colorado", "Connecticut",
+	     "Delaware",
+	     "Florida", "Georgia", "Hawaii",
+	     "Idaho", "Illinois", "Indiana", "Iowa",
+	     "Kansas", "Kentucky", "Louisiana",
+	     "Maine", "Maryland", "Massachusetts", "Michigan",
+	     "Minnesota", "Mississippi", "Missouri", "Montana",
+	     "Nebraska", "Nevada", "New Hampshire", "New Jersey",
+	     "New Mexico", "New York", "North Carolina", "North Dakota",
+	     "Ohio", "Oklahoma", "Oregon",
+	     "Pennsylvania", "Rhode Island",
+	     "South Carolina", "South Dakota", "Tennessee", "Texas",
+	     "Utah", "Vermont", "Virginia",
+	     "Washington", "West Virginia", "Wisconsin", "Wyoming",
+	     "New Kory", "Wen Kory", "York New", "Kory New", "New Kory"],
+
+	maplist(goedel, L, R),
+
+	% sort remove duplicates
+	sort(R, RS),
+
+	study(RS).
+
+study([]).
+
+study([V-Word|T]) :-
+	study_1_Word(V-Word, T, T),
+	study(T).
+
+
+study_1_Word(_, [], _).
+study_1_Word(V1-W1, [V2-W2 | T1], T) :-
+	TT is V1+V2,
+	study_2_Word(W1, W2, TT, T),
+	study_1_Word(V1-W1, T1, T).
+
+study_2_Word(_W1, _W2, _TT, []).
+
+study_2_Word(W1, W2, TT, [V3-W3 | T]) :-
+	(   W2 \= W3 -> study_3_Word(W1, W2, TT, V3-W3, T); true),
+	study_2_Word(W1, W2, TT, T).
+
+study_3_Word(_W1, _W2, _TT, _V3-_W3, []).
+
+study_3_Word(W1, W2, TT, V3-W3, [V4-W4|T]) :-
+	TT1 is V3 + V4,
+	(   TT1 < TT -> study_3_Word(W1, W2, TT, V3-W3, T)
+	;   (TT1 = TT -> ( W4 \= W2 -> format('~w & ~w  with ~w & ~w~n', [W1, W2, W3, W4])
+	                               ; true),
+           	         study_3_Word(W1, W2, TT, V3-W3, T))
+	;   true).
+
+% Compute a Goedel number for the word
+goedel(Word, Goedel-A) :-
+	name(A, Word),
+	downcase_atom(A, Amin),
+	atom_codes(Amin, LA),
+	compute_Goedel(LA, 0, Goedel).
+
+compute_Goedel([], G, G).
+
+compute_Goedel([32|T], GC, GF) :-
+	compute_Goedel(T, GC, GF).
+
+compute_Goedel([H|T], GC, GF) :-
+	Ind is H - 97,
+	GC1 is GC + 26 ** Ind,
+	compute_Goedel(T, GC1, GF).

Task/State-name-puzzle/Python/state-name-puzzle.py

@@ -0,0 +1,26 @@
+from collections import defaultdict
+
+states = ["Alabama", "Alaska", "Arizona", "Arkansas",
+"California", "Colorado", "Connecticut", "Delaware", "Florida",
+"Georgia", "Hawaii", "Idaho", "Illinois", "Indiana", "Iowa", "Kansas",
+"Kentucky", "Louisiana", "Maine", "Maryland", "Massachusetts",
+"Michigan", "Minnesota", "Mississippi", "Missouri", "Montana",
+"Nebraska", "Nevada", "New Hampshire", "New Jersey", "New Mexico",
+"New York", "North Carolina", "North Dakota", "Ohio", "Oklahoma",
+"Oregon", "Pennsylvania", "Rhode Island", "South Carolina",
+"South Dakota", "Tennessee", "Texas", "Utah", "Vermont", "Virginia",
+"Washington", "West Virginia", "Wisconsin", "Wyoming",
+# Uncomment the next line for the fake states.
+# "New Kory", "Wen Kory", "York New", "Kory New", "New Kory"
+]
+
+states = sorted(set(states))
+
+smap = defaultdict(list)
+for i, s1 in enumerate(states[:-1]):
+    for s2 in states[i + 1:]:
+        smap["".join(sorted(s1 + s2))].append(s1 + " + " + s2)
+
+for pairs in sorted(smap.itervalues()):
+    if len(pairs) > 1:
+        print " = ".join(pairs)

Task/State-name-puzzle/README

@@ -0,0 +1 @@
+Data source: http://rosettacode.org/wiki/State_name_puzzle

Task/State-name-puzzle/REXX/state-name-puzzle.rexx

@@ -0,0 +1,88 @@
+/*REXX pgm: state name puzzle, rearrange 2 state's names──►2 new states.*/
+!='Alabama,  Alaska, Arizona,  Arkansas, California,    Colorado, Connecticut,       Delaware, Florida, Georgia,',
+  'Hawaii,   Idaho,  Illinois, Indiana,  Iowa, Kansas,  Kentucky, Louisiana,  Maine, Maryland, Massachusetts,   ',
+  'Michigan, Minnesota, Mississippi, Missouri, Montana, Nebraska, Nevada, New Hampshire, New Jersey, New Mexico,',
+  'New York, North Carolina,  North Dakota,  Ohio, Oklahoma, Oregon, Pennsylvania, Rhode Island, South Carolina,',
+  'South Dakota,  Tennessee,  Texas,  Utah,  Vermont,   Virginia, Washington, West Virginia, Wisconsin,  Wyoming'
+
+parse arg xtra;    !=! ',' xtra           /*add optional fictitious ones*/
+@abcU='ABCDEFGHIJKLMNOPQRSTUVWXYZ';     !=space(!)    /*ABCs, state list*/
+deads=0;   dups=0;   L.=0;   !orig=!;   z=0;   @@.=   /*initialize stuff*/
+
+  do de=0 to 1;    !=!orig;    @.=        /*use the original state list.*/
+
+    do states=0  until !==''              /*parse 'til da cows come home*/
+    parse var ! x ',' !;   x=space(x)     /*remove all blanks from state*/
+    if @.x\=='' then do                   /*state was already specified.*/
+                     if de then iterate   /*don't tell error if 2nd pass*/
+                     dups=dups+1          /*bump the duplicate counter. */
+                     say 'ignoring the 2nd naming of the state: ' x
+                     iterate
+                     end
+    @.x=x                                 /*indicate this state exists. */
+    y=space(x,0);  upper y;  yLen=length(y)
+
+    if de then do
+                  do j=1 for yLen         /*see if it's a dead-end state*/
+                  _=substr(y,j,1)         /* _ is some state character. */
+                  if L._\==1 then iterate /*if count ¬1, state is O.K.  */
+                  say 'removing dead-end state  [which has the letter ' _"]: "  x
+                  deads=deads+1           /*bump # of dead-ends states. */
+                  iterate states
+                  end   /*j*/
+               z=z+1                      /*bump counter of the states. */
+               #.z=y;  ##.z=x             /*assign state name; &original*/
+               end
+          else do k=1 for yLen            /*inventorize state's letters.*/
+               _=substr(y,k,1); L._=L._+1 /*count each letter in state. */
+               end   /*k*/
+
+    end   /*states*/
+  end     /*de*/
+
+say;                  do i=1  for z       /*list states in order given. */
+                      say right(i,9) ##.i
+                      end   /*i*/
+
+                   say; say z 'state name's(z)          "are useable."
+if dups \==0 then  say dups  'duplicate of a state's(dups)  'ignored.'
+if deads\==0 then  say deads 'dead-end state's(deads)       'deleted.'
+say
+sols=0                                    /*number of solutions found.  */
+
+     do j=1 for z  /*◄────────────────────────────────────────────────┐ */
+                                         /*look for mix&match states. │ */
+       do k=j+1 to z                     /* ◄─── state K,  state J ►──┘ */
+       if #.j<<#.k  then JK=#.j || #.k                   /*proper order.*/
+                    else JK=#.k || #.j                   /*state J || K */
+
+         do m=1 for z;     if m==j | m==k then iterate   /*no overlaps. */
+         if verify(#.m,jk)\==0            then iterate   /*is possible? */
+         nJK=elider(JK,#.m)           /*new JK, after eliding #.m chars.*/
+
+           do n=m+1 to z;  if n==j | n==k then iterate   /*no overlaps. */
+           if verify(#.n,nJK)\==0         then iterate   /*is possible? */
+           if elider(nJK,#.n)\==''        then iterate   /*leftovers ?  */
+           if #.m<<#.n  then MN=#.m || #.n               /*proper order.*/
+                        else MN=#.n || #.m               /*state M || N */
+           if @@.JK.MN\=='' | @@.MN.JK\=='' then iterate /*done before? */
+           say 'found: '  ##.j',' ##.k     "  ──►  "     ##.m','  ##.n
+           @@.JK.MN=1                 /*indicate this solution as found.*/
+           sols=sols+1                /*bump the number of solutions.   */
+           end   /*n*/
+         end     /*m*/
+       end       /*k*/
+     end         /*j*/
+say                                    /*show blank line; easier reading*/
+if sols==0  then sols='No'             /*use mucher gooder (sic) English*/
+say sols 'solution's(sols) "found."    /*display the number of solutions*/
+exit                                   /*stick a fork in it, we're done.*/
+/*───────────────────────────────────ELIDER─────────────────────────────*/
+elider: parse arg hay,pins             /*remove letters (pins) from hay.*/
+                            do e=1 for length(pins);  _=substr(pins,e,1)
+                            p=pos(_,hay);             if p==0 then iterate
+                            hay=overlay(' ',hay,p)    /*remove a letter.*/
+                            end   /*e*/
+return space(hay,0)                                   /*remove blanks.  */
+/*──────────────────────────────────S subroutine────────────────────────*/
+s: if arg(1)==1 then return arg(3);return word(arg(2) 's',1)  /*plurals.*/

Task/State-name-puzzle/Racket/state-name-puzzle-1.rkt

@@ -0,0 +1,30 @@
+#lang racket
+(define states
+  (list->set
+   (map string-downcase
+        '("Alabama" "Alaska" "Arizona" "Arkansas"
+          "California" "Colorado" "Connecticut"
+          "Delaware"
+          "Florida" "Georgia" "Hawaii"
+          "Idaho" "Illinois" "Indiana" "Iowa"
+          "Kansas" "Kentucky" "Louisiana"
+          "Maine" "Maryland" "Massachusetts" "Michigan"
+          "Minnesota" "Mississippi" "Missouri" "Montana"
+          "Nebraska""Nevada" "New Hampshire" "New Jersey"
+          "New Mexico" "New York" "North Carolina" "North Dakota"
+          "Ohio" "Oklahoma" "Oregon"
+          "Pennsylvania" "Rhode Island"
+          "South Carolina" "South Dakota" "Tennessee" "Texas"
+          "Utah" "Vermont" "Virginia"
+          "Washington" "West Virginia" "Wisconsin" "Wyoming"
+          ; "New Kory" "Wen Kory" "York New" "Kory New" "New Kory"
+          ))))
+
+(define (canon s t)
+  (sort (append (string->list s) (string->list t)) char<? ))
+
+(define seen (make-hash))
+(for* ([s1 states] [s2 states] #:when (string<? s1 s2))
+  (define c (canon s1 s2))
+  (cond [(hash-ref seen c (λ() (hash-set! seen c (list s1 s2)) #f))
+         => (λ(states) (displayln (~v states (list s1 s2))))]))

Task/State-name-puzzle/Racket/state-name-puzzle-2.rkt

@@ -0,0 +1 @@
+'("north dakota" "south carolina") '("north carolina" "south dakota")

Task/State-name-puzzle/Ruby/state-name-puzzle.rb

@@ -0,0 +1,45 @@
+require 'set'
+
+# 26 prime numbers
+Primes = [ 2,  3,  5,  7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
+          43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101]
+States = [
+    "Alabama", "Alaska", "Arizona", "Arkansas", "California", "Colorado",
+    "Connecticut", "Delaware", "Florida", "Georgia", "Hawaii", "Idaho",
+    "Illinois", "Indiana", "Iowa", "Kansas", "Kentucky", "Louisiana", "Maine",
+    "Maryland", "Massachusetts", "Michigan", "Minnesota", "Mississippi",
+    "Missouri", "Montana", "Nebraska", "Nevada", "New Hampshire", "New Jersey",
+    "New Mexico", "New York", "North Carolina", "North Dakota", "Ohio",
+    "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina",
+    "South Dakota", "Tennessee", "Texas", "Utah", "Vermont", "Virginia",
+    "Washington", "West Virginia", "Wisconsin", "Wyoming"
+]
+
+def print_answer(states)
+  # find goedel numbers for all pairs of states
+  goedel = lambda {|str| str.chars.map {|c| Primes[c.ord - 65]}.reduce(:*)}
+  pairs = Hash.new {|h,k| h[k] = Array.new}
+  map = states.uniq.map {|state| [state, goedel[state.upcase.delete("^A-Z")]]}
+  map.combination(2) {|(s1,g1), (s2,g2)| pairs[g1 * g2] << [s1, s2]}
+
+  # find pairs without duplicates
+  result = []
+  pairs.values.select {|val| val.length > 1}.each do |list_of_pairs|
+    list_of_pairs.combination(2) do |pair1, pair2|
+      if Set[*pair1, *pair2].length == 4
+        result << [pair1, pair2]
+      end
+    end
+  end
+
+  # output the results
+  result.each_with_index do |(pair1, pair2), i|
+    puts "%d\t%s\t%s" % [i+1, pair1.join(', '), pair2.join(', ')]
+  end
+end
+
+puts "real states only"
+print_answer(States)
+puts ""
+puts "with fictional states"
+print_answer(States + ["New Kory", "Wen Kory", "York New", "Kory New", "New Kory"])

Task/State-name-puzzle/Scala/state-name-puzzle.scala

@@ -0,0 +1,26 @@
+object StateNamePuzzle extends App {
+  // Logic:
+  def disjointPairs(pairs: Seq[Set[String]]) =
+    for (a <- pairs; b <- pairs; if a.intersect(b).isEmpty) yield Set(a,b)
+
+  def anagramPairs(words: Seq[String]) =
+    (for (a <- words; b <- words; if a != b) yield Set(a, b)) // all pairs
+    .groupBy(_.mkString.toLowerCase.replaceAll("[^a-z]", "").sorted) // grouped anagram pairs
+    .values.map(disjointPairs).flatMap(_.distinct) // unique non-overlapping anagram pairs
+
+  // Test:
+  val states = List(
+    "New Kory", "Wen Kory", "York New", "Kory New", "New Kory",
+    "Alabama", "Alaska", "Arizona", "Arkansas", "California", "Colorado",
+    "Connecticut", "Delaware", "Florida", "Georgia", "Hawaii", "Idaho",
+    "Illinois", "Indiana", "Iowa", "Kansas", "Kentucky", "Louisiana", "Maine",
+    "Maryland", "Massachusetts", "Michigan", "Minnesota", "Mississippi",
+    "Missouri", "Montana", "Nebraska", "Nevada", "New Hampshire", "New Jersey",
+    "New Mexico", "New York", "North Carolina", "North Dakota", "Ohio",
+    "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina",
+    "South Dakota", "Tennessee", "Texas", "Utah", "Vermont", "Virginia",
+    "Washington", "West Virginia", "Wisconsin", "Wyoming"
+  )
+
+  println(anagramPairs(states).map(_.map(_ mkString " + ") mkString " = ") mkString "\n")
+}

Task/State-name-puzzle/Tcl/state-name-puzzle.tcl

@@ -0,0 +1,67 @@
+package require Tcl 8.5
+# Gödel number generator
+proc goedel s {
+    set primes {
+	2 3 5 7 11 13 17 19 23 29 31 37 41
+	43 47 53 59 61 67 71 73 79 83 89 97 101
+    }
+    set n 1
+    foreach c [split [string toupper $s] ""] {
+	if {![string is alpha $c]} continue
+	set n [expr {$n * [lindex $primes [expr {[scan $c %c] - 65}]]}]
+    }
+    return $n
+}
+# Calculates the pairs of states
+proc groupStates {stateList} {
+    set stateList [lsort -unique $stateList]
+    foreach state1 $stateList {
+	foreach state2 $stateList {
+	    if {$state1 >= $state2} continue
+	    dict lappend group [goedel $state1$state2] [list $state1 $state2]
+	}
+    }
+    foreach g [dict values $group] {
+	if {[llength $g] > 1} {
+	    foreach p1 $g {
+		foreach p2 $g {
+		    if {$p1 < $p2 && [unshared $p1 $p2]} {
+			lappend result [list $p1 $p2]
+		    }
+		}
+	    }
+	}
+    }
+    return $result
+}
+proc unshared args {
+    foreach p $args {
+	foreach a $p {incr s($a)}
+    }
+    expr {[array size s] == [llength $args]*2}
+}
+# Pretty printer for state name pair lists
+proc printPairs {title groups} {
+    foreach group $groups {
+	puts "$title Group #[incr count]"
+	foreach statePair $group {
+	    puts "\t[join $statePair {, }]"
+	}
+    }
+}
+
+set realStates {
+    "Alabama" "Alaska" "Arizona" "Arkansas" "California" "Colorado"
+    "Connecticut" "Delaware" "Florida" "Georgia" "Hawaii" "Idaho" "Illinois"
+    "Indiana" "Iowa" "Kansas" "Kentucky" "Louisiana" "Maine" "Maryland"
+    "Massachusetts" "Michigan" "Minnesota" "Mississippi" "Missouri" "Montana"
+    "Nebraska" "Nevada" "New Hampshire" "New Jersey" "New Mexico" "New York"
+    "North Carolina" "North Dakota" "Ohio" "Oklahoma" "Oregon" "Pennsylvania"
+    "Rhode Island" "South Carolina" "South Dakota" "Tennessee" "Texas" "Utah"
+    "Vermont" "Virginia" "Washington" "West Virginia" "Wisconsin" "Wyoming"
+}
+printPairs "Real States" [groupStates $realStates]
+set falseStates {
+    "New Kory" "Wen Kory" "York New" "Kory New" "New Kory"
+}
+printPairs "Real and False States" [groupStates [concat $realStates $falseStates]]