```Ruby Quiz wrote:
> This quiz is to make a Hangman guessing player in Ruby. Play should proceed as
> follows:

I focused on building a program that makes good guesses.

== Algorithm overview

The guesser reads a dictionary and then builds a database (which is
reused) with the following information about each word:
* size
* positions of each character
* number of occurrences of each character

The basic algorithm is as follows:
* Remove all words that do not have a matching length.
* While the game has not been solved:
** Pick the character included in the most words still remaining.
** If the character is not in the word: remove all words with the character.
** If the character is in the word: remove all words that do not contain
the character at exactly the revealed positions.

=== Weaknesses

The algorithm is not optimal. The character that's included in the most
words is not necessarily the character which will give the largest
reduction in number of potential words since position is not considered.
Consider a dictionary with the following:

bdc
ebc
fcb

b and c are tied for number of occurrences, but b would be the better
choice. If we pick b we will in all cases be left with one potential
word. If we pick c and the word is one of the first two we get two
potential words.

My guess is that it's a good enough heuristic in most cases though.

Also note that this program is built on the assumption that the word is
picked randomly from the dictionary. More refined solutions could weigh
in the relative frequency of different words in normal English text.

== Speed

It takes about 40 minutes to create the database for a dictionary with
4*10^5 words, but it only has to be created once.

Computing all guesses for a word (i.e. from being given the length to
having the correct word) takes about 30 to 40 seconds for a dictionary
with 4*10^5 words. That time includes about 10 seconds to reset the
database from previous uses, another 10 seconds for pruning based on
word length and the rest for the remaining search.

=== Possible improvements

Much of the initial sorting could be precomputed (e.g. split words into
different table based on length and then only work against the table
with the specified length) to cut down on the time needed reset and do
the initial pruning. The first (and possibly some additional steps)
could also be precomputed.

== Dependencies

Requires a mysql database and the mysql-gem. You need to enter your

== The code

#!/usr/bin/env ruby
# == Synopsis
#
# automated_hangman: plays a game of hangman with the word of your
# choice
#
# == Usage
#
# automated_hangman [OPTION] ... WORD
#
# -h, --help:
#    show help
#
# -d, --dictionary [dictionary location]:
#    sets up the database to use the specified dictionary (defaults to
#    /usr/share/dict/words), can take some time
#
# WORD: The word that the program should try to guess.

require 'getoptlong'
require 'rdoc/usage'
require 'mysql'

# Describes a game of hangman.
class Hangman
LIVES = 6

# Creates a new game of hangman where word is the target word.
def initialize(word)
@guesses = []
@word_characters = word.chomp.downcase.split(//)
end

# Returns an array containing the incorrect guessed characters.
def incorrect_guesses
@guesses - @word_characters
end

# Guesses a specified character. Returns an array of indices (possibly
# empty) where the character was found.
def guess(char_guess)
@guesses << char_guess
indices = []
@word_characters.each_with_index do |character, index|
indices << index if character == char_guess
end
return indices
end

# Returns a string representation of the current progress.
def to_s
hidden_characters = @word_characters - @guesses
return @word_characters.join(' ') if hidden_characters.empty?
@word_characters.join(' ').gsub(
/[#{hidden_characters.uniq.join}]/, '_')
end

# Checks whether the player has won.
def won?
(@word_characters - @guesses).empty?
end

# Checks whether the player has lost.
def lost?
incorrect_guesses.size > LIVES
end

# Gets the number of characters in the word.
def character_count
@word_characters.size
end
end

# The guessing machine which picks the guesses.
class HangmanGuesser
# The location of the default dictionary to use.
DICTIONARY_FILE = '/usr/share/dict/words'
# An array of the characters that should be considered.
CHARACTERS = ('a'..'z').to_a
# Set this to true to see how the search progresses.
VERBOSE = true
# The maximum word length accepted.
MAX_WORD_LENGTH = 50

# The dictionary given should be the location of a file containing one
# word per line. The characters should be an array of all characters
# that should be considered (i.e. no words with other characters are
# included).
def initialize(hangman_game, characters = CHARACTERS)
@con = self.class.db_connection
@characters = characters
@hangman_game = hangman_game

reset_tables
prune_by_word_length @hangman_game.character_count
end

# Returns the guesses that the guesser would make.
def guesses
@guesses = []
log{ "There are #{word_count} potential words left." }
while not @hangman_game.won?
guess = next_guess
raise 'The word is not in the dictionary.' if guess.nil?
@guesses << guess
log{ "Guessing #{guess}" }
log_state
log{ "\n" }
end
return @guesses
end

class << self
# Creates the database and populates it with the dictionary file
# located at the specified location. Only considers the specified
# characters (array).
def create_database(dictionary = DICTIONARY_FILE,
characters = CHARACTERS)
@con = db_connection
@characters = characters
@tables = ['words'] + @characters +
@characters.map{ |c| c + '_occurrences'}
create_tables
populate_tables File.open(dictionary)
end

# Connects to the database that should store the tables.
def db_connection
end

private

# Creates the tables used to store words.
def create_tables
# Drop old tables.
@tables.each do |table|
@con.query "DROP TABLE IF EXISTS `#{table}`"
end

# Words table.
@con.query <<-"end_sql"
CREATE TABLE `words` (
`word_id` mediumint(8) unsigned NOT NULL AUTO_INCREMENT,
`word` varchar(#{MAX_WORD_LENGTH}) NOT NULL,
`length` tinyint(3) unsigned NOT NULL,
`removed` tinyint(1) unsigned NOT NULL DEFAULT '0',
PRIMARY KEY (`word_id`),
INDEX (`removed`),
INDEX (`length`)
) ENGINE=MyISAM
end_sql

# Tables for the number of occurrences of each character.
character_occurrences_table_template =<<-'end_template'
CREATE TABLE `%s_occurrences` (
`word_id` mediumint(8) unsigned NOT NULL,
`occurrences` tinyint(3) unsigned NOT NULL,
PRIMARY KEY (`occurrences`, `word_id`),
INDEX (`word_id`)
) ENGINE=MyISAM
end_template

# Tables for the positions of each character.
character_table_template =<<-'end_template'
CREATE TABLE `%s` (
`word_id` mediumint(8) unsigned NOT NULL,
`position` tinyint(3) unsigned NOT NULL,
PRIMARY KEY (`position`, `word_id`),
INDEX (`word_id`)
) ENGINE=MyISAM
end_template

@characters.each do |character|
@con.query character_occurrences_table_template % character
@con.query character_table_template % character
end
end

# Loads a dictionary into the database.
def populate_tables(dictionary_file)
# Disable the keys so that we don't update the indices while
@tables.each do |table|
@con.query("ALTER TABLE #{table} DISABLE KEYS")
end

# Prepare statements.
"INSERT INTO words (word, length) VALUES (?, ?)")
@characters.each do |character|
"INSERT INTO #{character} (word_id, position) VALUES (?, ?)")
"INSERT INTO #{character}_occurrences " +
"(word_id, occurrences) VALUES (?, ?)")
end

# Populate the database.
previous_word = nil
dictionary_file.each_line do |line|
# Only consider words that only contain characters a-z. Make
# sure we don't get duplicates.
word = line.chomp.downcase
next if word == previous_word or word =~ /[^a-z]/ or
word.size > MAX_WORD_LENGTH

# Add the word, its character positions and number of
# occurrences.
word_id = @con.insert_id
characters = word.split(//)
characters.each_with_index do |character, position|
end
@characters.each do |character|
occurrences = characters.select{ |c| c == character }.size
word_id, occurrences)
end

previous_word = word
end

# Generate the indices.
@tables.each do |table|
@con.query("ALTER TABLE #{table} ENABLE KEYS")
end
end
end

private

# Logs the current state of the guessing process.
def log_state
log do
messages = []
messages << @hangman_game.to_s
count = word_count
messages << "There are #{count} potential words left."
if count <= 10
res = @con.query('SELECT word FROM words WHERE removed = 0')
res.each{ |row| messages << row[0] }
res.free
end
messages.join("\n")
end
end

# Logs the string produced by the block (may not be executed at all).
def log(&block)
puts yield() if VERBOSE
end

# Gets the number of potential words left.
def word_count
res = @con.query('SELECT COUNT(*) FROM words WHERE removed = 0')
count = res.fetch_row[0].to_i
res.free
return count
end

# Computes the next character that should be guessed. The next guess
# is the character (that has not yet been tried) that occurrs in the
# most words remaining.
def next_guess
next_character = nil
max_count = 0
(@characters - @guesses).each do |character|
res = @con.query(
"SELECT COUNT(DISTINCT word_id) FROM #{character} " +
"NATURAL JOIN words WHERE removed = 0")
count = res.fetch_row[0].to_i
res.free
if count > max_count
next_character = character
max_count = count
end
end
return next_character
end

# Adds the information about at what indices in the word the specified
# character can be found to the guesser.
if indices.empty?
# The character isn't in the word.
sql =<<-"end_sql"
UPDATE words SET removed = 1 WHERE removed = 0 AND word_id IN (
SELECT word_id FROM #{character}
)
end_sql
else
# Remove all words where the character isn't at the specified
# places.
sql =<<-"end_sql"
UPDATE words NATURAL JOIN #{character}_occurrences
SET removed = 1
WHERE removed = 0
AND (occurrences != #{indices.size}
OR word_id IN (
SELECT word_id FROM #{character}
WHERE position NOT IN (#{indices.join(', ')})
)
)
end_sql
end
@con.query(sql)
end

# Resets the table to start a new round of guesses.
def reset_tables
@con.query('UPDATE words SET removed = 0')
end

# Prunes all words that do not have the specified length.
def prune_by_word_length(expected_length)
@con.query(
"UPDATE words SET removed = 1 WHERE length != #{expected_length}")
end
end

opts = GetoptLong.new(
[ '--help', '-h', GetoptLong::NO_ARGUMENT],
['--dictionary', '-d', GetoptLong::OPTIONAL_ARGUMENT])
opts.each do |opt, arg|
case opt
when '--help'
RDoc::usage
when '--dictionary'
if arg != ''
HangmanGuesser.create_database(arg)
else
HangmanGuesser.create_database
end
end
end

if ARGV.size != 1
abort "Incorrect usage, see --help"
end

game = Hangman.new(ARGV[0])
guesses =  HangmanGuesser.new(game).guesses
if game.won?
puts 'Successfully guessed the word.'
else game.lost?
puts 'Failed guessing the word.'
end
puts "Made the following guesses: #{guesses.join(', ')}"
puts "Expended a total of #{game.incorrect_guesses.size} lives."

--
Andreas Launila

```