Cleanup instructions headings

exercises/concept/key-comparison/.docs/introduction.md

@@ -1,5 +1,3 @@
-## sameness
-
 Common Lisp has many different equality predicates. This differs from other programming languages which may have only one or two (perhaps `==` and `===` for example). Some of these predicates in Common Lisp are specific to types, while others are generic. It is these latter that this exercise will teach.
 
 There are four generic equality predicates and they differ by their restrictiveness on what they consider "equal". They are, in order from most restrictive to least restrictive: `eq`, `eql`, `equal`, and `equalp`.

exercises/concept/leslies-lists/.docs/introduction.md

@@ -1,5 +1,3 @@
-## lists
-
 Given that the name of the language is Lisp which stands of _LISt Processing_ one might assume that the language has facilities for handling lists of items, and you'd be correct!
 
 While Common Lisp has other data structures as well as lists, lists are still heavily used.

exercises/concept/lillys-lasagna/.docs/introduction.md

@@ -1,5 +1,3 @@
-## functions
-
 To define a global function in Common Lisp one uses the `defun`
 expression. This expression takes as its first argument a list of
 parameters (and empty list means the function has no parameters). This

exercises/concept/pal-picker/.docs/introduction.md

@@ -1,8 +1,8 @@
-## truthy-and-falsy
+## Truthy And Falsy
 
 In Common Lisp all values are "true" except for `()` which is "false". There are two special constant symbols `t` and `nil` whose values are true and false respectively.
 
-## conditionals
+## Conditionals
 
 Common lisp provides several different conditional expressions, the main difference being the number of branches they support.
 

exercises/concept/pizza-pi/.docs/introduction.md

@@ -1,6 +1,6 @@
 In Common Lisp, like many languages, numbers come in a few of types – two of the most basic are:
 
-## integers
+## Integers
 
 Like many languages Common Lisp contains integers. These are whole numbers without a decimal point (like `-6`, `0`, `25`, `1234`,
 etc.)
@@ -11,11 +11,11 @@ In general, if you are working with only whole numbers, you should prefer
 integers as they don't suffer from the same loss of precision as floating-point
 numbers do over many calculations.
 
-## floating-point-numbers
+## Floating Point Numbers
 
 Also like many languages, Common Lisp contains floating point numbers. These are fractional or whole numbers including a decimal point (like `3.14`, `-1.7`, `99.99`, `2048.0`)
 
-## arithmetic
+## Arithmetic
 
 Common Lisp uses the standard arithmetic operators for most operations but is
 somewhat unique in using a "prefix-notation" as opposed to the more familiar

exercises/concept/socks-and-sexprs/.docs/introduction.md

@@ -1,4 +1,4 @@
-## comments
+## Comments
 
 Common Lisp allows the programmer to write "comments" that are ignored by the
 computer. Single-line comments begin with one or more semi-colons (`;`) and,
@@ -11,7 +11,7 @@ occasionally, you may see the following:
 Where the comment is being used to indicate what value is returned by Common
 Lisp after running the code on that line.
 
-## cons
+## Cons
 
 All Common Lisp code is either an "atom" (a single, indivisible value) or a list
 (also termed a "cons"). A cons is made up of two parts: the first element and
@@ -25,7 +25,7 @@ the rest of the elements. For historical reasons these two parts are called the
 ; ^ car ^  |        ^ cdr ^
 ```
 
-## expressions
+## Expressions
 
 Together, the atoms and conses that make up Lisp code are referred to as
 S-Expressions (or sexpr for short). When S-Expressions are evaluated, they
@@ -40,7 +40,7 @@ the `defun` is automatically returned:
 (gimme-foo) ; => FOO
 ```
 
-## symbols
+## Symbols
 
 There are a couple of things to note regarding the example above. Firstly, the
 _symbol_ `FOO` is an atom, as it only has one "part" (unlike a cons which has