Ruby - 如何提高阵列扫描的性能？

Question

Partly based on ruby - how to generate the possible sequential combination of letters from an array of strings? I now have a program to match words, using:

class Dictionary
  attr :words

  def words
    @words.map(&:upcase).uniq
  end 

  @@MAPPINGS= {A: 2, B: 2, C: 2, D: 3, E: 3, F: 3, G: 4, H: 4, I: 4, J: 5, K: 5, L: 5,
  M: 6, N: 6, O: 6, P: 7, Q: 7, R: 7, S: 7, T: 8, U: 8, V: 8, W: 9, X: 9, Y: 9, Z: 9}
  @@PHONE_NUMBER_LENGTH=10

  def initialize
    @words=[]
  end 

  def add_word(word)
    word.length < @@PHONE_NUMBER_LENGTH ? (@words << word) : nil 
  end 

  def load_system_dictionary(words_file='/usr/share/dict/american-english')
    File.open(words_file).each {|word| add_word(word)}
    true
  rescue Errno::ENOENT
    false
  end 

  def word_combinations(letters)
    possibles=[]
    letters.each_char do |one_letter|
      possibles << letter_mappings(one_letter)
    end 
    possibles.map(&:chars).map(&:to_a).reduce(&:product).map(&:join)
  end 

  def contains_word(word)
    @words.join.include?(word.upcase)
  end 

  def word_from_word_combinations(number_string)
    returns=[]
    word_combinations(number_string).each do |word|
      returns << word if @words.include?(word)
    end 
    returns
  end 

  private

  def letter_mappings(letter)
    @@MAPPINGS.select{ |key,val| val==letter.to_i }.keys.join
  end 

end

work fine for short and medium length words in less than a tenth of s second, eg for ANIMALS. However for longer words such as MUMMIFICATION, ie

it "should see that the valid words for 6866434228466 is 'MUMMIFICATION'" do
  expect(dictionary.word_from_word_combinations('6866434228466')).to match_array(['MUMMIFICATION'])
end

the test takes 30 seconds.

I've tried adding .uniq at each stage of

possibles.map(&:chars).map(&:to_a).reduce(&:product).map(&:join)

and I've also switched to making ruby 2.0 my default but that's just added 6 more seconds to the run time :(

I've since switched to sawa's approach now of:

first, *rest = possibles.map{|s| s.each_char.to_a}
first.product(*rest).map(&:join)

ie

def word_combinations(letters)
  possibles=[]
  letters.each_char do |one_letter|
    possibles << letter_mappings(one_letter)
  end 
  first, *rest = possibles.map{|s| s.each_char.to_a}
  first.product(*rest).map(&:join) 
end

and that has helped, has reduced it down to 15 seconds,

The .map(&:chars) from Marshal, ie

def word_combinations(letters)
  possibles=[]
  letters.each_char do |one_letter|
    possibles << letter_mappings(one_letter)
  end 
  first, *rest = possibles.map(&:chars)
  first.product(*rest).map(&:join) 
end

was interesting but not improving the performance.

Is there anything else I might do?

Answer 1

words = File.read("/usr/share/dict/american-english")
  .split.map{|w| w.chomp.upcase}
mapping = {A: 2, B: 2, C: 2, D: 3, E: 3, F: 3, G: 4, H: 4, I: 4, J: 5, K: 5,
  L: 5, M: 6, N: 6, O: 6, P: 7, Q: 7, R: 7, S: 7, T: 8, U: 8, V: 8, W: 9, X: 9,
  Y: 9, Z: 9}
better_mapping = mapping.map{|k, v| [k.to_s, v]}.to_h

t = Time.now
p words.select{|w| w.chars.map{|c| better_mapping[c]}.join == "6866434228466"}
puts Time.now - t

Result:

["MUMMIFICATION"]
0.847988125

---

mapping = {A: 2, B: 2, C: 2, D: 3, E: 3, F: 3, G: 4, H: 4, I: 4, J: 5, K: 5,
  L: 5, M: 6, N: 6, O: 6, P: 7, Q: 7, R: 7, S: 7, T: 8, U: 8, V: 8, W: 9, X: 9,
  Y: 9, Z: 9}
better_mapping = mapping.map{|k, v| [k.to_s, v]}.to_h
words = File.read("/usr/share/dict/american-english")
  .split.map{|w|
    w = w.chomp.upcase
    [w, w.chars.map{|c| better_mapping[c]}.join]
  }.group_by(&:last)
.map{|k, a| [k, a.map(&:first)]}.to_h

t = Time.now
p words["6866434228466"]
puts Time.now - t

Result:

["MUMMIFICATION"]
8.5981e-05

Answer 2

In the test, the rehearsal is to basically allocate the memory so we can test the actual implementation.

As you can see it's running at ~10 seconds, 15 if you run it just once.

require 'spec_helper'
require 'benchmark'


module SystemLoader
  def load_words(words_file)
    p words_file
    File.open(words_file).to_enum
  rescue Errno::ENOENT
    p "System loading failure"
  end
end

class Dictionary
  include SystemLoader

  attr_reader :words

  def initialize(source)
    @words = load_words(source).each_with_object({}) do |word, hash|
      hash[word.chomp.to_sym] = word.chomp
    end
  end

  def [] word
    words[word]
  end

end


class PhoneNumberWordMapper
  MAPPING = {:"0" => [""],
              :"1" => [""],
              :"2" => ["A", "B", "C"],
              :"3" => ["D", "E", "F"],
              :"4" => ["G", "H", "I"],
              :"5" => ["J", "K", "L"],
              :"6" => ["M", "N", "O"],
              :"7" => ["P", "Q", "R","S"],
              :"8" => ["T", "U", "V"],
              :"9" => ["W", "X", "Y","Z"]}

  DEFAULT_OPTIONS = {
    phone_number_length: 10,
    source: "words.txt",
    mapping: MAPPING
  }

  attr_reader :dictionary, :mapping, :max_number_length

  def initialize(options = {})
    options    = DEFAULT_OPTIONS.merge(options)
    @dictionary = Dictionary.new(options[:source])
    @max_number_length = options[:phone_number_length]
    @mapping    = options[:mapping]
  end

  def word_from_word_combinations(number)
    matches = []
    word_combinations(number).select do |word|
      word = word.join
      matches << word.upcase if @dictionary[word.to_sym]
    end
    matches
  end

  def word_combinations(number, combinations = [])

    first, *rest = get_possible_letters(number)
    number = number[(1 -number.length)..-1]

    combinations = first.map{|letter| [letter] } if combinations.empty?
    combinations = combinations.product(rest[0]).map(&:flatten)

    return combinations if number.length <= 1
    word_combinations(number, combinations)

  end

  def get_possible_letters(number)
    max_number_length ||= 124
    return [] if number.length > max_number_length
    number.split('').map{|num| MAPPING[num.to_sym]}
  end


  def possibles(number)
    get_letters(number)
  end
end



Benchmark.bmbm(7) do |bm|
  bm.report('testing word_from_word ') do
    mapper = PhoneNumberWordMapper.new
    mapper.word_from_word_combinations('6866434228466')
  end
end


describe PhoneNumberWordMapper do
  it "should see that the valid words for 6866434228466 is 'MUMMIFICATION'" do
    dictionary = PhoneNumberWordMapper.new
    expect(dictionary.word_from_word_combinations('6866434228466')).to match_array(['MUMMIFICATION'    ])
  end
end


# Rehearsal -----------------------------------------------------------
# testing word_from_word  "source: words.txt"
# "words.txt"
#  15.830000   0.450000  16.280000 ( 16.340899)
# ------------------------------------------------- total: 16.280000sec
# 
#                               user     system      total        real
# testing word_from_word  "source: words.txt"
# "words.txt"
#  10.210000   0.150000  10.360000 ( 10.393033)
# "source: words.txt"
# "words.txt"
# .
# 
# Finished in 10.06 seconds
# 1 example, 0 failures#     

Answer 3

If you map the dictionary like below, on my pc i have a result in 2.8 seconds. I used http://www.math.sjsu.edu/~foster/dictionary.txt as dictionary and added the word mummification at the end (±350000 words/lines). The words are all lowercase and one per line. This is the whole working script. The rewind is necessary if you do a second lookup to reposition the file pointer.

@mapping = {a: 2, b: 2, c: 2, d: 3, e: 3, f: 3, g: 4, h: 4, i: 4, j: 5, k: 5,
  l: 5, m: 6, n: 6, o: 6, p: 7, q: 7, r: 7, s: 7, t: 8, u: 8, v: 8, w: 9, x: 9,
  y: 9, z: 9}

@words = File.open('dictionary.txt').map

def get_word number
  @words.rewind.select{|word|word.chomp.chars.map{|char| @mapping[char.to_sym].to_s}.join.to_i == number.to_i}
end

get_word '6866434228466' => mummification