Use hyphens for bulleted lists (#2138)

Author: kytrinyx

.markdownlint.jsonc

@@ -1,6 +1,7 @@
 // For information on writing markdownlint configuration see:
 //  https://github.com/DavidAnson/markdownlint/blob/main/README.md#optionsconfig
 {
+    "MD004": "dash", // Prefer hyphens for unordered lists
     "MD013": false,  // Exercism tends to break lines at sentence ends rather than at a column limit
     "MD024": false   // The format for instructions.md requires  repeated headings, e.g. "Task"
 }

exercises/allergies/description.md

@@ -6,21 +6,21 @@ An allergy test produces a single numeric score which contains the information a
 
 The list of items (and their value) that were tested are:
 
-* eggs (1)
-* peanuts (2)
-* shellfish (4)
-* strawberries (8)
-* tomatoes (16)
-* chocolate (32)
-* pollen (64)
-* cats (128)
+- eggs (1)
+- peanuts (2)
+- shellfish (4)
+- strawberries (8)
+- tomatoes (16)
+- chocolate (32)
+- pollen (64)
+- cats (128)
 
 So if Tom is allergic to peanuts and chocolate, he gets a score of 34.
 
 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.
+- 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.).
 Your program should ignore those components of the score.

exercises/bowling/description.md

@@ -11,13 +11,13 @@ The game consists of 10 frames.
 A frame is composed of one or two ball throws with 10 pins standing at frame initialization.
 There are three cases for the tabulation of a frame.
 
-* An open frame is where a score of less than 10 is recorded for the frame.
+- An open frame is where a score of less than 10 is recorded for the frame.
   In this case the score for the frame is the number of pins knocked down.
 
-* A spare is where all ten pins are knocked down by the second throw.
+- A spare is where all ten pins are knocked down by the second throw.
   The total value of a spare is 10 plus the number of pins knocked down in their next throw.
 
-* A strike is where all ten pins are knocked down by the first throw.
+- A strike is where all ten pins are knocked down by the first throw.
   The total value of a strike is 10 plus the number of pins knocked down in the next two throws.
   If a strike is immediately followed by a second strike, then the value of the first strike cannot be determined until the ball is thrown one more time.
 
@@ -50,7 +50,7 @@ For a tenth frame of XXX (three strikes), the total value is 30.
 Write code to keep track of the score of a game of bowling.
 It should support two operations:
 
-* `roll(pins : int)` is called each time the player rolls a ball.
+- `roll(pins : int)` is called each time the player rolls a ball.
   The argument is the number of pins knocked down.
-* `score() : int` is called only at the very end of the game.
+- `score() : int` is called only at the very end of the game.
   It returns the total score for that game.

exercises/darts/description.md

@@ -6,10 +6,10 @@ 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:
 
-* 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.
-* If the dart lands in the inner circle of the target, player earns 10 points.
+- 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.
+- If the dart lands in the inner circle of the target, player earns 10 points.
 
 The outer circle has a radius of 10 units (this is equivalent to the total radius for the entire target), the middle circle a radius of 5 units, and the inner circle a radius of 1.
 Of course, they are all centered at the same point (that is, the circles are [concentric][] defined by the coordinates (0, 0).

exercises/diamond/description.md

@@ -5,17 +5,17 @@ Given a letter, it prints a diamond starting with 'A', with the supplied letter
 
 ## Requirements
 
-* The first row contains one 'A'.
-* The last row contains one 'A'.
-* All rows, except the first and last, have exactly two identical letters.
-* All rows have as many trailing spaces as leading spaces. (This might be 0).
-* The diamond is horizontally symmetric.
-* The diamond is vertically symmetric.
-* The diamond has a square shape (width equals height).
-* The letters form a diamond shape.
-* The top half has the letters in ascending order.
-* The bottom half has the letters in descending order.
-* The four corners (containing the spaces) are triangles.
+- The first row contains one 'A'.
+- The last row contains one 'A'.
+- All rows, except the first and last, have exactly two identical letters.
+- All rows have as many trailing spaces as leading spaces. (This might be 0).
+- The diamond is horizontally symmetric.
+- The diamond is vertically symmetric.
+- The diamond has a square shape (width equals height).
+- The letters form a diamond shape.
+- The top half has the letters in ascending order.
+- The bottom half has the letters in descending order.
+- The four corners (containing the spaces) are triangles.
 
 ## Examples
 

exercises/dnd-character/description.md

@@ -13,12 +13,12 @@ Write a random character generator that follows the rules above.
 
 For example, the six throws of four dice may look like:
 
-* 5, 3, 1, 6: You discard the 1 and sum 5 + 3 + 6 = 14, which you assign to strength.
-* 3, 2, 5, 3: You discard the 2 and sum 3 + 5 + 3 = 11, which you assign to dexterity.
-* 1, 1, 1, 1: You discard the 1 and sum 1 + 1 + 1 = 3, which you assign to constitution.
-* 2, 1, 6, 6: You discard the 1 and sum 2 + 6 + 6 = 14, which you assign to intelligence.
-* 3, 5, 3, 4: You discard the 3 and sum 5 + 3 + 4 = 12, which you assign to wisdom.
-* 6, 6, 6, 6: You discard the 6 and sum 6 + 6 + 6 = 18, which you assign to charisma.
+- 5, 3, 1, 6: You discard the 1 and sum 5 + 3 + 6 = 14, which you assign to strength.
+- 3, 2, 5, 3: You discard the 2 and sum 3 + 5 + 3 = 11, which you assign to dexterity.
+- 1, 1, 1, 1: You discard the 1 and sum 1 + 1 + 1 = 3, which you assign to constitution.
+- 2, 1, 6, 6: You discard the 1 and sum 2 + 6 + 6 = 14, which you assign to intelligence.
+- 3, 5, 3, 4: You discard the 3 and sum 5 + 3 + 4 = 12, which you assign to wisdom.
+- 6, 6, 6, 6: You discard the 6 and sum 6 + 6 + 6 = 18, which you assign to charisma.
 
 Because constitution is 3, the constitution modifier is -4 and the hitpoints are 6.
 

exercises/linked-list/description.md

@@ -13,10 +13,10 @@ You will write an implementation of a doubly linked list.
 Implement a Node to hold a value and pointers to the next and previous nodes.
 Then implement a List which holds references to the first and last node and offers an array-like interface for adding and removing items:
 
-* `push` (*insert value at back*);
-* `pop` (*remove value at back*);
-* `shift` (*remove value at front*).
-* `unshift` (*insert value at front*);
+- `push` (*insert value at back*);
+- `pop` (*remove value at back*);
+- `shift` (*remove value at front*).
+- `unshift` (*insert value at front*);
 
 To keep your implementation simple, the tests will not cover error conditions.
 Specifically: `pop` or `shift` will never be called on an empty list.

exercises/list-ops/description.md

@@ -7,11 +7,11 @@ Implement a series of basic list operations, without using existing functions.
 
 The precise number and names of the operations to be implemented will be track dependent to avoid conflicts with existing names, but the general operations you will implement include:
 
-* `append` (*given two lists, add all items in the second list to the end of the first list*);
-* `concatenate` (*given a series of lists, combine all items in all lists into one flattened list*);
-* `filter` (*given a predicate and a list, return the list of all items for which `predicate(item)` is True*);
-* `length` (*given a list, return the total number of items within it*);
-* `map` (*given a function and a list, return the list of the results of applying `function(item)` on all items*);
-* `foldl` (*given a function, a list, and initial accumulator, fold (reduce) each item into the accumulator from the left using `function(accumulator, item)`*);
-* `foldr` (*given a function, a list, and an initial accumulator, fold (reduce) each item into the accumulator from the right using `function(item, accumulator)`*);
-* `reverse` (*given a list, return a list with all the original items, but in reversed order*);
+- `append` (*given two lists, add all items in the second list to the end of the first list*);
+- `concatenate` (*given a series of lists, combine all items in all lists into one flattened list*);
+- `filter` (*given a predicate and a list, return the list of all items for which `predicate(item)` is True*);
+- `length` (*given a list, return the total number of items within it*);
+- `map` (*given a function and a list, return the list of the results of applying `function(item)` on all items*);
+- `foldl` (*given a function, a list, and initial accumulator, fold (reduce) each item into the accumulator from the left using `function(accumulator, item)`*);
+- `foldr` (*given a function, a list, and an initial accumulator, fold (reduce) each item into the accumulator from the right using `function(item, accumulator)`*);
+- `reverse` (*given a list, return a list with all the original items, but in reversed order*);

exercises/micro-blog/description.md

@@ -16,18 +16,18 @@ The task is to truncate input strings to 5 characters.
 Text stored digitally has to be converted to a series of bytes.
 There are 3 ways to map characters to bytes in common use.
 
-* **ASCII** can encode English language characters.
+- **ASCII** can encode English language characters.
   All characters are precisely 1 byte long.
-* **UTF-8** is a Unicode text encoding.
+- **UTF-8** is a Unicode text encoding.
   Characters take between 1 and 4 bytes.
-* **UTF-16** is a Unicode text encoding.
+- **UTF-16** is a Unicode text encoding.
   Characters are either 2 or 4 bytes long.
 
 UTF-8 and UTF-16 are both Unicode encodings which means they're capable of representing a massive range of characters including:
 
-* Text in most of the world's languages and scripts
-* Historic text
-* Emoji
+- Text in most of the world's languages and scripts
+- Historic text
+- Emoji
 
 UTF-8 and UTF-16 are both variable length encodings, which means that different characters take up different amounts of space.
 

exercises/resistor-color-duo/description.md

@@ -3,8 +3,8 @@
 If you want to build something using a Raspberry Pi, you'll probably use _resistors_.
 For this exercise, you need to know two things about them:
 
-* Each resistor has a resistance value.
-* Resistors are small - so small in fact that if you printed the resistance value on them, it would be hard to read.
+- Each resistor has a resistance value.
+- Resistors are small - so small in fact that if you printed the resistance value on them, it would be hard to read.
 
 To get around this problem, manufacturers print color-coded bands onto the resistors to denote their resistance values.
 Each band has a position and a numeric value.
@@ -17,16 +17,16 @@ The program will take color names as input and output a two digit number, even i
 
 The band colors are encoded as follows:
 
-* Black: 0
-* Brown: 1
-* Red: 2
-* Orange: 3
-* Yellow: 4
-* Green: 5
-* Blue: 6
-* Violet: 7
-* Grey: 8
-* White: 9
+- Black: 0
+- Brown: 1
+- Red: 2
+- Orange: 3
+- Yellow: 4
+- Green: 5
+- Blue: 6
+- Violet: 7
+- Grey: 8
+- White: 9
 
 From the example above:
 brown-green should return 15