1
0
Fork 0
mirror of https://github.com/notohh/rustlings.git synced 2024-12-20 23:48:09 -05:00
rustlings/solutions/18_iterators/iterators5.rs

169 lines
5.2 KiB
Rust
Raw Normal View History

2024-06-28 10:11:14 -04:00
// Let's define a simple model to track Rustlings' exercise progress. Progress
// will be modelled using a hash map. The name of the exercise is the key and
// the progress is the value. Two counting functions were created to count the
// number of exercises with a given progress. Recreate this counting
// functionality using iterators. Try to not use imperative loops (for/while).
use std::collections::HashMap;
#[derive(Clone, Copy, PartialEq, Eq)]
enum Progress {
None,
Some,
Complete,
}
fn count_for(map: &HashMap<String, Progress>, value: Progress) -> usize {
let mut count = 0;
for val in map.values() {
if *val == value {
count += 1;
}
}
count
}
fn count_iterator(map: &HashMap<String, Progress>, value: Progress) -> usize {
// `map` is a hash map with `String` keys and `Progress` values.
// map = { "variables1": Complete, "from_str": None, … }
map.values().filter(|val| **val == value).count()
}
fn count_collection_for(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
let mut count = 0;
for map in collection {
count += count_for(map, value);
}
count
}
fn count_collection_iterator(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
// `collection` is a slice of hash maps.
// collection = [{ "variables1": Complete, "from_str": None, … },
// { "variables2": Complete, … }, … ]
collection
.iter()
.map(|map| count_iterator(map, value))
.sum()
}
2024-07-05 05:49:56 -04:00
// Equivalent to `count_collection_iterator` and `count_iterator`, iterating as
// if the collection was a single container instead of a container of containers
// (and more accurately, a single iterator instead of an iterator of iterators).
fn count_collection_iterator_flat(
collection: &[HashMap<String, Progress>],
value: Progress,
) -> usize {
// `collection` is a slice of hash maps.
// collection = [{ "variables1": Complete, "from_str": None, … },
// { "variables2": Complete, … }, … ]
collection
.iter()
.flat_map(HashMap::values) // or just `.flatten()` when wanting the default iterator (`HashMap::iter`)
.filter(|val| **val == value)
.count()
}
2024-06-28 10:11:14 -04:00
fn main() {
// You can optionally experiment here.
}
#[cfg(test)]
mod tests {
use super::*;
2024-07-05 05:49:56 -04:00
use Progress::*;
2024-06-28 10:11:14 -04:00
fn get_map() -> HashMap<String, Progress> {
let mut map = HashMap::new();
map.insert(String::from("variables1"), Complete);
map.insert(String::from("functions1"), Complete);
map.insert(String::from("hashmap1"), Complete);
map.insert(String::from("arc1"), Some);
map.insert(String::from("as_ref_mut"), None);
map.insert(String::from("from_str"), None);
map
}
fn get_vec_map() -> Vec<HashMap<String, Progress>> {
let map = get_map();
let mut other = HashMap::new();
other.insert(String::from("variables2"), Complete);
other.insert(String::from("functions2"), Complete);
other.insert(String::from("if1"), Complete);
other.insert(String::from("from_into"), None);
other.insert(String::from("try_from_into"), None);
vec![map, other]
}
#[test]
fn count_complete() {
let map = get_map();
2024-07-05 05:49:56 -04:00
assert_eq!(count_iterator(&map, Complete), 3);
2024-06-28 10:11:14 -04:00
}
#[test]
fn count_some() {
let map = get_map();
2024-07-05 05:49:56 -04:00
assert_eq!(count_iterator(&map, Some), 1);
2024-06-28 10:11:14 -04:00
}
#[test]
fn count_none() {
let map = get_map();
2024-07-05 05:49:56 -04:00
assert_eq!(count_iterator(&map, None), 2);
2024-06-28 10:11:14 -04:00
}
#[test]
fn count_complete_equals_for() {
let map = get_map();
2024-07-05 05:49:56 -04:00
let progress_states = [Complete, Some, None];
2024-06-28 10:11:14 -04:00
for progress_state in progress_states {
assert_eq!(
count_for(&map, progress_state),
count_iterator(&map, progress_state),
);
}
}
#[test]
fn count_collection_complete() {
let collection = get_vec_map();
2024-07-05 05:49:56 -04:00
assert_eq!(count_collection_iterator(&collection, Complete), 6);
assert_eq!(count_collection_iterator_flat(&collection, Complete), 6);
2024-06-28 10:11:14 -04:00
}
#[test]
fn count_collection_some() {
let collection = get_vec_map();
2024-07-05 05:49:56 -04:00
assert_eq!(count_collection_iterator(&collection, Some), 1);
assert_eq!(count_collection_iterator_flat(&collection, Some), 1);
2024-06-28 10:11:14 -04:00
}
#[test]
fn count_collection_none() {
let collection = get_vec_map();
2024-07-05 05:49:56 -04:00
assert_eq!(count_collection_iterator(&collection, None), 4);
assert_eq!(count_collection_iterator_flat(&collection, None), 4);
2024-06-28 10:11:14 -04:00
}
#[test]
fn count_collection_equals_for() {
let collection = get_vec_map();
2024-07-05 05:49:56 -04:00
let progress_states = [Complete, Some, None];
2024-06-28 10:11:14 -04:00
for progress_state in progress_states {
assert_eq!(
count_collection_for(&collection, progress_state),
count_collection_iterator(&collection, progress_state),
);
assert_eq!(
count_collection_for(&collection, progress_state),
count_collection_iterator_flat(&collection, progress_state),
);
2024-06-28 10:11:14 -04:00
}
}
}