```Here's my solution.

I also eschewed doing any google research and started from scratch.  I
think I've taken a slightly different approach than any already
described.

The basic approach is to start with a circle containing only the first
point, and then add the points one by one changing the circle as
necessary.  So

First point
Set center to the point and radius to zero.

Subsequent points.
If the point is already in the circle then the point is simply
added to the collection of points and the circle is unchanged.  The
point is in the circle if the distance from the center of the circle
is less than the radius (within some epsilon to deal with floating
point comparisons).

If the point is further from the center than the radius, the we know
that it must lie on the circumference of the new circle which will
contain all of the points examined thus far.  We now find the set of
points which are furthest from the new point (again within some
epsilon).  There will of course be one or more of these points.

Now the center of the new circle is the average of those furthest
points plus the new points, and the radius is the distance between the
center and the new point.

The code is in several files:

==== lib/circle.rb =====
def to_s
end
end

==== lib/point.rb =====
class Point < Struct.new(:x, :y)

def self.random
new(rand, rand)
end

def to_s
"Point(#{x}, #{y})"
end

def inspect
to_s
end

def -(aPoint)
Point.new(x - aPoint.x, y - aPoint.y)
end

def dist_squared(other_point)
diff = self - other_point
diff.x * diff.x + diff.y * diff.y
end

def dist(other_point)
Math.sqrt(dist_squared(other_point))
end

def ==(other_point)
x = other_point.x && y == other_point.y
end

def center(other_point)
Point.new((x + other_point.x)/2, (y + other_point.y)/2)
end

end

==== lib/point_collection.rb ====
require File.dirname(__FILE__) + '/point'
require File.dirname(__FILE__) + '/circle'

class PointCollection

def initialize
@points = []
end

def circle
end

@points << a_point
end

def empty?
@points.empty?
end

private
# Recalculate the center and radius if a point has been added.
# If the new point is within the current circle then no change
# is needed.
# If it isn't then, it must be on the circumference of the new circle
# In this case find the point or points furthest from the new point,
# The new center will be the center of the new point plus these far points
# The new radius will be the distance of the new point from the new center.
if @center
circ_points = (farthest_from(a_point) + [a_point]).uniq
@center = center_of(circ_points)
end
else
@center = a_point
end
end

# Given an array of points find the center.
def center_of(an_array_of_points)
x_sum = y_sum = 0.0
an_array_of_points.each do |point|
x_sum += point.x
y_sum += point.y
end
Point.new(x_sum / an_array_of_points.length, y_sum /
an_array_of_points.length)
end

def farthest_from(a_point)
max_dist_squared = 0.0
delta = 0.000001
farthest = []
p @points
@points.each do |point|
dist_squared = point.dist_squared(a_point)
diff = dist_squared - max_dist_squared
if diff.abs <= delta
max_dist_squared = dist_squared if diff > 0
farthest << point
elsif diff > delta
max_dist_squared = dist_squared
farthest = [ point ]
end
end
farthest
end
end

==== spec/point_spec.rb
require File.dirname(__FILE__) + '/../lib/point'

def reflect(point)
Point.new(-point.x, -point.y)
end

describe Point, "(4, 5)" do

before(:each) do
@point = Point.new(4, 5)
end

it "should have a dist_squared of 25.0 from point(1, 1)" do
@point.dist_squared(Point.new(1,1)).should == 25.0
end

it "should have a dist of 5 from point(1,1)" do
@point.dist(Point.new(1,1)).should be_close(5.0, 0.0000001)

end

it "should equal a new point with the same coordinates" do
@point.should == Point.new(4, 5)
end

it "should be its own center when paired with self" do
@point.center(@point).should == @point
end

it "should have a center of zero when paired with its reflection" do
@point.center(reflect(@point)).should == Point.new(0,0)
end
end

==== spec/point_collection_spec.rb =====
require File.dirname(__FILE__) + '/../lib/point'
require File.dirname(__FILE__) + '/../lib/point_collection'

describe PointCollection do
before(:each) do
@pc = PointCollection.new
end

it "should be empty initially" do
@pc.should be_empty
end

it "should should have a radius of zero" do
end

it "should not have a center" do
@pc.center.should == nil
end

describe PointCollection, "with one point" do
before(:each) do
@first_point = Point.new(1,1)
end

it "should not be empty" do
@pc.should_not be_empty
end

it "should have the first point as the center" do
@pc.center.should == @first_point
end
end

describe PointCollection, "with two points" do
before(:each) do
@first_point = Point.new(1,1)
@second_point = Point.new(5, 5)
end

it "should have the center of the two points as its center" do
@pc.center.should == @first_point.center(@second_point)
end

it "should have a radius half the distance between the two points" do
end

describe PointCollection, "adding a point inside" do

before(:each) do
end

it "should have the same radius as before" do
end

it "should have the same center as before" do
@pc.center.should == @old_center
end
end

describe PointCollection, "adding a point ouside" do
before(:each) do
@third_point = Point.new(6,6)
end

it "should calculate the radius correctly" do
be_close(@first_point.dist(@third_point)/2.0, 0.0001)
end
end
end
end
==============

This much was done about 5 days ago,  I've spent time sporadically
since then getting rmagick working with X11 on OS X Leopard so that I
could visually convince myself that this was working.

Here's the final piece, with the visualization code adapted from
someone elses submission (sorry but I can't seem to find it).

==== lib/main.rb =====
#! /usr/bin/env ruby

require 'rubygems'
require File.dirname(__FILE__) + '/point'
require File.dirname(__FILE__) + '/circle'
require File.dirname(__FILE__) + '/point_collection'

def generate_samples(n)
(1..n).map { Point.random }
end

def encircle(points)
point_collection = PointCollection.new
points.each do |point|
end
point_collection.circle
end

def scale(value)
\$size / 6 + value * \$size / 1.5
end

def draw_circle(circle, color=false)
center = circle.center
\$gc.stroke_color(color.to_s) if color
\$gc.circle(scale(center.x), scale(center.y), scale(center.x),
end

def draw_point(center, color=false)
\$gc.stroke_color(color.to_s) if color
\$gc.circle(scale(center.x), scale(center.y), scale(center.x),
scale(center.y)+2)
end

def draw_line(p0, p1, color=false)
\$gc.stroke_color(color.to_s) if color
\$gc.line(scale(p0.x), scale(p0.y), scale(p1.x), scale(p1.y))
end

require 'RMagick'
\$size = 600
\$gc = Magick::Draw.new
\$gc.fill_opacity(0)
\$gc.stroke_width(2)
\$gc.stroke_opacity(1)

samples = generate_samples(ARGV[0].to_i)
circle = encircle(samples)
puts circle

samples.each { |p| draw_point(p, :black) }
draw_circle(circle)
canvas = Magick::ImageList.new
canvas.new_image(\$size, \$size)
\$gc.draw(canvas)
canvas.display
=======

--
Rick DeNatale

My blog on Ruby