Exercise: Counter

In this exercise you will take a very simple data structure and make it generic. It uses a std::collections::HashMap to keep track of which values have been seen and how many times each one has appeared.

The initial version of Counter is hard coded to only work for u32 values. Make the struct and its methods generic over the type of value being tracked, that way Counter can track any type of value.

If you finish early, try using the entry method to halve the number of hash lookups required to implement the count method.

  1. use std::collections::HashMap;
  3. /// Counter counts the number of times each value of type T has been seen.
  4. struct Counter {
  5.     values: HashMap<u32, u64>,
  6. }
  8. impl Counter {
  9.     /// Create a new Counter.
  10.     fn new() -> Self {
  11.         Counter {
  12.             values: HashMap::new(),
  13.         }
  14.     }
  16.     /// Count an occurrence of the given value.
  17.     fn count(&mut self, value: u32) {
  18.         if self.values.contains_key(&value) {
  19.             *self.values.get_mut(&value).unwrap() += 1;
  20.         } else {
  21.             self.values.insert(value, 1);
  22.         }
  23.     }
  25.     /// Return the number of times the given value has been seen.
  26.     fn times_seen(&self, value: u32) -> u64 {
  27.         self.values.get(&value).copied().unwrap_or_default()
  28.     }
  29. }
  31. fn main() {
  32.     let mut ctr = Counter::new();
  33.     ctr.count(13);
  34.     ctr.count(14);
  35.     ctr.count(16);
  36.     ctr.count(14);
  37.     ctr.count(14);
  38.     ctr.count(11);
  40.     for i in 10..20 {
  41.         println!("saw {} values equal to {}", ctr.times_seen(i), i);
  42.     }
  44.     let mut strctr = Counter::new();
  45.     strctr.count("apple");
  46.     strctr.count("orange");
  47.     strctr.count("apple");
  48.     println!("got {} apples", strctr.times_seen("apple"));
  49. }