, "hangman")
> 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
> # adding.
> @tables.each do |table|
> @con.query("ALTER TABLE #{table} DISABLE KEYS")
> end
>
> # Prepare statements.
> add\_word = @con.prepare(
> "INSERT INTO words (word, length) VALUES (?, ?)")
> add\_character = {}
> add\_character\_occurrences = {}
> @characters.each do |character|
> add\_character[character] = @con.prepare(
> "INSERT INTO #{character} (word\_id, position) VALUES (?, ?)")
> add\_character\_occurrences[character] = @con.prepare(
> "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.
> add\_word.execute(word, word.size)
> word\_id = @con.insert\_id
> characters = word.split(//)
> characters.each\_with\_index do |character, position|
> add\_character[character].execute(word\_id, position)
> end
> @characters.each do |character|
> occurrences = characters.select{ |c| c == character }.size
> add\_character\_occurrences[character].execute(
> 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.
> def add\_information(character, indices)
> 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
---
### Author:  [@Yossef\_Mendelssohn](https://rubytalk.org/u/Yossef_Mendelssohn)
#### Post date: [11 July 2007 18:34 UTC](https://rubytalk.org/t/quiz-hangman-130/38893/4 "2007-07-11T18:34:58Z")
Maybe people aren't trying this quiz because they're busy. I hope
it's not because they find it uninteresting. I banged out something
fairly quickly during the weekend and was waiting to find some time to
clean it up. It seems I won't get that, so I'm going to post what I
have now.
It's a fairly simple algorithm that uses a combination of the
"established" frequency order of letters in the English language, as
seen on Linotype machines, and a dictionary (/usr/dict/share/words, of
course) to provide the next guess. What I find interesting about this
is how many common words it cannot get before exhausting its allotment
of wrong guesses. For instance, it won't get "book". Sometimes I'm
surprised with the guesses it gives. Maybe the dictionary I'm using
is \*too\* large.
> **ยทยทยท**
>
> -------------------------------------------------------------------------------
> #!/usr/bin/env ruby
>
> ALLOWED\_WRONG\_GUESSES = 6
>
> WORD\_LIST\_FILENAME = '/usr/share/dict/words'
>
> WORD\_LIST = {}
>
> File.open(WORD\_LIST\_FILENAME) do |f|
> f.each { |word| WORD\_LIST[word.strip.downcase] = true }
> end
>
> FREQUENCY\_ORDER = %w{etaoin shrdlu cmfwyp vbgkqj xz}.collect { |elem|
> elem.split('') }.flatten
>
> GUESSES\_MADE = {}
>
> puts 'Enter a word pattern'
> old\_pattern = pattern = gets.chomp
>
> loop do
> if pattern.match(/^[a-zA-Z\-]+$/)
> if pattern.match(/-/)
> if GUESSES\_MADE.values.select { |val| val == false }.length \>
> ALLOWED\_WRONG\_GUESSES
> puts 'crap I lost'
> exit
> end
>
> regex = Regexp.new("^#{pattern.downcase.gsub(/-/, '.')}$")
> possible\_words = WORD\_LIST.keys.select { |word|
> word.match(regex) }
> possible\_letters = possible\_words.collect { |word|
> word.split('') }.flatten.uniq
> guess = ((FREQUENCY\_ORDER - GUESSES\_MADE.keys) &
> possible\_letters).first
> puts guess.upcase
> pattern = gets.chomp
>
> GUESSES\_MADE[guess] = (pattern != old\_pattern)
> puts "wrong guesses made: #{GUESSES\_MADE.values.select { |val|
> val == false }.length}"
> old\_pattern = pattern
> else
> puts 'Yay I won'
> exit
> end
> else
> puts 'This pattern makes no sense.'
> exit
> end
> end
> -------------------------------------------------------------------------------
>
> -yossef
---
### Author:  [@James\_Koppel](https://rubytalk.org/u/James_Koppel)
#### Post date: [11 July 2007 21:41 UTC](https://rubytalk.org/t/quiz-hangman-130/38893/5 "2007-07-11T21:41:57Z")
Sorry it's a little late; I'm on vacation and have spent limited time on a computer with Ruby installed.
My solution reads a dictionary stored in "words.txt." It uses this to construct an array of arrays containing the possible words for each word in the pattern, which is constantly updated according to feedback.
I thought about making something based on making sure each word has a vowel and hardcoding in the general English language letter frequencies, but I realized that that would be compeltely unnecessary, as I could constantly calculate the true letter frequency for the possible letters. This is highly effective and surprisingly simple, although it could definitely benefit from some basic knowledge of English grammar and parts of speech.
Unfortunately, this program is definitely not unbeatqable. Likewise, with only 6 lives, probably none of the others are as well. As expected, when facing the word "cwm," the program guesses AEOIUY ["A" is more frequent than "E" for three-letter words, apparently], and loses before it has a chance to guess correctly.
$Words = (file=File.new("words.txt")).read.upcase.split(/\n/)
file.close
def hangman\_start
puts "Please enter word pattern."
word\_pattern = gets.chomp
possible\_words = []
word\_pattern.split.length.times do |t|
possible\_words \<\< $Words.select{ |word|
word\_pattern.split[t].length == word.length}
end
hangman\_round word\_pattern, possible\_words
end
$avail\_letters= ("A".."Z").to\_a
def hangman\_round(word\_pattern, possible\_words, lives=6)
guess(word\_pattern, possible\_words)
puts word\_pattern
puts "Are there any #{$guess}s?\t\tComputer lives=#{lives}"
if gets.chomp=="y"
puts "Please indicate all positions with a #{$guess}"
puts "(0-indexed, comma-delimited)"
gets.chomp.split(/,/).each{|pstr| word\_pattern[pstr.to\_i] = $guess}
possible\_words.each\_index do |i|
possible\_words[i] = possible\_words[i].select{|word|
word.gsub(/[^#{$guess}]/, '\_') ==
word\_pattern.split[i].gsub(/[^#{$guess}]/, '\_')}
end
else
lives -= 1
possible\_words.each {|words| words.reject! {|word| word.index $guess}}
end
if word\_pattern !~ /\_/
puts word\_pattern
puts "I win"
elsif lives \> 0
hangman\_round(word\_pattern, possible\_words, lives)
else
puts "You win"
end
end
#Guesses by frequency analysis. If a letter appears in a possible word, it's a vote for
#that letter. If a word is possible more than once, that's multiple votes, but not
#if the letter appears multiple times in a possible word (it's still one possibility)
#It then removes that letter from $avail\_letters and stores the guess into $guess
#for convenience
def guess(word\_pattern, possible\_words)
all\_words = possible\_words.flatten
guess = $avail\_letters.sort\_by {|c|
all\_words.select{|w|w.index c}.length}.last
$avail\_letters -= [guess]
$guess = guess
end
hangman\_start
> **ยทยทยท**
>
> ---------------------------------
> Boardwalk for $500? In 2007? Ha!
> Play Monopoly Here and Now (it's updated for today's economy) at Yahoo! Games.
---
### Author:  [@James\_Edward\_Gray\_II](https://rubytalk.org/u/James_Edward_Gray_II)
#### Post date: [11 July 2007 02:41 UTC](https://rubytalk.org/t/quiz-hangman-130/38893/6 "2007-07-11T02:41:23Z")
Not many people solved this one, so I wanted to see if it was too tough. Didn't seem so:
#!/usr/bin/env ruby -wKU
puts "One moment..."
puts
words = File.open(ARGV.shift || "/usr/share/dict/words") do |dict|
dict.inject(Hash.new) do |all, word|
all.update(word.delete("^A-Za-z").downcase =\> true)
end.keys
end
guesses = Array.new
loop do
puts guesses.empty? ?
"Please enter a word pattern (\_ \_ \_ \_ for example):" :
"Please update your pattern according to my guess (\_ i \_ \_ for example):"
pattern = $stdin.gets.to\_s.delete("^A-Za-z\_")
if pattern.include? "\_"
if (guesses - pattern.delete("\_").split("")).size \> 6
puts "I'm out of guesses. You win."
puts
exit
end
else
puts "I guessed your word. Pretty smart, huh?"
puts
exit
end
choices = words.grep(/\A#{[pattern.tr](http://pattern.tr)("\_", ".")}\Z/i)
odds = Hash.new(0)
choices.each do |word|
word.split("").each do |l|
next if guesses.include? l
odds[l] += word.count(l)
end
end
guess = odds.max { |(\_, c1), (\_, c2)| c1 \<=\> c2 }.first rescue nil
guesses \<\< guess
puts "I guess the letter '#{guess}'."
puts
end
\_\_END\_\_
James Edward Gray II
---
### Author:  [@James\_Edward\_Gray\_II](https://rubytalk.org/u/James_Edward_Gray_II)
#### Post date: [11 July 2007 18:47 UTC](https://rubytalk.org/t/quiz-hangman-130/38893/7 "2007-07-11T18:47:03Z")
A second version of my code. Minor changes mainly to support me testing it. I tried different guessing algorithms, but nothing beat the original strategy with my dictionary.
First, this is a tiny words.rb lib used by both the guesser and test scripts:
#!/usr/bin/env ruby -wKU
WORDS\_CASH\_FILE = "words.cache"
if File.exist? WORDS\_CASH\_FILE
WORDS = File.open(WORDS\_CASH\_FILE) { |file| Marshal.load(file) }
else
WORDS = File.open( ARGV.find { |arg| arg =~ /\A[^-]/ } ||
"/usr/share/dict/words" ) do |dict|
dict.inject(Hash.new) do |all, word|
all.update(word.delete("^A-Za-z").downcase =\> true)
end.keys
end
File.open(WORDS\_CASH\_FILE, "w") { |file| Marshal.dump(WORDS, file) }
end
\_\_END\_\_
Next, my guesser script which works the same as yesterday's version but is optimized here and there for testing:
#!/usr/bin/env ruby -wKU
puts "One moment..."
puts
require "words"
choices = WORDS
guesses = Array.new
loop do
puts guesses.empty? ?
"Please enter a word pattern (\_ \_ \_ \_ for example):" :
"Please update your pattern according to my guess (\_ i \_ \_ for example):"
$stdout.flush
pattern = $stdin.gets.to\_s.delete("^A-Za-z\_")
if (guesses - pattern.delete("\_").split("")).size \> 5 and pattern.include? "\_"
puts "I'm out of guesses. You win."
elsif not pattern.include? "\_"
puts "I guessed your word. Pretty smart, huh?"
else
choices = choices.grep(/\A#{[pattern.tr](http://pattern.tr)("\_", ".")}\Z/i)
odds = Hash.new(0)
choices.each do |word|
word.split("").each do |l|
next if guesses.include? l
odds[l] += word.count(l)
end
end
guess = odds.max { |(\_, c1), (\_, c2)| c1 \<=\> c2 }.first rescue nil
guesses \<\< guess
puts "I guess the letter '#{guess}'."
puts
next
end
puts
if ARGV.include? "--loop"
choices = WORDS
guesses = Array.new
else
break
end
end
\_\_END\_\_
Finally, this is my test script:
#!/usr/bin/env ruby -wKU
require "words"
results = Hash.new(0)
at\_exit do
results[:total] = results[:right] + results[:wrong]
puts
puts "Words: #{results[:total]}"
puts "Guessed: #{results[:right]}"
puts "Missed: #{results[:wrong]}"
printf "Accuracy: %.2f%%\n", results[:right] / results[:total].to\_f \* 100
puts
end
trap("INT") { exit }
IO.popen( File.join(File.dirname(\_\_FILE\_\_), "hangman.rb --loop"),
"r+" ) do |hangman|
WORDS.each do |word|
pattern = [word.tr](http://word.tr)("a-z", "\_")
loop do
input = String.new
hangman.each do |line|
input \<\< line
break if input =~ /^(?:I'm out|I guessed)|:\Z/
end
if input =~ /^I'm out/
puts "It missed '#{word}'."
results[:wrong] += 1
break
elsif input =~ /^I guessed/
puts "It guessed '#{word}'."
results[:right] += 1
break
elsif input =~ /^I guess the letter '(.)'/
guess = $1
word.split("").each\_with\_index do |letter, i|
pattern[i, 1] = letter if letter == guess
end
end
hangman.puts pattern
end
end
end
\_\_END\_\_
James Edward Gray II
---
### Author:  [@Thomas\_Wieczorek](https://rubytalk.org/u/Thomas_Wieczorek)
#### Post date: [11 July 2007 19:10 UTC](https://rubytalk.org/t/quiz-hangman-130/38893/8 "2007-07-11T19:10:18Z")
> Not many people solved this one, so I wanted to see if it was too
> tough. Didn't seem so:
I was busy until today.
Here's my solution and my first quiz solution since I learn Ruby. It
wasn't that hard. I learned a lot about Ruby with it.
> ruby hangman.rb [-w=word] [-l=lifes]
If you don't pass a word it will choose a random word from the
dictionary. Lifes is set to 6 if you don't provide it.
\
#Ruby Quiz 130
#solution by Thomas Wieczorek \
#11.07.2007
require 'yaml'
$debug = true
class Player
public
def initialize(word)
@word = word
@dictionary = YAML.load\_file(DICTIONARYFILE)
@letters = ('a'..'z').to\_a
@guessed =
scan\_dictionary(word)
end
def guess()
return @dictionary[0] if @dictionary.length == 1
while (true)
letter = @probabilities.pop
next if @guessed.include?(letter[0])
@guessed \<\< letter[0]
break
end
return letter[0]
end
def word=(value)
if not value.include?(".") then
#lost
#unknown word
if not @dictionary.include?(value) then
@dictionary = load\_dictionary()
@dictionary \<\< value
File.open("dictionary.yaml", "w") { |f| YAML.dump(@dictionary, f) }
end
else
if @word.eql?(value) then
@word = value
scan\_dictionary(value)
end
end
end
private
DICTIONARYFILE = "dictionary.yaml"
def scan\_dictionary(masked)
@dictionary = @dictionary or load\_dictionary()
@dictionary = @dictionary.grep(Regexp.new("^#{@word}$"))
set\_probability()
end
def set\_probability
alphabet = ('a'..'z').to\_a
@probabilities = {}
alphabet.each { |l| @probabilities[l] = 0 }
@dictionary.each do |word|
word.each\_byte do |letter|
#p letter
l = letter.chr
@probabilities[l] += 1 if alphabet.include?(l)
end
end
@probabilities = @probabilities.sort {|a,b| a[1]\<=\>b[1]}
end
def load\_dictionary()
return YAML.load\_file(DICTIONARYFILE)
end
end #of Player
def random\_word
words = YAML.load\_file("dictionary.yaml")
return words[rand(words.length)]
end
def check\_for\_letters(word, guess, masked\_word)
if word.include?(guess) then
#puts "#{guess} is in #{word}"
word.length.times do |i|
if word[i].chr == guess then
masked\_word[i] = guess
end
end
end
return masked\_word
end
def play\_game(word = "", lifes = 6, give\_output = false)
#user given word
word = random\_word if word == ""
masked\_word = word.gsub(/\w/, ".")
guess = ""
player = Player.new(masked\_word)
while(lifes \> 0)
#AI guesses a letter or word
puts "AI is looking for \>#{masked\_word}\<" if give\_output
guess = player.guess()
new\_word = ""
won = false
puts "AI guessed '#{guess}'" if give\_output
if guess.length == 1 then
masked\_word = check\_for\_letters(word, guess, masked\_word)
else
if guess.length \> 1 then
break if guess == word
lifes -= 1
next
else
#nil
end
end
#wrong guess
if not masked\_word.include?(guess) then
lifes -= 1
puts "AI lost a life. #{lifes} lifes left."
else
#found word
if masked\_word == word then
break
else
#found a letter
player.word = masked\_word
next
end
end
end
if lifes \> 0 then
won = true
else
#give word to player to extend dictionary
player.word = word
won = false
end
return won, word, lifes
end #of play\_game
won = false
word = ""
lifes = 6
if ARGV.length \> 0
ARGV.each do |arg|
option = arg.split("=")
case option[0]
when "-w"
word = option[1]
when "-l"
lifes = option[1].to\_i
end
end
end
won, word, lifes = play\_game(word, lifes, true)
if won then
puts "AI won! It guessed \"#{word}\" with #{lifes} lifes left."
else
puts "Awww! Lost! AI couldn't guess \"#{word}\"."
end
\
[hangman.rb](https://rubytalk.org/uploads/short-url/h9b7XEtz53GYtmkmWWrJ84Ya4qD.rb) (3.79 KB)
> **ยทยทยท**
>
> 2007/7/11, James Edward Gray II \:
---
### Author:  [@Thomas\_Wieczorek](https://rubytalk.org/u/Thomas_Wieczorek)
#### Post date: [11 July 2007 19:12 UTC](https://rubytalk.org/t/quiz-hangman-130/38893/9 "2007-07-11T19:12:53Z")
A few words to my solution:
- It saves the dictionary in a yaml file. If the AI doesn't know a
word, it will add it to the dictionary
- it guesses letters which have the highest possibility
It is a bit rough. I am happy about every suggestion to improve it.
> **ยทยทยท**
>
> 2007/7/11, Thomas Wieczorek \:
>
> > I was busy until today.
> >
> > Here's my solution and my first quiz solution since I learn Ruby. It
> > wasn't that hard. I learned a lot about Ruby with it.
> >
> > \>ruby hangman.rb [-w=word] [-l=lifes]
> > If you don't pass a word it will choose a random word from the
> > dictionary. Lifes is set to 6 if you don't provide it.
---
### Author:  [@James\_Edward\_Gray\_II](https://rubytalk.org/u/James_Edward_Gray_II)
#### Post date: [11 July 2007 19:27 UTC](https://rubytalk.org/t/quiz-hangman-130/38893/10 "2007-07-11T19:27:59Z")
> A second version of my code.
One last tiny tweak.
> First, this is a tiny words.rb lib used by both the guesser and test scripts:
>
> #!/usr/bin/env ruby -wKU
>
> WORDS\_CASH\_FILE = "words.cache"
>
> if File.exist? WORDS\_CASH\_FILE
> WORDS = File.open(WORDS\_CASH\_FILE) { |file| Marshal.load(file) }
> else
> WORDS = File.open( ARGV.find { |arg| arg =~ /\A[^-]/ } ||
> "/usr/share/dict/words" ) do |dict|
> dict.inject(Hash.new) do |all, word|
> all.update(word.delete("^A-Za-z").downcase =\> true)
> end.keys
Changing that line to:
end.keys.sort\_by { |w| [w.length, w] }
helps me see where I'm at in the tests.
> end
> File.open(WORDS\_CASH\_FILE, "w") { |file| Marshal.dump(WORDS, file) }
> end
>
> \_\_END\_\_
James Edward Gray II
> **ยทยทยท**
>
> On Jul 11, 2007, at 1:47 PM, James Edward Gray II wrote:
---
### Author:  [@James\_Edward\_Gray\_II](https://rubytalk.org/u/James_Edward_Gray_II)
#### Post date: [11 July 2007 20:42 UTC](https://rubytalk.org/t/quiz-hangman-130/38893/11 "2007-07-11T20:42:19Z")
Last tweak, I promise!
Here's a new version of the guesser script that fairs a bit better. I found the improvement by trying some changes and running my testing script:
#!/usr/bin/env ruby -wKU
puts "One moment..."
puts
require "words"
def frequency(words)
freq = Hash.new(0)
words.each do |word|
word.split("").each { |letter| freq[letter] += word.count(letter) }
end
freq
end
FREQ = frequency(WORDS).sort\_by { |\_, count| -count }.map { |letter, \_| letter }
choices = WORDS
guesses = Array.new
loop do
puts guesses.empty? ?
"Please enter a word pattern (\_ \_ \_ \_ for example):" :
"Please update your pattern according to my guess (\_ i \_ \_ for example):"
$stdout.flush
pattern = $stdin.gets.to\_s.delete("^A-Za-z\_")
if (guesses - pattern.delete("\_").split("")).size \> 5 and pattern.include? "\_"
puts "I'm out of guesses. You win."
elsif not pattern.include? "\_"
puts "I guessed your word. Pretty smart, huh?"
else
choices = choices.grep(/\A#{[pattern.tr](http://pattern.tr)("\_", ".")}\Z/i)
guess = frequency(choices).
reject { |letter, \_| guesses.include? letter }.
sort\_by { |letter, count| [-count, FREQ.index(letter)] }.
first.first rescue nil
guesses \<\< guess
puts "I guess the letter '#{guess}'."
puts
next
end
puts
if ARGV.include? "--loop"
choices = WORDS
guesses = Array.new
else
break
end
end
\_\_END\_\_
James Edward Gray II
---
### Author:  [@James\_Edward\_Gray\_II](https://rubytalk.org/u/James_Edward_Gray_II)
#### Post date: [11 July 2007 21:01 UTC](https://rubytalk.org/t/quiz-hangman-130/38893/12 "2007-07-11T21:01:41Z")
This time I really mean last. ๐
I found another change that improves the algorithm:
#!/usr/bin/env ruby -wKU
puts "One moment..."
puts
require "words"
def frequency(words)
freq = Hash.new(0)
words.each do |word|
word.split("").each { |letter| freq[letter] += word.count(letter) }
end
freq
end
FREQ = frequency(WORDS).sort\_by { |\_, count| -count }.map { |letter, \_| letter }
choices = WORDS
guesses = Array.new
loop do
puts guesses.empty? ?
"Please enter a word pattern (\_ \_ \_ \_ for example):" :
"Please update your pattern according to my guess (\_ i \_ \_ for example):"
$stdout.flush
pattern = $stdin.gets.to\_s.delete("^A-Za-z\_")
bad\_guesses = guesses - pattern.delete("\_").split("")
if bad\_guesses.size \> 5 and pattern.include? "\_"
puts "I'm out of guesses. You win."
elsif not pattern.include? "\_"
puts "I guessed your word. Pretty smart, huh?"
else
choices = choices.grep(
bad\_guesses.empty? ?
/\A#{pattern.tr("\_", ".")}\Z/i :
/\A(?!.\*[#{bad\_guesses.join}])#{pattern.tr("\_", ".")}\Z/i
)
guess = frequency(choices).
reject { |letter, \_| guesses.include? letter }.
sort\_by { |letter, count| [-count, FREQ.index(letter)] }.
first.first rescue nil
guesses \<\< guess
puts "I guess the letter '#{guess}'."
puts
next
end
puts
if ARGV.include? "--loop"
choices = WORDS
guesses = Array.new
else
break
end
end
\_\_END\_\_
James Edward Gray II
> **ยทยทยท**
>
> On Jul 11, 2007, at 3:42 PM, James Edward Gray II wrote:
>
> > Last tweak, I promise!
---
### Author:  [@Thomas\_Wieczorek](https://rubytalk.org/u/Thomas_Wieczorek)
#### Post date: [11 July 2007 21:24 UTC](https://rubytalk.org/t/quiz-hangman-130/38893/13 "2007-07-11T21:24:47Z")
Sorry, it is late
Please replace
> word = "Salawzander"
with
word = ""
[hangman.rb](https://rubytalk.org/uploads/short-url/6zBggE1RlgeRTqB3vRaHXaQIh3M.rb) (4.45 KB)