Skip to content

Commit

Permalink
feat: Added iterators5.rs exercise.
Browse files Browse the repository at this point in the history
  • Loading branch information
apogeeoak committed Feb 10, 2021
1 parent ab57c26 commit b29ea17
Show file tree
Hide file tree
Showing 2 changed files with 128 additions and 0 deletions.
113 changes: 113 additions & 0 deletions exercises/standard_library_types/iterators5.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,113 @@
// iterators5.rs

// Rustling progress is 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. These counting
// functions use imperative style for loops. Recreate this counting
// functionality using iterators.
// Execute `rustlings hint iterators5` for hints.
//
// Make the code compile and the tests pass.

// I AM NOT DONE

use std::collections::HashMap;

#[derive(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(map: &HashMap<String, Progress>, value: Progress) -> usize {
}

fn count_stack_for(stack: &[HashMap<String, Progress>], value: Progress) -> usize {
let mut count = 0;
for map in stack {
for val in map.values() {
if val == &value {
count += 1;
}
}
}
count
}

fn count_stack(stack: &[HashMap<String, Progress>], value: Progress) -> usize {
}

#[cfg(test)]
mod tests {
use super::*;

#[test]
fn count_complete() {
let map = get_map();
assert_eq!(3, count(&map, Progress::Complete));
}

#[test]
fn count_equals_for() {
let map = get_map();
assert_eq!(
count_for(&map, Progress::Complete),
count(&map, Progress::Complete)
);
}

#[test]
fn count_stack_complete() {
let stack = get_map_stack();
assert_eq!(6, count_stack(&stack, Progress::Complete));
}

#[test]
fn count_stack_equals_for() {
let stack = get_map_stack();
assert_eq!(
count_stack_for(&stack, Progress::Complete),
count_stack(&stack, Progress::Complete)
);
}

fn get_map() -> HashMap<String, Progress> {
use 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_map_stack() -> Vec<HashMap<String, Progress>> {
use 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]
}
}
15 changes: 15 additions & 0 deletions info.toml
Original file line number Diff line number Diff line change
Expand Up @@ -741,6 +741,21 @@ a mutable variable. Or, you might write code utilizing recursion
and a match clause. In Rust you can take another functional
approach, computing the factorial elegantly with ranges and iterators."""

[[exercises]]
name = "iterators5"
path = "exercises/standard_library_types/iterators5.rs"
mode = "test"
hint = """
The documentation for the std::iter::Iterator trait contains numerous methods
that would be helpful here.
Return 0 from count_stack to make the code compile in order to test count.
The stack variable in count_stack is a slice of HashMaps. It needs to be
converted into an iterator in order to use the iterator methods.
The fold method can be useful in the count_stack function."""

# THREADS

[[exercises]]
Expand Down

0 comments on commit b29ea17

Please sign in to comment.