pangram: add approaches (#1584)

* Create snippet.md

* Create main.rs

* Create content.md

* Create config.json

* Create config.json

* Create snippet.txt

* Update content.md

* Create content.md

* Create snippet.txt

* Create content.md

* Update snippet.txt

* Update content.md

* Create introduction.md

* Create snippet.txt

* Create content.md

* Create snippet.txt

* Create content.md

* Update content.md

* Update content.md

* Update introduction.md

* Update introduction.md

* Update content.md

* Update content.md

* Update content.md

* Update main.rs

* Update content.md

* Update content.md

* Update snippet.txt

* Update introduction.md

* Update content.md

* Update content.md

* Update content.md

* Update introduction.md

* Update exercises/practice/pangram/.approaches/bitfield/snippet.txt

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

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

Author: bobahop

exercises/practice/pangram/.approaches/all-contains/content.md

@@ -0,0 +1,19 @@
+# `all` with `contains` on lowercased letters
+
+```rust
+pub fn is_pangram(sentence: &str) -> bool {
+    let sentence_lowered = sentence.to_lowercase();
+    ('a'..='z').all(|ltr| sentence_lowered.contains(ltr))
+}
+```
+
+- This begins by lowercasing the input by using [to_lowercase][tolower].
+- It then checks if all letters in the alphabet are contained in the `sentence`,
+using the [`Iterator`][iterator] method [`all`][all] with the [`str`][str] method [`contains`][contains].
+If all of the letters in the alphabet are contained in the `sentence`, then the function will return `true`.
+
+[tolower]: https://doc.rust-lang.org/std/string/struct.String.html#method.to_lowercase
+[iterator]: https://doc.rust-lang.org/std/iter/trait.Iterator.html
+[all]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.all
+[str]: https://doc.rust-lang.org/std/primitive.str.html
+[contains]: https://doc.rust-lang.org/std/primitive.str.html#method.contains

exercises/practice/pangram/.approaches/all-contains/snippet.txt

@@ -0,0 +1,4 @@
+pub fn is_pangram_all_contains(sentence: &str) -> bool {
+    let sentence_lowered = sentence.to_lowercase();
+    ('a'..='z').all(|ltr| sentence_lowered.contains(ltr))
+}

exercises/practice/pangram/.approaches/bitfield/content.md

@@ -0,0 +1,60 @@
+# Bit field
+
+```rust
+const A_LCASE: u8 = 97;
+const A_UCASE: u8 = 65;
+const ALL_26_BITS_SET: u32 = 67108863;
+
+pub fn is_pangram(sentence: &str) -> bool {
+    let mut letter_flags = 0;
+
+    for letter in sentence.chars() {
+        if letter >= 'a' && letter <= 'z' {
+            letter_flags |= 1 << (letter as u8 - A_LCASE);
+        } else if letter >= 'A' && letter <= 'Z' {
+            letter_flags |= 1 << (letter as u8 - A_UCASE);
+        }
+    }
+    letter_flags == ALL_26_BITS_SET
+}
+```
+
+This solution uses the [ASCII][ascii] value of the letter to set the corresponding bit position.
+First, some [`const`][const] values are set.
+These values will be used for readability in the body of the `is_pangram` function.
+The ASCII value for `a` is `97`.
+The ASCII value for `A` is `65`.
+The value for all of the rightmost `26` bits being set in a [`u32`][u32] is `67108863`.
+
+- The [`for` loop][for-loop] loops through the [chars][chars] of `sentence`.
+We don't iterate by bytes because, as of this writing, some tests may include multi-byte characters in `sentence`.
+- Each letter is tested for being `a` through `z` or `A` through `Z`.
+- If the lower-cased letter is subtracted by `a`, then `a` will result in `0`, because `97` minus `97`  equals `0`.
+`z` would result in `25`, because `122` minus `97` equals `25`.
+So `a` would have `1` [shifted left][shift-left] 0 places (so not shifted at all) and `z` would have `1` shifted left 25 places.
+- If the upper-cased letter is subtracted by `A`, then `A` will result in `0`, because `65` minus `65`  equals `0`.
+`Z` would result in `25`, because `90` minus `65` equals `25`.
+So `A` would have `1` [shifted left][shift-left] 0 places (so not shifted at all) and `Z` would have `1` shifted left 25 places.
+
+In that way, both a lower-cased `z` and an upper-cased `Z` can share the same position in the bit field.
+
+So, for an unsigned thirty-two bit integer, if the values for `a` and `Z` were both set, the bits would look like
+
+```
+      zyxwvutsrqponmlkjihgfedcba
+00000010000000000000000000000001
+```
+
+We can use the [bitwise OR operator][or] to set the bit.
+After the loop completes, the function returns `true` if the `letter_flags` value is the same value as when all of the rightmost  `26` bits are set,
+which is `67108863`.
+
+This approach is relatively very fast compared with other approaches.
+
+[ascii]: https://www.asciitable.com/
+[const]: https://doc.rust-lang.org/std/keyword.const.html
+[u32]: https://doc.rust-lang.org/std/primitive.u32.html
+[for-loop]: https://doc.rust-lang.org/reference/expressions/loop-expr.html#iterator-loops
+[chars]: https://doc.rust-lang.org/std/primitive.str.html#method.chars
+[shift-left]: https://doc.rust-lang.org/std/ops/trait.Shl.html
+[or]: https://doc.rust-lang.org/std/ops/trait.BitOr.html

exercises/practice/pangram/.approaches/bitfield/snippet.txt

@@ -0,0 +1,8 @@
+for letter in sentence.chars() {
+    if letter >= 'a' && letter <= 'z' {
+        letter_flags |= 1 << (letter as u8 - A_LCASE);
+    } else if letter >= 'A' && letter <= 'Z' {
+        letter_flags |= 1 << (letter as u8 - A_UCASE);
+    }
+}
+letter_flags == ALL_26_BITS_SET

exercises/practice/pangram/.approaches/config.json

@@ -0,0 +1,35 @@
+{
+  "introduction": {
+    "authors": ["bobahop"]
+  },
+  "approaches": [
+    {
+      "uuid": "e2afccc3-5503-47a3-ae59-fd3f7ff48935",
+      "slug": "all-contains",
+      "title": "all with contains on lower case",
+      "blurb": "Use all with contains on lowercased letters.",
+      "authors": ["bobahop"]
+    },
+    {
+      "uuid": "eb75431e-8295-40fb-8239-d207b45d4e8b",
+      "slug": "hashset-is-subset",
+      "title": "HashSet with is_subset",
+      "blurb": "Use HashSet with is_subset.",
+      "authors": ["bobahop"]
+    },
+    {
+      "uuid": "159732d1-3a19-4e77-914d-a71e7e96439d",
+      "slug": "hashset-len",
+      "title": "HashSet with len",
+      "blurb": "Use HashSet with len.",
+      "authors": ["bobahop"]
+    },    
+    {
+      "uuid": "7907873a-10b8-4f9e-8c7d-52aa5d460392",
+      "slug": "bitfield",
+      "title": "Bit field",
+      "blurb": "Use a bit field to keep track of used letters.",
+      "authors": ["bobahop"]
+    }
+  ]
+}

exercises/practice/pangram/.approaches/hashset-is-subset/content.md

@@ -0,0 +1,24 @@
+# `HashSet` with `is_subset`
+
+```rust
+use std::collections::HashSet;
+
+pub fn is_pangram(sentence: &str) -> bool {
+    let all: HashSet<char> = HashSet::from_iter("abcdefghijklmnopqrstuvwxyz".chars());
+    let used: HashSet<char> = HashSet::from_iter(sentence.to_lowercase().chars());
+    all.is_subset(&used)
+}
+```
+
+In this approach a [HashSet][hashset] is made of the lowercase alphabet [chars][chars] using the [from_iter][from-iter] method,
+and another `HashSet` is made from the [to_lowercase][to-lowercase] `sentence` `chars`.
+
+The function returns if the alphabet `HashSet` [is_subset][is-subset] of the `sentence` `HashSet`.
+If all of the letters in the alphabet are a subset of the letters in the `sentence`,
+then `is_subset` will return `true`.
+
+[hashset]: https://doc.rust-lang.org/std/collections/struct.HashSet.html
+[chars]: https://doc.rust-lang.org/std/primitive.str.html#method.chars
+[from-iter]: https://doc.rust-lang.org/std/iter/trait.FromIterator.html#tymethod.from_iter
+[to-lowercase]: https://doc.rust-lang.org/std/primitive.str.html#method.to_lowercase
+[is-subset]: https://doc.rust-lang.org/std/collections/hash_set/struct.HashSet.html#method.is_subset

exercises/practice/pangram/.approaches/hashset-is-subset/snippet.txt

@@ -0,0 +1,7 @@
+use std::collections::HashSet;
+
+pub fn is_pangram(sentence: &str) -> bool {
+    let all: HashSet<char> = HashSet::from_iter("abcdefghijklmnopqrstuvwxyz".chars());
+    let used: HashSet<char> = HashSet::from_iter(sentence.to_lowercase().chars());
+    all.is_subset(&used)
+}

exercises/practice/pangram/.approaches/hashset-len/content.md

@@ -0,0 +1,33 @@
+# `HashSet` with `len`
+
+```rust
+use std::collections::HashSet;
+
+pub fn is_pangram(sentence: &str) -> bool {
+    sentence
+        .to_lowercase()
+        .chars()
+        .filter(|c| c.is_ascii_alphabetic())
+        .collect::<HashSet<char>>()
+        .len()
+        == 26
+}
+```
+
+This approach chains several functions together to determine the result.
+
+- It first passes the `sentence` [to_lowercase][to-lowercase].
+- The lowercased `sentence` is then iterated by [chars][chars].
+- The `chars` are [filter][filter]ed in its [closure][closure] so that only a character that [is_ascii_alphabetic][is-ascii-alphabetic]
+makes it through to be [collect][collect]ed into a [HashSet][hashset].
+- The function returns if the [len][len] of the `HashSet` is `26`.
+If the number of unique letters in the `HashSet` is equal to the `26` letters in the alphabet, then the function will return `true`.
+
+[to-lowercase]: https://doc.rust-lang.org/std/primitive.str.html#method.to_lowercase
+[chars]: https://doc.rust-lang.org/std/primitive.str.html#method.chars
+[filter]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter
+[closure]: https://doc.rust-lang.org/rust-by-example/fn/closures.html
+[is-ascii-alphabetic]: https://doc.rust-lang.org/std/primitive.u8.html#method.is_ascii_alphabetic
+[collect]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.collect
+[hashset]: https://doc.rust-lang.org/std/collections/struct.HashSet.html
+[len]: https://doc.rust-lang.org/std/collections/struct.HashSet.html#method.len

exercises/practice/pangram/.approaches/hashset-len/snippet.txt

@@ -0,0 +1,7 @@
+sentence
+    .to_lowercase()
+    .chars()
+    .filter(|c| c.is_ascii_alphabetic())
+    .collect::<HashSet<char>>()
+    .len()
+    == 26

exercises/practice/pangram/.approaches/introduction.md

@@ -0,0 +1,91 @@
+# Introduction
+
+There are various idomatic approaches to Pangram.
+You can use the `all` method on the alphabet letters with the `contains` method on the lowercased letters of sentence.
+You can see if the `HashSet` of the alphabet `is_substring` of a `HashSet` of the lowercased `sentence`.
+Or you can see if the `HashSet` `len` of the lowercased `sentence` filtered to just ASCII letters is `26`.
+Or you can use a bit field to keep track of used letters.
+
+
+## General guidance
+
+The key to solving Pangram is determining if all of the letters in the alphabet are in the `&str` being tested.
+The occurrence of either the letter `a` or the letter `A` would count as the same letter.
+
+## Approach: `all` with `contains` on lowercased letters
+
+```rust
+pub fn is_pangram(sentence: &str) -> bool {
+    let sentence_lowered = sentence.to_lowercase();
+    ('a'..='z').all(|ltr| sentence_lowered.contains(ltr))
+}
+```
+
+For more information, check the [`all` with `contains` approach][approach-all-contains].
+
+## Approach: `HashSet` with `is_subset` on lowercased characters
+
+```rust
+use std::collections::HashSet;
+
+pub fn is_pangram(sentence: &str) -> bool {
+    let all: HashSet<char> = HashSet::from_iter("abcdefghijklmnopqrstuvwxyz".chars());
+    let used: HashSet<char> = HashSet::from_iter(sentence.to_lowercase().chars());
+    all.is_subset(&used)
+}
+```
+
+For more information, check the [`HashSet` with `is_subset` approach][approach-hashset-is-subset].
+
+## Approach: `HashSet` with `len` on lowercased characters
+
+```rust
+use std::collections::HashSet;
+
+pub fn is_pangram(sentence: &str) -> bool {
+    sentence
+        .to_lowercase()
+        .chars()
+        .filter(|c| c.is_ascii_alphabetic())
+        .collect::<HashSet<char>>()
+        .len()
+        == 26
+}
+```
+
+For more information, check the [`HashSet` with `len` approach][approach-hashset-len].
+
+## Bit field
+
+```rust
+const A_LCASE: u8 = 97;
+const A_UCASE: u8 = 65;
+const ALL_26_BITS_SET: u32 = 67108863;
+
+pub fn is_pangram(sentence: &str) -> bool {
+    let mut letter_flags = 0;
+
+    for letter in sentence.chars() {
+        if letter >= 'a' && letter <= 'z' {
+            letter_flags |= 1 << (letter as u8 - A_LCASE);
+        } else if letter >= 'A' && letter <= 'Z' {
+            letter_flags |= 1 << (letter as u8 - A_UCASE);
+        }
+    }
+    letter_flags == ALL_26_BITS_SET
+}
+```
+
+For more information, check the [Bit field approach][approach-bitfield].
+
+## Which approach to use?
+
+The fastest is the `Bit field` approach.
+
+To compare performance of the approaches, check the [Performance article][article-performance].
+
+[approach-all-contains]: https://exercism.org/tracks/rust/exercises/pangram/approaches/all-contains
+[approach-hashset-is-subset]: https://exercism.org/tracks/rust/exercises/pangram/approaches/hashset-is-subset
+[approach-hashset-len]: https://exercism.org/tracks/rust/exercises/pangram/approaches/hashset-len
+[approach-bitfield]: https://exercism.org/tracks/rust/exercises/pangram/approaches/bitfield
+[article-performance]: https://exercism.org/tracks/rust/exercises/pangram/articles/performance