suffix_tree_ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f63b159f00880e92a880c4a86d014312d9b74bbc51b14d2129813378b0e2258f
+  data.tar.gz: bf254242be7c1aac06549891371efb13de2008b72da84477c19eb1f2af1c2255
+SHA512:
+  metadata.gz: 7310c3ae440526fad97c07bc02cd9ded850106b3c3ac87ea8aaf1230deb5f4bac75851ff43940037a7da16d38027f298c9c4736caa5682306816f4e0623ee879
+  data.tar.gz: 81f81eb06bd65304a2b4b4013374168b2019a36196a6a8b99cef75d4703a09c4143108d09a8c9451e98786d64b12e7d8bd9e1fd46a6dcac18ebf0d978fc75a73

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/suffix_tree.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'suffix_tree/version'
+
+module SuffixTree
+  autoload :Node, 'suffix_tree/node'
+  autoload :ActivePoint, 'suffix_tree/active_point'
+  autoload :End, 'suffix_tree/end'
+end
+require 'suffix_tree/base'

data/lib/suffix_tree/active_point.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SuffixTree
+  # Active point - It is the point from which traversal starts for next extension or next phase.
+  # Active point always starts from root. Other extension will get active point set up
+  # correctly by last extension.
+
+  # Active node - Node from which active point will start
+  # Active Edge - It is used to choose the edge from active node. It has index of character.
+  # Active Length - How far to go on active edge.
+
+  # Active point rules
+  # 1) If rule 3 extension is applied then active length will increment by 1 if active length is
+  #    not greater then length of path on edge.
+  # 2) If rule 3 extension is applied and if active length gets greater than length path of edge
+  #    then change active node, active edge and active length
+  # 3) If active length is 0 then always start looking for the character from root.
+  # 4) If rule 2 extension is applied and if active node is root then active edge is active edge + 1
+  #    and active length is active lenght -1
+  # 5) If rule 2 extension is applied and if active node is not root then follow suffix link and
+  #    make active node as suffix link and do no change anything.
+  class ActivePoint
+    attr_accessor :length, :edge, :node
+
+    def initialize(node)
+      @length = 0
+      @edge = -1
+      @node = node
+    end
+  end
+end

data/lib/suffix_tree/base.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module SuffixTree
+  # https://en.wikipedia.org/wiki/Ukkonen%27s_algorithm
+  class Base
+    attr_accessor :input, :root, :remaining, :end, :active, :words, :uniq_word_map, :l_map
+
+    UNIQ_IDENTIFIERS = ((0...97).map(&:chr) + (135...200).map(&:chr)).freeze
+
+    def initialize(words)
+      @words = words
+      @input = ''
+      @l_map = {}
+      @uniq_word_map = {}
+      words.each_with_index do |word, index|
+        id = UNIQ_IDENTIFIERS[index]
+        @uniq_word_map[id] = index
+        @input += "#{word}#{id}"
+      end
+      @input = @input.split('')
+      @remaining = 0
+    end
+
+    def build
+      self.root = Node.new(1, End.new(0), words.count)
+      root.index = -1
+      self.active = ActivePoint.new(root)
+      self.end = End.new(-1)
+      input.each_with_index do |_elm, index|
+        start_phase(index)
+      end
+
+      set_index_dfs(root, 0, input.length)
+      set_lvalues_dfs(root)
+    end
+
+    def set_lvalues_dfs(node, str = '')
+      return unless node
+
+      return if node.index != -1
+
+      str += input[node.start..node.end.end].join('')
+      if l_map[node.c_value]
+        if l_map[node.c_value].length < str.length
+          l_map[node.c_value] = str
+        elsif l_map[node.c_value].length == str.length
+          l_map[node.c_value] = [str, l_map[node.c_value]].min
+        end
+      else
+        l_map[node.c_value] = str
+      end
+
+      node.child.each do |_key, child|
+        set_lvalues_dfs(child, str)
+      end
+    end
+
+    def set_index_dfs(node, val, size)
+      return unless node
+
+      val += node.end.end - node.start + 1
+      if node.index != -1
+        node.index = size - val
+        c_index = node.index
+
+        c_index += 1 until uniq_word_map[input[c_index]]
+        node.c_values[uniq_word_map[input[c_index]]] = 1
+        return
+      end
+      nums = [node.c_values]
+      node.child.each do |_key, child|
+        set_index_dfs(child, val, size)
+        nums << child.c_values
+      end
+      if node != root
+        node.c_values = nums.transpose.map(&:sum).map { |e| e.positive? ? 1 : 0 }
+      end
+      node.c_value = node.c_values.sum
+    end
+
+    def start_phase(index)
+      last_created_internal_node = nil
+      self.end.end += 1
+      self.remaining += 1
+
+      while remaining.positive?
+        if active.length.zero?
+          if select_node(index)
+            active.edge = select_node(index).start
+            active.length += 1
+            break
+          else
+            root.child[input[index]] = Node.new(index, self.end, words.count)
+            self.remaining -= 1
+          end
+        else
+          begin
+            char = next_char(index)
+            if char == input[index]
+              last_created_internal_node.suffix_link = selected_node if last_created_internal_node
+              walk_down(index)
+              break
+            else
+              node = selected_node
+              temp_start = node.start
+              node.start = node.start + active.length
+              new_internal_node = Node.new(temp_start, End.new(temp_start + active.length - 1), words.count)
+
+              new_leaf_node = Node.new(index, self.end, words.count)
+
+              new_internal_node.child[input[new_internal_node.start + active.length]] = node
+              new_internal_node.child[input[index]] = new_leaf_node
+              new_internal_node.index = -1
+              active.node.child[input[new_internal_node.start]] = new_internal_node
+
+              last_created_internal_node.suffix_link = new_internal_node if last_created_internal_node
+
+              last_created_internal_node = new_internal_node
+              new_internal_node.suffix_link = root
+
+              if active.node != root
+                active.node = active.node.suffix_link
+              else
+                active.edge = active.edge + 1
+                active.length -= 1
+              end
+              self.remaining -= 1
+            end
+          rescue StandardError
+            node = selected_node
+            node.child[input[index]] = Node.new(index, self.end, words.count)
+            last_created_internal_node.suffix_link = node if last_created_internal_node
+            last_created_internal_node = node
+
+            if active.node != root
+              active.node = active.node.suffix_link
+            else
+              active.edge = active.edge + 1
+              active.length -= 1
+            end
+            self.remaining -= 1
+          end
+        end
+      end
+    end
+
+    def walk_down(index)
+      node = selected_node
+
+      if diff(node) < active.length
+        active.node = node
+        active.length = active.length - diff(node)
+        active.edge = node.child[input[index]].start
+      else
+        active.length += 1
+      end
+    end
+
+    def next_char(i)
+      node = selected_node
+      return input[active.node.child[input[active.edge]].start + active.length] if diff(node) >= active.length
+
+      if diff(node) + 1 == active.length
+        return input[i] if node.child[input[i]]
+      else
+        active.node = node
+        active.length = active.length - diff(node) - 1
+        active.edge = active.edge + diff(node) + 1
+        return next_char(i)
+      end
+      raise 'End Of Path Reached'
+    end
+
+    def diff(node)
+      node.end.end - node.start
+    end
+
+    def selected_node
+      active.node.child[input[active.edge]]
+    end
+
+    def select_node(index)
+      active.node.child[input[index]]
+    end
+
+    def longest_common_substring(k = words.length)
+      raise 'Input has to be integer' unless k.is_a? Integer
+      raise 'Invalid Input' if k <= 0
+
+      return base_case if k == 1
+
+      max_length = -1
+      answer = ''
+
+      l_map.each do |key, v|
+        next if key < k
+
+        if v.length > max_length
+          max_length = v.length
+          answer = v
+        elsif v.length == max_length
+          answer = [v, answer].min
+        end
+      end
+      answer
+    end
+
+    def base_case
+      max_length = -1
+      answer = ''
+
+      words.each do |word|
+        if max_length < word.length
+          max_length = word.length
+          answer = word
+        elsif max_length == word.length
+          answer = [answer, word].min
+        end
+      end
+      answer
+    end
+  end
+end

data/lib/suffix_tree/end.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SuffixTree
+  class End
+    attr_accessor :end
+
+    def initialize(end_p)
+      @end = end_p
+    end
+  end
+end

data/lib/suffix_tree/node.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SuffixTree
+  class Node
+    attr_accessor :child, :suffix_link, :start, :end, :index, :c_values, :c_value
+
+    def initialize(start, end_p, word_count)
+      @child = {}
+      @suffix_link = nil
+      @start = start
+      @end = end_p
+      @index = 0
+      @depth = 0
+      @c_value = 0
+      @c_values = [0] * word_count
+    end
+  end
+end

data/lib/suffix_tree/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SuffixTree
+  VERSION = '0.0.1'
+end

data/test/test_suffix_tree.rb

@@ -0,0 +1,26 @@
+require 'minitest/autorun'
+require 'suffix_tree'
+
+describe "SuffixTreeTest" do
+  let(:words) { ["sandollar", "sandlot", "handler", "grand", "pantry"] }
+  let(:tree) { SuffixTree::Base.new(words) }
+  
+  it 'initializes with input' do
+    assert tree.words, words
+  end
+
+  it 'builds suffix tree' do
+    assert tree.build
+  end
+
+  describe "find longest commom substring" do
+    it 'finds longest common subtring for all the strings' do
+      assert tree.longest_common_substring, "an" 
+    end
+
+    it 'finds longest common subtring for at least k substrings' do
+      assert tree.longest_common_substring(2), "sand" 
+      assert tree.longest_common_substring(3), "and" 
+    end
+  end
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: suffix_tree_ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sudheer Meka
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-04-23 00:00:00.000000000 Z
+dependencies: []
+description: Construct Generalized Suffix tree using Ukkonen's algorithm
+email: reachme@sudheer-meka.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/suffix_tree.rb
+- lib/suffix_tree/active_point.rb
+- lib/suffix_tree/base.rb
+- lib/suffix_tree/end.rb
+- lib/suffix_tree/node.rb
+- lib/suffix_tree/version.rb
+- test/test_suffix_tree.rb
+homepage: https://rubygems.org/gems/suffix_tree
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/sudheer-meka/suffix_tree
+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: []
+rubygems_version: 3.0.9
+signing_key:
+specification_version: 4
+summary: Suffix Tree Implementaion and operation using ruby
+test_files:
+- test/test_suffix_tree.rb