leap: add approaches (#1577)

leap: add approaches

Co-authored-by: Erik Schierboom <[email protected]>

Author: bobahop

exercises/practice/leap/.approaches/boolean-one-line/content.md

@@ -0,0 +1,27 @@
+# One line of Boolean conditions
+
+```rust
+pub fn is_leap_year(year: u64) -> bool {
+    (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0))
+}
+```
+
+The first boolean condition uses the [remainder operator][remainder-operator] to check if the year is evenly divided by `4`.
+- If the year is not evenly divisible by `4`, then the chain will "short circuit" due to the next operator being a [logical AND][operators] (`&&`), and will return `false`.
+- If the year _is_ evenly divisible by `4`, then the year is checked to _not_ be evenly divisible by `100`.
+- If the year is not evenly divisible by `100`, then the expression is `true` and the chain will "short-circuit" to return `true`,
+since the next operator is a [logical OR][operators] (`||`).
+- If the year _is_ evenly divisible by `100`, then the expression is `false`, and the returned value from the chain will be if the year is evenly divisible by `400`.
+
+| year | year % 4 == 0 | year % 100 != 0 | year % 400 == 0 | is leap year |
+| ---- | ------------- | --------------- | --------------- | ------------ |
+| 2020 |          true |            true |   not evaluated |         true |
+| 2019 |         false |   not evaluated |   not evaluated |        false |
+| 2000 |          true |           false |            true |         true |
+| 1900 |          true |           false |           false |        false |
+
+
+The chain of boolean expressions is efficient, as it proceeds from testing the most likely to least likely conditions.
+
+[remainder-operator]: https://doc.rust-lang.org/std/ops/trait.Rem.html
+[operators]: https://doc.rust-lang.org/book/appendix-02-operators.html

exercises/practice/leap/.approaches/boolean-one-line/snippet.txt

@@ -0,0 +1,3 @@
+pub fn is_leap_year(year: u64) -> bool {
+    (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0))
+}

exercises/practice/leap/.approaches/config.json

@@ -0,0 +1,43 @@
+{
+  "introduction": {
+    "authors": ["bobahop"],
+    "contributors": []
+  },
+  "approaches": [
+    {
+      "uuid": "6772ef04-12db-4388-82f2-3e3486998665",
+      "slug": "boolean-one-line",
+      "title": "Boolean one line",
+      "blurb": "Use one line of boolean conditions.",
+      "authors": ["bobahop"]
+    },
+    {
+      "uuid": "5c072736-3d9a-4a20-877e-8108ccaa59bd",
+      "slug": "ternary-expression",
+      "title": "Ternary operator",
+      "blurb": "Use a ternary expression of boolean conditions.",
+      "authors": ["bobahop"]
+    },
+    {
+      "uuid": "a66c7016-c697-4b03-b05c-4febaca07dfc",
+      "slug": "match-on-a-tuple",
+      "title": "match on a tuple",
+      "blurb": "Use a match on a tuple made from boolean conditions.",
+      "authors": ["bobahop"]
+    },
+    {
+      "uuid": "07b68663-d4e4-4ec2-ab0b-9f1366eba06c",
+      "slug": "date-addition-time",
+      "title": "Date addition with time crate",
+      "blurb": "Use time::Date addition.",
+      "authors": ["bobahop"]
+    },
+    {
+      "uuid": "232280a3-37a4-4e7c-bfcc-ade90fd85586",
+      "slug": "date-addition-chrono",
+      "title": "Date addition with chrono crate",
+      "blurb": "Use chrono::Date addition.",
+      "authors": ["bobahop"]
+    }
+  ]
+}

exercises/practice/leap/.approaches/date-addition-chrono/content.md

@@ -0,0 +1,31 @@
+# `chrono::Date` addition
+
+```rust
+use chrono::{prelude::*, Duration};
+
+pub fn is_leap_year(year: u64) -> bool {
+    (Utc.ymd(year as i32, 2, 28) + Duration::days(1)).day() == 29
+}
+```
+
+```exercism/caution
+This approach may be considered a "cheat" for this exercise.
+```
+By adding a day to February 28th for the year, you can see if the new day is the 29th or the 1st.
+If it is the 29th, then the year is a leap year.
+This is done by using the [`Duration::days(1)`][day-duration] method to add a day to a [`chrono::Date`][chrono-date] `struct` and comparing it to `29` with the [`day`][day-method] method.
+
+The documentation suggests using [NaiveDate][naive] instead of `Date`, in which case the code would be
+
+```rust
+pub fn is_leap_year_naive(year: u64) -> bool {
+    (NaiveDate::from_ymd(year as i32, 2, 28) + chrono::Duration::days(1)).day() == 29
+}
+```
+
+Running benchmarks gave similar results for `Date` and `NaiveDate`.
+
+[day-duration]: https://docs.rs/chrono/latest/chrono/struct.Duration.html#method.days
+[chrono-date]: https://docs.rs/chrono/latest/chrono/struct.Date.html
+[day-method]: https://docs.rs/chrono/latest/chrono/struct.Date.html#method.day
+[naive]: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html

exercises/practice/leap/.approaches/date-addition-chrono/snippet.txt

@@ -0,0 +1,5 @@
+use chrono::{prelude::*, Duration};
+
+pub fn is_leap_year(year: u64) -> bool {
+    (Utc.ymd(year as i32, 2, 28) + Duration::days(1)).day() == 29
+}

exercises/practice/leap/.approaches/date-addition-time/content.md

@@ -0,0 +1,21 @@
+# `time::Date` addition
+
+```rust
+use time::{Date, Duration, Month};
+
+pub fn is_leap_year(year: u64) -> bool {
+    (Date::from_calendar_date(year as i32, Month::February, 28).unwrap() + Duration::DAY).day()
+        == 29
+}
+```
+
+```exercism/caution
+This approach may be considered a "cheat" for this exercise.
+```
+By adding a day to February 28th for the year, you can see if the new day is the 29th or the 1st.
+If it is the 29th, then the year is a leap year.
+This is done by adding a [`Duration::DAY`][day-duration] to a [`time::Date`][time-date] `struct` and comparing it to `29` with the [`day`][day-method] method.
+
+[day-duration]: https://docs.rs/time/latest/time/struct.Duration.html#associatedconstant.DAY
+[time-date]: https://docs.rs/time/latest/time/struct.Date.html
+[day-method]: https://docs.rs/time/latest/time/struct.Date.html#method.day

exercises/practice/leap/.approaches/date-addition-time/snippet.txt

@@ -0,0 +1,6 @@
+use time::{Date, Duration, Month};
+
+pub fn is_leap_year(year: u64) -> bool {
+    (Date::from_calendar_date(year as i32, Month::February, 28).unwrap() + Duration::DAY).day()
+        == 29
+}

exercises/practice/leap/.approaches/introduction.md

@@ -0,0 +1,84 @@
+# Introduction
+
+There are various idiomatic approaches to solve Leap.
+You can use one line of boolean expressions to test the conditions.
+Or you can use a [ternary expression][ternary-expression].
+Another approach you can use is a [match][match] on a [tuple][tuple].
+
+## General guidance
+
+The key to solving Leap is to know if the year is evenly divisible by `4`, `100` and `400`.
+For determining that, you will use the [remainder operator][remainder-operator].
+
+## Approach: One line of Boolean conditions
+
+```rust
+pub fn is_leap_year(year: u64) -> bool {
+    (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0))
+}
+```
+
+For more information, check the [Boolean one-line approach][approach-boolean-line].
+
+## Approach: Ternary expression of Boolean conditions
+
+```rust
+pub fn is_leap_year(year: u64) -> bool {
+    if year % 100 == 0 {
+        year % 400 == 0
+    } else {
+        year % 4 == 0
+    }
+}
+```
+
+For more information, check the [Ternary expression approach][approach-ternary-expression].
+
+## Approach: `match` on a `tuple`
+
+```rust
+pub fn is_leap_year(year: u64) -> bool {
+    match (year % 4, year % 100, year % 400) {
+        (_, _, 0) => true,
+        (_, 0, _) => false,
+        (0, _, _) => true,
+        _ => false,
+    }
+}
+```
+
+For more information, check the [`match` on a `tuple` approach][approach-match-on-a-tuple].
+
+## Other approaches
+
+Besides the aforementioned, idiomatic approaches, you could also approach the exercise as follows:
+
+### Other approach: `time::Date` addition approach:
+
+Add a day to February 28th for the year and see if the new day is the 29th. For more information, see the [`time::Date` addition approach][approach-date-add-time].
+
+### Other approach: `chrono::Date` addition approach:
+
+Add a day to February 28th for the year and see if the new day is the 29th. For more information, see the [`chrono::Date` addition approach][approach-date-add-chrono].
+
+## Which approach to use?
+
+- The one line of boolean conditions is most efficient, as it proceeds from the most likely to least likely conditions.
+It has a maximum of three checks.
+- The ternary expression has a maximum of only two checks, but it starts from a less likely condition.
+- The `match` on a `tuple` may be considered more "functional", but it is more verbose and may be considered less readable.
+- Using `Date` addition may be considered "cheats" for the exercise,
+and they are less performant than the three main approaches.
+
+For more information, check the [Performance article][article-performance].
+
+[remainder-operator]: https://doc.rust-lang.org/std/ops/trait.Rem.html
+[match]: https://doc.rust-lang.org/rust-by-example/flow_control/match.html
+[tuple]: https://doc.rust-lang.org/rust-by-example/primitives/tuples.html
+[ternary-expression]: (https://doc.rust-lang.org/reference/expressions/if-expr.html)
+[approach-boolean-line]: https://exercism.org/tracks/rust/exercises/leap/approaches/boolean-one-line
+[approach-ternary-expression]: https://exercism.org/tracks/rust/exercises/leap/approaches/ternary-expression
+[approach-match-on-a-tuple]: https://exercism.org/tracks/rust/exercises/leap/approaches/match-on-a-tuple
+[approach-date-add-time]: https://exercism.org/tracks/rust/exercises/leap/approaches/date-addition-time
+[approach-date-add-chrono]: https://exercism.org/tracks/rust/exercises/leap/approaches/date-addition-chrono
+[article-performance]: https://exercism.org/tracks/rust/exercises/leap/articles/performance

exercises/practice/leap/.approaches/match-on-a-tuple/content.md

@@ -0,0 +1,37 @@
+# `match` on a `tuple`
+
+```rust
+pub fn is_leap_year(year: u64) -> bool {
+    match (year % 4, year % 100, year % 400) {
+        (_, _, 0) => true,
+        (_, 0, _) => false,
+        (0, _, _) => true,
+        _ => false,
+    }
+}
+```
+
+A [tuple][tuple] is made from the conditions for the year being evenly divisible by `4`, `100` and `400`.
+
+- The `tuple` is tested in a [match expression][match].
+- It tests from top to bottom, so the `(_, _, 0) => true,` arm is tested first.
+- It checks the values of the expressions in the `tuple`, and uses the `_` [wildcard pattern][wildcard] to disregard a value inside the tuple.
+- If the pattern matches, then the arm returns the value to the right of the `=>`.
+- If the pattern does not match, then the pattern in the next arm is tested.
+- In the final arm of the `match`, the wildcard pattern is applied to the entire tuple.
+This is similar to `default` used in `switch` statements in other languages.
+It returns `false` no matter what the values in the tuple are.
+
+| year | year % 4 | year % 100 | year % 400 == 0 | is leap year |
+| ---- | -------- | ---------- | --------------- | ------------ |
+| 2020 |        0 |         20 |              20 |         true |
+| 2019 |        3 |         19 |              19 |        false |
+| 2020 |        0 |          0 |               0 |         true |
+| 1900 |        0 |          0 |             300 |        false |
+
+Although some may consider it to be a more "functional" approach, the `switch` on a `tuple` approach is somewhat more verbose than other approaches,
+and may also be considered less readable.
+
+[match]: https://doc.rust-lang.org/rust-by-example/flow_control/match.html
+[tuple]: https://doc.rust-lang.org/rust-by-example/primitives/tuples.html
+[wildcard]: https://doc.rust-lang.org/book/ch18-03-pattern-syntax.html#ignoring-values-in-a-pattern

exercises/practice/leap/.approaches/match-on-a-tuple/snippet.txt

@@ -0,0 +1,8 @@
+pub fn is_leap_year(year: u64) -> bool {
+    match (year % 4, year % 100, year % 400) {
+        (_, _, 0) => true,
+        (_, 0, _) => false,
+        (0, _, _) => true,
+        _ => false,
+    }
+}