sieve: add approaches (#1631)

Add approaches for the `sieve` exercise

Author: bobahop

exercises/practice/sieve/.approaches/config.json

@@ -0,0 +1,22 @@
+{
+  "introduction": {
+    "authors": ["bobahop"],
+    "contributors": []
+  },
+  "approaches": [
+    {
+      "uuid": "32faf3d8-5035-4242-992b-be92a248184b",
+      "slug": "ranges-and-filtermap",
+      "title": "ranges and filter_map",
+      "blurb": "Use two ranges and filter_map to iterate to the result.",
+      "authors": ["bobahop"]
+    },
+    {
+      "uuid": "d3deae2e-fa6c-42d9-9e94-6af5de090090",
+      "slug": "for-in-ranges-with-filter",
+      "title": "for in ranges  with filter",
+      "blurb": "Use two for in ranges with filter to iterate to the result.",
+      "authors": ["bobahop"]
+    }
+  ]
+}

exercises/practice/sieve/.approaches/for-in-ranges-with-filter/content.md

@@ -0,0 +1,54 @@
+# `for` in ranges with `filter()`
+
+```rust
+pub fn primes_up_to(upper_bound: u64) -> Vec<u64> {
+    let mut work: Vec<u64> = (0..=upper_bound).collect();
+    work[1] = 0;
+    let stop = (upper_bound as f64).sqrt() as usize + 1usize;
+    let upper_bound = upper_bound as usize;
+    for i in 2..stop {
+        if (work[i]) != 0 {
+            for idx in (i * i..=upper_bound).step_by(i) {
+                work[idx] = 0;
+            }
+        }
+    }
+    work.iter().filter(|num| *num != &0u64).copied().collect()
+}
+```
+
+This approach starts by defining a `Vec` of values from `0` through the upper bound.
+Since numbers below `2` are not valid primes, the element at index `1` is set to `0`.
+
+Since squares of numbers are processed, the [`sqrt()`][sqrt] method is used to determine when iterating the `Vec` indexes will stop.
+
+To minimize type conversions, the upper bound is redefined as a [`usize`][usize].
+
+A [`for` in range][for-in-range] is defined from `2` up to but not including the `stop` value.
+Each number in the range is used inside the loop as an index to test if the element value in the `Vec` at that index is not `0`.
+
+If the element value is not `0`, then an inner `for` in range is defined, starting with the number times itself and going through the upper bound.
+The [`step_by()`][stepby] method is used to traverse the range in steps the size of the outer range number.
+
+Each number from the inner range is used as an index to set the element value at that index in the `Vec` to `0`.
+
+When the outer range is done, the `Vec` is passed through the [`iter()`][iter] method to the [`filter()`][filter] method.
+The [closure][closure] (also known as a lambda) in the body of the `filter()` tests that the element is not `0`.
+It dereferences the number to convert it from a "reference to a reference" to a "reference", and it references the `0` literal
+`u64` value to enable comparison between references.
+
+The surviving values are chained to the [`copied()`][copied] method, which changes the iterator of references to an iterator of the copied values.
+
+The copied values ae chained to the [`collect()`][collect] method, which uses [type inference][type-inference] to return the `Vec<u64>`.
+
+[sqrt]: https://doc.rust-lang.org/std/primitive.f64.html#method.sqrt
+[usize]: https://doc.rust-lang.org/std/primitive.usize.html
+[for-in-range]: https://doc.rust-lang.org/rust-by-example/flow_control/for.html
+[filter]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter
+[stepby]: https://doc.rust-lang.org/core/iter/trait.Iterator.html#method.step_by
+[iter]: https://doc.rust-lang.org/core/primitive.slice.html#method.iter
+[filter]: https://doc.rust-lang.org/core/iter/trait.Iterator.html#method.filter
+[closure]: https://doc.rust-lang.org/rust-by-example/fn/closures.html
+[collect]: https://doc.rust-lang.org/core/iter/trait.Iterator.html#method.collect
+[copied]: https://doc.rust-lang.org/core/iter/trait.Iterator.html#method.copied
+[type-inference]: https://doc.rust-lang.org/rust-by-example/types/inference.html

exercises/practice/sieve/.approaches/for-in-ranges-with-filter/snippet.txt

@@ -0,0 +1,8 @@
+for i in 2..stop {
+    if (work[i]) != 0 {
+        for idx in (i * i..=upper_bound).step_by(i) {
+            work[idx] = 0;
+        }
+    }
+}
+work.iter().filter(|num| *num != &0u64).copied().collect()

exercises/practice/sieve/.approaches/introduction.md

@@ -0,0 +1,84 @@
+# Introduction
+
+There are many ways to implement Sieve.
+One approach can use a couple of  [`Range`][range]s to iterate the indexes of the `Vec`, both outside and inside a [`filter_map()`][filtermap] method,
+to process the numbers.
+Another approach could use a couple of [for in range][for-in-range] loops to iterate and process the numbers,
+and then use the [`filter()`][filter] method to return the `Vec`.
+
+## General guidance
+
+One of the things to try to minimize is [mutability][mutability].
+If using `mut` for anything than the `Vec`, then the solution may use more mutability than required.
+
+## Approach: `Range`s and `filter-map()`
+
+```rust
+pub fn primes_up_to(upper_bound: u64) -> Vec<u64> {
+    let mut numbers: Vec<_> = (0..=upper_bound).map(Option::from).collect();
+    let upper_bound = upper_bound as usize;
+    (2..numbers.len())
+        .filter_map(|i| {
+            let prime = numbers[i].take()? as usize;
+            (prime + prime..=upper_bound)
+                .step_by(prime)
+                .for_each(|j| numbers[j] = None);
+            Some(prime as u64)
+        })
+        .collect()
+}
+```
+
+For more information, check the [`Range`s and `filter_map()` approach][approach-ranges-and-filtermap].
+
+
+## Approach: `for` in ranges with `filter()`
+
+```rust
+pub fn primes_up_to(upper_bound: u64) -> Vec<u64> {
+    let mut work: Vec<u64> = (0..=upper_bound).collect();
+    work[1] = 0;
+    let stop = (upper_bound as f64).sqrt() as usize + 1usize;
+    let upper_bound = upper_bound as usize;
+    for i in 2..stop {
+        if (work[i]) != 0 {
+            for idx in (i * i..=upper_bound).step_by(i) {
+                work[idx] = 0;
+            }
+        }
+    }
+    work.iter().filter(|num| *num != &0u64).copied().collect()
+}
+```
+
+For more information, check the [`for` in ranges with `filter()` approach][approach-for-in-ranges-with-filter].
+
+## Which approach to use?
+
+The `filter_map` approach may be considered more idiomatic.
+Using the following benchmark, the `filter_map()` approach was also faster.
+
+```rust
+#[bench]
+fn limit_of_1000(b: &mut Bencher) {
+    b.iter(|| primes_up_to(1000));
+}
+```
+
+Results
+
+```
+// range and filter_map
+test limit_of_1000 ... bench:       5,164 ns/iter (+/- 206)
+
+// for in ranges with filter
+test limit_of_1000 ... bench:       5,945 ns/iter (+/- 310)
+```
+
+[range]: https://doc.rust-lang.org/reference/expressions/range-expr.html
+[filtermap]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map
+[for-in-range]: https://doc.rust-lang.org/rust-by-example/flow_control/for.html
+[filter]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter
+[mutability]: https://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/mutability.html
+[approach-ranges-and-filtermap]: https://exercism.org/tracks/rust/exercises/sieve/approaches/ranges-and-filtermap
+[approach-for-in-ranges-with-filter]: https://exercism.org/tracks/rust/exercises/sieve/approaches/for-in-ranges-with-filter

exercises/practice/sieve/.approaches/ranges-and-filtermap/content.md

@@ -0,0 +1,50 @@
+# `Range`s and `filter-map()`
+
+```rust
+pub fn primes_up_to(upper_bound: u64) -> Vec<u64> {
+    let mut numbers: Vec<_> = (0..=upper_bound).map(Option::from).collect();
+    let upper_bound = upper_bound as usize;
+    (2..numbers.len())
+        .filter_map(|i| {
+            let prime = numbers[i].take()? as usize;
+            (prime + prime..=upper_bound)
+                .step_by(prime)
+                .for_each(|j| numbers[j] = None);
+            Some(prime as u64)
+        })
+        .collect()
+}
+```
+
+This approach starts by defining a `Vec` of [`Some`][some] values from `0` through the upper bound.
+To minimize type conversions, the upper bound is redefined as a [`usize`][usize].
+
+A [Range][range] is defined that goes from `2` through the length of the `Vec`.
+Each number from the range is passed to the [`filter_map()`][filtermap].
+
+The [closure][closure] (also known as a lambda) in the body of the `filter_map()` uses the [`take()`][take] method, combined with the
+unwrap operator (`?`), to get the element value in the `Vec` at the index of the number passed in from the range.
+If the element value is `None`, then no further processing happens in the lambda for that iteration.
+If the element value is `Some` number, then an inner range is defined, starting from the element value plus itself and going through the upper bound.
+
+The [`step_by()`][stepby] method is used to traverse the range in steps the size of the element value.
+
+Each number from the inner range is passed to the [`for_each()`][foreach] method.
+The lambda inside the `for_each` sets `None` as the value for the element in the `Vec` at the index of the value passed in.
+
+After the inner range is done, the `filter_map()` lambda returns the element value rewrapped in a `Some` as type `u64`.
+
+After the outer range is done, all of the `Some` values are [collect][collect]ed from the `Vec` and returned.
+[Type inference][type-inference] is used to return the values as a type `Vec<u64>`.
+
+[some]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some
+[none]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.None
+[usize]: https://doc.rust-lang.org/std/primitive.usize.html
+[range]: https://doc.rust-lang.org/reference/expressions/range-expr.html
+[filtermap]: https://doc.rust-lang.org/core/iter/trait.Iterator.html#method.filter_map
+[closure]: https://doc.rust-lang.org/rust-by-example/fn/closures.html
+[take]: https://doc.rust-lang.org/core/option/enum.Option.html#method.take
+[stepby]: https://doc.rust-lang.org/core/iter/trait.Iterator.html#method.step_by
+[foreach]: https://doc.rust-lang.org/core/iter/trait.Iterator.html#method.for_each
+[type-inference]: https://doc.rust-lang.org/rust-by-example/types/inference.html
+[collect]: https://doc.rust-lang.org/core/iter/trait.Iterator.html#method.collect

exercises/practice/sieve/.approaches/ranges-and-filtermap/snippet.txt

@@ -0,0 +1,8 @@
+(2..numbers.len())
+    .filter_map(|i| {
+        let prime = numbers[i].take()? as usize;
+        (prime + prime..=upper_bound)
+            .step_by(prime)
+            .for_each(|j| numbers[j] = None);
+        Some(prime as u64)
+    }).collect()