Sync exercises

exercises/practice/acronym/.docs/instructions.md

@@ -10,8 +10,8 @@ Punctuation is handled as follows: hyphens are word separators (like whitespace)
 
 For example:
 
-|Input|Output|
-|-|-|
-|As Soon As Possible|ASAP|
-|Liquid-crystal display|LCD|
-|Thank George It's Friday!|TGIF|
+| Input                     | Output |
+| ------------------------- | ------ |
+| As Soon As Possible       | ASAP   |
+| Liquid-crystal display    | LCD    |
+| Thank George It's Friday! | TGIF   |

exercises/practice/affine-cipher/.docs/instructions.md

@@ -6,7 +6,7 @@ The affine cipher is a type of monoalphabetic substitution cipher.
 Each character is mapped to its numeric equivalent, encrypted with a mathematical function and then converted to the letter relating to its new numeric value.
 Although all monoalphabetic ciphers are weak, the affine cipher is much stronger than the atbash cipher, because it has many more keys.
 
-[//]: # ( monoalphabetic as spelled by Merriam-Webster, compare to polyalphabetic )
+[//]: # " monoalphabetic as spelled by Merriam-Webster, compare to polyalphabetic "
 
 ## Encryption
 
@@ -23,7 +23,7 @@ Where:
   For the Roman alphabet `m` is `26`.
 - `a` and `b` are integers which make the encryption key
 
-Values `a` and `m` must be *coprime* (or, *relatively prime*) for automatic decryption to succeed, i.e., they have number `1` as their only common factor (more information can be found in the [Wikipedia article about coprime integers][coprime-integers]).
+Values `a` and `m` must be _coprime_ (or, _relatively prime_) for automatic decryption to succeed, i.e., they have number `1` as their only common factor (more information can be found in the [Wikipedia article about coprime integers][coprime-integers]).
 In case `a` is not coprime to `m`, your program should indicate that this is an error.
 Otherwise it should encrypt or decrypt with the provided key.
 

exercises/practice/all-your-base/.docs/instructions.md

@@ -14,20 +14,20 @@ Given a number in base **a**, represented as a sequence of digits, convert it to
 
 In positional notation, a number in base **b** can be understood as a linear combination of powers of **b**.
 
-The number 42, *in base 10*, means:
+The number 42, _in base 10_, means:
 
 `(4 * 10^1) + (2 * 10^0)`
 
-The number 101010, *in base 2*, means:
+The number 101010, _in base 2_, means:
 
 `(1 * 2^5) + (0 * 2^4) + (1 * 2^3) + (0 * 2^2) + (1 * 2^1) + (0 * 2^0)`
 
-The number 1120, *in base 3*, means:
+The number 1120, _in base 3_, means:
 
 `(1 * 3^3) + (1 * 3^2) + (2 * 3^1) + (0 * 3^0)`
 
 I think you got the idea!
 
-*Yes. Those three numbers above are exactly the same. Congratulations!*
+_Yes. Those three numbers above are exactly the same. Congratulations!_
 
 [positional-notation]: https://en.wikipedia.org/wiki/Positional_notation

exercises/practice/allergies/.docs/instructions.md

@@ -22,6 +22,6 @@ Now, given just that score of 34, your program should be able to say:
 - Whether Tom is allergic to any one of those allergens listed above.
 - All the allergens Tom is allergic to.
 
-Note: a given score may include allergens **not** listed above (i.e.  allergens that score 256, 512, 1024, etc.).
+Note: a given score may include allergens **not** listed above (i.e. allergens that score 256, 512, 1024, etc.).
 Your program should ignore those components of the score.
 For example, if the allergy score is 257, your program should only report the eggs (1) allergy.

exercises/practice/anagram/.meta/tests.toml

@@ -46,6 +46,11 @@ description = "detects anagrams using case-insensitive possible matches"
 
 [7cc195ad-e3c7-44ee-9fd2-d3c344806a2c]
 description = "does not detect an anagram if the original word is repeated"
+include = false
+
+[630abb71-a94e-4715-8395-179ec1df9f91]
+description = "does not detect an anagram if the original word is repeated"
+reimplements = "7cc195ad-e3c7-44ee-9fd2-d3c344806a2c"
 
 [9878a1c9-d6ea-4235-ae51-3ea2befd6842]
 description = "anagrams must use all letters exactly once"

exercises/practice/anagram/spec/anagram_spec.cr

@@ -43,7 +43,7 @@ describe "Anagram" do
   end
 
   pending "does not detect an anagram if the original word is repeated" do
-    Anagram.find("go", ["go Go GO"]).should eq([] of String)
+    Anagram.find("go", ["goGoGO"]).should eq([] of String)
   end
 
   pending "anagrams must use all letters exactly once" do

exercises/practice/armstrong-numbers/.docs/instructions.md

@@ -5,9 +5,9 @@ An [Armstrong number][armstrong-number] is a number that is the sum of its own d
 For example:
 
 - 9 is an Armstrong number, because `9 = 9^1 = 9`
-- 10 is *not* an Armstrong number, because `10 != 1^2 + 0^2 = 1`
+- 10 is _not_ an Armstrong number, because `10 != 1^2 + 0^2 = 1`
 - 153 is an Armstrong number, because: `153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153`
-- 154 is *not* an Armstrong number, because: `154 != 1^3 + 5^3 + 4^3 = 1 + 125 + 64 = 190`
+- 154 is _not_ an Armstrong number, because: `154 != 1^3 + 5^3 + 4^3 = 1 + 125 + 64 = 190`
 
 Write some code to determine whether a number is an Armstrong number.
 

exercises/practice/binary-search-tree/.meta/config.json

@@ -19,6 +19,5 @@
     ]
   },
   "blurb": "Insert and search for numbers in a binary tree.",
-  "source": "Josh Cheek",
-  "source_url": "https://twitter.com/josh_cheek"
+  "source": "Josh Cheek"
 }

exercises/practice/binary-search/.docs/instructions.md

@@ -11,7 +11,7 @@ Binary search only works when a list has been sorted.
 
 The algorithm looks like this:
 
-- Find the middle element of a *sorted* list and compare it with the item we're looking for.
+- Find the middle element of a _sorted_ list and compare it with the item we're looking for.
 - If the middle element is our item, then we're done!
 - If the middle element is greater than our item, we can eliminate that element and all the elements **after** it.
 - If the middle element is less than our item, we can eliminate that element and all the elements **before** it.

exercises/practice/book-store/.docs/instructions.md

@@ -36,8 +36,8 @@ This would give a total of:
 
 Resulting in:
 
-- 5 × (100% - 25%) * $8 = 5 × $6.00 = $30.00, plus
-- 3 × (100% - 10%) * $8 = 3 × $7.20 = $21.60
+- 5 × (100% - 25%) × $8 = 5 × $6.00 = $30.00, plus
+- 3 × (100% - 10%) × $8 = 3 × $7.20 = $21.60
 
 Which equals $51.60.
 
@@ -53,8 +53,8 @@ This would give a total of:
 
 Resulting in:
 
-- 4 × (100% - 20%) * $8 = 4 × $6.40 = $25.60, plus
-- 4 × (100% - 20%) * $8 = 4 × $6.40 = $25.60
+- 4 × (100% - 20%) × $8 = 4 × $6.40 = $25.60, plus
+- 4 × (100% - 20%) × $8 = 4 × $6.40 = $25.60
 
 Which equals $51.20.
 

exercises/practice/bowling/.docs/instructions.md

@@ -23,9 +23,9 @@ There are three cases for the tabulation of a frame.
 
 Here is a three frame example:
 
-| Frame 1         | Frame 2       | Frame 3                |
-| :-------------: |:-------------:| :---------------------:|
-| X (strike)      | 5/ (spare)    | 9 0 (open frame)       |
+|  Frame 1   |  Frame 2   |     Frame 3      |
+| :--------: | :--------: | :--------------: |
+| X (strike) | 5/ (spare) | 9 0 (open frame) |
 
 Frame 1 is (10 + 5 + 5) = 20
 

exercises/practice/circular-buffer/.docs/instructions.md

@@ -4,39 +4,55 @@ A circular buffer, cyclic buffer or ring buffer is a data structure that uses a
 
 A circular buffer first starts empty and of some predefined length.
 For example, this is a 7-element buffer:
-<!-- prettier-ignore -->
-    [ ][ ][ ][ ][ ][ ][ ]
+
+```text
+[ ][ ][ ][ ][ ][ ][ ]
+```
 
 Assume that a 1 is written into the middle of the buffer (exact starting location does not matter in a circular buffer):
-<!-- prettier-ignore -->
-    [ ][ ][ ][1][ ][ ][ ]
+
+```text
+[ ][ ][ ][1][ ][ ][ ]
+```
 
 Then assume that two more elements are added — 2 & 3 — which get appended after the 1:
-<!-- prettier-ignore -->
-    [ ][ ][ ][1][2][3][ ]
+
+```text
+[ ][ ][ ][1][2][3][ ]
+```
 
 If two elements are then removed from the buffer, the oldest values inside the buffer are removed.
 The two elements removed, in this case, are 1 & 2, leaving the buffer with just a 3:
-<!-- prettier-ignore -->
-    [ ][ ][ ][ ][ ][3][ ]
+
+```text
+[ ][ ][ ][ ][ ][3][ ]
+```
 
 If the buffer has 7 elements then it is completely full:
-<!-- prettier-ignore -->
-    [5][6][7][8][9][3][4]
+
+```text
+[5][6][7][8][9][3][4]
+```
 
 When the buffer is full an error will be raised, alerting the client that further writes are blocked until a slot becomes free.
 
 When the buffer is full, the client can opt to overwrite the oldest data with a forced write.
 In this case, two more elements — A & B — are added and they overwrite the 3 & 4:
-<!-- prettier-ignore -->
-    [5][6][7][8][9][A][B]
+
+```text
+[5][6][7][8][9][A][B]
+```
 
 3 & 4 have been replaced by A & B making 5 now the oldest data in the buffer.
 Finally, if two elements are removed then what would be returned is 5 & 6 yielding the buffer:
-<!-- prettier-ignore -->
-    [ ][ ][7][8][9][A][B]
+
+```text
+[ ][ ][7][8][9][A][B]
+```
 
 Because there is space available, if the client again uses overwrite to store C & D then the space where 5 & 6 were stored previously will be used not the location of 7 & 8.
 7 is still the oldest element and the buffer is once again full.
-<!-- prettier-ignore -->
-    [C][D][7][8][9][A][B]
+
+```text
+[C][D][7][8][9][A][B]
+```

exercises/practice/clock/.meta/config.json

@@ -14,6 +14,5 @@
     ]
   },
   "blurb": "Implement a clock that handles times without dates.",
-  "source": "Pairing session with Erin Drummond",
-  "source_url": "https://twitter.com/ebdrummond"
+  "source": "Pairing session with Erin Drummond"
 }

exercises/practice/darts/.docs/instructions.md

@@ -6,6 +6,8 @@ Write a function that returns the earned points in a single toss of a Darts game
 
 In our particular instance of the game, the target rewards 4 different amounts of points, depending on where the dart lands:
 
+![Our dart scoreboard with values from a complete miss to a bullseye](https://assets.exercism.org/images/exercises/darts/darts-scoreboard.svg)
+
 - If the dart lands outside the target, player earns no points (0 points).
 - If the dart lands in the outer circle of the target, player earns 1 point.
 - If the dart lands in the middle circle of the target, player earns 5 points.
@@ -16,8 +18,14 @@ Of course, they are all centered at the same point — that is, the circles are
 
 Write a function that given a point in the target (defined by its [Cartesian coordinates][cartesian-coordinates] `x` and `y`, where `x` and `y` are [real][real-numbers]), returns the correct amount earned by a dart landing at that point.
 
+## Credit
+
+The scoreboard image was created by [habere-et-dispertire][habere-et-dispertire] using [Inkscape][inkscape].
+
 [darts]: https://en.wikipedia.org/wiki/Darts
 [darts-target]: https://en.wikipedia.org/wiki/Darts#/media/File:Darts_in_a_dartboard.jpg
 [concentric]: https://mathworld.wolfram.com/ConcentricCircles.html
 [cartesian-coordinates]: https://www.mathsisfun.com/data/cartesian-coordinates.html
 [real-numbers]: https://www.mathsisfun.com/numbers/real-numbers.html
+[habere-et-dispertire]: https://exercism.org/profiles/habere-et-dispertire
+[inkscape]: https://en.wikipedia.org/wiki/Inkscape

exercises/practice/hello-world/.meta/config.json

@@ -20,7 +20,7 @@
       ".meta/src/example.cr"
     ]
   },
-  "blurb": "The classical introductory exercise. Just say \"Hello, World!\".",
+  "blurb": "Exercism's classic introductory exercise. Just say \"Hello, World!\".",
   "source": "This is an exercise to introduce users to using Exercism",
   "source_url": "https://en.wikipedia.org/wiki/%22Hello,_world!%22_program"
 }

exercises/practice/isogram/.docs/instructions.md

@@ -11,4 +11,4 @@ Examples of isograms:
 - downstream
 - six-year-old
 
-The word *isograms*, however, is not an isogram, because the s repeats.
+The word _isograms_, however, is not an isogram, because the s repeats.

exercises/practice/knapsack/.docs/instructions.md

@@ -13,10 +13,12 @@ Given a knapsack with a specific carrying capacity (W), help Bob determine the m
 Note that Bob can take only one of each item.
 
 All values given will be strictly positive.
-Items will be represented as a list of pairs, `wi` and `vi`, where the first element `wi` is the weight of the *i*th item and `vi` is the value for that item.
+Items will be represented as a list of items.
+Each item will have a weight and value.
 
 For example:
 
+```none
 Items: [
   { "weight": 5, "value": 10 },
   { "weight": 4, "value": 40 },
@@ -25,6 +27,7 @@ Items: [
 ]
 
 Knapsack Limit: 10
+```
 
 For the above, the first item has weight 5 and value 10, the second item has weight 4 and value 40, and so on.
 

exercises/practice/knapsack/.meta/test_template.ecr

@@ -4,7 +4,7 @@ require "../src/*"
 describe <%= to_capitalized(@json["exercise"].to_s).inspect %> do
     <% @json["cases"].as_a.each do |cases| %>
         <%= status()%> "<%-= cases["description"] %>" do
-            <%= cases["property"].to_s.underscore %> = <%= to_capitalized(@json["exercise"].to_s) %>.<%= cases["property"].to_s.underscore %>(<%= cases["input"]["maximumWeight"].inspect %>, <%= cases["input"]["items"].inspect.gsub("\"", "").gsub(" =>", ":").gsub("{", "\n{").gsub("\n{}", "[] of NamedTuple(weight: Int32, value: Int32)") %>)
+            <%= cases["property"].to_s.underscore %> = <%= to_capitalized(@json["exercise"].to_s) %>.<%= cases["property"].to_s.underscore %>(<%= cases["input"]["maximumWeight"].inspect %>, <%= cases["input"]["items"].inspect.gsub("\"", "").gsub(" =>", ":").gsub("{", "\n{").gsub("[]", "[] of NamedTuple(weight: Int32, value: Int32)") %>)
             <%= cases["property"].to_s.underscore %>.should eq(<%= cases["expected"].inspect %>)
         end
     <% end %>

exercises/practice/knapsack/.meta/tests.toml

@@ -11,6 +11,11 @@
 
 [a4d7d2f0-ad8a-460c-86f3-88ba709d41a7]
 description = "no items"
+include = false
+
+[3993a824-c20e-493d-b3c9-ee8a7753ee59]
+description = "no items"
+reimplements = "a4d7d2f0-ad8a-460c-86f3-88ba709d41a7"
 
 [1d39e98c-6249-4a8b-912f-87cb12e506b0]
 description = "one item, too heavy"

exercises/practice/meetup/.meta/config.json

@@ -15,5 +15,5 @@
   },
   "blurb": "Calculate the date of meetups.",
   "source": "Jeremy Hinegardner mentioned a Boulder meetup that happens on the Wednesteenth of every month",
-  "source_url": "https://twitter.com/copiousfreetime"
+  "source_url": "http://www.copiousfreetime.org/"
 }

exercises/practice/perfect-numbers/.docs/instructions.md

@@ -1,24 +1,39 @@
 # Instructions
 
-Determine if a number is perfect, abundant, or deficient based on
-Nicomachus' (60 - 120 CE) classification scheme for positive integers.
-
-The Greek mathematician [Nicomachus][nicomachus] devised a classification scheme for positive integers, identifying each as belonging uniquely to the categories of **perfect**, **abundant**, or **deficient** based on their [aliquot sum][aliquot-sum].
-The aliquot sum is defined as the sum of the factors of a number not including the number itself.
-For example, the aliquot sum of 15 is (1 + 3 + 5) = 9
-
-- **Perfect**: aliquot sum = number
-  - 6 is a perfect number because (1 + 2 + 3) = 6
-  - 28 is a perfect number because (1 + 2 + 4 + 7 + 14) = 28
-- **Abundant**: aliquot sum > number
-  - 12 is an abundant number because (1 + 2 + 3 + 4 + 6) = 16
-  - 24 is an abundant number because (1 + 2 + 3 + 4 + 6 + 8 + 12) = 36
-- **Deficient**: aliquot sum < number
-  - 8 is a deficient number because (1 + 2 + 4) = 7
-  - Prime numbers are deficient
-
-Implement a way to determine whether a given number is **perfect**.
-Depending on your language track, you may also need to implement a way to determine whether a given number is **abundant** or **deficient**.
+Determine if a number is perfect, abundant, or deficient based on Nicomachus' (60 - 120 CE) classification scheme for positive integers.
+
+The Greek mathematician [Nicomachus][nicomachus] devised a classification scheme for positive integers, identifying each as belonging uniquely to the categories of [perfect](#perfect), [abundant](#abundant), or [deficient](#deficient) based on their [aliquot sum][aliquot-sum].
+The _aliquot sum_ is defined as the sum of the factors of a number not including the number itself.
+For example, the aliquot sum of `15` is `1 + 3 + 5 = 9`.
+
+## Perfect
+
+A number is perfect when it equals its aliquot sum.
+For example:
+
+- `6` is a perfect number because `1 + 2 + 3 = 6`
+- `28` is a perfect number because `1 + 2 + 4 + 7 + 14 = 28`
+
+## Abundant
+
+A number is abundant when it is less than its aliquot sum.
+For example:
+
+- `12` is an abundant number because `1 + 2 + 3 + 4 + 6 = 16`
+- `24` is an abundant number because `1 + 2 + 3 + 4 + 6 + 8 + 12 = 36`
+
+## Deficient
+
+A number is deficient when it is greater than its aliquot sum.
+For example:
+
+- `8` is a deficient number because `1 + 2 + 4 = 7`
+- Prime numbers are deficient
+
+## Task
+
+Implement a way to determine whether a given number is [perfect](#perfect).
+Depending on your language track, you may also need to implement a way to determine whether a given number is [abundant](#abundant) or [deficient](#deficient).
 
 [nicomachus]: https://en.wikipedia.org/wiki/Nicomachus
 [aliquot-sum]: https://en.wikipedia.org/wiki/Aliquot_sum