ruby-anagrams 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b4354f4fdcda04c67e8f3b2e11afbe9b6999fc22
-  data.tar.gz: 7cf6680ff7f4de0aa5aff21768852fab28e51d7a
+  metadata.gz: ec31af73831e6d121c7a68d31d6f034d2ce8a056
+  data.tar.gz: 8199632ddb78960c4df770470f8228837967d305
 SHA512:
-  metadata.gz: 28216d0fefce0b01b630e56e7eec4d9cf330183c7e76666cd94db7bd17fd8bd8dc5b7a14d7c6121069ec35a70bfce2952ca5aac6780f20b27582e192339b3ada
-  data.tar.gz: dceb898b96b5f0b67cdbd014fb1d8bde14586725ed18c35f4f5d6128037c725cf3c3f027067def25a37502b4e26f5be3c131cdbf588c62cf110c0ccb549b01b9
+  metadata.gz: 71362f70f599bd5ed3ee10342614825ae306b0fea0f304952776c60d9787e2ebc890eb4642a25c3e92a1db8f94e17b418c195595b6c280a979f29118fbc114e2
+  data.tar.gz: 2f02a8847de091de0886aa97921742e83888476adefd1258788c633e5b3e0f6d82a9f22c7d8112ccdcfab5d25a1838a995918ac5794387192c78dc9d260d7cdf

data/lib/anagrams/anagrams.rb

@@ -7,85 +7,64 @@ module RubyAnagrams
     # A Hash associating symbols with unique prime numbers.
     SYM_PRIMES = (:a..:z).to_a.zip(Prime.first(26)).to_h
 
-    # Returns all words in the trie data structure that are anagrams
-    # of the string provided. "*" indicates a wildcard.
-    # @note Default behavior finds complete anagrams that use every character
-    #   in the string. Partial anagrams can be included by setting include_partial
-    #   to true.
-    # @example without partial anagrams
-    #   root << "rise"
-    #   root << "sire"
-    #   root << "rie"
-    #   #anagrams "rise" #=> ['rise', 'sire']
-    # @example with partial anagrams
-    #   root << "rise"
-    #   root << "sire"
-    #   root << "rie"
-    #   #anagrams "rise", include_partial: true #=> ['rie', 'rise', 'sire']
-    # @example with wildcards
-    #   root << "bin"
-    #   root << "ban"
-    #   root << "bun"
-    #   #anagrams "b*n" #=> ['ban', 'bin', 'bun']
-    # @param string [String] the string to find anagrams of.
-    # @param include_partial [Boolean] include partial anagrams?
-    # @return [Array<String>] all anagrams of the given string.
-    def anagrams string, include_partial: false
-      symbols = str_to_sym_a string
-      anagrams = []
-      find_symbol_permutations(symbols).each do |permutation|
-        anagrams.concat find_anagrams(as_product(permutation), include_partial: include_partial)
+    class << self
+      # Returns the product of each symbol's associated prime number.
+      # @param symbols [Array<Symbol>] the symbols to multiply.
+      # @return [Integer] the product of each symbol's associated prime number.
+      def sym_a_to_product symbols
+        symbols.inject(1) { |acc,sym| acc * SYM_PRIMES[sym] }
       end
-      anagrams.uniq.sort
-    end
 
-    protected
-      # Returns anagrams in the trie data structure by performing depth-first search,
-      # following subtrees whose symbol's associated prime number is a prime factor
-      # of the product representing a string. The words of visited terminal nodes
-      # are returned as an array.
-      # @note Default behavior finds words that consume all prime factors
-      #   of the given product. Words that do not consume all prime factors can
-      #   be included by setting include_partial to true.
-      # @param product [Integer] the product representing the string to find
-      #   anagrams of.
-      # @param include_partial [Boolean] include partial anagrams?
-      # @return [Array<String>] all anagrams whose product divides into the given
-      #   product.
-      def find_anagrams product, include_partial: false
-        anagrams = []
-        anagrams << word if terminal? && (include_partial ? true : product == 1)
-        @children.each do |symbol,child|
-          if product % SYM_PRIMES[symbol] == 0
-            anagrams += child.find_anagrams(product / SYM_PRIMES[symbol], include_partial: include_partial)
-          end
+      # Returns all permutations of a symbol array, where "*" wildcards
+      # are replaced with symbols in the trie's alphabet.
+      # @param symbols [Array<Symbol>] the symbols to permute.
+      # @return [Array<Array<Symbol>>] the permutations.
+      def sym_a_permutations symbols
+        permutations = []
+        base_symbols = symbols.reject { |s| s == :* }
+        wildcard_permutations = (:a..:z).to_a.repeated_permutation(symbols.count :*)
+        wildcard_permutations.each do |permutation|
+          permutations << permutation.concat(base_symbols)
         end
-        anagrams
+        permutations.empty? ? [symbols] : permutations
       end
+    end
 
-      # Returns all permutations of the given set of symbols, where "*" wildcards
-      # are replaced with all possible permutations of symbols in the trie's
-      # alphabet.
-      # @example with 1 wildcard
-      #   alphabet = [:a, :b, :c]
-      #   #find_symbol_permutations [:a, :*, :c] #=> [[:a, :a, :c], [:a, :b, :c], [:a, :c, :c]]
-      # @param symbols [Array<Symbol>] the symbols to permute.
-      # @return [Array<Array<Symbol>>] all permutations of the symbols.
-      def find_symbol_permutations symbols
-        symbol_permutations = []
-        non_wild_symbols = symbols.reject{|s| s == :*}
-        (:a..:z).to_a.repeated_permutation(symbols.count :*).each do |permutation|
-          symbol_permutations << non_wild_symbols + permutation
-        end
-        symbol_permutations.empty? ? [symbols] : symbol_permutations
+    # Returns all string anagrams of the given symbol array by calling
+    # #anagrams_by_product on all permutations of the symbol array.
+    # @note Default behavior only includes complete anagrams. Partial anagrams
+    #   can be included by setting partial to true.
+    # @param symbols [Array<Symbol>] the symbols to find anagrams for.
+    # @param partial [Boolean] include partial anagrams?
+    # @return [Array<Array<String>>] all anagrams of the symbols.
+    def search_for_anagrams symbols, partial: partial
+      anagrams = []
+      Anagrams.sym_a_permutations(symbols).each do |permutation|
+        product = Anagrams.sym_a_to_product permutation
+        anagrams.concat anagrams_by_product(product, partial: partial)
       end
+      anagrams.uniq.sort
+    end
 
-      # Returns the product of each symbol's associated prime number.
-      # @param symbols [Array<Symbol>] the symbols to multiply.
-      # @return [Integer] the product of each symbol's associated prime number.
-      def as_product symbols
-        symbols.inject(1) { |acc,sym| acc * SYM_PRIMES[sym] }
+    # Depth-first searches the trie data structure for anagrams based on their
+    # node's associated prime number. Returns an array of anagrams whose product
+    # divides into the given product.
+    # @note Default behavior only includes words with a product equal to the
+    #   given product. Words that are divisors of the given product can be
+    #   included by setting partial to true.
+    # @param product [Integer] a product of a symbol array.
+    # @param partial [Boolean] include partial anagrams?
+    # @return [Array<String>] all anagrams of the given product.
+    def anagrams_by_product product, partial: partial
+      anagrams = []
+      anagrams << word if terminal? && (partial ? true : product == 1)
+      @children.each do |symbol,child|
+        if product % SYM_PRIMES[symbol] == 0
+          anagrams += child.anagrams_by_product(product / SYM_PRIMES[symbol], partial: partial)
+        end
       end
+      anagrams
+    end
 
   end
 end

data/lib/anagrams/enumerable.rb

@@ -9,11 +9,9 @@ module RubyAnagrams
     # an Enumerator is returned.
     # @return [Enumerator] the enumerator for the words in the trie data structure.
     def each &block
-      enumerator = Enumerator.new do |y|
-        y << word if terminal?
-        @children.each_value do |child|
-          child.each { |word| y << word }
-        end
+      enumerator = Enumerator.new do |yielder|
+        yielder << word if terminal?
+        @children.each_value { |child| child.each { |word| yielder << word } }
       end
       block.nil? ? enumerator : enumerator.each(&block)
     end

data/lib/anagrams/root.rb

@@ -1,8 +1,8 @@
-# Namespace for the Ruby-Anagrams gem.
 module RubyAnagrams
   # A representation of the Root node of the trie data structure.
   # @author Connor Lay
   class Root < Node
+
     # Creates a new trie.
     # @param path [String, nil] the path to a dictionary text file.
     # @return [Root] the Root node of the trie just created.
@@ -19,25 +19,46 @@ module RubyAnagrams
     # @param word [String] the new word to add to the trie.
     # @return [String] the word just added to the trie.
     def << word
-      symbols = str_to_sym_a word
+      symbols = word.to_sym_a
       add_to_subtree symbols
     end
 
+    alias :add :<<
+
     # If the trie contains the word.
     # @param word [String] the word to search for.
     # @return [Boolean] true if the word is found, false otherwise.
     def include? word
-      symbols = str_to_sym_a word
+      symbols = word.to_sym_a
       search_subtree symbols
     end
 
-    # Returns a symbol array based on the chatacters of a string.
-    # @example
-    #   str_to_sym_a "apple" #=> [:a, :p, :p, :l, :e]
-    # @param string [String] the string to process
-    # @return [Array<Symbol>] an array of symbols
-    def str_to_sym_a string
-      string.chars.map { |char| char.to_sym }
+    alias :contains? :include?
+
+    # Returns all anagrams of the given word. Wildcards are indicated with "*".
+    # @note Default behavior only includes complete anagrams. Partial anagrams
+    #   can be included by setting partial to true.
+    # @example without partial anagrams
+    #   root << "rise"
+    #   root << "sire"
+    #   root << "rie"
+    #   #anagrams "rise" #=> ['rise', 'sire']
+    # @example with partial anagrams
+    #   root << "rise"
+    #   root << "sire"
+    #   root << "rie"
+    #   #anagrams "rise", partial: true #=> ['rie', 'rise', 'sire']
+    # @example with wildcards
+    #   root << "bin"
+    #   root << "ban"
+    #   root << "bun"
+    #   #anagrams "b*n" #=> ['ban', 'bin', 'bun']
+    # @param word [String] the word to find anagrams for.
+    # @param partial [Boolean] include partial anagrams?
+    # @return [Array<String>] anagrams of word.
+    def anagrams word, partial: false
+      symbols = word.to_sym_a
+      search_for_anagrams symbols, partial: partial
     end
 
   end

data/lib/anagrams/string_to_symbol_array.rb

@@ -0,0 +1,9 @@
+class String
+  # Returns a symbol array representation of the reciever's characters.
+  # @example
+  #   "apple".to_sym_a #=> [:a, :p, :p, :l, :e]
+  # @return [Array<Symbol>] an array of symbols
+  def to_sym_a
+    self.chars.map { |char| char.to_sym }
+  end
+end

data/lib/anagrams/subtrees.rb

@@ -14,33 +14,41 @@ module RubyAnagrams
       nodes
     end
 
+    # Descends the trie data structure following the given sequence of symbols.
+    # The last node visited is returned, either because it is a leaf or there
+    # are no symbols left.
+    # @note This method alters the symbol array.
+    # @param symbols [Array<Symbol>] the symbol sequence to follow.
+    # @return [Node] the last node visited.
+    def descend symbols
+      return self unless symbol = symbols[0]
+      return self unless child = @children[symbol]
+      symbols.slice! 0
+      child.descend symbols
+    end
+
   protected
     # Descends the trie data structure, adding nodes when needed, for a given
     # sequence of symbols. The last node visited is designated as a terminal.
     # @param symbols [Array<Symbol>] the symbol sequence to follow.
     # @return [String] the word represented by the last node visited.
     def add_to_subtree symbols
-      if symbols.empty?
-        terminal!
-        return word
-      end
-      s = symbols.slice! 0
-      unless child = @children[s]
-        child = Node.new s, self
-        @children[s] = child
+      current = descend symbols
+      symbols.each do |symbol|
+        current[symbol] = Node.new symbol, current
+        current = current[symbol]
       end
-      child.add_to_subtree symbols
+      current.terminal!
+      current.word
     end
 
-    # Performs depth-first search, following a sequence of symbols, on the trie
-    # data structure. Returns true if the last node visited is a terminal.
+    # Depth-first searches the trie data structure for a node representing a
+    # given sequence of symbols.
     # @param symbols [Array<Symbol>] the symbol sequence to follow.
     # @return [Boolean] true if the last node visited is a terminal, false otherwise.
     def search_subtree symbols
-      return true if symbols.empty? && terminal?
-      s = symbols.slice! 0
-      return false unless child = @children[s]
-      child.search_subtree symbols
+      current = descend symbols
+      current.terminal? && symbols.empty?
     end
 
   end

data/lib/ruby-anagrams.rb

@@ -1,5 +1,10 @@
+require_relative 'anagrams/string_to_symbol_array'
 require_relative 'anagrams/subtrees'
 require_relative 'anagrams/enumerable'
 require_relative 'anagrams/anagrams'
 require_relative 'anagrams/node'
-require_relative 'anagrams/root'
+require_relative 'anagrams/root'
+
+module RubyAnagrams
+  # Namespace for the Ruby-Anagrams gem.
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-anagrams
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Connor Lay
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-02 00:00:00.000000000 Z
+date: 2015-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -76,6 +76,7 @@ files:
 - lib/anagrams/enumerable.rb
 - lib/anagrams/node.rb
 - lib/anagrams/root.rb
+- lib/anagrams/string_to_symbol_array.rb
 - lib/anagrams/subtrees.rb
 - lib/ruby-anagrams.rb
 homepage: https://github.com/connorlay/ruby-anagrams