data_structures_101 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d0d92b27cd70fa2884b0dd6079a3a88581438604
-  data.tar.gz: 174e6747d82bde23b1951693a9d4e66d7e677293
+  metadata.gz: f215d1362121ff577224993028a8870cd3fd1b82
+  data.tar.gz: 9785b4159ec72926f1fb81c5baeda8281d2840cb
 SHA512:
-  metadata.gz: 34d2614a243cd65c97215ed7013b22db6b37b88f75203bbaeaf3ac4401bc109d9a92282f6bae1beda5114586fb6d8ee58cedecd537c9f04342cd1d3b35980c53
-  data.tar.gz: bff1fb5af12eb3441061517b34a102213a273beb4ba727d54170413d0359d895ebdc8db17ff950e9326d00bf6f2f9760ec6cba98b2e5e965c039a6ea6ba9f67c
+  metadata.gz: 005a8f910dad00e6db443761b725eac89b384e1f6f79a0deb94d526c511d791b1b110d111159c80d202d142f3b0d2cb11aac984e925e468e25158fd3416f89e3
+  data.tar.gz: f477fe15da1f404dc753690b7d0ae27861f9785d81bcf6725ce2d8f862a8ad491075871e2883ac122d0a6f29edbe35ce35477975c1657afe39995b4df952b5b2

data/.travis.yml

@@ -1,6 +1,14 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.4.0
-before_install: gem install bundler -v 1.14.6
+- 2.4.0
 script: bundle exec rspec
+deploy:
+  provider: rubygems
+  api_key:
+    secure: YDkCNjnzyBTEcZLjKqt6ep1rIHYGF6tbqwNVUXEOFiBpQA534xl8AcsNIcb4MZGcNzn9ZeJiHstIeHKKP135sLKnA00RptoVtNAHn9F5hBgDyPc5GyIEzml4wDv7NM+jcM4df39CEBIyYi+77vRUvUfrOJ+0RF7CxvlGX4ZUvbI+5edFXjt9ioVPOhG+V6FyTbGlNEG2Rj4lx6jjUF3HYVVhwHCva3F4uXNh/3CjZXvcJ6ZahKCiO0/pqxZsS6L/xfDaih/jg/8B3nQ2L7Lx+g5A8uNLCZ4u2G4SPoCg0a+mrttJAkIgTNC8reVBAbS9V7BV6/OJcJwwhJKNQ+UsleTv0oDdOWsSFgL8I2qtUJb7r1cpmFHi/LC5fnfpfC6xcoRk7sxrFboYsbm8yGt2KEk68Jregl9j0EqrHynog/9zFKx9Sfcrw2Fo+6oMACDYm3NzlcAo+6bQHni/kV94oaD58nZ3OQgvBMh4jeZ854jjCbpJaCMs2u2CgezjlTZCY7+E38t+/tiFlAOakVBSC9oGEYCFxh5X/clKXi7Q2PZj8j/pmcc51wmVFEMB5Led7kj1R1YWCnalhIZO4hpz83yBGCYZQgm2AZy0r8k741L9ab0H/KhMSJHGN2ym2Dgdpg1a0QdlMGVidIQGNjeSEx7TPkkDStuM588qKcR8C6M=
+  gem: data_structures_101
+  on:
+    tags: true
+    repo: renehernandez/data_structures_101
+    branch: master

data/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-slate

data/lib/data_structures_101.rb

@@ -1,5 +1,9 @@
 require "data_structures_101/version"
 require "data_structures_101/linked_list"
+require "data_structures_101/hash/base_hash_table"
+require "data_structures_101/hash/bucket"
+require "data_structures_101/chained_hash_table"
+require "data_structures_101/probe_hash_table"
 
 module DataStructures101
   # Your code goes here...

data/lib/data_structures_101/chained_hash_table.rb

@@ -0,0 +1,40 @@
+module DataStructures101
+
+    class ChainedHashTable < Hash::BaseHashTable
+
+        def initialize(capacity = 31, prime = 109345121, hash_lambda = nil)
+            super
+        end
+
+        private
+
+        def bucket_find(hash_code, key)
+            bucket = @table[hash_code]
+            return nil if bucket.nil?
+            
+            bucket.find(key)
+        end
+
+        def bucket_insert(hash_code, key, value)
+            bucket = @table[hash_code]
+            bucket = @table[hash_code] = Hash::Bucket.new if bucket.nil?
+
+            old_size = bucket.size()
+            old_value = bucket.insert(key, value)
+            @size += (bucket.size - old_size)
+
+            old_value
+        end
+
+        def bucket_delete(hash_code, key)
+            bucket = @table[hash_code]
+            return nil if bucket.nil?
+
+            old_size = bucket.size
+            value = bucket.delete(key)
+            @size -= (old_size - bucket.size)
+
+            value
+        end
+    end
+end

data/lib/data_structures_101/hash/base_hash_table.rb

@@ -0,0 +1,62 @@
+module DataStructures101  
+    module Hash
+        class BaseHashTable
+
+            attr_reader :size, :hash_lambda
+
+            def initialize(capacity, prime, hash_lambda = nil) 
+                @capacity = capacity
+                @size = 0
+                @table = Array.new(@capacity)
+                
+                random = Random.new
+                scale = random.rand(prime - 1) + 1
+                shift = random.rand(prime)
+                
+                @hash_lambda =   if hash_lambda.nil?                                   
+                                    ->(key) { return (((key.hash * scale + shift) % prime) % @capacity).abs }
+                                else
+                                    hash_lambda
+                                end
+            end
+
+            def []=(key, value)
+                insert(key, value)
+            end     
+
+            def insert(key, value)
+                old_value = bucket_insert(hash_lambda.call(key), key, value)
+
+                # keep load factor <= 0.5
+                resize(new_capacity) if @size > @capacity / 2
+
+                old_value
+            end
+            
+            def [](key)
+                bucket_find(hash_lambda.call(key), key)
+            end
+
+            def delete(key)
+                bucket_delete(hash_lambda.call(key), key)
+            end
+
+            private
+
+            def new_capacity()
+                2 * capacity - 1
+            end
+
+            def resize(new_capacity)
+                @capacity = new_capacity
+
+                buffer = self.map { |key, value| [key, value] }
+
+                create_table
+                @size = 0
+
+                buffer.each { |key, value| self[key] = value }
+            end
+        end
+    end
+end

data/lib/data_structures_101/hash/bucket.rb

@@ -0,0 +1,52 @@
+module DataStructures101
+    module Hash
+        class Bucket
+
+            attr_reader :table
+
+            def initialize()
+                @table = []
+            end
+
+            def [](key)
+                find(key)
+            end
+
+            def []=(key, value)
+                insert(key, value)
+            end
+
+            def insert(key, value)
+                idx = @table.find_index {|_key, _| _key == key} 
+
+                if idx.nil?
+                    @table << [key, value]
+                    return nil
+                else
+                    value, @table[idx][1] = @table[idx][1], value
+                    return value
+                end
+            end
+
+            def size()
+                @table.size
+            end
+
+            def find(key)
+                pair = @table.find {|_key, _| _key == key}
+                pair.nil? ? nil : pair.last
+            end
+
+            def delete(key) 
+                idx = @table.find_index {|_key, _| _key == key}
+                return nil if idx.nil?
+
+                value = @table[idx].last
+                @table[idx] = @table.last if idx != @table.size - 1
+                @table.pop
+                value
+            end
+
+        end
+    end
+end

data/lib/data_structures_101/linked_list.rb

@@ -69,36 +69,20 @@ module DataStructures101
       self
     end
 
-    def first(*args)
-      if args.size == 0
-        return @head.next.value
-      end
+    def first(n = nil)
+      return @head.next.value if n.nil?
 
-      if args.size > 1
-        raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 1)"
-      end
+      raise ArgumentError, "negative array size" if n < 0
 
-      if args.first < 0
-        raise ArgumentError, "negative array size"
-      end
-
-      return new_list_from_range(0, args.first - 1)
+      return new_list_from_range(0, n - 1)
     end
 
-    def last(*args)
-      if args.size == 0
-        return @tail.prev.value
-      end
-
-      if args.size > 1
-        raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 1)"
-      end
-
-      if args.first < 0
-        raise ArgumentError, "negative array size"
-      end
+    def last(n = nil)
+      return @tail.prev.value if n.nil?
+    
+      raise ArgumentError, "negative array size" if n < 0
 
-      return new_list_from_range(size - args.first, size - 1)
+      return new_list_from_range(size - n, size - 1)
     end
 
     def push(*values)

data/lib/data_structures_101/probe_hash_table.rb

@@ -0,0 +1,79 @@
+require 'singleton'
+
+module DataStructures101
+    class ProbeHashTable < Hash::BaseHashTable
+
+        attr_reader :probe_lambda
+
+        def initialize(capacity = 31, prime = 109345121, 
+                        hash_lambda = nil, probe_lambda = nil)
+            super(capacity, prime, hash_lambda)
+
+            @probe_lambda = if probe_lambda.nil?
+                                ->(h, i) { return (h + i) % @capacity }
+                            else
+                                probe_lambda
+                            end
+        end
+
+        private
+
+        Sentinel = Class.new do 
+            include Singleton
+        end
+
+        def bucket_find(hash_code, key)
+            idx = find_slot(hash_code, key)
+            
+            slot_available?(idx) ? nil : @table[idx].last
+        end
+
+        def bucket_insert(hash_code, key, value)
+            idx = find_slot(hash_code, key)
+
+            if !slot_available?(idx)
+                old_value = @table[idx].last
+                @table[idx] = [key, value]
+                return old_value
+            end
+            
+            @table[idx] = [key, value]
+            @size += 1
+
+            nil
+        end
+        
+        def bucket_delete(hash_code, key)
+            idx = find_slot(hash_code, key)
+            return nil if slot_available?(idx)
+
+            value = @table[idx].last
+            @table[idx] = Sentinel.instance
+            @size -= 1
+
+            value
+        end
+
+        def find_slot(h, key)
+            idx = -1
+
+            j = 0
+            loop do
+                i = @probe_lambda.call(h, j)
+                if slot_available?(i)
+                    idx = i if idx == -1
+                    break if @table[i].nil?
+                elsif @table[i].first == key
+                    return i
+                end
+                j += 1
+            end
+
+            idx
+        end
+
+        def slot_available?(i)
+            @table[i].nil? || @table[i] == Sentinel.instance
+        end
+    end
+end

data/lib/data_structures_101/version.rb

@@ -1,3 +1,3 @@
 module DataStructures101
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: data_structures_101
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - aegis
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-11 00:00:00.000000000 Z
+date: 2017-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,11 +66,16 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- _config.yml
 - bin/console
 - bin/setup
 - data_structures_101.gemspec
 - lib/data_structures_101.rb
+- lib/data_structures_101/chained_hash_table.rb
+- lib/data_structures_101/hash/base_hash_table.rb
+- lib/data_structures_101/hash/bucket.rb
 - lib/data_structures_101/linked_list.rb
+- lib/data_structures_101/probe_hash_table.rb
 - lib/data_structures_101/version.rb
 homepage: https://github.com/renehernandez/bok-data_structures_101
 licenses:
@@ -92,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: DataStructures101 is a simple gem that groups several implementations of