```Please allow me a quick clarification, before I talk about this week's quiz.
Joe Cheng asked:

Will you accept solutions that just print out the e-mails
instead of sending them? :)

My answer to this is simply that you may submit whatever you like to a Ruby
Quiz.  There's no right and wrong answers here.  However, when I define a
specification in a quiz, that's what I'm prepared to benchmark, test and
summarize.  Please understand if I do not include altered solutions in those
processes.  (This has been added to the Ruby Quiz FAQ.)

Let's move on to the problem at hand.

As many have now pointed out, this problem is trickier than it first appears.
The first solution that came to my mind when playing with this problem was
simple:

1.  Choose a name from the list.
2.  Filter all matching surnames out of the Santa list.
3.  Assign a random Santa from the list in step 2, to the name in step 1.
4.  Repeat until all names are assigned...

As I quickly learned, that doesn't quite work.  The easiest way to see why it
doesn't work is to consider three families, one member each:

Skywalker can be assigned as a Santa for Portokalos.
Portokalos can then be assigned as the Santa for Skywalker.
And then we're stuck!  There are no matches left for Brigman or whoever.

Depending on how you implement the above, you'll probably get incorrect output
or get stuck in an infinite loop at this point.  That was when I personally
began to take this problem seriously, and look at other options.  Let's see what
others found.

The submitted solutions are more or less variations on three major themes:

Random Sorts
Circular Lists and/or Family Grouping
"Hill Climbing" Algorithms

Let's examine each of those in turn, starting with random sorts.  Here's the
code from my own submission that handles this:

\$players = STDIN.readlines.map { |line| line.chomp }
\$santas = \$players.sort_by { rand }

def check_families?
\$players.each_with_index do |who, i|
return false if who[/\S+ </] == \$santas[i][/\S+ </]
end
return true
end

\$santas = \$players.sort_by { rand } until check_families?

The idea there is simple, keep randomly shuffling \$santas until we can verify
that none of the match-ups share the same surname.  That ensures no one will
have themself or common family members, of course.  This method does give us a
good random shuffle of the match-ups, but unfortunately, the performance is far
from stellar.

Still, in a Secret Santa selection script, how critical is performance?  This
type of answer could be a viable solution in this case, though it usually isn't
in the majority of "Real World" problems.

The techniques in the second category of solutions, circular lists/family
groupings, were quite varied.  One solution built a circular linked list,
separated family members in that list, and then assigned Santas straight down.
Another tactic, used in more than one submission, was to separate the input into
family groups, choose a member from the most populated family, and assign a
Santa from the next highest populated family, until the list was exhausted.

Algorithms like this are far more efficient that my random sort above,
critically so in pathological cases.  They do make a trade off though.  These
types of assignments are not unbiased and do not allow for all possible
permutations of assignment.  Consider this: in a circular list approach, it is
impossible for two players of the game to be assigned to each other as Santas.
That's not to say this is a minus of these algorithms, some groups may even
prefer this behavior, but if you're looking for something quite random you
probably need to look at little further.

However, Niklas Frykholm submitted what I believe to be a variation of the
family grouping theme that does produce unbiased matches.  Here's the matching
portion of his code:

class Array
def random_member(&block)
return select(&block).random_member if block
return self[rand(size)]
end
def count(&block)
return select(&block).size
end
end

class String
def clean_here_string
indent = self[/^\s*/]
return self.gsub(/^#{indent}/, "")
end
end

class Person
attr_reader :first, :family, :mail
def initialize(first, family, mail)
@first, @family, @mail = first, family, mail
end
def to_s() "#{first} #{family} <#{mail}>" end
end

class AssignSanta
def initialize(persons)
@persons = persons.dup
@santas = persons.dup
@families = persons.collect {|p| p.family}.uniq
@families.each { |f|
if santa_surplus(f) < 0
raise "No santa configuration possible"
}
end

# Key function -- extra santas available for a family
#		if this is negative -- no santa configuration is possible
#		if this is 0 -- next santa must be assigned to this family
def santa_surplus(family)
return @santas.count {|s| s.family != family} -
@persons.count {|p| p.family == family}
end

def call
while @persons.size() > 0
family = @families.detect { |f|
santa_surplus(f)==0 and
@persons.count{|p| p.family == f} > 0
}
person = @persons.random_member { |p|
family == nil || p.family == family
}
santa = @santas.random_member{ |s|
s.family != person.family
}
yield(person, santa)
@persons.delete(person)
@santas.delete(santa)
end
end
end

The exciting stuff is at the bottom, particularly the santa_surplus() method.
Niklas' code tracks how many Santas are still available to all the families at
each step and uses this information to avoid running out of options for future
selections.  But don't take my word for it, he posted a wonderful follow-up
breakdown of exactly how it works to Ruby Talk:

http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/114760

The final type of solution was what is generally known as a "Hill Climbing"
algorithm.  Dennis Ranke explains his version nicely:

I start by assigning a random santa to everyone without caring about the
constraints. Then I go through the list of people and for each one not
having a correct santa I swap santas with someone else, so that both have
correct santas afterwards.
As far as I can see, this will only fail when no solution is possible and
should be reasonably unbiased.

Put another way, you start with a random and likely quite incorrect match-up,
then correct it one swap at a time.  Here's the code to match the description:

class Person
attr_reader :first, :last, :email
attr_accessor :santa

def initialize(line)
m = /(\S+)\s+(\S+)\s+<(.*)>/.match(line)
raise unless m
@first = m[1].capitalize
@last = m[2].capitalize
@email = m[3]
end

def can_be_santa_of?(other)
@last != other.last
end
end

input = \$stdin.read

people = []
input.each_line do |line|
line.strip!
people << Person.new(line) unless line.empty?
end

santas = people.dup
people.each do |person|
person.santa = santas.delete_at(rand(santas.size))
end

people.each do |person|
unless person.santa.can_be_santa_of? person
candidates = people.select { |p|
p.santa.can_be_santa_of?(person) &&
person.santa.can_be_santa_of?(p)
}
raise if candidates.empty?
other = candidates[rand(candidates.size)]
temp = person.santa
person.santa = other.santa
other.santa = temp
finished = false
end
end

people.each do |person|
printf "%s %s -> %s %s\n", person.santa.first, person.santa.last,
person.first, person.last
end

Santas are randomly assigned in the first people.each() iteration above and then
swapped until correct in the following people.each() iteration.  I was surprised
at how simple this solution came out, with such effective results.

That's all I have time to cover, but that's certainly not all there is to see in
the submitted solutions.  I learn new tricks every time I read the code to put
together one of these summaries.  They're certainly worth a look, if you haven't
given them one already.  Other highlights include Warren Brown's rules based
approach and Gavin Kistner's Ouroboros class for building circular lists, but
again, I think all the solutions are worth examining.

Before I wrap this up, let me congratulate Robo and Cristi BALAN who both
claimed inexperience and promptly proved it false with working code.  I singled
Robo out in the discussion early on to hint at the quiz's complexity, but the
truth is that his solution could work fine for the problem at hand.  Who cares
if you sometimes have to run it twice?  I sure don't.

My thanks to all who submitted and all those that just tolerate our babble on
Ruby Talk.  Look for Gavin's quiz tomorrow morning...

```