scrabbler 0.1.2

data/lib/data/scores.yml

@@ -0,0 +1,54 @@
+--- 
+:en: 
+  :l: 1
+  :a: 1
+  :x: 8
+  :v: 4
+  :g: 2
+  :n: 1
+  :y: 4
+  :h: 4
+  :u: 1
+  :i: 1
+  :t: 1
+  :w: 4
+  :p: 3
+  :b: 3
+  :c: 3
+  :s: 1
+  :e: 1
+  :k: 5
+  :f: 4
+  :j: 8
+  :m: 3
+  :d: 2
+  :q: 10
+  :r: 1
+  :o: 1
+:nl: 
+  :l: 3
+  :a: 1
+  :x: 8
+  :v: 4
+  :g: 3
+  :n: 1
+  :y: 8
+  :h: 4
+  :u: 4
+  :t: 2
+  :i: 1
+  :w: 5
+  :p: 3
+  :b: 3
+  :c: 5
+  :s: 2
+  :e: 1
+  :f: 4
+  :k: 3
+  :j: 4
+  :m: 3
+  :d: 2
+  :q: 10
+  :r: 1
+  :z: 4
+  :o: 1

data/lib/score.rb

@@ -0,0 +1,22 @@
+# Author::    Peter Maas (pfmmaas [at] gmail [dot] com)
+# Copyright:: Copyright (c) 2008
+# License::   Distributes under the same terms as Ruby
+#
+
+class Score
+   attr_accessor(:word, :score, :explanation)
+   
+   def initialize(word, score, explanation)
+     @word = word
+     @score = score
+     @explanation = explanation
+   end
+   
+   def inspect
+      "Scrabble score [word=#{@word}, score=#{@score}]"
+   end
+   
+   def <=> other
+     other.score <=> @score
+   end
+end

data/lib/scrabbler.rb

@@ -0,0 +1,113 @@
+# Author::    Peter Maas (pfmmaas [at] gmail [dot] com)
+# Copyright:: Copyright (c) 2008
+# License::   Distributes under the same terms as Ruby
+
+require 'rubygems'
+require 'ostruct'
+require 'yaml'
+
+require File.dirname(__FILE__) +'/array_extensions'
+require File.dirname(__FILE__) +'/score'
+require File.dirname(__FILE__) +'/vocabulary'
+
+
+# Class for solving scrabble puzzles
+class Scrabbler
+  MIN_WORD_SIZE = 3
+  
+  SCRABBLER_DICTIONARIES = {
+                            :nl => File.dirname(__FILE__) +"/data/nederlands.dict", 
+                            :en => File.dirname(__FILE__) +"/data/en-US.dict"
+                           }
+
+  SCORES = YAML::load(File.new(File.dirname(__FILE__) + "/data/scores.yml").read)
+  MAX_THREADS = 10;
+  
+  # TODO: rates in constant
+  
+  # initializes the Scrabbler with:
+  # - the array if the given object is of type array
+  # - the dictonary file specified by the given symbos (:nl, :en)
+  def initialize(_dictionary)
+    case _dictionary
+      when Symbol 
+        @dictionary = Vocabulary.new(File.read(SCRABBLER_DICTIONARIES[_dictionary]))
+        @dictionary.info = _dictionary
+      when Array
+        @dictionary = Vocabulary.new(_dictionary)
+        @dictionary.info = "based on supplied array"
+    end
+  end
+    
+  # find possible solutions of the given array of letters
+  def scrabble(letters, min_score = 10, rating = :nl, wildcard = '$')
+    raise "Wildcard can not be a word character" if wildcard =~ /[\w]/
+      
+    letters = letters.scan(/[a-z#{wildcard}]/)
+    num_wildcards = letters.select{|c| c == wildcard}.length # count the number of wildcards
+    
+    # create a subset based on the word letters
+    dictonary_subset = @dictionary.calculate_subset(letters, wildcard, MIN_WORD_SIZE)
+    
+    scores, threads = [], []
+    chunks = dictonary_subset.chunk(@dictionary.words.length / (MAX_THREADS - 1) + 1)
+  
+    chunks.each do |chunk|
+       threads << Thread.new(chunk) do |c|
+        chunk_scores = []
+        chunk.each do |word|
+          score = calculate_score(letters, word, num_wildcards, rating)
+          chunk_scores << score if score && score.score > min_score
+        end
+        chunk_scores
+      end    
+    end
+    
+    threads.each {|t| scores = scores + t.value} # gather values from all threads
+
+    scores.sort
+  end
+
+  # calculate the score of the test_word. Doesn't return anything
+  # if it is impossible to create the word from the given letters
+  def calculate_score(letters, test_word, num_wild = 0, rating = :nl)
+    return if letters.length < test_word.length
+    
+    letters = letters.dup # make a copy, we'll use the array desctructively
+    score_sum, score_explanation = 0, []
+    
+    test_word.scan(/[a-z]/).each do |c|
+      if letters.include? c
+        letters.remove_first{|v| v == c} # we've used this letter, remove it
+        curr_rate = SCORES[rating][c.to_sym];
+        score_sum = score_sum + curr_rate
+        score_explanation << "#{c} (#{curr_rate})"
+      elsif num_wild > 0 # see if we've got any wildcards left
+        num_wild = num_wild - 1
+        score_explanation << "#{c} (wildcard)"
+      else
+        return
+      end
+    end
+    
+    # return the result
+    Score.new(test_word, score_sum , score_explanation)
+  end
+    
+  def inspect
+    "scrabbler, dictionary: #{@dictionary.info}"
+  end
+  
+  def self.def_singletons(*args)
+    args.each do |arg|
+      module_eval <<-EOS
+        def self.get_#{arg}
+          @@instance_#{arg} ||= Scrabbler.new(:#{arg})
+        end
+      EOS
+    end
+  end
+  
+  def_singletons *SCRABBLER_DICTIONARIES.keys
+  
+end

data/lib/vocabulary.rb

@@ -0,0 +1,51 @@
+# Author::    Peter Maas (pfmmaas [at] gmail [dot] com)
+# Copyright:: Copyright (c) 2008
+# License::   Distributes under the same terms as Ruby
+
+# Vocabulary is a simple dictionary with options for creating subsets
+class Vocabulary
+  attr_accessor(:words, :info, :index)
+  
+  # removes non-word characters
+  SANITIZE_FILTER = proc{|v| v.chomp.downcase.gsub(/\W/,'')}
+  
+  def initialize(words)
+    @words = words.map(&SANITIZE_FILTER)
+    build_index
+  end
+  
+  def build_index
+    @index = Hash.new { |hash, key| hash[key] = [] }
+    @words.each do |w|
+      w.scan(/[a-z]/).uniq.each do |c|
+        @index[c.to_sym] << w
+      end
+    end
+  end
+  
+  def calculate_subset(letters, wildcard, min_word_size = 3)
+    # create a subset based on the word letters
+    lf = length_filter(min_word_size..letters.length)
+    
+    if letters.include? wildcard
+      subset = @words.select(&lf)
+    else
+      subset = []
+      letters.uniq.each do |c|
+        subset = subset + index[c.to_sym]
+      end
+      subset = subset.select(&lf)
+      subset = subset.uniq.grep(create_pattern(letters, min_word_size))
+    end
+    
+    subset
+  end
+  
+  def length_filter(range)
+    proc{|s| range.include? s.length}
+  end
+  
+  def create_pattern(letters, min_word_size = 3)
+    /^[#{letters.join}]{#{min_word_size},#{letters.length}}$/
+  end
+end

data/test/test_array_extensions.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestScrabbler < Test::Unit::TestCase
+
+  def test_remove_first
+    r = %w(the quick brown fox jumps over the lazy dog)
+    r.remove_first{|i| i == 'the'}
+    assert_equal(%w(quick brown fox jumps over the lazy dog), r)
+    
+    r.remove_first{|i| i == 'the'}
+    assert_equal(%w(quick brown fox jumps over lazy dog), r)    
+    
+    r.remove_first{|i| i == 'the'}
+    assert_equal(%w(quick brown fox jumps over lazy dog), r)
+  end
+  
+  def test_uses_input_block
+    assert_raise BlockCalled do
+      r = %w(the quick brown fox jumps over the lazy dog)
+      r.remove_first{|i| raise BlockCalled}      
+    end
+  end
+  
+  def test_chunk
+    r = %w(the quick brown fox jumps over the lazy dog)
+    assert_equal([%w(the quick brown),%w(fox jumps over),%w(the lazy dog)], r.chunk(3))
+    
+    r = %w(the quick brown fox jumps over the lazy dog but didn't jump over the fast bunny)
+    assert_equal([%w(the quick brown),%w(fox jumps over),%w(the lazy dog), %w(but didn't jump), %w(over the fast), %w(bunny)], r.chunk(3))
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/scrabbler.rb'
+
+# class to use in
+class BlockCalled < RuntimeError
+end

data/test/test_scrabbler.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestScrabbler < Test::Unit::TestCase
+
+  def setup
+    dictionary = %w(the quick brown fox jumps over the lazy dog but not over the quicker bunny)
+    @scrabbler = Scrabbler.new(dictionary)
+  end
+    
+  def test_run_scrabble
+    results = @scrabbler.scrabble("q,u,i,c,k", 19, :en)
+    assert_equal(1, results.length)
+    assert_equal(20, results[0].score)
+  end
+  
+  def test_illegal_wildcard
+    assert_raise RuntimeError do
+      results = @scrabbler.scrabble("q,u,i,c,k", 19, :en,'a') # wildcard can not be a word character
+    end
+  end
+  
+  def test_run_scrabble_with_one_wildcard
+    results = @scrabbler.scrabble("q,u,i,$,k", 15, :en)
+    assert_equal(1, results.length)
+    assert_equal(17, results[0].score) # score should be lower, wildcard has no score
+  end
+  
+  def test_run_scrabble_with_two_wildcards
+    results = @scrabbler.scrabble("q,u,i,c,k,$,$", 19, :en)
+    assert_equal(2, results.length)
+    assert_equal(results[0].score, results[1].score)
+  end
+  
+  def test_results_should_be_ordered_by_score
+    results = @scrabbler.scrabble("q,u,i,c,k,e,r", 19, :en)
+    assert_equal(2, results.length)
+    assert(results[0].score > results[1].score, "scores are not ordered correctly")
+  end
+  
+  #def test_singleton_methods
+  #  assert Scrabbler.get_nl.equal?(Scrabbler.get_nl)
+  #  assert Scrabbler.get_en.equal?(Scrabbler.get_en)
+  #end
+end

data/test/test_vocabulary.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestVocabulary < Test::Unit::TestCase
+
+  def setup
+    dictionary = %w(the quick brown fox jumps over the lazy dog but not over the quicker bunny)
+    @voc = Vocabulary.new(dictionary)
+  end
+    
+  def test_create_pattern
+    ta = ('a'..'j').to_a
+    assert_equal(/^[#{ta.join()}]{#{Scrabbler::MIN_WORD_SIZE},#{ta.length}}$/, @voc.create_pattern(ta))
+  end
+  
+  def test_calculate_subset
+    tl = %w(q u i c k)
+    assert_equal(['quick'], @voc.calculate_subset(tl, '$'))
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: scrabbler
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+date: 2008-01-30 00:00:00 +01:00
+summary: A bruteforce word finder for scrabble.
+require_paths: 
+- lib
+email: pfmmaas @nospam@ gmail -dot- com
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: scrabbler
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Peter Maas
+files: 
+- lib/array_extensions.rb
+- lib/score.rb
+- lib/scrabbler.rb
+- lib/vocabulary.rb
+- lib/data/en-US.dict
+- lib/data/nederlands.dict
+- lib/data/scores.yml
+- bin/scrabblit
+- README
+test_files: 
+- test/test_array_extensions.rb
+- test/test_helper.rb
+- test/test_scrabbler.rb
+- test/test_vocabulary.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: 
+- scrabblit
+extensions: []
+
+requirements: []
+
+dependencies: []
+