Add concept and exercise

Author: meatball133

concepts/hashes/.meta/config.json

@@ -0,0 +1,5 @@
+{
+  "blurb": "Hashes are collections of key-value pairs, where each unique key maps to a specific value. They are useful for storing and retrieving data based on keys rather than numerical indices.",
+  "authors": ["meatball133"],
+  "contributors": []
+}

concepts/hashes/about.md

@@ -1,17 +1,200 @@
 # About
 
+[Hashes][hash] or also known as dictionary or map in other languages, is a mutable unsorted collection which maps keys to values.
+Each key is unique and is used to retrieve the corresponding value.
+The keys can be of any data type, including strings, numbers, or even other objects.
+
+Even though hashes are unordered collections, Ruby maintains the insertion order of key-value pairs.
+This means that when you iterate over a hash, the pairs will be returned in the order they were added.
+However, deleting elements may affect the order of remaining elements.
+
 ## Creating hashes
 
+You can create a hash using curly braces `{}` with key-value pairs formed as `key => value` and separated by commas:
+
+```ruby
+my_hash = { "name" => "Alice", "age" => 30, "city" => "New York" }
+```
+
+You can also mix and match different types of keys and values:
+
+```ruby
+my_hash = { 1 => "one", :two => 2, "three" => [3, "three"] }
+```
+
+Alternatively if the keys are symbols, you can use a more JSON-style syntax:
+
+```ruby
+my_hash = { name: "Alice", age: 30, city: "New York" }
+```
+
+You can create an empty hash using the `Hash.new` method:
+
+```ruby
+empty_hash = Hash.new
+```
+
+## Accessing values
+
+You can access values in a hash using their corresponding keys, the syntax reminds of array indexing, but using the key instead of an index:
 
+```ruby
+my_hash = { "name" => "Alice", "age" => 30, "city" => "New York" }
+my_hash["name"]
+# => "Alice"
+```
 
-## Indexing
+If the key does not exist in the hash, it will return `nil`:
+
+```ruby
+my_hash = { "name" => "Alice", "age" => 30 }
+my_hash["city"]
+# => nil
+```
+
+If the disired behavior is to not return `nil` for non-existing keys, another way of accessing values is by using the [`fetch`][fetch] method, which allows you to provide a default value if the key does not exist.
+If the fetch method is used without a default value and the key does not exist, it will raise a `KeyError` exception.
+
+```ruby
+my_hash = { "name" => "Alice", "age" => 30 }
+my_hash.fetch("city", "Unknown")
+# => "Unknown"
+
+my_hash.fetch("city")
+# => KeyError: key not found: "city"
+```
 
 ## Modifying
 
+You can add or update key-value pairs in a hash by assigning a value to a key using the assignment operator `=`.
+Assigning a value to an existing key will update the value, while assigning a value to a new key will add a new key-value pair:
+
+```ruby
+my_hash = { "name" => "Alice", "age" => 30 }
+my_hash["city"] = "New York"
+my_hash["age"] = 31          
+
+my_hash
+# => { "name" => "Alice", "age" => 31, "city" => "New York" }
+```
+
+## Default values
+
+When fetching a value for a key that does not exist in the hash, Ruby returns `nil` by default.
+
+```ruby
+my_hash = { "name" => "Alice" }
+my_hash["age"]
+# => nil
+```
+
+This might not always be desirable, so you can set a default value for the hash using `Hash.new(default_value)`.
+See that the default value is returned only for keys that do not exist in the hash.
+
+```ruby
+my_hash = Hash.new("unknown")
+my_hash["name"] = "Alice"
+my_hash["age"]
+# => "unknown"
+
+my_hash["name"]
+# => "Alice"
+```
+
+~~~~exercism/caution
+Be cautious when using mutable objects (like arrays or other hashes) as default values, as they can lead to unexpected behavior.
+~~~~
+
+## Deleting key-value pairs
+
+You can delete a key-value pair from a hash using the [`delete`][delete] method, which takes the key as an argument:
+
+```ruby
+my_hash = { "name" => "Alice", "age" => 30, "city" => "New York" }
+my_hash.delete("age")
+my_hash
+# => { "name" => "Alice", "city" => "New York" }
+```
+
 ## Methods
 
-has_value?
-include?
+There are several useful methods available for hashes in Ruby.
+Here are some commonly used ones:
+
+### `has_value?` and `include?`
+
+You can check if a hash contains a specific value using the [`has_value?`][has_value?] method.
+
+```ruby
+my_hash = { "name" => "Alice", "age" => 30 }
+my_hash.has_value?(30)
+# => true
+my_hash.has_value?(25)
+# => false
+```
+
+You can check if a hash contains a specific key using the [`include?`][include?] method.
+
+```ruby
+my_hash = { "name" => "Alice", "age" => 30 }
+my_hash.include?("name")
+# => true
+my_hash.include?("city")
+# => false
+```
+
+### `keys` and `values`
+
+You can retrieve all the keys of a hash using the [`keys`][keys] method, which returns an array of keys.
+
+```ruby
+my_hash = { "name" => "Alice", "age" => 30 }
+my_hash.keys
+# => ["name", "age"]
+```
+
+You can retrieve all the values of a hash using the [`values`][values] method, which returns an array of values.
+
+```ruby
+my_hash = { "name" => "Alice", "age" => 30 }
+my_hash.values
+# => ["Alice", 30]
+```
+
+## Iterating over hashes
+
+You can iterate over the key-value pairs in a hash using the `each_pair` method.
+This will give you access to both the key and the value for each pair:
+
+```ruby
+my_hash = { "name" => "Alice", "age" => 30 }
+my_hash.each_pair do |key, value|
+  puts "#{key}: #{value}"
+end
+# Output:
+# name: Alice
+# age: 30
+```
+
+You can also iterate over just the keys or just the values using the [`each_key`][each_key] and [`each_value`][each_value] methods, respectively:
+
+```ruby
+my_hash = { "name" => "Alice", "age" => 30 }
+my_hash.each_key do |key|
+  puts key
+end
+# Output:
+# name
+# age
+```
 
-keys
-values
+[each_pair]: https://docs.ruby-lang.org/en/4.0/Hash.html#method-i-each_pair
+[each_key]: https://docs.ruby-lang.org/en/4.0/Hash.html#method-i-each_key
+[keys]: https://docs.ruby-lang.org/en/4.0/Hash.html#method-i-keys
+[each_value]: https://docs.ruby-lang.org/en/4.0/Hash.html#method-i-each_value
+[values]: https://docs.ruby-lang.org/en/4.0/Hash.html#method-i-values
+[has_value?]: https://docs.ruby-lang.org/en/4.0/Hash.html#method-i-has_value-3F
+[include?]: https://docs.ruby-lang.org/en/4.0/Hash.html#method-i-include-3F
+[hash]: https://docs.ruby-lang.org/en/4.0/Hash.html
+[fetch]: https://docs.ruby-lang.org/en/4.0/Hash.html#method-i-fetch
+[delete]: https://docs.ruby-lang.org/en/4.0/Hash.html#method-i-delete