summaryrefslogtreecommitdiff
path: root/solutions/18_iterators
diff options
context:
space:
mode:
Diffstat (limited to 'solutions/18_iterators')
-rw-r--r--solutions/18_iterators/iterators1.rs26
-rw-r--r--solutions/18_iterators/iterators2.rs56
-rw-r--r--solutions/18_iterators/iterators3.rs73
-rw-r--r--solutions/18_iterators/iterators4.rs71
-rw-r--r--solutions/18_iterators/iterators5.rs183
5 files changed, 409 insertions, 0 deletions
diff --git a/solutions/18_iterators/iterators1.rs b/solutions/18_iterators/iterators1.rs
new file mode 100644
index 0000000..93a6008
--- /dev/null
+++ b/solutions/18_iterators/iterators1.rs
@@ -0,0 +1,26 @@
+// When performing operations on elements within a collection, iterators are
+// essential. This module helps you get familiar with the structure of using an
+// iterator and how to go through elements within an iterable collection.
+
+fn main() {
+ // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+ #[test]
+ fn iterators() {
+ let my_fav_fruits = ["banana", "custard apple", "avocado", "peach", "raspberry"];
+
+ // Create an iterator over the array.
+ let mut fav_fruits_iterator = my_fav_fruits.iter();
+
+ assert_eq!(fav_fruits_iterator.next(), Some(&"banana"));
+ assert_eq!(fav_fruits_iterator.next(), Some(&"custard apple"));
+ assert_eq!(fav_fruits_iterator.next(), Some(&"avocado"));
+ assert_eq!(fav_fruits_iterator.next(), Some(&"peach"));
+ assert_eq!(fav_fruits_iterator.next(), Some(&"raspberry"));
+ assert_eq!(fav_fruits_iterator.next(), None);
+ // ^^^^ reached the end
+ }
+}
diff --git a/solutions/18_iterators/iterators2.rs b/solutions/18_iterators/iterators2.rs
new file mode 100644
index 0000000..db05f29
--- /dev/null
+++ b/solutions/18_iterators/iterators2.rs
@@ -0,0 +1,56 @@
+// In this exercise, you'll learn some of the unique advantages that iterators
+// can offer.
+
+// "hello" -> "Hello"
+fn capitalize_first(input: &str) -> String {
+ let mut chars = input.chars();
+ match chars.next() {
+ None => String::new(),
+ Some(first) => first.to_uppercase().to_string() + chars.as_str(),
+ }
+}
+
+// Apply the `capitalize_first` function to a slice of string slices.
+// Return a vector of strings.
+// ["hello", "world"] -> ["Hello", "World"]
+fn capitalize_words_vector(words: &[&str]) -> Vec<String> {
+ words.iter().map(|word| capitalize_first(word)).collect()
+}
+
+// Apply the `capitalize_first` function again to a slice of string
+// slices. Return a single string.
+// ["hello", " ", "world"] -> "Hello World"
+fn capitalize_words_string(words: &[&str]) -> String {
+ words.iter().map(|word| capitalize_first(word)).collect()
+}
+
+fn main() {
+ // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_success() {
+ assert_eq!(capitalize_first("hello"), "Hello");
+ }
+
+ #[test]
+ fn test_empty() {
+ assert_eq!(capitalize_first(""), "");
+ }
+
+ #[test]
+ fn test_iterate_string_vec() {
+ let words = vec!["hello", "world"];
+ assert_eq!(capitalize_words_vector(&words), ["Hello", "World"]);
+ }
+
+ #[test]
+ fn test_iterate_into_string() {
+ let words = vec!["hello", " ", "world"];
+ assert_eq!(capitalize_words_string(&words), "Hello World");
+ }
+}
diff --git a/solutions/18_iterators/iterators3.rs b/solutions/18_iterators/iterators3.rs
new file mode 100644
index 0000000..d66d1ef
--- /dev/null
+++ b/solutions/18_iterators/iterators3.rs
@@ -0,0 +1,73 @@
+#[derive(Debug, PartialEq, Eq)]
+enum DivisionError {
+ DivideByZero,
+ NotDivisible,
+}
+
+fn divide(a: i64, b: i64) -> Result<i64, DivisionError> {
+ if b == 0 {
+ return Err(DivisionError::DivideByZero);
+ }
+
+ if a % b != 0 {
+ return Err(DivisionError::NotDivisible);
+ }
+
+ Ok(a / b)
+}
+
+fn result_with_list() -> Result<Vec<i64>, DivisionError> {
+ // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ let numbers = [27, 297, 38502, 81];
+ let division_results = numbers.into_iter().map(|n| divide(n, 27));
+ // Collects to the expected return type. Returns the first error in the
+ // division results (if one exists).
+ division_results.collect()
+}
+
+fn list_of_results() -> Vec<Result<i64, DivisionError>> {
+ // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ let numbers = [27, 297, 38502, 81];
+ let division_results = numbers.into_iter().map(|n| divide(n, 27));
+ // Collects to the expected return type.
+ division_results.collect()
+}
+
+fn main() {
+ // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_success() {
+ assert_eq!(divide(81, 9), Ok(9));
+ }
+
+ #[test]
+ fn test_divide_by_0() {
+ assert_eq!(divide(81, 0), Err(DivisionError::DivideByZero));
+ }
+
+ #[test]
+ fn test_not_divisible() {
+ assert_eq!(divide(81, 6), Err(DivisionError::NotDivisible));
+ }
+
+ #[test]
+ fn test_divide_0_by_something() {
+ assert_eq!(divide(0, 81), Ok(0));
+ }
+
+ #[test]
+ fn test_result_with_list() {
+ assert_eq!(result_with_list().unwrap(), [1, 11, 1426, 3]);
+ }
+
+ #[test]
+ fn test_list_of_results() {
+ assert_eq!(list_of_results(), [Ok(1), Ok(11), Ok(1426), Ok(3)]);
+ }
+}
diff --git a/solutions/18_iterators/iterators4.rs b/solutions/18_iterators/iterators4.rs
new file mode 100644
index 0000000..4c3c49d
--- /dev/null
+++ b/solutions/18_iterators/iterators4.rs
@@ -0,0 +1,71 @@
+// 3 possible solutions are presented.
+
+// With `for` loop and a mutable variable.
+fn factorial_for(num: u64) -> u64 {
+ let mut result = 1;
+
+ for x in 2..=num {
+ result *= x;
+ }
+
+ result
+}
+
+// Equivalent to `factorial_for` but shorter and without a `for` loop and
+// mutable variables.
+fn factorial_fold(num: u64) -> u64 {
+ // Case num==0: The iterator 2..=0 is empty
+ // -> The initial value of `fold` is returned which is 1.
+ // Case num==1: The iterator 2..=1 is also empty
+ // -> The initial value 1 is returned.
+ // Case num==2: The iterator 2..=2 contains one element
+ // -> The initial value 1 is multiplied by 2 and the result
+ // is returned.
+ // Case num==3: The iterator 2..=3 contains 2 elements
+ // -> 1 * 2 is calculated, then the result 2 is multiplied by
+ // the second element 3 so the result 6 is returned.
+ // And so on…
+ (2..=num).fold(1, |acc, x| acc * x)
+}
+
+// Equivalent to `factorial_fold` but with a built-in method that is suggested
+// by Clippy.
+fn factorial_product(num: u64) -> u64 {
+ (2..=num).product()
+}
+
+fn main() {
+ // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn factorial_of_0() {
+ assert_eq!(factorial_for(0), 1);
+ assert_eq!(factorial_fold(0), 1);
+ assert_eq!(factorial_product(0), 1);
+ }
+
+ #[test]
+ fn factorial_of_1() {
+ assert_eq!(factorial_for(1), 1);
+ assert_eq!(factorial_fold(1), 1);
+ assert_eq!(factorial_product(1), 1);
+ }
+ #[test]
+ fn factorial_of_2() {
+ assert_eq!(factorial_for(2), 2);
+ assert_eq!(factorial_fold(2), 2);
+ assert_eq!(factorial_product(2), 2);
+ }
+
+ #[test]
+ fn factorial_of_4() {
+ assert_eq!(factorial_for(4), 24);
+ assert_eq!(factorial_fold(4), 24);
+ assert_eq!(factorial_product(4), 24);
+ }
+}
diff --git a/solutions/18_iterators/iterators5.rs b/solutions/18_iterators/iterators5.rs
new file mode 100644
index 0000000..85d9a4f
--- /dev/null
+++ b/solutions/18_iterators/iterators5.rs
@@ -0,0 +1,183 @@
+// 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()
+}
+
+// Equivalent to `count_collection_iterator`+`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()
+}
+
+fn main() {
+ // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ 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_vec_map() -> 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]
+ }
+
+ #[test]
+ fn count_complete() {
+ let map = get_map();
+ assert_eq!(count_iterator(&map, Progress::Complete), 3);
+ }
+
+ #[test]
+ fn count_some() {
+ let map = get_map();
+ assert_eq!(count_iterator(&map, Progress::Some), 1);
+ }
+
+ #[test]
+ fn count_none() {
+ let map = get_map();
+ assert_eq!(count_iterator(&map, Progress::None), 2);
+ }
+
+ #[test]
+ fn count_complete_equals_for() {
+ let map = get_map();
+ let progress_states = [Progress::Complete, Progress::Some, Progress::None];
+ 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();
+ assert_eq!(
+ count_collection_iterator(&collection, Progress::Complete),
+ 6,
+ );
+ assert_eq!(
+ count_collection_iterator_flat(&collection, Progress::Complete),
+ 6,
+ );
+ }
+
+ #[test]
+ fn count_collection_some() {
+ let collection = get_vec_map();
+ assert_eq!(count_collection_iterator(&collection, Progress::Some), 1);
+ assert_eq!(
+ count_collection_iterator_flat(&collection, Progress::Some),
+ 1
+ );
+ }
+
+ #[test]
+ fn count_collection_none() {
+ let collection = get_vec_map();
+ assert_eq!(count_collection_iterator(&collection, Progress::None), 4);
+ assert_eq!(
+ count_collection_iterator_flat(&collection, Progress::None),
+ 4
+ );
+ }
+
+ #[test]
+ fn count_collection_equals_for() {
+ let collection = get_vec_map();
+ let progress_states = [Progress::Complete, Progress::Some, Progress::None];
+
+ 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),
+ );
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.46.0) at 2026-04-07 08:53:43 +0000