simms_structures 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e04c9d575010abad0bad21e41e2a428286a09689
-  data.tar.gz: 7714183f1273c98edc2e1f5413b7e2a9a7fc5231
+  metadata.gz: 353026f3f3254975c9415d6aa60351d51980b84d
+  data.tar.gz: 822573baead5d38dc2bb6df5fa9b9f4ecb9affb1
 SHA512:
-  metadata.gz: fa21d3dce610f58c3af9b73d7c9e58690f45fee300470c2c261dc66b7ab7af9b24695d42b2200d72f59dad913a5d43166f98650b1c5d32dd7d48afe68670292a
-  data.tar.gz: bd0a435a9c3e8068d936aba4064103c5af3a1eca9dd5c55f92236478205b0d493ef65f13fc49ce3c7eadc5b30b637fa3fc2dc71ec5e542aca60aa2d17a1a84c6
+  metadata.gz: 82fba3dfb293477766ca98c33d3993af22df4737b0bb6deeed21bc18a968f719b4f951fa673dcfde18fc8521af9577cd10a05ca534318ee9a88d249a4d5cee62
+  data.tar.gz: 9020d22aab60ff58f49a300f7f3e4991b496bd387e8f0679e025070b4b1182fc9a16d22886a2dbe72692cc73a580bb9a38761eb6165f5bd62258e6118b1d1604

data/lib/simms_structures/dynamic_array.rb

@@ -0,0 +1,75 @@
+require_relative "static_array"
+
+class DynamicArray
+  attr_reader :length
+
+  def initialize(size = 8)
+    @store = StaticArray.new(size)
+    @length = 0
+    @capacity = size
+  end
+
+  # O(1)
+  def [](index)
+    raise 'index out of bounds' if index >= (@length)
+    @store[index]
+  end
+
+  # O(1)
+  def []=(index, value)
+    @store[index] = value
+  end
+
+  # O(1)
+  def pop
+    raise 'index out of bounds' if @length == 0
+    value = self[@length - 1]
+    @length -= 1
+    value
+  end
+
+  # O(1) ammortized; O(n) worst case. Variable because of the possible
+  # resize.
+  def push(value)
+    resize! if @length == @capacity
+    self[@length] = value
+    @length += 1
+  end
+
+  # O(n): has to shift over all the elements.
+  def shift
+    raise 'index out of bounds' if @length == 0
+    1.upto(@length - 1) do |idx|
+      self[idx - 1] = self[idx]
+    end
+    @length -= 1
+  end
+
+  # O(n): has to shift over all the elements.
+  def unshift(value)
+    resize! if @length == @capacity
+
+    (@length - 1).downto(0) do |idx|
+      self[idx + 1] = self[idx]
+    end if @length > 0
+    self[0] = value
+    @length += 1
+  end
+
+  protected
+  attr_accessor :capacity, :store
+  attr_writer :length
+
+  def check_index(index)
+
+  end
+
+  # O(n): has to copy over all the elements to the new store.
+  def resize!
+    new_capacity = @capacity * 2
+    new_store = StaticArray.new(new_capacity)
+    @length.times { |idx| new_store[idx] = self[idx] }
+    @store = new_store
+    @capacity = new_capacity
+  end
+end

data/lib/simms_structures/hash_map.rb

@@ -0,0 +1,72 @@
+require_relative 'hashing'
+require_relative 'linked_list'
+
+class HashMap
+
+  include Enumerable
+
+  attr_reader :count
+
+  def initialize(num_buckets = 8)
+    @store = Array.new(num_buckets) { LinkedList.new }
+    @count = 0
+  end
+
+  def include?(key)
+    bucket(key).include?(key)
+  end
+
+  def set(key, val)
+    resize! if @count == num_buckets
+    include?(key) ? delete(key) : (@count += 1)
+    bucket(key).insert(key, val)
+  end
+
+  def get(key)
+    bucket(key).get(key)
+  end
+
+  def delete(key)
+    @count-= 1 if bucket(key).remove(key)
+  end
+
+  def each(&block)
+    @store.each do |bucket|
+      bucket.each do |link|
+        block.yield(link.key, link.val)
+      end
+    end
+  end
+
+  def to_s
+    pairs = inject([]) do |strs, (k, v)|
+      strs << "#{k.to_s} => #{v.to_s}"
+    end
+    "{\n" + pairs.join(",\n") + "\n}"
+  end
+
+  alias_method :[], :get
+  alias_method :[]=, :set
+
+  # private
+
+  def num_buckets
+    @store.length
+  end
+
+  def resize!
+    old_store = @store
+    @store = Array.new( num_buckets * 2 ) { LinkedList.new }
+    @count = 0
+
+    old_store.each do |bucket|
+      bucket.each do |link|
+        self[link.key] = link.val
+      end
+    end
+  end
+
+  def bucket(key)
+    @store[key.hash % num_buckets]
+  end
+end

data/lib/simms_structures/hash_set.rb

@@ -0,0 +1,47 @@
+require_relative 'hashing'
+
+class HashSet
+  attr_reader :count
+
+  def initialize(num_buckets = 8)
+    @store = Array.new(num_buckets) { Array.new }
+    @count = 0
+  end
+
+  def insert(key)
+    resize! if @count == num_buckets
+    self[key] << key unless include?(key)
+    @count += 1
+  end
+
+  def include?(key)
+    self[key].include?(key)
+  end
+
+  def remove(key)
+    self[key].delete(key)
+    @count -= 1
+  end
+
+  private
+
+  def [](num)
+    @store[num.hash % num_buckets]
+  end
+
+  def num_buckets
+    @store.length
+  end
+
+  def resize!
+    old_store = @store
+    new_num_buckets = num_buckets * 2
+
+    @store = Array.new(new_num_buckets) { Array.new }
+    @count = 0
+
+    old_store.each do |bucket|
+      bucket.each { |num| insert(num) }
+    end
+  end
+end

data/lib/simms_structures/hashing.rb

@@ -0,0 +1,34 @@
+class Array
+  # this doesn't type check, but needs the array to be only integer values.
+  # XOR and converting to binary produces a unique binary digit, which is then
+  # hashed with Ruby's built in Fixnum#hash
+
+  def hash
+    output = []
+    each_with_index do |el, idx|
+      el = el.hash unless el.is_a?(Numeric)
+      output << (el ^ idx).to_s(2).to_i
+    end
+    output.join.to_i.hash
+  end
+end
+
+class String
+  def hash
+    characters = chars.map { |let| let.ord }
+    characters.hash
+  end
+end
+
+class Hash
+  def hash
+    hashed_array = []
+    each do |key, val|
+      hashed_array << key.hash * val.hash
+    end
+
+    # we need to sort the hashed_array to ensure that the same hash is
+    # generated from two hashes with different order of elements
+    hashed_array.sort.hash
+  end
+end

data/lib/simms_structures/heap.rb

@@ -0,0 +1,80 @@
+class BinaryMinHeap
+  def initialize(&prc)
+    @prc = prc
+    @store = Array.new
+  end
+
+  def count
+    @store.length
+  end
+
+  def peek
+    @store.last
+  end
+
+  def extract
+    last = @store.length - 1
+    @store[0], @store[last] = @store[last], @store[0]
+    output = @store.pop
+    BinaryMinHeap.heapify_down(@store, 0)
+    output
+  end
+
+  def insert(val)
+    @store.push(val)
+    BinaryMinHeap.heapify_up(@store, @store.length - 1)
+  end
+
+  protected
+  attr_accessor :prc, :store
+
+  public
+  def self.child_indices(len, parent_idx)
+    first_child_idx = ( parent_idx * 2 ) + 1
+    second_child_idx = ( parent_idx * 2 ) + 2
+
+    [first_child_idx, second_child_idx].select do |idx|
+      idx < len && idx > -1
+    end
+  end
+
+  def self.parent_index(child_idx)
+    raise 'root has no parent' if child_idx == 0
+    ( child_idx - 1 ) / 2
+  end
+
+  def self.heapify_down(array, parent_idx, len = array.length, &prc)
+    prc ||= Proc.new { |a, b| a <=> b }
+
+    child_idxs = BinaryMinHeap.child_indices(len, parent_idx)
+    if child_idxs.empty?
+      return array
+    elsif child_idxs.count == 1
+      target_child = child_idxs.first
+    else
+      if prc.call(array[child_idxs.first], array[child_idxs.last]) > -1
+        target_child = child_idxs.last
+      else
+        target_child = child_idxs.first
+      end
+    end
+
+    if prc.call(array[parent_idx], array[target_child]) > -1
+      array[parent_idx], array[target_child] = array[target_child], array[parent_idx]
+      BinaryMinHeap.heapify_down(array, target_child, len, &prc)
+    end
+    array
+  end
+
+  def self.heapify_up(array, child_idx, len = array.length, &prc)
+    return if child_idx == 0
+    prc ||= Proc.new { |a, b| a <=> b }
+
+    parent_idx = BinaryMinHeap.parent_index(child_idx)
+    if prc.call(array[parent_idx], array[child_idx]) > -1
+      array[parent_idx], array[child_idx] = array[child_idx], array[parent_idx]
+      BinaryMinHeap.heapify_up(array, parent_idx, len, &prc)
+    end
+    array
+  end
+end

data/lib/simms_structures/heap_sort.rb

@@ -0,0 +1,17 @@
+require_relative 'heap'
+
+class Array
+  def heap_sort!
+
+    0.upto(length - 1) do |idx|
+      BinaryMinHeap.heapify_up(self, idx)
+    end
+
+    (length - 1).downto(1) do |idx|
+      self[0], self[idx] = self[idx], self[0]
+      BinaryMinHeap.heapify_down(self, 0, idx )
+    end
+
+    reverse!
+  end
+end

data/lib/simms_structures/int_set.rb

@@ -0,0 +1,104 @@
+class MaxIntSet
+  def initialize(max)
+    @store = Array.new(max, false)
+  end
+
+  def insert(num)
+    validate!(num)
+    @store[num] = true
+  end
+
+  def remove(num)
+    validate!(num)
+    @store[num] = false
+  end
+
+  def include?(num)
+    validate!(num)
+    @store[num]
+  end
+
+  private
+
+  def is_valid?(num)
+    num <= @store.length && num >= 0
+  end
+
+  def validate!(num)
+    raise "Out of bounds" unless is_valid?(num)
+  end
+end
+
+
+class IntSet
+  def initialize(num_buckets = 20)
+    @num_buckets = num_buckets
+    @store = Array.new(@num_buckets) { Array.new }
+  end
+
+  def insert(num)
+    self[num] << num unless include?(num)
+  end
+
+  def remove(num)
+    self[num].delete(num)
+  end
+
+  def include?(num)
+    self[num].include?(num)
+  end
+
+  private
+
+  def [](num)
+    @store[num % @num_buckets]
+  end
+end
+
+class ResizingIntSet
+  attr_reader :count
+
+  def initialize(num_buckets = 20)
+    @store = Array.new(num_buckets) { Array.new }
+    @count = 0
+  end
+
+  def insert(num)
+    resize! if @count == num_buckets
+    self[num] << num unless include?(num)
+    @count += 1
+  end
+
+  def remove(num)
+    if include?(num)
+      self[num].delete(num)
+      @count -= 1
+    end
+  end
+
+  def include?(num)
+    self[num].include?(num)
+  end
+
+  private
+
+  def [](num)
+    @store[num % num_buckets]
+  end
+
+  def num_buckets
+    @store.length
+  end
+
+  def resize!
+    old_store = @store
+    new_num_buckets = num_buckets * 2
+
+    @store = Array.new(new_num_buckets) { Array.new }
+    @count = 0
+
+    old_store.each do |bucket|
+      bucket.each { |num| insert(num) }
+    end
+  end
+end

data/lib/simms_structures/linked_list.rb

@@ -0,0 +1,92 @@
+class Link
+  attr_accessor :key, :val, :next, :prev
+
+  def initialize(key = nil, val = nil)
+    @key = key
+    @val = val
+    @next = nil
+    @prev = nil
+  end
+
+  def to_s
+    "#{@key}: #{@val}"
+  end
+end
+
+class LinkedList
+  include Enumerable
+
+  def initialize
+    @head = nil
+    @tail = nil
+  end
+
+  def [](i)
+    each { |link, j| return link if i == j }
+    nil
+  end
+
+  def first
+    @head
+  end
+
+  def last
+    @tail
+  end
+
+  def empty?
+    @head == nil
+  end
+
+  def get(key)
+    self[key].val if include?(key)
+  end
+
+  def include?(key)
+    any? {|link| link.key == key}
+  end
+
+  def insert(key, val)
+    link = Link.new(key, val)
+    if empty?
+      @head = link
+    else
+      @tail.next = link
+      link.prev = @tail
+    end
+    @tail = link
+  end
+
+  def remove(key)
+    link = self[key]  #the O(n) step
+
+    return nil unless link
+
+    if link == first
+      link.next.prev = nil
+      @head = link.next
+    elsif link == last
+      link.prev.next = nil
+      @tail = link.prev
+    else
+      link.prev.next = link.next
+      link.next.prev = link.prev
+    end
+  end
+
+  def each(&block)
+    return nil if empty?
+
+    link = first
+    loop do
+      block.yield(link, link.key)
+      link = link.next
+      break unless link
+    end
+
+  end
+
+  def to_s
+    inject([]) { |acc, link| acc << "[#{link.key}, #{link.val}]" }.join(", ")
+  end
+end

data/lib/simms_structures/lru_cache.rb

@@ -0,0 +1,52 @@
+require_relative 'hash_map'
+require_relative 'linked_list'
+
+class LRUCache
+
+  attr_reader :count
+
+  def initialize(max, prc)
+    @map = HashMap.new
+    @store = LinkedList.new
+    @max = max
+    @prc = prc
+  end
+
+  def count
+    @map.count
+  end
+
+  def get(key)
+    link = @map[key]
+    if link
+      update_link!(link)
+      link.val
+    else
+      eject! if @map.count == @max
+      calc!(key).val
+    end
+  end
+
+  def to_s
+    "Map: " + @map.to_s + "\n" + "Store: " + @store.to_s
+  end
+
+  private
+
+  # insert an (un-cached) key
+  def calc!(key)
+    @store.insert(key, @prc.call(key))
+    @map[key] = @store.last
+  end
+
+  # move a link to the end of the list
+  def update_link!(link)
+    @store.insert(link.key, link.val)
+
+  end
+
+  def eject!
+    link = @store.first
+    @store.remove(link)
+  end
+end

data/lib/simms_structures/quick_sort.rb

@@ -0,0 +1,63 @@
+class QuickSort
+  # Quick sort has average time complexity O(nlogn), but worst
+  # case O(n**2).
+
+  # Not in-place. Uses O(n) memory.
+  def self.sort1(array)
+    return array if array.length < 2
+    pivot = array.first
+
+    left = []
+    right = []
+
+    array.drop(1).each do |el|
+      if el < pivot
+        left << el
+      elsif el > pivot
+        right << el
+      end
+    end
+
+    QuickSort.sort1(left) + [pivot] + QuickSort.sort1(right)
+  end
+
+  # In-place.
+  def self.sort2!(array, start = 0, length = array.length, &prc)
+    return array if length < 2
+    prc ||= Proc.new { |a, b| a <=> b }
+
+    pivot_idx = QuickSort.partition(array, start, length, &prc)
+
+    left_length = pivot_idx - start
+    right_length = length - (left_length + 1)
+
+    sort2!(array, start, left_length, &prc)
+    sort2!(array, pivot_idx + 1, right_length, &prc)
+    array
+  end
+
+  def self.partition(array, start, length = array.length, &prc)
+    prc ||= Proc.new { |a, b| a <=> b }
+
+    first_right_idx = nil
+    (start + 1).upto(start + length - 1) do |idx|
+      case prc.call(array[start], array[idx])
+      when -1
+        first_right_idx ||= idx
+      when 1
+        if first_right_idx
+          array[first_right_idx], array[idx] = array[idx], array[first_right_idx]
+          first_right_idx += 1
+        end
+      end
+    end
+
+    # swap pivot with last 'left' element
+    if first_right_idx
+      array[start], array[first_right_idx - 1] = array[first_right_idx - 1], array[start]
+      (first_right_idx - 1)
+    else
+      start
+    end
+  end
+end

data/lib/simms_structures/ring_buffer.rb

@@ -0,0 +1,80 @@
+require_relative 'static_array'
+require_relative 'dynamic_array'
+
+class RingBuffer
+  attr_reader :length
+
+  def initialize(size = 8)
+    @store = StaticArray.new(size)
+    @start_idx = 0
+    @length = 0
+    @capacity = size
+  end
+
+  def relative_index(index)
+    (@start_idx + index) % @capacity
+  end
+
+  # O(1)
+  def [](index)
+    check_index(index)
+    @store[relative_index(index)]
+  end
+
+  # O(1)
+  def []=(index, value)
+    check_index(index)
+    @store[relative_index(index)] = value
+  end
+
+  # O(1)
+  def pop
+    check_index(0)
+    @length -= 1
+    @store[(@start_idx + @length) % @capacity]
+  end
+
+  # O(1) ammortized
+  def push(value)
+    resize! if @length == @capacity
+    @store[(@start_idx + @length) % @capacity] = value
+    @length += 1
+    nil
+    # debugger
+  end
+
+  # O(1)
+  def shift
+    check_index(0)
+    value = self[0]
+    @start_idx = (@start_idx + 1) % @capacity
+    @length -= 1
+    value
+  end
+
+  # O(1) ammortized
+  def unshift(value)
+    resize! if @length == @capacity
+    @start_idx = (@start_idx - 1) % @capacity
+    @store[@start_idx] = value
+    @length += 1
+  end
+
+  protected
+  attr_accessor :capacity, :start_idx, :store
+  attr_writer :length
+
+  def check_index(index)
+    raise 'index out of bounds' if index >= @length
+  end
+
+  def resize!
+    new_capacity = @capacity * 2
+    new_store = StaticArray.new(new_capacity)
+    @length.times { |idx| new_store[idx] = @store[relative_index(idx)]}
+
+    @store = new_store
+    @capacity = new_capacity
+    @start_idx = 0
+  end
+end

data/lib/simms_structures/static_array.rb

@@ -0,0 +1,26 @@
+# This class just dumbs down a regular Array to be staticly sized.
+class StaticArray
+  def initialize(length)
+    @store = Array.new(length, nil)
+  end
+
+  # O(1)
+  def [](index)
+    @store[index]
+  end
+
+  # O(1)
+  def []=(index, value)
+    check_index(index)
+    @store[index] = value
+  end
+
+  private
+
+  def check_index(idx)
+    raise TypeError 'Invalid Position' if 0 > idx || idx > @store.length
+  end
+
+  protected
+  attr_accessor :store
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simms_structures
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Charles Simms
@@ -11,12 +11,24 @@ cert_chain: []
 date: 2016-06-14 00:00:00.000000000 Z
 dependencies: []
 description: Structures and Algorithms implemented for fun
-email: 
+email: cs.simms@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/simms_structures.rb
+- lib/simms_structures/dynamic_array.rb
+- lib/simms_structures/hash_map.rb
+- lib/simms_structures/hash_set.rb
+- lib/simms_structures/hashing.rb
+- lib/simms_structures/heap.rb
+- lib/simms_structures/heap_sort.rb
+- lib/simms_structures/int_set.rb
+- lib/simms_structures/linked_list.rb
+- lib/simms_structures/lru_cache.rb
+- lib/simms_structures/quick_sort.rb
+- lib/simms_structures/ring_buffer.rb
+- lib/simms_structures/static_array.rb
 homepage: http://rubygems.org/gem/simms_structures
 licenses:
 - MIT