Separate re.finditer() into a variation

also add username to contributors array

Author: Yrahcaz7

exercises/practice/acronym/.approaches/config.json

@@ -9,49 +9,56 @@
       "slug": "functools-reduce",
       "title": "Functools Reduce",
       "blurb": "Use functools.reduce() to form an acronym from text cleaned using str.replace().",
-      "authors": ["bethanyg"]
+      "authors": ["bethanyg"],
+      "contributors": ["yrahcaz7"]
     },
     {
       "uuid": "d568ea30-b839-46ad-9c9b-73321a274325",
       "slug": "generator-expression",
       "title": "Generator Expression",
       "blurb": "Use a generator expression with str.join() to form an acronym from text cleaned using str.replace().",
-      "authors": ["bethanyg"]
+      "authors": ["bethanyg"],
+      "contributors": ["yrahcaz7"]
     },
     {
       "uuid": "da53b1bc-35c7-47a7-88d5-56ebb9d3658d",
       "slug": "list-comprehension",
       "title": "List Comprehension",
       "blurb": "Use a list comprehension with str.join() to form an acronym from text cleaned using str.replace().",
-      "authors": ["bethanyg"]
+      "authors": ["bethanyg"],
+      "contributors": ["yrahcaz7"]
     },
     {
       "uuid": "abd51d7d-3743-448d-b8f1-49f484ae6b30",
       "slug": "loop",
       "title": "Loop",
       "blurb": "Use str.replace() to clean the input string and a loop with string concatenation to form the acronym.",
-      "authors": ["bethanyg"]
+      "authors": ["bethanyg"],
+      "contributors": ["yrahcaz7"]
     },
     {
       "uuid": "9eee8db9-80f8-4ee4-aaaf-e55b78221283",
       "slug": "map-function",
       "title": "Map Built-in",
       "blurb": "Use the built-in map() function to form an acronym after cleaning the input string with str.replace().",
-      "authors": ["bethanyg"]
+      "authors": ["bethanyg"],
+      "contributors": ["yrahcaz7"]
     },
     {
       "uuid": "8f4dc8ba-fd1c-4c85-bcc3-8ef9dca34c7f",
       "slug": "regex-join",
       "title": "Regex join",
       "blurb": "Use regex to clean the input string and form the acronym with str.join().",
-      "authors": ["bethanyg"]
+      "authors": ["bethanyg"],
+      "contributors": ["yrahcaz7"]
     },
     {
       "uuid": "8830be43-44c3-45ab-8311-f588f60dfc5f",
       "slug": "regex-sub",
       "title": "Regex Sub",
       "blurb": "Use re.sub() to clean the input string and create the acronym in one step.",
-      "authors": ["bethanyg"]
+      "authors": ["bethanyg"],
+      "contributors": ["yrahcaz7"]
     },
     {
       "uuid": "0ce3eaf7-da79-403d-a481-5dd8f476d286",

exercises/practice/acronym/.approaches/regex-join/content.md

@@ -1,10 +1,9 @@
-# Approach: filter with `re.findall()` and join via `str.join()`
+# Approach: Filter with `re.findall()` and join via `str.join()`
 
 
 ```python
 import re
 
-###re.findall###
 
 def abbreviate(to_abbreviate):
     # Capitalize the input before cleaning.
@@ -18,24 +17,6 @@ def abbreviate(to_abbreviate):
     # Capitalize the result after joining.
     return "".join(word[0] for word in
                    re.findall(r"[a-zA-Z']+", to_abbreviate)).upper()
-                   
-###re.finditer###
-
-def abbreviate(to_abbreviate):
-    # Capitalize the input before cleaning.
-    cleaned = re.finditer(r"[a-zA-Z']+", to_abbreviate.upper())
-
-    # word.group(0)[0] (first letter of Matched word) can also be written as
-    # word[0][0], with the first bracketed number referring to Match group 0.
-    return "".join(word.group(0)[0] for word in cleaned)
-
-#OR#
-
-def abbreviate(to_abbreviate):
-    # Capitalize the output after joining.
-    # Use bracket notation for Match group.
-    return "".join(word[0][0] for word in
-                   re.finditer(r"[a-zA-Z']+", to_abbreviate)).upper()
 ```
 
 
@@ -48,43 +29,72 @@ Regular expression matching starts at the left-hand side of the input and travel
 `re.findall()` searches text for all matching patterns, returning results (_including 'empty' matches_) in a `list` of strings.
 
 
-The [`re.finditer()`][re-finditer] method works in the same fashion as `re.findall()`, but returns results as a _[lazy iterator][lazy iterator]_ over [`Match` objects][match objects].
-This means that `re.finditer()` produces matches _on demand_ instead of saving them to memory, but needs to have both the iterator and the `Match` objects _unpacked_.
-
-
-The regular expression `r[a-zA-Z']+` in the code example looks for any single character in the range `a-z` lowercase and `A-Z` uppercase, plus the `'` (_apostrophe_) character.
+The regular expression `[a-zA-Z']+` in the code example looks for any single character in the range `a-z` (_lowercase_) and `A-Z` (_uppercase_), plus the `'` (_apostrophe_) character.
 The `+` operator is a 'greedy' modifier that matches the previous range one to unlimited times.
 This means that the expression will match any collection or repeat of letters (_a word_), but will not match any sort of space or 'non-letter' character, such as a tab, space, hyphen, or underscore.
 
 For example, in `Complementary metal-oxide semiconductor`, the regex will match `Complementary`, `metal`, `oxide`, and `semiconductor`.
-The regex will not match on ` ` or `-`.
+The regex will not match any of the spaces or the hyphen (`-`).
 The result returned by `findall()` will then be `["Complementary", "metal", "oxide", "semiconductor"]`.
 
 
 ~~~~exercism/note
 `to_abbreviate.replace("-", " ").replace("_", " ").upper().split()` can also be used to clean `to_abbreviate` and turn the results into a `list`.
-The `.replace()` approach benchmarked faster than using `re.findall()`/`re.finditer()` to clean, most likely due to overhead in importing the `re` module and in the [backtracking][backtracking] behavior of regex searching and matching.
+The `.replace()` approach benchmarked faster than using `re.findall()` to clean, most likely due to overhead in importing the `re` module and in the [backtracking][backtracking] behavior of regex searching and matching.
 
 [backtracking]: https://stackoverflow.com/questions/9011592/in-regular-expressions-what-is-a-backtracking-back-referencing
 ~~~~
 
 
-Once `findall()` or `finditer()` completes, a [`generator-expression`][generator-expression] is used to iterate through the results and select the first letters of each word via [`bracket notation`][subscript notation].
-Note that when using `finditer()`, the `Match object` has to be unpacked via `match.group(0)`/`match[0]` before the first letter can be selected.
+Once `findall()` completes, a [`generator-expression`][generator-expression] is used to iterate through the results and select the first letters of each word via [`bracket notation`][subscript notation].
 
 
-Generator expressions are short-form [generators][generators] — lazy iterators that produce their values _on demand_, instead of saving them to memory.
+Generator expressions are short-form [generators][generators] — [lazy iterators][lazy iterator] that produce their values _on demand_, instead of saving them to memory.
 This generator expression is consumed by [`str.join()`][str-join], which joins the generated letters together using an empty string.
 Other "separator" strings can be used with `str.join()` — see [concept:python/string-methods]() for some additional examples.
 
 
 Finally, the result of `.join()` is capitalized using the [chained][chaining] [`str.upper()`][str-upper].
-Alternatively, `str.upper()` can be used on `to_abbreviate` within `findall()`/`finditer()`, to uppercase the input before cleaning.
+Alternatively, `str.upper()` can be used on `to_abbreviate` within `findall()`, to uppercase the input before cleaning.
 Since the solution is fairly succinct, it can be condensed onto the `return` line, rather than assigning and returning an intermediate variable for the acronym.
 
 
 This approach was less performant in benchmarks than those using `loop`, `map`, `list-comprehension`, and `reduce`.
 
+
+## Variation 1: `re.finditer()`
+
+
+```python
+import re
+
+
+def abbreviate(to_abbreviate):
+    # Capitalize the input before cleaning.
+    cleaned = re.finditer(r"[a-zA-Z']+", to_abbreviate.upper())
+
+    # word.group(0)[0] (first letter of Matched word) can also be written as
+    # word[0][0], with the first bracketed number referring to Match group 0.
+    return "".join(word.group(0)[0] for word in cleaned)
+
+#OR#
+
+def abbreviate(to_abbreviate):
+    # Capitalize the output after joining.
+    # Use bracket notation for Match group.
+    return "".join(word[0][0] for word in
+                   re.finditer(r"[a-zA-Z']+", to_abbreviate)).upper()
+```
+
+
+This variant uses [`re.finditer()`][re-finditer] for cleaning instead of `re.findall()`.
+
+The `re.finditer()` method works in the same fashion as `re.findall()`, but it returns results as a _[lazy iterator][lazy iterator]_ over [`Match` objects][match objects].
+This means that `re.finditer()` produces matches _on demand_ instead of saving them to memory, but needs to have both the iterator and the `Match` objects _unpacked_.
+
+Due to this, the generator expression was modified to unpack the `Match` objects via `word.group(0)` (or `word[0]`) before the first letter is selected.
+
+
 [chaining]: https://pyneng.readthedocs.io/en/latest/book/04_data_structures/method_chaining.html
 [generator-expression]: https://dbader.org/blog/python-generator-expressions
 [generators]: https://dbader.org/blog/python-generators