[Acronym] Add new approach and update performance article (#4203)

* fix benchmark & add timings for new approach

* update "measurements were taken on" part

* improve performance article

* fix the performance article's `config.json`

* add approach docs for new approach

* Apply suggestions from code review

Co-authored-by: BethanyG <BethanyG@users.noreply.github.com>

* minor fixes

---------

Co-authored-by: BethanyG <BethanyG@users.noreply.github.com>

Author: Yrahcaz7

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

@@ -1,6 +1,7 @@
 {
   "introduction": {
-    "authors": ["bethanyg"]
+    "authors": ["bethanyg"],
+    "contributors": ["yrahcaz7"]
   },
   "approaches": [
     {
@@ -51,6 +52,13 @@
       "title": "Regex Sub",
       "blurb": "Use re.sub() to clean the input string and create the acronym in one step.",
       "authors": ["bethanyg"]
+    },
+    {
+      "uuid": "0ce3eaf7-da79-403d-a481-5dd8f476d286",
+      "slug": "double-generator-expression",
+      "title": "Double Generator Expression",
+      "blurb": "Use generator expressions for both cleaning and joining the input.",
+      "authors": ["yrahcaz7"]
     }
   ]
 }

exercises/practice/acronym/.approaches/double-generator-expression/content.md

@@ -0,0 +1,38 @@
+# Using a `generator-expression` for both cleaning and joining
+
+```python
+from string import ascii_letters
+
+
+VALID_CHARS = {' ', '-'} | set(ascii_letters)
+
+
+def abbreviate(to_abbreviate):
+    to_abbreviate = ''.join(' ' if char == '-' else char
+                            for char in to_abbreviate
+                            if char in VALID_CHARS)
+
+    return ''.join(word[0] for word in to_abbreviate.split()).upper()
+```
+
+One way someone might try to increase performce is to use a single [generator expression][generator-expression] to clean the input, rather than using multiple calls to [`str.replace()`][str-replace].
+However, this approach is actually amongst the slower ones.
+(See the [performance article][article-performance] for more detail.)
+
+In this approach, the `VALID_CHARS` constant is first defined using `string.ascii_letters`, a space, and a hyphen.
+In `abbreviate()`, the first generator expression iterates over `to_abbreviate`, excluding any code points that are not a member of the `VALID_CHARS` set.
+For each code point that is not excluded, the expression passes it into [`str.join()`][str-join] (unless it is a hyphen, in which case it replaces the hyphen with a space).
+`to_abbreviate` is then set to the result of the `str.join()`, preparing it for the next step.
+
+Next, [`to_abbreviate.split()`][str-split] is used to split `to_abbreviate` into words separated by whitespace — we can ignore the case of hyphens as we already replaced all of them with spaces.
+Now the second generator expression iterates over the list returned by `to_abbreviate.split()`, yeilding the first code point in each word.
+These code points are passed to another `str.join()`, which is then [chained][chaining] to [`str.upper()`][str-upper].
+Now that both steps are complete, we return the result of `str.upper()` directly on the same line.
+
+[article-performance]: https://exercism.org/tracks/python/exercises/acronym/articles/performance
+[chaining]: https://pyneng.readthedocs.io/en/latest/book/04_data_structures/method_chaining.html
+[generator-expression]: https://dbader.org/blog/python-generator-expressions
+[str-join]: https://docs.python.org/3/library/stdtypes.html#str.join
+[str-replace]: https://docs.python.org/3/library/stdtypes.html#str.replace
+[str-split]: https://docs.python.org/3/library/stdtypes.html#str.split
+[str-upper]: https://docs.python.org/3/library/stdtypes.html#str.upper

exercises/practice/acronym/.approaches/double-generator-expression/snippet.txt

@@ -0,0 +1,8 @@
+VALID_CHARS = {' ', '-'} | set(ascii_letters)
+
+def abbreviate(to_abbreviate):
+    to_abbreviate = ''.join(' ' if char == '-' else char
+                            for char in to_abbreviate
+                            if char in VALID_CHARS)
+
+    return ''.join(word[0] for word in to_abbreviate.split()).upper()

exercises/practice/acronym/.approaches/introduction.md

@@ -6,13 +6,12 @@ Among them are:
 - Using `str.replace()` to scrub the input, and:
   - joining with a `for loop` with string concatenation via the `+` operator.
   - joining via `str.join()`, passing a `list-comprehension` or `generator-expression`.
-  - joining via `str.join()`,  passing `map()`.
+  - joining via `str.join()`, passing `map()`.
   - joining via `functools.reduce()`.
 
 - Using `re.findall()`/`re.finditer()` to scrub the input, and:
   - joining via `str.join()`, passing a `generator-expression`.
-
- - Using `re.sub()` for both cleaning and joining (_using "only" regex for almost everything_)`
+  - Using `re.sub()` for both cleaning and joining (_using "only" regex for almost everything_)`
 
 
 ## General Guidance
@@ -51,25 +50,25 @@ def abbreviate(to_abbreviate):
 For more information, take a look at the [loop approach][approach-loop].
 
 
-## Approach: scrub with `replace()` and join via `list comprehension` or `Generator expression`
+## Approach: scrub with `replace()` and join via `list comprehension` or `generator expression`
 
 
 ```python
 def abbreviate(to_abbreviate):
     phrase = to_abbreviate.replace('-', ' ').replace('_', ' ').upper().split()
 
     return ''.join([word[0] for word in phrase])
-    
-###OR### 
-    
+
+###OR###
+
 def abbreviate(to_abbreviate):
     phrase = to_abbreviate.replace('-', ' ').replace('_', ' ').upper().split()
 
-    # note the parenthesis instead of square brackets.    
+    # Note the parenthesis instead of square brackets.
     return ''.join((word[0] for word in phrase))
 ```
 
-For more information, check out the [list-comprehension][approach-list-comprehension]  approach or the [generator-expression][approach-generator-expression] approach.
+For more information, check out the [list-comprehension][approach-list-comprehension] approach or the [generator-expression][approach-generator-expression] approach.
 
 
 ## Approach: scrub with `replace()` and join via `map()`
@@ -96,7 +95,7 @@ def abbreviate(to_abbreviate):
     return reduce(lambda start, word: start + word[0], phrase, "")
 ```
 
-For more information, take a look at the [functools.reduce()][approach-functools-reduce] approach.
+For more information, take a look at the [`functools.reduce()`][approach-functools-reduce] approach.
 
 
 ## Approach: filter with `re.findall()` and join via `str.join()`
@@ -105,8 +104,8 @@ For more information, take a look at the [functools.reduce()][approach-functools
 import re
 
 
-def abbreviate(phrase):
-    removed = re.findall(r"[a-zA-Z']+", phrase)
+def abbreviate(to_abbreviate):
+    removed = re.findall(r"[a-zA-Z']+", to_abbreviate)
 
     return ''.join(word[0] for word in removed).upper()
 ```
@@ -120,36 +119,57 @@ For more information, take a look at the [regex-join][approach-regex-join] appro
 import re
 
 
-def abbreviate_regex_sub(to_abbreviate):
+def abbreviate(to_abbreviate):
     pattern = re.compile(r"(?<!_)\B[\w']+|[ ,\-_]")
 
-    return  re.sub(pattern, "", to_abbreviate.upper())
+    return re.sub(pattern, "", to_abbreviate.upper())
 ```
 
 For more information, read the [regex-sub][approach-regex-sub] approach.
 
 
+## Approach: use a `generator-expression` for both cleaning and joining
+
+```python
+from string import ascii_letters
+
+
+VALID_CHARS = {' ', '-'} | set(ascii_letters)
+
+
+def abbreviate(to_abbreviate):
+    to_abbreviate = ''.join(' ' if char == '-' else char
+                            for char in to_abbreviate
+                            if char in VALID_CHARS)
+
+    return ''.join(word[0] for word in to_abbreviate.split()).upper()
+```
+
+For more information, take a look at the [double `generator-expression` approach][approach-double-generator-expression].
+
+
 ## Other approaches
 
-Besides these seven idiomatic approaches, there are a multitude of possible variations using different string cleaning and joining methods.
+Besides these eight idiomatic approaches, there are a multitude of possible variations using different string cleaning and joining methods.
 
 However, these listed approaches cover the majority of 'mainstream' strategies.
 
 
 ## Which approach to use?
 
-All seven approaches are idiomatic, and show multiple paradigms and possibilities.
+All eight approaches are idiomatic, and show multiple paradigms and possibilities.
 All approaches are also `O(n)`, with `n` being the length of the input string.
 No matter the removal method, the entire input string must be iterated through to be cleaned and the first letters extracted.
 
-Of these strategies, the `loop` approach is the fastest, although `list-comprehension`, `map`,  and `reduce` have near-identical performance for the test data.
+Of these strategies, the `loop` approach is the fastest, although `list-comprehension`, `map`, and `reduce` have near-identical performance for the test data.
 All approaches are fairly succinct and readable, although the 'classic' loop is probably the easiest understood by those coming to Python from other programming languages.
 
 
-The least performant for the test data was using a `generator-expression`, `re.findall` and  `re.sub` (_least performant_).
+The least performant for the test data was using `generator-expression`s (both one and two), `re.findall`, and `re.sub`.
 
 To compare performance of the approaches, take a look at the [Performance article][article-performance].
 
+[approach-double-generator-expression]: https://exercism.org/tracks/python/exercises/acronym/approaches/double-generator-expression
 [approach-functools-reduce]: https://exercism.org/tracks/python/exercises/acronym/approaches/functools-reduce
 [approach-generator-expression]: https://exercism.org/tracks/python/exercises/acronym/approaches/generator-expression
 [approach-list-comprehension]: https://exercism.org/tracks/python/exercises/acronym/approaches/list-comprehension

exercises/practice/acronym/.articles/config.json

@@ -5,7 +5,8 @@
       "slug": "performance",
       "title": "Performance deep dive",
       "blurb": "Deep dive to find out the most performant approach to forming an acronym.",
-      "authors": ["bethanyg, colinleach"]
+      "authors": ["bethanyg", "colinleach"],
+      "contributors": ["yrahcaz7"]
     }
   ]
-}
+}

exercises/practice/acronym/.articles/performance/code/Benchmark.py

@@ -12,11 +12,18 @@
 import timeit
 import re
 from functools import reduce
+from string import ascii_letters
 
 import pandas as pd
 import numpy as np
 
 
+FIND_INCLUSION_REGEX = re.compile(r"[a-zA-Z']+")
+SUB_EXCLUSION_REGEX = re.compile(r"(?<!_)\B[\w']+|[ ,\-_]")
+FINDALL_INCLUSION_REGEX = re.compile(r"(?<!')\b[a-zA-Z]|(?<=_)[^ _']")
+VALID_CHARS = {' ', '-'} | set(ascii_letters)
+
+
 # ------------ FUNCTIONS TO TIME ------------- #
 def abbreviate_list_comprehension(to_abbreviate):
     phrase = to_abbreviate.replace("_", " ").replace("-", " ").upper().split()
@@ -52,27 +59,34 @@ def abbreviate_reduce(to_abbreviate):
 
 
 def abbreviate_regex_join(phrase):
-    removed = re.findall(r"[a-zA-Z']+", phrase)
+    removed = re.findall(FIND_INCLUSION_REGEX, phrase)
     return ''.join(word[0] for word in removed).upper()
 
 
 def abbreviate_finditer_join(to_abbreviate):
     return ''.join(word[0][0] for word in
-                   re.finditer(r"[a-zA-Z']+", to_abbreviate)).upper()
+                   re.finditer(FIND_INCLUSION_REGEX, to_abbreviate)).upper()
 
 
 def abbreviate_regex_sub(to_abbreviate):
-    pattern = re.compile(r"(?<!_)\B[\w']+|[ ,\-_]")
-    return re.sub(pattern, "", to_abbreviate).upper()
+    return re.sub(SUB_EXCLUSION_REGEX, "", to_abbreviate).upper()
 
 
 def abbreviate_regex_findall(to_abbreviate):
-    return ''.join(re.findall(r"(?<!')\b[a-zA-Z]|(?<=_)[^ _']", to_abbreviate.upper()))
+    return ''.join(re.findall(FINDALL_INCLUSION_REGEX, to_abbreviate.upper()))
+
+
+def abbreviate_double_genex(to_abbreviate):
+    to_abbreviate = ''.join(' ' if char == '-' else char
+                            for char in to_abbreviate
+                            if char in VALID_CHARS)
+
+    return ''.join(word[0] for word in to_abbreviate.split()).upper()
 
 
 ## ---------END FUNCTIONS TO BE TIMED-------------------- ##
 
-## --------  Timing Code Starts Here ---------------------##
+## --------- Timing Code Starts Here -------------------- ##
 
 
 # Input Data Setup
@@ -109,22 +123,23 @@ def abbreviate_regex_findall(to_abbreviate):
 ]
 
 
-# #Set up columns and rows for Pandas Data Frame
-col_headers = [f'Length: {len(item)}'for item in inputs]
+# Set up columns and rows for Pandas Data Frame
+col_headers = [f'Length: {len(item)}' for item in inputs]
 row_headers = ["loop with str.replace",
-               "list_comprehension with str.join()",
+               "list comprehension with str.join()",
                "map() with str.replace()",
                "functools.reduce() with str.replace()",
                "generator expression with str.join()",
                "regex to clean with str.join()",
                "re.finditer() with str.join()",
                "re.sub() to clean and join",
-               "re.findall() 1st letters w/ str.join()"]
+               "re.findall() 1st letters with str.join()",
+               "two generator expressions"]
 
-# # empty dataframe will be filled in one cell at a time later
+# Empty dataframe will be filled in one cell at a time later.
 df = pd.DataFrame(np.nan, index=row_headers, columns=col_headers)
 
-# #Function List to Call When Timing
+# Function List to Call When Timing.
 functions = [abbreviate_loop,
              abbreviate_list_comprehension,
              abbreviate_map,
@@ -133,9 +148,10 @@ def abbreviate_regex_findall(to_abbreviate):
              abbreviate_regex_join,
              abbreviate_finditer_join,
              abbreviate_regex_sub,
-             abbreviate_regex_findall]
+             abbreviate_regex_findall,
+             abbreviate_double_genex]
 
-# Run timings using timeit.autorange().  Run Each Set 3 Times.
+# Run timings using timeit.autorange(). Run Each Set 3 Times.
 for function, title in zip(functions, row_headers):
     timings = [[
             timeit.Timer(lambda: function(data), globals=globals()).autorange()[1] /
@@ -149,9 +165,9 @@ def abbreviate_regex_findall(to_abbreviate):
     print(f'{title}', f'Timings : {timing_result}')
 
     # Insert results into the dataframe
-    df.loc[title, 'Length: 13':'Length: 1114'] = timing_result
+    df.loc[title, 'Length: 13':'Length: 2940'] = timing_result
 
-# The next bit is useful for `introduction.md`
+# The next bit is useful for updating `content.md` with new results.
 pd.options.display.float_format = '{:,.2e}'.format
 print('\nDataframe in Markdown format:\n')
-print(df.to_markdown(floatfmt=".2e"))
+print(df.to_markdown(floatfmt=".2e"))