Add approaches to Bob (exercism#3200)

Add approaches to Bob

Author: bobahop

exercises/practice/bob/.approaches/answer-list/content.md

@@ -0,0 +1,67 @@
+# Answer list
+
+```python
+_ANSWERS = ['Whatever.', 'Sure.', 'Whoa, chill out!',
+            "Calm down, I know what I'm doing!"]
+
+
+def response(hey_bob):
+    hey_bob = hey_bob.rstrip()
+    if not hey_bob:
+        return 'Fine. Be that way!'
+    isShout = (2 if hey_bob.isupper() else 0)
+    isQuestion = (1 if hey_bob.endswith('?') else 0)
+    return _ANSWERS[isShout + isQuestion]
+
+```
+
+In this approach you define a [list][list] that contains Bob’s answers, and each condition is given a score.
+The correct answer is selected from the list by using the score as the list index.
+
+Python doesn't _enforce_ having real constant values,
+but the `_ANSWERS` list is defined with all uppercase letters, which is the naming convention for a Python [constant][const].
+It indicates that the value is not intended to be changed.
+Python also does not have real [private][private] variables,
+but a leading underscore is the naming convention for indicating that a variable is not meant to be part of the public API.
+It should be considered an implementation detail and subject to change without notice.
+
+The [`rstrip`][rstrip] method is applied to the input to eliminate any whitespace at the end of the input.
+If the input has no characters left, it uses the [falsiness][falsiness] of an empty string with the [`not`][not] operator to return the response for saying nothing.
+Since it doesn't matter if there is leading whitespace, the `rstrip` function is used instead of [`strip`][strip].
+
+A [ternary operator][ternary] is used for determining the score for a shout and a question.
+
+The [`isupper`][isupper] method is used to test that there is at least one cased character and that all cased characters are uppercase.
+
+```exercism/note
+A cased character is one which differs between lowercase and uppercase.
+For example, `?` and `3` are not cased characters, as they do not change between lowercase and uppercase.
+`a` and `z` are cased characters, since their lowercase form changes to `A` and ` Z` when uppercase.
+```
+
+If `isupper` is `True`, then `isShout` is given the value of `2`; otherwise, it is given the value of `0`.
+
+The [`endswith`][endswith] method is used to determine if the input ends with a question mark.
+If the test for `endswith('?')` is `True`, then `isQuestion` is given the value of `1`; otherwise it is given the value of `0`.
+
+
+The response is selected from the list by the index like so
+
+| isShout | isQuestion | Index     | Answer                                |
+| ------- | ---------- | --------- | ------------------------------------- |
+| `false` | `false`    | 0 + 0 = 0 | `"Whatever."`                         |
+| `false` | `true`     | 0 + 1 = 1 | `"Sure."`                             |
+| `true`  | `false`    | 2 + 0 = 2 | `"Whoa, chill out!"`                  |
+| `true`  | `true`     | 2 + 1 = 3 | `"Calm down, I know what I'm doing!"` |
+
+
+[list]: https://docs.python.org/3/library/stdtypes.html?highlight=list#list
+[const]: https://realpython.com/python-constants/
+[private]: https://docs.python.org/3/tutorial/classes.html#private-variables
+[rstrip]: https://docs.python.org/3/library/stdtypes.html?highlight=rstrip#str.rstrip
+[falsiness]: https://www.pythontutorial.net/python-basics/python-boolean/
+[not]: https://docs.python.org/3/reference/expressions.html#not
+[strip]: https://docs.python.org/3/library/stdtypes.html?highlight=strip#str.strip
+[ternary]: https://www.pythontutorial.net/python-basics/python-ternary-operator/
+[isupper]: https://docs.python.org/3/library/stdtypes.html?highlight=isupper#str.isupper
+[endswith]: https://docs.python.org/3/library/stdtypes.html?highlight=endswith#str.endswith

exercises/practice/bob/.approaches/answer-list/snippet.txt

@@ -0,0 +1,6 @@
+_ANSWERS = ['Whatever.', 'Sure.', 'Whoa, chill out!',
+            "Calm down, I know what I'm doing!"]
+# code snipped
+isShout = (2 if hey_bob.isupper() else 0)
+isQuestion = (1 if hey_bob.endswith('?') else 0)
+return _ANSWERS[isShout + isQuestion]

exercises/practice/bob/.approaches/config.json

@@ -0,0 +1,29 @@
+{
+  "introduction": {
+    "authors": ["bobahop"],
+    "contributors": []
+  },
+  "approaches": [
+    {
+      "uuid": "972b7546-67ca-4364-9367-02d68a8c0314",
+      "slug": "if-statements",
+      "title": "If statements",
+      "blurb": "Use if statements to return the answer.",
+      "authors": ["bobahop"]
+    },
+    {
+      "uuid": "138fcf61-262c-47f6-aac3-96528b24ee6b",
+      "slug": "if-statements-nested",
+      "title": "if statements nested",
+      "blurb": "Use nested if statements to return the answer.",
+      "authors": ["bobahop"]
+    },
+    {
+      "uuid": "d74a1d7d-af85-417c-8deb-164536e4ab1b",
+      "slug": "answer-list",
+      "title": "Answer list",
+      "blurb": "Index into a list to return the answer.",
+      "authors": ["bobahop"]
+    }
+  ]
+}

exercises/practice/bob/.approaches/if-statements-nested/content.md

@@ -0,0 +1,48 @@
+# `if` statements nested
+
+```python
+def response(hey_bob):
+    hey_bob = hey_bob.rstrip()
+    if not hey_bob:
+        return 'Fine. Be that way!'
+    isShout = hey_bob.isupper()
+    isQuestion = hey_bob.endswith('?')
+    if isShout:
+        if isQuestion:
+            return "Calm down, I know what I'm doing!"
+        else:
+            return 'Whoa, chill out!'
+    if isQuestion:
+        return 'Sure.'
+    return 'Whatever.'    
+
+```
+
+In this approach you have a series of `if` statements using the calculated variables to evaluate the conditions, some of which are nested.
+As soon as a `True` condition is found, the correct response is returned.
+
+The [`rstrip`][rstrip] method is applied to the input to eliminate any whitespace at the end of the input.
+If the input has no characters left, it uses the [falsiness][falsiness] of an empty string with the [`not`][not] operator to return the response for saying nothing.
+Since it doesn't matter if there is leading whitespace, the `rstrip` function is used instead of [`strip`][strip].
+
+The [`isupper`][isupper] method is used to test that there is at least one cased character and that all cased characters are uppercase.
+
+```exercism/note
+A cased character is one which differs between lowercase and uppercase.
+For example, `?` and `3` are not cased characters, as they do not change between lowercase and uppercase.
+`a` and `z` are cased characters, since their lowercase form changes to `A` and ` Z` when uppercase.
+```
+
+The [`endswith`][endswith] method is used to determine if the input ends with a question mark.
+
+Instead of testing a shout and a question on the same line, this approach first tests if the input is a shout.
+If it is a shout, then the nested `if`/[`else`][else] statement returns if it is a shouted question or just a shout.
+If it is not a shout, then the flow of execution skips down to the non-nested test for if the input is a question.
+
+[rstrip]: https://docs.python.org/3/library/stdtypes.html?highlight=rstrip#str.rstrip
+[falsiness]: https://www.pythontutorial.net/python-basics/python-boolean/
+[not]: https://docs.python.org/3/reference/expressions.html#not
+[strip]: https://docs.python.org/3/library/stdtypes.html?highlight=strip#str.strip
+[isupper]: https://docs.python.org/3/library/stdtypes.html?highlight=isupper#str.isupper
+[endswith]: https://docs.python.org/3/library/stdtypes.html?highlight=endswith#str.endswith
+[else]: https://docs.python.org/3/reference/compound_stmts.html#else

exercises/practice/bob/.approaches/if-statements-nested/snippet.txt

@@ -0,0 +1,8 @@
+if isShout:
+    if isQuestion:
+        return "Calm down, I know what I'm doing!"
+    else:
+        return 'Whoa, chill out!'
+if isQuestion:
+    return 'Sure.'
+return 'Whatever.'

exercises/practice/bob/.approaches/if-statements/content.md

@@ -0,0 +1,51 @@
+# `if` statements
+
+```python
+def response(hey_bob):
+    hey_bob = hey_bob.rstrip()
+    if not hey_bob:
+        return 'Fine. Be that way!'
+    isShout = hey_bob.isupper()
+    isQuestion = hey_bob.endswith('?')
+    if isShout and isQuestion:
+        return "Calm down, I know what I'm doing!"
+    if isShout:
+        return 'Whoa, chill out!'
+    if isQuestion:
+        return 'Sure.'
+    return 'Whatever.'
+    
+```
+
+In this approach you have a series of `if` statements using the calculated variables to evaluate the conditions.
+As soon as a `True` condition is found, the correct response is returned.
+
+```exercism/note
+Note that there are no `elif` or `else` statements.
+If an `if` statement can return, then an `elif` or `else` is not needed.
+Execution will either return or will continue to the next statement anyway.
+```
+
+The [`rstrip`][rstrip] method is applied to the input to eliminate any whitespace at the end of the input.
+If the input has no characters left, it uses the [falsiness][falsiness] of an empty string with the [`not`][not] operator to return the response for saying nothing.
+Since it doesn't matter if there is leading whitespace, the `rstrip` function is used instead of [`strip`][strip].
+
+The [`isupper`][isupper] method is used to test that there is at least one cased character and that all cased characters are uppercase.
+
+```exercism/note
+A cased character is one which differs between lowercase and uppercase.
+For example, `?` and `3` are not cased characters, as they do not change between lowercase and uppercase.
+`a` and `z` are cased characters, since their lowercase form changes to `A` and ` Z` when uppercase.
+```
+
+The [`endswith`][endswith] method is used to determine if the input ends with a question mark.
+
+The [logical AND operator][and] (`and`) is used to test a shout and a question together.
+
+[rstrip]: https://docs.python.org/3/library/stdtypes.html?highlight=rstrip#str.rstrip
+[falsiness]: https://www.pythontutorial.net/python-basics/python-boolean/
+[not]: https://docs.python.org/3/reference/expressions.html#not
+[strip]: https://docs.python.org/3/library/stdtypes.html?highlight=strip#str.strip
+[isupper]: https://docs.python.org/3/library/stdtypes.html?highlight=isupper#str.isupper
+[endswith]: https://docs.python.org/3/library/stdtypes.html?highlight=endswith#str.endswith
+[and]: https://realpython.com/python-and-operator/

exercises/practice/bob/.approaches/if-statements/snippet.txt

@@ -0,0 +1,7 @@
+if isShout and isQuestion:
+    return "Calm down, I know what I'm doing!"
+if isShout:
+    return 'Whoa, chill out!'
+if isQuestion:
+    return 'Sure.'
+return 'Whatever.'

exercises/practice/bob/.approaches/introduction.md

@@ -0,0 +1,92 @@
+# Introduction
+
+There are various idiomatic approaches to solve Bob.
+A basic approach can use a series of `if` statements to test the conditions.
+The `if` statements could also be nested.
+A list can contain answers from which the right response is selected by an index calculated from scores given to the conditions.
+
+## General guidance
+
+Regardless of the approach used, some things you could look out for include
+
+- If the input is stripped, [`rstrip`][rstrip] only once.
+
+- Use the [`endswith`][endswith] method instead of checking the last character by index for `?`.
+
+- Don't copy/paste the logic for determining a shout and for determing a question into determing a shouted question.
+  Combine the two determinations instead of copying them.
+  Not duplicating the code will keep the code [DRY][dry].
+
+- Perhaps consider making `IsQuestion` and `IsShout` values set once instead of functions that are possibly called twice.
+
+- If an `if` statement can return, then an `elif` or `else` is not needed.
+  Execution will either return or will continue to the next statement anyway.
+
+## Approach: `if` statements
+
+```python
+def response(hey_bob):
+    hey_bob = hey_bob.rstrip()
+    if not hey_bob:
+        return 'Fine. Be that way!'
+    isShout = hey_bob.isupper()
+    isQuestion = hey_bob.endswith('?')
+    if isShout and isQuestion:
+        return "Calm down, I know what I'm doing!"
+    if isShout:
+        return 'Whoa, chill out!'
+    if isQuestion:
+        return 'Sure.'
+    return 'Whatever.'
+    
+```
+
+For more information, check the [`if` statements approach][approach-if].
+
+## Approach: `if` statements nested
+
+```python
+def response(hey_bob):
+    hey_bob = hey_bob.rstrip()
+    if not hey_bob:
+        return 'Fine. Be that way!'
+    isShout = hey_bob.isupper()
+    isQuestion = hey_bob.endswith('?')
+    if isShout:
+        if isQuestion:
+            return "Calm down, I know what I'm doing!"
+        else:
+            return 'Whoa, chill out!'
+    if isQuestion:
+        return 'Sure.'
+    return 'Whatever.'    
+
+```
+
+For more information, check the [`if` statements nested approach][approach-if-nested].
+
+## Other approaches
+
+Besides the aforementioned, idiomatic approaches, you could also approach the exercise as follows:
+
+### Other approach: answer list
+
+A list can be defined that contains Bob’s answers, and each condition is given a score.
+The correct answer is selected from the list by using the score as the list index.
+For more information, check the [answer list approach][approach-answer-list].
+
+## Which approach to use?
+
+The nested `if` approach is fastest, but some may consider it a bit less readable than the unnested `if` statements.
+The answer list approach is slowest, but some may prefer doing away with the chain of `if` statements.
+Since the difference between them is a few nanoseconds, which one is used may be a matter of stylistic preference.
+
+- To compare the performance of the approaches, check out the [Performance article][article-performance].
+
+[rstrip]: https://docs.python.org/3/library/stdtypes.html?highlight=rstrip#str.rstrip
+[endswith]: https://docs.python.org/3/library/stdtypes.html?highlight=strip#str.endswith
+[dry]: https://en.wikipedia.org/wiki/Don%27t_repeat_yourself
+[approach-if]: https://exercism.org/tracks/python/exercises/bob/approaches/if-statements
+[approach-if-nested]: https://exercism.org/tracks/python/exercises/bob/approaches/if-statements-nested
+[approach-answer-list]: https://exercism.org/tracks/python/exercises/bob/approaches/answer-list
+[article-performance]: https://exercism.org/tracks/python/exercises/bob/articles/performance

exercises/practice/bob/.articles/config.json

@@ -0,0 +1,11 @@
+{
+  "articles": [
+    {
+      "uuid": "7b04a95b-d56f-48d3-bb79-3523cfee44ad",
+      "slug": "performance",
+      "title": "Performance deep dive",
+      "blurb": "Deep dive to find out the most performant approach for Bob's response.",
+      "authors": ["bobahop"]
+    }
+  ]
+}

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

@@ -0,0 +1,62 @@
+import timeit
+
+loops = 1_000_000
+
+val = timeit.timeit("""response("I really don't have anything to say.")""",
+                    """
+def response(hey_bob):
+    hey_bob = hey_bob.rstrip()
+    if not hey_bob:
+        return 'Fine. Be that way!'
+    isShout = hey_bob.isupper()
+    isQuestion = hey_bob.endswith('?')
+    if isShout and isQuestion:
+        return "Calm down, I know what I'm doing!"
+    if isShout:
+        return 'Whoa, chill out!'
+    if isQuestion:
+        return 'Sure.'
+    return 'Whatever.'
+
+""", number=loops) / loops
+
+print(f"if statements: {val}")
+
+
+val = timeit.timeit("""response("I really don't have anything to say.")""",
+                    """
+def response(hey_bob):
+    hey_bob = hey_bob.rstrip()
+    if not hey_bob:
+        return 'Fine. Be that way!'
+    isShout = hey_bob.isupper()
+    isQuestion = hey_bob.endswith('?')
+    if isShout:
+        if isQuestion:
+            return "Calm down, I know what I'm doing!"
+        else:
+            return 'Whoa, chill out!'    
+    if isQuestion:
+        return 'Sure.'
+    return 'Whatever.'
+
+""", number=loops) / loops
+
+print(f"if statements nested: {val}")
+
+val = timeit.timeit("""response("I really don't have anything to say.")""",
+                    """
+
+_ANSWERS = ["Whatever.", "Sure.", "Whoa, chill out!", "Calm down, I know what I'm doing!"]
+
+def response(hey_bob):
+    hey_bob = hey_bob.rstrip()
+    if not hey_bob: return 'Fine. Be that way!'
+    isShout = 2 if hey_bob.isupper() else 0
+    isQuestion = 1 if hey_bob.endswith('?') else 0
+    return _ANSWERS[isShout + isQuestion]
+    
+
+""", number=loops) / loops
+
+print(f"answer list: {val}")