From 1cb018146d1da3bc93caa21dbc8c83a0fb6b9947 Mon Sep 17 00:00:00 2001
From: Cody Boone Ferguson <53008573+xexyl@users.noreply.github.com>
Date: Sun, 30 Apr 2023 08:55:28 -0700
Subject: [PATCH] Format fix 2006/meyer/README.md

---
 2006/meyer/README.md | 72 ++++++++++++++++++++++++++------------------
 1 file changed, 43 insertions(+), 29 deletions(-)

diff --git a/2006/meyer/README.md b/2006/meyer/README.md
index b44a09b47..88331cd4a 100644
--- a/2006/meyer/README.md
+++ b/2006/meyer/README.md
@@ -1,7 +1,7 @@
 # Best Game
 
-    Raphael Meyer
-    US
+Raphael Meyer  
+US  
 
 ## To build:
 
@@ -34,41 +34,46 @@ more text to fulfil the program's requirements.
 
 This entry turns a newspaper solitaire puzzle into a competition
 with the computer to be the last one moving.  The object of this
-source code is to determine the object of this source code!  :-)
+[source code](meyer.c) is to determine the object of this [source
+code](meyer.c)!  :-)
 
 ## Author's remarks:
 
 I wanted submit a fully object-oriented entry to show that
 object-orientated code:
 
-  1. is ridiculously bloated
-  2. is unreadable
-  3. isn't WYWIWID (what you write is what it does) anymore
+1. is ridiculously bloated.
+2. is unreadable.
+3. isn't '`WYWIWID`' ('what you write is what it does') anymore.
 
 But I just totally failed. No, I didn't fail in showing any of
 the points above. Before I even had the chance to prove any of
 these claims, (1) already brought me to my knees. The code got
-so much bloated up, that I missed the size limit by a few hundred
+so bloated up, that I missed the size limit by a few hundred
 bytes. Therefore, I broke the only rule in this contest, I think
 you shouldn't break in any case: Rule Nr 2, The size of ...
 
 The degree of claim (2) actually depends on the compiler. As I
-_manually_ compiled it from [a generic object-oriented programming
-language] to C, it didn't just end up unreadable, but awfully
+_manually_ translated it from a generic object-oriented programming
+language to C, it didn't just end up unreadable, but awfully
 messed up, i.e. obfuscated.
 
-As it is already (pre)compiled to C, you could also call it an object-
+As it is already (pre)translated to C, you could also call it an object-
 disoriented program.
 
 Comparing this program to a potential object-oriented implementation,
-it is obvious, that object-oriented code isn't WYWIWID (what
-you write is what it does). It may be tempting to think that
+it is obvious, that object-oriented code isn't '`WYWIWID`' ('what
+you write is what it does'). It may be tempting to think that
 
+```
         Object o;
+```
 
 might do something similar as
 
+```c
         struct not_an_object o;
+```
 
 But this program reveals that it doesn't. Even worse, this program only
 reveals the tip of the iceberg, what kind of black magic is involved in
@@ -77,43 +82,52 @@ a simple declaration of an object.
 A few things you can explore about object-orientation in this program
 include:
 
-  - constructors (invoked by the new operator)
-  - new operators (every class gets its own new operator at compile time)
-  - virtual method tables
-    (all the virtual method tables have been combined to a single vtable)
-  - runtime method binding
-  - inheritance and polymorphism
+- constructors (invoked by the new operator).
+- new operators (every class gets its own new operator at compile time).
+- virtual method tables (all the virtual method tables have been combined to a
+single [vtable](https://en.wikipedia.org/wiki/Virtual_method_table)).
+- runtime method binding.
+-
+[inheritance](https://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming))
+and
+[polymorphism](https://en.wikipedia.org/wiki/Polymorphism_(computer_science)).
 
 It is left as an exercise to the reader to find a corresponding
 implementation in a popular object-oriented programming language.
 
 ### Starting the game
 
-        ./meyer [SEED]
+```sh
+./meyer [SEED]
+```
 
 ### Gameplay
 
-It is a sudoku based game. The goal of the game is to be able
-to do the last valid 'move'.
+It is a [sudoku](https://en.wikipedia.org/wiki/Sudoku) based game. The goal of
+the game is to be able to do the last valid 'move'.
 
 On your turn you have to set a free cell to a value between 1 to 9 without
 breaking the following rule. Any number must be unique in its:
 
-    1. row
-    2. column
-    3. 3x3 block.
+1. row
+2. column
+3. 3x3 block.
 
 Expected input for your move:
 
-        row column number
+```
+row column number
+```
 
 where
 
-        row:    [a-i]
-        column: [0-8]
-        number: [1-9].
+```
+row:    [a-i]
+column: [0-8]
+number: [1-9].
+```
 
-The game can be aborted with 'q'.
+The game can be aborted with `q`.
 
 The one who can do the last move wins the game.