Cleaned up typos and changed toss to throw.

Author: BethanyG

exercises/practice/darts/.approaches/booleans-as-ints/content.md

@@ -9,8 +9,8 @@ def score(x_coord, y_coord):
 
 
 In Python, the [Boolean values `True` and `False` are _subclasses_ of `int`][bools-as-ints] and can be interpreted as `0` (False) and `1` (True) in a mathematical context.
-This approach leverages that interpretation by checking which areas the toss falls into and multiplying each Boolean `int` by a scoring multiple.
-For example, a toss that lands on the 25 (_or 5 if using `math.sqrt(x**2 + y**2)`_) circle should have a score of 5:
+This approach leverages that interpretation by checking which areas the throw falls into and multiplying each Boolean `int` by a scoring multiple.
+For example, a throw that lands on the 25 (_or 5 if using `math.sqrt(x**2 + y**2)`_) circle should have a score of 5:
 
 ```python
 >>> (False)*5 + (True)*4 + (True)*1
@@ -30,7 +30,7 @@ def score(x_coord, y_coord):
 ```
 
 Beyond that recommendation, the terseness of this approach might be harder to reason about or decode — especially if a programmer is coming from a programming langauge that does not treat Boolean values as `ints`.
-Despite the "radius" variable name, is also more difficult to relate the scoring "rings" of the Dartboard to the values being checked and calculated in the `return` statement.
+Despite the "radius" variable name, it is also more difficult to relate the scoring "rings" of the Dartboard to the values being checked and calculated in the `return` statement.
 If using this code in a larger program, it would be strongly recommended that a docstring be provided to explain the Dartboard rings, scoring rules, and the corresponding scores.
 
 [bools-as-ints]: https://docs.python.org/3/library/stdtypes.html#boolean-type-bool

exercises/practice/darts/.approaches/config.json

@@ -8,35 +8,35 @@
       "uuid": "7d78f598-8b4c-4f7f-89e1-e8644e934a4c",
       "slug": "if-statements",
       "title": "Use If Statements",
-      "blurb": "Use if-statements to check scoring boundaries for a dart toss.",
+      "blurb": "Use if-statements to check scoring boundaries for a dart throw.",
       "authors": ["bethanyg"]
     },
     {
       "uuid": "f8f5533a-09d2-4b7b-9dec-90f268bfc03b",
       "slug": "tuple-and-loop",
       "title": "Use a Tuple & Loop through Scores",
-      "blurb": "Score the Dart toss by looping through a tuple of scores.",
+      "blurb": "Score the Dart throw by looping through a tuple of scores.",
       "authors": ["bethanyg"]
     },
     {
       "uuid": "a324f99e-15bb-43e0-9181-c1652094bc4f",
       "slug": "match-case",
       "title": "Use Structural Pattern Matching ('Match-Case')",
-      "blurb": "Use a Match-Case (Structural Pattern Matching) to score the dart toss.)",
+      "blurb": "Use a Match-Case (Structural Pattern Matching) to score the dart throw.)",
       "authors": ["bethanyg"]
     },
     {
       "uuid": "966bd2dd-c4fd-430b-ad77-3a304dedd82e",
       "slug": "dict-and-generator",
       "title": "Use a Dictionary with a Generator Expression",
-      "blurb": "Use a generator expression looping over a scoring dictionary, getting the max score for the dart toss.",
+      "blurb": "Use a generator expression looping over a scoring dictionary, getting the max score for the dart throw.",
       "authors": ["bethanyg"]
     },
     {
       "uuid": "5b087f50-31c5-4b84-9116-baafd3a30ed6",
       "slug": "booleans-as-ints",
       "title": "Use Boolean Values as Integers",
-      "blurb": "Use True and False as integer values to calculate the score of the dart toss.",
+      "blurb": "Use True and False as integer values to calculate the score of the dart throw.",
       "authors": ["bethanyg"]
     },
     {

exercises/practice/darts/.approaches/dict-and-dict-get/content.md

@@ -22,7 +22,7 @@ However, this approach is **not** interpreting Booleans as integers and is inste
 3.  Duplicate keys _overwrite_ existing keys.
     If the first key is `True` and the third key is `True`, the _value_ from the third key will overwrite the value from the first key.
 
-Finally, the `return` line uses [`dict.get()`][dict-get] to `return` a default value of 0 when a toss is outside the existing circle radii.
+Finally, the `return` line uses [`dict.get()`][dict-get] to `return` a default value of 0 when a throw is outside the existing circle radii.
 To see this in action, you can view this code on [Python Tutor][dict-get-python-tutor].
 
 

exercises/practice/darts/.approaches/dict-and-generator/content.md

@@ -2,50 +2,50 @@
 
 ```python
 def score(x_coord, y_coord):
-    toss = x_coord**2 + y_coord**2
+    throw = x_coord**2 + y_coord**2
     rules = {1: 10, 25: 5, 100: 1, 200: 0}
 
     return max(point for distance, point in 
-               rules.items() if toss <= distance)
+               rules.items() if throw <= distance)
 ```
 
 
 This approach is very similar to the  [tuple and loop][approach-tuple-and-loop] approach, but iterates over [`dict.items()`][dict-items] and writes the `loop` as a [`generator-expression`][generator-expression] inside `max()`.
-In cases where the scoring circles overlap, `max()` will return the maximum score available for the toss.
+In cases where the scoring circles overlap, `max()` will return the maximum score available for the throw.
 The generator expression inside `max()` is the equivalent of using a `for-loop` and a variable to determine the max score:
 
 
 ```python
 def score(x_coord, y_coord):
-    toss = x_coord**2 + y_coord**2
+    throw = x_coord**2 + y_coord**2
     rules = {1: 10, 25: 5, 100: 1}
     max_score = 0
 
     for distance, point in rules.items():
-        if toss <= distance and point > max_score:
+        if throw <= distance and point > max_score:
             max_score = point
     return max_score
 ```
 
 
-A `list` or `tuple` can also be used in place of `max()`, but then requires and index to return the max score:
+A `list` or `tuple` can also be used in place of `max()`, but then requires an index to return the max score:
 
 ```python
 def score(x_coord, y_coord):
-    toss = x_coord**2 + y_coord**2
+    throw = x_coord**2 + y_coord**2
     rules = {1: 10, 25: 5, 100: 1, 200: 0}
 
     return [point for distance, point in 
-               rules.items() if toss <= distance][0] #<-- have to specify index 0.
+               rules.items() if throw <= distance][0] #<-- have to specify index 0.
 
 #OR#
 
 def score(x_coord, y_coord):
-    toss = x_coord**2 + y_coord**2
+    throw = x_coord**2 + y_coord**2
     rules = {1: 10, 25: 5, 100: 1, 200: 0}
 
     return tuple(point for distance, point in 
-               rules.items() if toss <= distance)[0]
+               rules.items() if throw <= distance)[0]
 ```
 
 
@@ -59,7 +59,7 @@ def score(x_coord, y_coord):
                (x_coord**2 + y_coord**2) <= distance)
 ```
 
-While all of these variations do pass the tests, they suffer from even more over-engineering/performance caution than the earlier tuple and loop approach.
+While all of these variations do pass the tests, they suffer from even more over-engineering/performance caution than the earlier tuple and loop approach (_although for the data in this problem, the performance hit is slight_).
 Additionally, the dictionary will take much more space in memory than using a `tuple` of tuples to hold scoring values.
 In some circumstances, these variations might also be harder to reason about for those not familiar with `generator-expressions` or `list comprehensions`.
 

exercises/practice/darts/.approaches/introduction.md

@@ -15,8 +15,8 @@ Among them are:
 
 ## General guidance
 
-The goal of the Darts exercise is to score a single toss in a Darts game.
-The scoring areas are _concentric circles_, so boundary values need to be checked in order to properly score a toss.
+The goal of the Darts exercise is to score a single throw in a Darts game.
+The scoring areas are _concentric circles_, so boundary values need to be checked in order to properly score a throw.
 The key is to determine how far from the center the dart lands (_by calculating sqrt(x**2 + y**2), or a variation_) and then determine what scoring ring it falls into.
 
 
@@ -53,11 +53,11 @@ For more details, see the [if statements][approach-if-statements] approach.
 
 ```python
 def score(x_coord, y_coord):
-    toss = x_coord**2 + y_coord**2
+    throw = x_coord**2 + y_coord**2
     rules = (1, 10), (25, 5), (100, 1), (200, 0)
 
     for distance, points in rules:
-        if toss <= distance:
+        if throw <= distance:
             return points
 ```
 
@@ -70,11 +70,11 @@ For more details, see the [tuple and loop][approach-tuple-and-loop] approach.
 
 ```python
 def score(x_coord, y_coord):
-    toss = x_coord**2 + y_coord**2
+    throw = x_coord**2 + y_coord**2
     rules = {1: 10, 25: 5, 100: 1, 200: 0}
 
     return max(point for distance, point in 
-               rules.items() if toss <= distance)
+               rules.items() if throw <= distance)
 ```
 
 This approach is very similar to the  [tuple and loop][approach-tuple-and-loop] approach, but iterates over [`dict.items()`][dict-items].

exercises/practice/darts/.approaches/match-case/content.md

@@ -6,9 +6,9 @@ from math import hypot, ceil
 
 
 def score(x, y):
-    toss = ceil(hypot(x, y))
+    throw = ceil(hypot(x, y))
 
-    match toss:
+    match throw:
         case 0 | 1: return 10
         case 2 | 3 | 4 | 5: return 5
         case 6 | 7 | 8 | 9 | 10: return 1
@@ -27,19 +27,19 @@ def score(x, y):
 This approach uses `Python 3.10`'s [`structural pattern matching`][structural-pattern-matching] with `return` values on the same line as `case`.
 Because the match is numeric, each case explicitly lists allowed values using the `|` (OR) operator.
 A fallthrough case (`_`) is used if the dart throw is greater than 10  (_the outer circle radius of the target_).
-This is equivalent to using `if-statements` to check toss values although some might argue it is clearer to read.
+This is equivalent to using `if-statements` to check throw values although some might argue it is clearer to read.
 An `if-statement` equivalent would be:
 
 ```python
 from math import hypot, ceil
 
 
 def score(x, y):
-    toss =  ceil(hypot(x, y))
+    throw =  ceil(hypot(x, y))
 
-    if toss in (0, 1): return 10
-    if toss in (2, 3, 4, 5): return 5
-    if toss in (6, 7, 8, 9, 10): return 1
+    if throw in (0, 1): return 10
+    if throw in (2, 3, 4, 5): return 5
+    if throw in (6, 7, 8, 9, 10): return 1
 
     return 0
 ```
@@ -52,28 +52,28 @@ from math import hypot, ceil
 
 
 def score(x, y):
-    toss = ceil(hypot(x, y))
+    throw = ceil(hypot(x, y))
 
-    match toss:
-        case toss if toss <= 1: return 10
-        case toss if toss <= 5: return 5
-        case toss if toss <= 10: return 1
+    match throw:
+        case throw if throw <= 1: return 10
+        case throw if throw <= 5: return 5
+        case throw if throw <= 10: return 1
         case _: return 0
 ```
 
 
-Finally, one can use an [assignment expression][assignment-expression] or [walrus operator][walrus] to calculate the toss value rather than calculating and assigning a variable on a separate line.
+Finally, one can use an [assignment expression][assignment-expression] or [walrus operator][walrus] to calculate the throw value rather than calculating and assigning a variable on a separate line.
 This isn't necessary (_the first variations shows this clearly_) and might be harder to reason about/understand for some programmers:
 
 
 ```python
 from math import hypot, ceil
 
 def score(x, y):
-    match toss := ceil(hypot(x, y)):
-        case toss if toss <= 1: return 10
-        case toss if toss <=5: return 5
-        case toss if toss <=10: return 1
+    match throw := ceil(hypot(x, y)):
+        case throw if throw <= 1: return 10
+        case throw if throw <=5: return 5
+        case throw if throw <=10: return 1
         case _: return 0
 ```
 

exercises/practice/darts/.approaches/tuple-and-loop/content.md

@@ -2,47 +2,47 @@
 
 ```python
 def score(x_coord, y_coord):
-    toss = x_coord**2 + y_coord**2
+    throw = x_coord**2 + y_coord**2
     rules = (1, 10), (25, 5), (100, 1), (200, 0)
 
     for distance, points in rules:
-        if toss <= distance:
+        if throw <= distance:
             return points
 ```
 
 This approach uses a loop to iterate through the _rules_ `tuple`, unpacking each (`distance`, `points`) pair (_For a little more on unpacking, see [Tuple Unpacking Improves Python Code Readability][tuple-unpacking]_).
-If the calculated distance of the toss is less than or equal to a given distance, the score for that region is returned.
+If the calculated distance of the throw is less than or equal to a given distance, the score for that region is returned.
 A `list` of `lists`, a `list` of `tuples`, or a dictionary could be used here to the same effect:
 
 ```python
 def score(x_coord, y_coord):
-    toss = x_coord**2 + y_coord**2
+    throw = x_coord**2 + y_coord**2
     rules = [[1, 10], [25, 5], [100, 1]]
 
     for distance, points in rules:
-        if toss <= distance:
+        if throw <= distance:
             return points
 
     return 0
 
 #OR#
 
 def score(x_coord, y_coord):
-    toss = x_coord**2 + y_coord**2
+    throw = x_coord**2 + y_coord**2
     rules = [(1, 10), (25, 5), (100, 1), (200, 0)]
 
     for distance, points in rules:
-        if toss <= distance:
+        if throw <= distance:
             return points
 
 #OR#
 
 def score(x_coord, y_coord):
-    toss = x_coord**2 + y_coord**2
+    throw = x_coord**2 + y_coord**2
     rules = {1: 10, 25: 5, 100: 1}
 
     for distance, points in rules.items():
-        if toss <= distance:
+        if throw <= distance:
             return points
 
     return 0