Use backtick code blocks for syntax highlighting

10-03.md

@@ -45,49 +45,51 @@ Figure 10.3. Listing 10.3 is an implementation of Euclid's algorithm.
 
 **LISTING 10.3 L10-3.C**
 
-    /* Finds and returns the greatest common divisor of two integers.
-       Uses Euclid's algorithm: divides the larger integer by the
-       smaller; if the remainder is 0, the smaller integer is the GCD,
-       otherwise the smaller integer becomes the larger integer, the
-       remainder becomes the smaller integer, and the process is
-       repeated. */
+```c
+/* Finds and returns the greatest common divisor of two integers.
+   Uses Euclid's algorithm: divides the larger integer by the
+   smaller; if the remainder is 0, the smaller integer is the GCD,
+   otherwise the smaller integer becomes the larger integer, the
+   remainder becomes the smaller integer, and the process is
+   repeated. */
 
-    static unsigned int gcd_recurs(unsigned int, unsigned int);
+static unsigned int gcd_recurs(unsigned int, unsigned int);
 
-    unsigned int gcd(unsigned int int1, unsigned int int2) {
-       unsigned int temp;
-       /* If the two integers are the same, that's the GCD and we're
-          done */
-       if (int1 == int2) {
-          return(int1);
-       }
-       /* Swap if necessary to make sure that int1 >= int2 */
-       if (int1 < int2) {
-          temp = int1;
-          int1 = int2;
-          int2 = temp;
-       }
+unsigned int gcd(unsigned int int1, unsigned int int2) {
+   unsigned int temp;
+   /* If the two integers are the same, that's the GCD and we're
+      done */
+   if (int1 == int2) {
+      return(int1);
+   }
+   /* Swap if necessary to make sure that int1 >= int2 */
+   if (int1 < int2) {
+      temp = int1;
+      int1 = int2;
+      int2 = temp;
+   }
 
-       /* Now call the recursive form of the function, which assumes
-          that the first parameter is the larger of the two */
-       return(gcd_recurs(int1, int2));
-    }
+   /* Now call the recursive form of the function, which assumes
+      that the first parameter is the larger of the two */
+   return(gcd_recurs(int1, int2));
+}
 
-    static unsigned int gcd_recurs(unsigned int larger_int,
-          unsigned int smaller_int)
-    {
-       int temp;
+static unsigned int gcd_recurs(unsigned int larger_int,
+      unsigned int smaller_int)
+{
+   int temp;
 
-       /* If the remainder of larger_int divided by smaller_int is 0,
-          then smaller_int is the gcd */
-       if ((temp = larger_int % smaller_int) == 0) {
-          return(smaller_int);
-       }
-       /* Make smaller_int the larger integer and the remainder the
-          smaller integer, and call this function recursively to
-          continue the process */
-       return(gcd_recurs(smaller_int, temp));
-    }
+   /* If the remainder of larger_int divided by smaller_int is 0,
+      then smaller_int is the gcd */
+   if ((temp = larger_int % smaller_int) == 0) {
+      return(smaller_int);
+   }
+   /* Make smaller_int the larger integer and the remainder the
+      smaller integer, and call this function recursively to
+      continue the process */
+   return(gcd_recurs(smaller_int, temp));
+}
+```
 
 As you can see from Table 10.1, Euclid's algorithm is superior,
 especially for large numbers (and imagine if we were working with large
@@ -129,38 +131,40 @@ recursive operations that Listing 10.3 does.
 
 **LISTING 10.4 L10-4.C**
 
-    /* Finds and returns the greatest common divisor of two integers.
-       Uses Euclid's algorithm: divides the larger integer by the
-       smaller; if the remainder is 0, the smaller integer is the GCD,
-       otherwise the smaller integer becomes the larger integer, the
-       remainder becomes the smaller integer, and the process is
-       repeated. Avoids code recursion. */
+```c
+/* Finds and returns the greatest common divisor of two integers.
+   Uses Euclid's algorithm: divides the larger integer by the
+   smaller; if the remainder is 0, the smaller integer is the GCD,
+   otherwise the smaller integer becomes the larger integer, the
+   remainder becomes the smaller integer, and the process is
+   repeated. Avoids code recursion. */
 
-    unsigned int gcd(unsigned int int1, unsigned int int2) {
-       unsigned int temp;
+unsigned int gcd(unsigned int int1, unsigned int int2) {
+   unsigned int temp;
 
-       /* Swap if necessary to make sure that int1 >= int2 */
-       if (int1 < int2) {
-          temp = int1;
-          int1 = int2;
-          int2 = temp;
-       }
-       /* Now loop, dividing int1 by int2 and checking the remainder,
-          until the remainder is 0. At each step, if the remainder isn't
-          0, assign int2 to int1, and the remainder to int2, then
-          repeat */
-       for (;;) {
-          /* If the remainder of int1 divided by int2 is 0, then int2 is
-             the gcd */
-          if ((temp = int1 % int2) == 0) {
-             return(int2);
-          }
-          /* Make int2 the larger integer and the remainder the
-             smaller integer, and repeat the process */
-          int1 = int2;
-          int2 = temp;
-       }
-    }
+   /* Swap if necessary to make sure that int1 >= int2 */
+   if (int1 < int2) {
+      temp = int1;
+      int1 = int2;
+      int2 = temp;
+   }
+   /* Now loop, dividing int1 by int2 and checking the remainder,
+      until the remainder is 0. At each step, if the remainder isn't
+      0, assign int2 to int1, and the remainder to int2, then
+      repeat */
+   for (;;) {
+      /* If the remainder of int1 divided by int2 is 0, then int2 is
+         the gcd */
+      if ((temp = int1 % int2) == 0) {
+         return(int2);
+      }
+      /* Make int2 the larger integer and the remainder the
+         smaller integer, and repeat the process */
+      int1 = int2;
+      int2 = temp;
+   }
+}
+```
 
 #### Patient Optimization {#Heading7}