victory 0.0.0 → 0.0.1

data/lib/containers/list.rb

@@ -0,0 +1,81 @@
+class List
+  Node = Struct.new(:data, :prev, :next)
+  def initialize
+    @first = nil
+    @last = nil
+  end
+
+  def self.[](*arr)
+    from_a(arr)
+  end
+
+  def self.from_a(arr)
+    l = new
+    arr.each(&l.method(:push_front))
+    l
+  end
+
+  def empty?
+    @first == @last && @first.nil?
+  end
+
+  def push_front(element)
+    node = Node.new(element, nil, @first)
+    if @first.nil?
+      @last = node
+    else
+      @first.prev = node
+    end
+    @first = node
+  end
+
+  def pop_front
+    to_return = @first&.data
+    unless @first.nil?
+      @first = @first.next
+      if @first.nil?
+        @last = nil
+      else
+        @first.prev = nil unless @first.nil?
+      end
+    end
+    to_return
+  end
+
+  def push_back(element)
+    node = Node.new(element, @last, nil)
+    if @last.nil?
+      @first = node
+    else
+      @last.next = node
+    end
+    @last = node
+  end
+
+  def pop_back
+    to_return = @last&.data
+    unless @last.nil?
+      @last = @last.prev
+      if @last.nil?
+        @first = nil
+      else
+        @last.next = nil unless @last.nil?
+      end
+    end
+    to_return
+  end
+
+  def peek_front
+    @first&.data
+  end
+
+  def peek_back
+    @last&.data
+  end
+
+  alias push push_back
+  alias pop pop_back
+  alias unshift push_front
+  alias shift pop_front
+end
+L = List

data/lib/containers/prefix_tree.rb

@@ -0,0 +1,61 @@
+require 'containers/list'
+
+class PrefixTree
+  class Node
+    attr_accessor :data, :children
+
+    def initialize
+      @data = nil
+      @children = {}
+    end
+  end
+
+  def initialize
+    @root = Node.new
+  end
+
+  def <<(str, value = true)
+    insert(str, value)
+  end
+
+  def insert(str, value = true)
+    current = @root
+    str.each_char do |c|
+      current.children[c] = Node.new if current.children[c].nil?
+      current = current.children[c]
+    end
+    current.data = value
+  end
+
+  def [](str)
+    find(str)
+  end
+
+  def find(str)
+    current = @root
+    str.each_char do |c|
+      return nil if current.children[c].nil?
+
+      current = current.children[c]
+    end
+    current.data
+  end
+
+  def count_partial(str)
+    current = @root
+    str.each_char do |c|
+      return 0 if current.children[c].nil?
+
+      current = current.children[c]
+    end
+    stack = List.new
+    count = 0
+    current.children.each_value(&stack.method(:push))
+    until stack.empty?
+      current = stack.pop
+      count += 1 unless current.data.nil?
+      current.children.each_value(&stack.method(:push))
+    end
+    count
+  end
+end

data/lib/containers/priority_queue.rb

@@ -0,0 +1,135 @@
+require 'containers/heap'
+
+# rdoc
+#     A Priority Queue is a data structure that behaves like a queue except that elements have an
+#     associated priority. The #next and #pop methods return the item with the next highest priority.
+#
+#     Priority Queues are often used in graph problems, such as Dijkstra's Algorithm for shortest
+#     path, and the A* search algorithm for shortest path.
+#
+#     This container is implemented using the Fibonacci heap included in the Collections library.
+#
+# 
+#     MIT License
+#
+#     Copyright (c) 2009 Kanwei Li
+#
+#     Permission is hereby granted, free of charge, to any person obtaining a copy
+#     of this software and associated documentation files (the "Software"), to deal
+#     in the Software without restriction, including without limitation the rights
+#     to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#     copies of the Software, and to permit persons to whom the Software is
+#     furnished to do so, subject to the following conditions:
+#
+#     The above copyright notice and this permission notice shall be included in all
+#     copies or substantial portions of the Software.
+#
+#     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#     AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+#     SOFTWARE.
+class Containers::PriorityQueue
+  include Enumerable
+
+  # Create a new, empty PriorityQueue
+  def initialize(&block)
+    # We default to a priority queue that returns the largest value
+    block ||= lambda { |x, y| (x <=> y) == 1 }
+    @heap = Containers::Heap.new(&block)
+  end
+
+  # Returns the number of elements in the queue.
+  #
+  #    q = Containers::PriorityQueue.new
+  #    q.size #=> 0
+  #    q.push("Alaska", 1)
+  #    q.size #=> 1
+  def size
+    @heap.size
+  end
+  alias_method :length, :size
+
+  # Add an object to the queue with associated priority.
+  #
+  #   q = Containers::PriorityQueue.new
+  #   q.push("Alaska", 1)
+  #   q.pop #=> "Alaska"
+  def push(object, priority)
+    @heap.push(priority, object)
+  end
+
+  # Clears all the items in the queue.
+  def clear
+    @heap.clear
+  end
+
+  # Returns true if the queue is empty, false otherwise.
+  def empty?
+    @heap.empty?
+  end
+
+  # call-seq:
+  #     has_priority? priority -> boolean
+  #
+  # Return true if the priority is in the queue, false otherwise.
+  #
+  #     q = PriorityQueue.new
+  #     q.push("Alaska", 1)
+  #
+  #     q.has_priority?(1)    #=> true
+  #     q.has_priority?(2)    #=> false
+  def has_priority?(priority)
+    @heap.has_key?(priority)
+  end
+
+  # call-seq:
+  #     next -> object
+  #
+  # Return the object with the next highest priority, but does not remove it
+  #
+  #     q = Containers::PriorityQueue.new
+  #     q.push("Alaska", 50)
+  #     q.push("Delaware", 30)
+  #     q.push("Georgia", 35)
+  #     q.next          #=> "Alaska"
+  def next
+    @heap.next
+  end
+
+  # call-seq:
+  #     pop -> object
+  #
+  # Return the object with the next highest priority and removes it from the queue
+  #
+  #     q = Containers::PriorityQueue.new
+  #     q.push("Alaska", 50)
+  #     q.push("Delaware", 30)
+  #     q.push("Georgia", 35)
+  #     q.pop         #=> "Alaska"
+  #     q.size        #=> 2
+  def pop
+    @heap.pop
+  end
+  alias_method :next!, :pop
+
+  # call-seq:
+  #     delete(priority) -> object
+  #     delete(priority) -> nil
+  #
+  # Delete an object with specified priority from the queue. If there are duplicates, an
+  # arbitrary object with that priority is deleted and returned. Returns nil if there are
+  # no objects with the priority.
+  #
+  #     q = PriorityQueue.new
+  #     q.push("Alaska", 50)
+  #     q.push("Delaware", 30)
+  #     q.delete(50)            #=> "Alaska"
+  #     q.delete(10)            #=> nil
+  def delete(priority)
+    @heap.delete(priority)
+  end
+
+end

data/lib/containers/queue.rb

@@ -0,0 +1,89 @@
+require 'containers/deque'
+
+# rdoc
+#     A Queue is a container that keeps elements in a first-in first-out (FIFO) order. Because of its
+#     properties, it is often used as a buffer.
+#
+#     This implementation uses a doubly-linked list, guaranteeing O(1) complexity for all operations.
+#
+#
+#     MIT License
+#
+#     Copyright (c) 2009 Kanwei Li
+#
+#     Permission is hereby granted, free of charge, to any person obtaining a copy
+#     of this software and associated documentation files (the "Software"), to deal
+#     in the Software without restriction, including without limitation the rights
+#     to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#     copies of the Software, and to permit persons to whom the Software is
+#     furnished to do so, subject to the following conditions:
+#
+#     The above copyright notice and this permission notice shall be included in all
+#     copies or substantial portions of the Software.
+#
+#     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#     AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+#     SOFTWARE.
+class Containers::Queue
+  include Enumerable
+  # Create a new queue. Takes an optional array argument to initialize the queue.
+  #
+  #   q = Containers::Queue.new([1, 2, 3])
+  #   q.pop #=> 1
+  #   q.pop #=> 2
+  def initialize(ary=[])
+    @container = Containers::Deque.new(ary)
+  end
+
+  # Returns the next item from the queue but does not remove it.
+  #
+  #   q = Containers::Queue.new([1, 2, 3])
+  #   q.next #=> 1
+  #   q.size #=> 3
+  def next
+    @container.front
+  end
+
+  # Adds an item to the queue.
+  #
+  #   q = Containers::Queue.new([1])
+  #   q.push(2)
+  #   q.pop #=> 1
+  #   q.pop #=> 2
+  def push(obj)
+    @container.push_back(obj)
+  end
+  alias_method :<<, :push
+
+  # Removes the next item from the queue and returns it.
+  #
+  #   q = Containers::Queue.new([1, 2, 3])
+  #   q.pop #=> 1
+  #   q.size #=> 2
+  def pop
+    @container.pop_front
+  end
+
+  # Return the number of items in the queue.
+  #
+  #   q = Containers::Queue.new([1, 2, 3])
+  #   q.size #=> 3
+  def size
+    @container.size
+  end
+
+  # Returns true if the queue is empty, false otherwise.
+  def empty?
+    @container.empty?
+  end
+
+  # Iterate over the Queue in FIFO order.
+  def each(&block)
+    @container.each_forward(&block)
+  end
+
+end