prefix_tree 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4f64aa5bba6e670976b5fbeb9fe4045af84e48be0e3f9f5601d560d6ec4281fe
+  data.tar.gz: f87e303415e69c57a7fbe6c5d6ccef6be8eeb552602748f55ecc6c4d09af727d
+SHA512:
+  metadata.gz: 0e9daf017cbdc0de5f457ab0d326a42648e1a3f07f25659249f6cb8c7a1d8cc3466dc260d69b4da46b266f16c8affe03da802edc122a6ef6f7250a8bae61b5ad
+  data.tar.gz: dcf40a6123e877375fffaf49902a828b175c1bb642bd4ee86157ba33e9ca750d4cd98455d107ce2dc9fe4639b00791ad12715bb4d68a9ad0ce36d6104cf99644

data/lib/prefix_tree/csv_controller.rb

@@ -0,0 +1,44 @@
+# CSV file reader and writer
+
+$LOAD_PATH << '../../lib'
+
+require'../prefix_tree'
+
+class CsvController
+  def initialize(tree = PrefixTree.new)
+    @tree = tree
+  end
+
+  def fill_csv
+    strings = @tree.dictionary.map { |key, value| [key, value] }
+
+    CSV.open('dictionary.csv', 'w') do |csv|
+      csv << %w[id name]
+      strings.each { |string| csv << string }
+    end
+  end
+
+  def read_csv
+    strings = CSV.parse(File.read('strings_for_tree.csv'), headers: true).by_col[1]
+    fill_tree(strings)
+  end
+
+  private
+
+  def fill_tree(strings)
+    strings.each { |string| @tree.add(string) } 
+  end
+end
+
+tree = PrefixTree.new
+
+tree.add('dsbh')
+tree.add('mmss')
+tree.delete('dsbh')
+tree.add('string')
+
+csv_controller = CsvController.new(tree)
+
+csv_controller.read_csv
+csv_controller.fill_csv
+

data/lib/prefix_tree/node.rb

@@ -0,0 +1,80 @@
+# create node class
+
+$LOAD_PATH << '../../lib'
+
+class Node
+  attr_reader :value, :number_size, :children, :is_end_point, :strings_indexs
+
+  @@nodes = []
+
+  def self.nodes
+    @@nodes
+  end
+
+  def initialize(value = 'root')
+    @value = value
+    @children ||= []
+    @strings_indexs = []
+    @number_size = 0
+    @@nodes << self
+    @is_end_point = false
+  end
+
+  def create_child(char)
+    @children << child = Node.new(char)
+    child
+  end
+
+  def delete_node
+    @children.delete_if { |node| node.number_size.zero? }
+  end
+
+  def to_s
+    @value
+  end
+
+  def include?(char)
+    @children.any? { |node| node.value == char }
+  end
+
+  def find(char)
+    @children.each { |node| return node if node.value == char }
+    false
+  end
+
+  def become_end_point
+    @is_end_point = true
+  end
+
+  def not_end_point
+    @is_end_point = false
+  end
+
+  def increment_size
+    @number_size += 1
+  end
+
+  def decrement_size
+    @number_size -= 1
+  end
+
+  def add_strings_indexs(index)
+    @strings_indexs << index
+  end
+
+  def delete_strings_indexs
+    @children.each do |node|
+      erase_indexs(node)
+    end
+  end
+
+  def delete_element(value)
+    @strings_indexs.delete_if { |element| element.eql? value }
+  end
+
+  private
+
+  def erase_indexs(node)
+    @strings_indexs -= node.strings_indexs if node.number_size.zero?
+  end
+end

data/lib/prefix_tree.rb

@@ -0,0 +1,159 @@
+# create prefix tree
+$LOAD_PATH << '../lib'
+require 'prefix_tree/node'
+
+
+WORD_EXIST = 'This word is already exist in prefix tree'
+ADD_NEW_WORD = 'Add new word in prefix tree'
+NO_WORD = 'This word is not in tree'
+
+class PrefixTree
+  attr_reader :dictionary
+
+  def initialize
+    @root = Node.new
+    @number_of_input_strings = 0
+    @dictionary = {}
+    @dictionary_by_strings = {}
+  end
+
+  def add(input_value)
+    input_value = convert_to_string(input_value)
+    add_word(input_value.downcase)
+  end
+
+  def delete(input_value)
+    return NO_WORD unless find(input_value)
+
+    decrease_size(input_value)
+    delete_string_index(input_value)
+    delete_nodes(input_value)
+  end
+
+  def include?(input_value)
+    find_prefix_node(input_value) ? true : false
+  end
+
+  def find(input_value)
+    node = find_prefix_node(input_value)
+    return false unless node
+
+    node.is_end_point
+  end
+
+  def list(input_value)
+    node = @root
+    input_value.each_char do |char|
+      node = find_node(node, char)
+      return false unless node
+    end
+    write_appropriate_strings(node, input_value)
+  end
+
+  private
+
+  def write_appropriate_strings(node, input_value)
+    if input_value == ''
+      puts @dictionary.values
+    else
+      puts_answer(node.strings_indexs)
+    end
+  end
+
+  def puts_answer(indexs)
+    indexs.each { |index| puts @dictionary[index] }
+  end
+
+  def add_word(input_value)
+    return WORD_EXIST if find(input_value)
+
+    dictionary_filler(input_value)
+    fill_tree(input_value)
+    ADD_NEW_WORD
+  end
+
+  def dictionary_filler(input_value)
+    add_in_dictionary(input_value)
+  end
+
+  def add_in_dictionary(input_value)
+    @number_of_input_strings += 1
+    @dictionary_by_strings[input_value] = @number_of_input_strings
+    @dictionary[@number_of_input_strings] = input_value
+  end
+
+  def fill_tree(input_value)
+    node = @root
+    input_value.each_char  { |char| node = back_new_node(node, char) } 
+    node.become_end_point
+  end
+
+  def back_new_node(node, char)
+    new_node = create_or_find_node(node, char)
+    new_node.add_strings_indexs(@number_of_input_strings)
+    new_node.increment_size
+    new_node
+  end
+
+  def convert_to_string(input_value)
+    input_value.to_s
+  end
+
+  def find_prefix_node(input_value)
+    node = @root
+    input_value.each_char do |char|
+      node = find_node(node, char)
+      return false unless node
+    end
+    node
+  end
+
+  def create_or_find_node(node, char)
+    if node.include?(char)
+      node.find(char)
+    else
+      node.create_child(char)
+    end
+  end
+
+  def find_node(node, char)
+    node.include?(char) ? node.find(char) : false
+  end
+
+  def delete_string_index(input_value)
+    index = @dictionary_by_strings[input_value]
+    @dictionary.delete(index)
+    @dictionary_by_strings.delete(input_value)
+  end
+
+  def decrease_size(input_value)
+    node = @root
+    input_value.each_char do |char|
+      node = node.find(char)
+      change_size(node, input_value)
+    end
+    node.not_end_point
+  end
+
+  def change_size(node, input_value)
+    node.decrement_size
+    node.delete_element(@dictionary_by_strings[input_value])
+  end
+
+  def delete_nodes(input_value)
+    node = @root
+    input_value.each_char do |char|
+      break unless node
+
+      delete_nodes_in_node_class(node)
+      node = node.find(char)
+    end
+  end
+
+  def delete_nodes_in_node_class(node)
+    node.delete_strings_indexs
+    node.delete_node
+  end
+end
+
+

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: prefix_tree
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- tato
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-05-06 00:00:00.000000000 Z
+dependencies: []
+description: prefix_tree gem
+email: tzpanchulidze@unisens.ge
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/prefix_tree.rb
+- lib/prefix_tree/csv_controller.rb
+- lib/prefix_tree/node.rb
+homepage: ''
+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: []
+rubygems_version: 3.2.32
+signing_key: 
+specification_version: 4
+summary: prefix_tree
+test_files: []