Use emphasized style of return values consistently

Author: paulgoetze

2_Numbers/1_The_different_types_of_numbers/task.md

@@ -21,8 +21,8 @@ perfectly the same as `2000`.
 
 Another way to create an Integer is by calling `Integer()` with a parameter, e.g.:
 
-`  Integer(3)`   # => 3
-`  Integer('3')` # => 3
+`  Integer(3)`   *# => 3*
+`  Integer('3')` *# => 3*
 
 Internally, Ruby uses two different classes for Integers. Dependent on how big the
 Integer is it uses a *Fixnum* or a *Bignum*. You don't have to worry about which class to
@@ -32,8 +32,8 @@ However, you can check which class Ruby uses for your number by calling the `cla
 method on your number. Open a new terminal tab and open the interactive Ruby console
 with `irb`. Then check the class of different numbers:
 
-`  1000.class`                      # => *Fixnum*
-`  4_611_686_018_427_387_904.class` # => *Bignum*
+`  1000.class`                      *# => Fixnum*
+`  4_611_686_018_427_387_904.class` *# => Bignum*
 
 If you want to learn more, read about Fixnum and Bignum here:
 - http://patshaughnessy.net/2014/1/9/how-big-is-a-bignum
@@ -46,8 +46,8 @@ You can create a Float by declaring a number with a decimal place, like `3.0`
 or `-2_000.25`.
 Another way to create a Float is to call `Float()` with a parameter, e.g.:
 
-`  Float(3)`   # => 3.0
-`  Float('3')` # => 3.0
+`  Float(3)`   *# => 3.0*
+`  Float('3')` *# => 3.0*
 
 Read more about Float here: (ruby-doc core: Float).
 
@@ -56,9 +56,9 @@ Read more about Float here: (ruby-doc core: Float).
 A *Rational* represents a rational number (a paired integer number a/b, where b > 0).
 You can create a Rational by calling `Rational()` with one or two parameters, e.g.:
 
-`  Rational(2)`     # => *(2/1)*
-`  Rational(2, 3)`  # => *(2/3)*
-`  Rarional('2/3')` # => *(2/3)*
+`  Rational(2)`     *# => (2/1)*
+`  Rational(2, 3)`  *# => (2/3)*
+`  Rarional('2/3')` *# => (2/3)*
 
 Read more about Rational here: (ruby-doc core: Rational).
 
@@ -67,10 +67,10 @@ Read more about Rational here: (ruby-doc core: Rational).
 A *Complex* represents a complex number.
 You can create a complex number by calling `Complex()` with one or two parameters, e.g.:
 
-`  Complex(2)`          # => *(2+0i)*
-`  Complex(2.1, 0.2)`   # => *(2.1+0.2i)*
-`  Complex('2.1+0.2i')` # => *(2.1+0.2i)*
-`  Complex('2.1@0.2')`  # => *(2.0581398134666076+0.4172055946696286i)* - polar form
+`  Complex(2)`          *# => (2+0i)*
+`  Complex(2.1, 0.2)`   *# => (2.1+0.2i)*
+`  Complex('2.1+0.2i')` *# => (2.1+0.2i)*
+`  Complex('2.1@0.2')`  *# => (2.0581398134666076+0.4172055946696286i)* - polar form
 
 Read more about Complex here: (ruby-doc core: Complex).
 

2_Numbers/2_Basic_operators/task.md

@@ -20,11 +20,11 @@ share the following basic operator methods:
 You can apply these arithmetic operators by writing one of them between two
 numbers, e.g.:
 
-`  3.2 + 7`                              # => 10.2
-`  Rational(2, 3) - Rational(1, 2)`      # => (1/6)
-`  3 \* 5`                                # => 15
-`  Complex(2.0, 4) / Complex(4.0, 2.0)`  # => (0.8+0.6000000000000001i)
-`  2 \*\* 3`                               # => 8
+`  3.2 + 7`                              *# => 10.2*
+`  Rational(2, 3) - Rational(1, 2)`      *# => (1/6)*
+`  3 \* 5`                                *# => 15*
+`  Complex(2.0, 4) / Complex(4.0, 2.0)`  *# => (0.8+0.6000000000000001i)*
+`  2 \*\* 3`                               *# => 8*
 
 ## "Strange" behaviours
 
@@ -40,9 +40,9 @@ down *Integer* value (`5 / 2` equals *2*, `7 / 2` equals *3*).
 To get a floating point number you have to use a *Float* for either the numerator
 or the denominator or for both of them, i.e.:
 
-`  3.0 / 7`   # => 0.42857142857142855
-`  3 / 7.0`   # => 0.42857142857142855
-`  3.0 / 7.0` # => 0.42857142857142855
+`  3.0 / 7`   *# => 0.42857142857142855*
+`  3 / 7.0`   *# => 0.42857142857142855*
+`  3.0 / 7.0` *# => 0.42857142857142855*
 
 The inaccuracy when summing up *Floats* appears beacause a *Float* is an approximation
 of a decimal number. Since floating point numbers are stored in binary in your

2_Numbers/3_Converting_numbers/task.md

@@ -29,11 +29,11 @@ Note that the size of the fraction doesn't matter:
 `  2.01.to_i` and `2.95.to_i` will both return *2*.
 
 If you want to convert a float to an integer based on its digits after the decimal point,
-you should have a look at the `#floor`, `#ceil`, and `#round` methods of a Numeric:
+you should have a look at the following methods of a Numeric:
 
--  (ruby-doc core: Numeric#ceil)
--  (ruby-doc core: Numeric#floor)
--  (ruby-doc core: Numeric#round)
+`  #ceils`: (ruby-doc core: Numeric#ceil)
+`  #floor`: (ruby-doc core: Numeric#floor)
+`  #round`: (ruby-doc core: Numeric#round)
 
 One thing you can't do is converting a Complex number with an imaginary part other
 than `0` to an integer, float, or rational number.
@@ -54,3 +54,5 @@ Store each result in a variable that is named like the resulting type of the con
 for 1. *integer*,
 for 2. *float*,
 and so on.
+
+---