#!/usr/bin/python

by_anagram = {}

for line in open("dist.male.first"):
    name = (line.split())[0]
    sorted_name = "".join(sorted([letter for letter in name]))
    by_anagram.setdefault(sorted_name, []).append(name)
    
for names in by_anagram.itervalues():
    if len(names) > 1:
       print names

set f [open dist.male.first r]
while {[gets $f line] >= 0} {
    set name [lindex [split $line " "] 0]
    set sorted [lsort [split $name ""]]
    lappend by_anagram($sorted) $name
}

foreach sorted [array names by_anagram] {
    if {[llength $by_anagram($sorted)] > 1} {
        puts $by_anagram($sorted)
    }
}
close $f

File.open('dist.male.first').
  map {|line| line.split.first}.
  group_by {|name| name.chars.sort}.
  each {|key,names| p names if names.length>1}

#!/usr/bin/python

by_anagram = {}

for name in [l.split()[0] for l in open("dist.male.first")]:
        by_anagram.setdefault("".join(sorted(name)), []).append(name)

print "\n".join([" ".join(n) for n in by_anagram.itervalues() if len(n) > 1])

import Control.Arrow
import List
import qualified Data.Map as M

main = do
  dat <- readFile "dist.male.first"
  let pairs = map ((sort &&& (:[])) . head . words) $ lines dat
  mapM_ print $ filter ((>1) . length) $ M.elems $ M.fromListWith (++) pairs

#define STB_DEFINE
#include "stb.h"     // http://nothings.org/stb.h

stb_sdict *names;

int main(int argc, char **argv)
{
   int i,j;
   char **lines, *y;
   names = stb_sdict_new(1);
   lines = stb_stringfile("/sean/writing/tools/male.txt", NULL);
   for (; *lines; ++lines) {
      char **z = stb_tokens(*lines, " ", NULL), *p = strdup(z[0]), **s;
      qsort(z[0], strlen(z[0]), 1, stb_charcmp);
      s = stb_sdict_get(names, z[0]);
      stb_arr_push(s, p);
      stb_sdict_set(names, z[0], s);
   }
   stb_sdict_for(names, i, y, lines) {
      if (stb_arr_len(lines) > 1) {
         printf("[ ");
         for (j=0; j < stb_arr_len(lines); ++j) {
            printf("'%s' ", lines[j]);
         }
         printf("]\n");
      }
   }
   return 0;
}

Hey, no fair. No one’s showing the Perl version any love even though it has a lot of stuff you can get rid of:

#!/usr/bin/perl
use strict;

sub sort_chars { join '', sort split //, shift }

my %by_anagram;

@ARGV = "dist.male.first"; # better yet: pass it on the command line
while (<>) {
    s/\s.*//s;
    push @{ $by_anagram{ sort_chars($_) } }, $_;
}

for ( values %by_anagram ) {
    print "@$_\n" if @$_ > 1;
}

(Untested.)

Although I’d write it slightly longer in order to de-uglify the push line, by factoring out the addressing into an extra temporary:

    my $bucket = \$by_anagram{ sort_chars($_) }; # oh hai, iz mah...
    push @$bucket, $_;

Much nicer.

I thought it might be fun to do it in C#, just for kicks:

using System;
using System.IO;
using System.Linq;
using System.Collections.Generic;

public class AnagramNames {
	public static void Main(string[] args) {
		var names = from name in File.ReadAllLines("dist.male.first") select name.Split(' ')[0];
		var pairs = from pair in (
			from name in names group name by SortCharsInString(name)
		) where pair.Count() > 1 select pair;

		foreach (var pair in pairs) {
			Console.WriteLine(String.Join(",", pair.ToArray()));
		}
	}
	public static string SortCharsInString(string s) {
		char[] arr = s.ToArray();
		Array.Sort(arr);
		return new string(arr);
	}
}

It could be even shorter and more memory-efficient if I could find a way in the standard library to:

• Get an IEnumerable<string> for "lines in a file" without reading the whole file into an array (it's easy to write such a thing, so I'm sure it's in the standard library somewhere...)
• Sort the characters in a string in a functional way, rather than in-place

No timings, since I had to write this in Windows; Mono doesn't have stable LINQ support yet.

(require 'cl)
(with-current-buffer (find-file-noselect "input")
 (let ((hash (make-hash-table :test #'equal)))
    (while (and (not (eobp))
                (re-search-forward "^\\w*" nil t))
      (setf str (match-string 0))
      (sort* str #'<)
      (push (match-string 0) (gethash str hash)))
    (maphash (lambda (k v)
               (when (cdr v) (print v))) hash)))

by_anagram = {}
for line in file("dist.male.first"):
  by_anagram[sorted(line)]=by_anagram.get(sorted(line),[])+[line,]
for line in by_anagram.values():
  print line

Nice post, it's fun to see different approaches. Here's mine in Common Lisp:

(let ((hash (make-hash-table :test #'equal)))
    (with-open-file (stream "names")
                    (loop for line = (read-line stream nil nil)
                          for key = (sort (copy-seq line) #'char<)
                          until (null line)
                          do (push line (gethash key hash nil))))
    (loop for v being the hash-value of hash
          do (when (cdr v) (format t "~{~A~^, ~}~%" v))))