ruby-anagrams 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b4354f4fdcda04c67e8f3b2e11afbe9b6999fc22
+  data.tar.gz: 7cf6680ff7f4de0aa5aff21768852fab28e51d7a
+SHA512:
+  metadata.gz: 28216d0fefce0b01b630e56e7eec4d9cf330183c7e76666cd94db7bd17fd8bd8dc5b7a14d7c6121069ec35a70bfce2952ca5aac6780f20b27582e192339b3ada
+  data.tar.gz: dceb898b96b5f0b67cdbd014fb1d8bde14586725ed18c35f4f5d6128037c725cf3c3f027067def25a37502b4e26f5be3c131cdbf588c62cf110c0ccb549b01b9

data/lib/anagrams/anagrams.rb

@@ -0,0 +1,91 @@
+module RubyAnagrams
+  # Provides anagram solver behavior to the trie data structure.
+  # @author Connor Lay
+  module Anagrams
+    require 'prime'
+
+    # 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)
+      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
+        end
+        anagrams
+      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
+      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] }
+      end
+
+  end
+end

data/lib/anagrams/enumerable.rb

@@ -0,0 +1,25 @@
+module RubyAnagrams
+  # Provides enumerable behavior to the trie data structure.
+  # @author Connor Lay
+  module Enumerable
+
+    include ::Enumerable
+
+    # Calls a block for each word in the trie data strucutre. If no block is given,
+    # 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
+      end
+      block.nil? ? enumerator : enumerator.each(&block)
+    end
+
+    alias :size :count
+
+  end
+
+end

data/lib/anagrams/node.rb

@@ -0,0 +1,71 @@
+module RubyAnagrams
+  # A representation of a Node in the trie data structure.
+  # @author Connor Lay
+  class Node
+
+    include Subtrees
+    include Enumerable
+    include Anagrams
+
+    attr_reader :symbol, :children, :parent
+
+    # Creates a new, non-terminal node with no children.
+    # @param symbol [Symbol, nil] the symbol the node represents.
+    # @param parent [Node, nil] the parent of the node.
+    # @return [Node] the node just created.
+    def initialize symbol = nil, parent = nil
+      @symbol = symbol
+      @parent = parent
+      @children = {}
+      @terminal = false
+    end
+
+    # Adds a new child node representing a symbol to this node's children.
+    # @param symbol [Symbol] the symbol the node represents.
+    # @param child [Node] the node to add as a child.
+    # @return [Node] the node just added.
+    def []= symbol, child
+      @children[symbol] = child
+    end
+
+    # Returns the child node associated with a symbol.
+    # @param symbol [Symbol]
+    # @return [Node] the child node associated with the symbol.
+    def [] symbol
+      @children[symbol]
+    end
+
+    # Sets the node as a terminal.
+    def terminal!
+      @terminal = true
+    end
+
+    # Is the node a terminal?
+    # @return [Boolean] true if the node is a terminal, false otherwise
+    def terminal?
+      @terminal
+    end
+
+    # Returns the word the node represents based on its symbol and
+    # the symbols of its parents.
+    # @example called on the node representing :e
+    #   :a
+    #     :p
+    #       :p
+    #         :l
+    #           :e
+    #   #word #=> "apple"
+    # @return [String] the word the node represents.
+    def word
+      @parent ? "#{@parent.word}#{@symbol}" : "#{@symbol}"
+    end
+
+    def inspect
+      "<#{self.class}:#{self.object_id}, "\
+      "@symbol=#{@symbol ? ":#{@symbol}" : "nil"}, "\
+      "@word=#{terminal? ? word : "nil"}, "\
+      "@children=#{@children.each_key.to_a}>"
+    end
+
+  end
+end

data/lib/anagrams/root.rb

@@ -0,0 +1,44 @@
+# 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.
+    def initialize path = nil
+      super()
+      if path
+        file = File.open path, "r"
+        file.each_line { |line| self << line.downcase.strip }
+        file.close
+      end
+    end
+
+    # Adds a word to the trie.
+    # @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
+      add_to_subtree symbols
+    end
+
+    # 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
+      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 }
+    end
+
+  end
+end

data/lib/anagrams/subtrees.rb

@@ -0,0 +1,47 @@
+module RubyAnagrams
+  # Provides subtree branching and searching behavior to the trie data strucutre.
+  # @author Connor Lay
+  module Subtrees
+
+    # Returns the number of nodes in the subtree. When called on Root, returns
+    # the number of nodes in the entire trie data structure.
+    # @return [Integer] the number of nodes in the subtree.
+    def node_count
+      nodes = 1
+      @children.each_value do |child|
+        nodes += child.node_count
+      end
+      nodes
+    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
+      end
+      child.add_to_subtree symbols
+    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.
+    # @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
+    end
+
+  end
+end

data/lib/ruby-anagrams.rb

@@ -0,0 +1,5 @@
+require_relative 'anagrams/subtrees'
+require_relative 'anagrams/enumerable'
+require_relative 'anagrams/anagrams'
+require_relative 'anagrams/node'
+require_relative 'anagrams/root'

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: ruby-anagrams
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Connor Lay
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A trie-based anagram solver.
+email: connor.lay@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/anagrams/anagrams.rb
+- lib/anagrams/enumerable.rb
+- lib/anagrams/node.rb
+- lib/anagrams/root.rb
+- lib/anagrams/subtrees.rb
+- lib/ruby-anagrams.rb
+homepage: https://github.com/connorlay/ruby-anagrams
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Ruby Anagrams
+test_files: []
+has_rdoc: