In this project, we'll write a program that reads a block of text and tells us how many times each word appears.

Create a Histogram

Almost there! Finally, we'll need to iterate over the array to print out each key-value pair to the console.

```rb
fruit = {
  "apple" => 2,
  "banana" => 3,
  "cherry" => 5
}

fruit.each do |name, count|
  puts name + " " + count.to_s
end
```

1. In the example above, we create a hash called `fruit` that maps names of fruit to the amount that we own.
2. Then, we iterate over `.each` key/value pair, storing the key as `name` and the value as `count`.
3. Finally, we print out the key and value separated by a space. Note that we must first convert the value from a number to a string using `.to_s` before we can concatenate it.

Iterating Over the Hash

You know by now how we'll start: we need to get input from the user.

You Know the Drill

Next, we'll want to turn the user's string into something we can iterate over. A data structure made up of elements all in a line, you say? That sounds like an array!

By calling the `.split` method on `text`, we can transform it into an array.

Building the Words Array

Nice work! Your program is complete—run it a few times to see how it counts up the number of occurrences of each word in your string.

You Did It!

Perfect! Next up: we want to iterate over `words` to add each word to our `frequencies` hash, one at a time.

```rb
colors = { "red" => 2, "blue" => 3 }
colors["blue"] += 1
puts colors["blue"]
```

1. In the above example, we first create a hash mapping strings to integers.
2. Then, we increment the value stored by `"blue"` by `1`.
3. Finally, we print out `4`, the value stored by `"blue"`.

Iterating Over the Array

Great! We have a hash full of word / frequency key-value pairs. Now we need to figure out a way to get our information in the order we want it.

```rb
colors = { 
  "blue" => 3,
  "green" => 1,
  "red" => 2
}
colors = colors.sort_by do |color, count|
  count
end
colors.reverse!
```

1. In the example above, we first create a hash called `colors` that maps color strings to numbers.
2. Then, we sort `colors` into green, red, and blue, from smallest to largest by count. Just so you know, the `.sort_by` function returns an array of arrays, but that's fine for our purposes.
3. Finally, we reverse the array order so that the colors with the largest counts are first.

Can you do the same thing with the `frequencies` hash?

Sorting the Hash

Good! Now we'll start counting words using a hash.

We'll want to make sure the hash has a *default value*.

```rb
h = Hash.new("nothing here")

puts h
# {}

puts h["kitty"]
# nothing here
```

1. In the example above, we create a new, empty hash `h` that has a *default value* of `"nothing here"`.
2. Then we print out `{}`, the value of `h`, just to show that `h` really is empty.
3. Then we print out `nothing here` as we try to access the value stored by the key `"kitty"`.

If you have a hash with a default value, and you try to access a non-existent key, you get that default value.

Creating the Frequencies Hash

In this project, we'll write a program that takes a user's input, then builds a hash from that input. Each key in the hash will be a word from the user; each value will be the number of times that word occurs. For example, if our program gets the string "the rain in Spain falls mainly on the plain," it will return

```
the 2
falls 1
on 1
mainly 1
in 1
rain 1
plain 1
Spain 1
```

A visual representation of data like this is called a *histogram*.