Remove string prerequisite and apply review comments

Author: SleeplessByte

concepts/comparison/about.md

@@ -1 +1,44 @@
 # About
+
+TODO: this is a stub that needs more information
+
+## Comparing numbers
+
+Numbers are considered equal if they have the same value.
+
+```javascript
+1 == 1.0;
+// => true
+
+1 === 1.0;
+// => true
+// Remember, all numbers are floating-points, so this is different syntax for
+// the exact same value.
+
+1 === 1n;
+// => false
+// Strictly checking a number against a bigint will always result in false.
+
+1 == 1n;
+// => true
+// A number is equal to a bigint if they represent the same value.
+
+1.0 == 1n;
+// => true
+// A number is equal to a bigint if they represent the same value.
+```
+
+There are different outcomes when comparing numbers with different types.
+In general, only two operands of the type `number` can ever be _strictly equal_ (`===`), and the following can be used for _loose equality_ (`==`):
+
+| A      | B         | `==`                  |
+| ------ | --------- | --------------------- |
+| Number | Undefined | `false`               |
+| Number | Null      | `false`               |
+| Number | Number    | `A === B`             |
+| Number | String    | `A === ToNumber(B)`   |
+| Number | Boolean   | `A === ToNumber(B)`   |
+| Number | Object    | `A == ToPrimitive(B)` |
+
+- `ToNumber(X)` attempts to convert its argument `X` to a `number` before comparison. It is equivalent to `+B` (the unary `+` operator).
+- `ToPrimitive(X)` attempts to convert its object argument `X` to a primitive value, by attempting to invoke varying sequences of `X.toString` and `X.valueOf` methods on `X`.

concepts/numbers/about.md

@@ -1,6 +1,6 @@
 # About
 
-There are two different kinds of numbers in JavaScript - numbers and bigints
+There are two different kinds of numbers in JavaScript - numbers and "bigints"
 
 Numbers are the most used, and represent numeric data type in the double-precision 64-bit floating point format.
 
@@ -16,7 +16,7 @@ let numericValue = 42;
 
 A number literal like `42` in JavaScript code is a floating-point value, not an integer.
 There is no separate integer type in common everyday use.
-The `BigInt` type was not designed to replace `Number` for everyday uses.
+The `bigint` type is not designed to replace the `number` type for everyday uses.
 `42` is still a `Number`, not a `BigInt`.
 
 Number may also be expressed in literal forms like `0b101`, `0o13`, `0x0A`. Learn more on numeric lexical grammar [here][lexical-grammar].
@@ -28,7 +28,7 @@ There are two built-in objects that are useful when dealing with numbers:
 - [`Number`][built-in-number]: static properties for common / useful values, static methods for [type-checking][type-checking] and [type-conversion][type-conversion], instance methods for [type-conversion][type-conversion] and [formatting numbers as strings][string-formatting].
 - [`Math`][built-in-math]: properties and methods for mathematical constants and functions, does **not** work with `BigInt`.
 
-The `Number` built-in object is _also_ a global `function` that can be used to convert _almost anything_ that can be represented as a `number` to a `number`. It is less forgiving then _parsing_ a string to a number.
+The `Number` built-in global `object` is _also_ a global `function` that can be used to convert _almost anything_ number-like to a `number`. It is less forgiving than _parsing_ a `string` to a `number`.
 
 ```javascript
 const date = new Date('December 17, 1995 03:24:00');
@@ -45,11 +45,11 @@ There are three types of maximum (and minimum / maximum negative) values for num
 - `SAFE_INTEGER`: given by `Number.MAX_SAFE_INTEGER` and `Number.MIN_SAFE_INTEGER`
 
 Because of how numbers in JavaScript are implemented, **not** every number between `Number.MIN_VALUE` and `Number.MAX_VALUE` can be represented.
-However, _every_ number between `Number.MIN_SAFE_INTEGER - 1` and `Number.MAX_SAFE_INTEGER + ` **can** be represented.
+However, _every_ number between `Number.MIN_SAFE_INTEGER - 1` and `Number.MAX_SAFE_INTEGER + 1` **can** be represented.
 
 ## Comparison
 
-Numbers can be considered equal if they have the same value.
+Numbers are considered equal if they have the same value.
 
 ```javascript
 1 == 1.0;
@@ -63,31 +63,20 @@ Numbers can be considered equal if they have the same value.
 1 === 1n;
 // => false
 // Strictly checking a number against a bigint will always result in false.
+```
 
-1 == 1n;
-// => true
-// A number is equal to a bigint if they represent the same value.
+See [comparison][concept-comparison] for more information on comparisons in general and comparing numeric values in JavaScript.
 
-1.0 == 1n;
-// => true
-// A number is equal to a bigint if they represent the same value.
-```
+## Pitfalls
 
-Because there are different ways to do [comparison][comparison], there are different outcomes when comparing numbers with different types.
-In general, only two operands of the type `number` can ever be _strictly equal_ (`===`), and the following can be used for _loose equality_ (`==`):
+Becuase numbers in JavaScript are floating point numbers, all math using these values is floating point math. Therefore, in JavaScript:
 
-| Left   | Right     | `==`                  |
-| ------ | --------- | --------------------- |
-| Number | Undefined | `false`               |
-| Number | Null      | `false`               |
-| Number | Number    | `A === B`             |
-| Number | String    | `A === ToNumber(B)`   |
-| Number | Boolean   | `A === ToNumber(B)`   |
-| Number | Object    | `A == ToPrimitive(B)` |
+```javascript
+0.1 + 0.2 === 0.3;
+// => false
+```
 
-In the above table, `ToNumber(X)` attempts to convert its argument to a number before comparison.
-Its behavior is equivalent to `+A` (the unary `+` operator).
-`ToPrimitive(X)` attempts to convert its object argument to a primitive value, by attempting to invoke varying sequences of `X.toString` and `X.valueOf` methods on `X`.
+See [0.30000000000000004.com](https://0.30000000000000004.com/) for a brief explanation and [Appendix D](https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html) of Oracle's Numerical Computation Guide "What Every Computer Scientist Should Know About Floating-Point Arithmetic" for an in depth explanation.
 
 ## Related concepts
 
@@ -103,5 +92,6 @@ Normally these would be put in a list, but it renders better when it's next to e
 [comparison]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness
 [lexical-grammar]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#numeric_literals
 [string-formatting]: https://exercism.lol/tracks/javascript/concepts/string-formating
-[type-checking]: https://exercism.lol/tracks/javascript/concepts/type-checking
-[type-conversion]: https://exercism.lol/tracks/javascript/concepts/type-conversion
+[concept-comparison]: ..
+[concept-type-checking]: https://exercism.lol/tracks/javascript/concepts/type-checking
+[concept-type-conversion]: https://exercism.lol/tracks/javascript/concepts/type-conversion

concepts/numbers/introduction.md

@@ -1,13 +1,11 @@
 # Introduction
 
-There are two different types of numbers in JavaScript:
+Many programming languages have specific numeric types to represent different types of numbers, but JavaScript only has two:
 
 - `number`: a numeric data type in the double-precision 64-bit floating point format (IEEE 754).
   Examples are `-6`, `-2.4`, `0`, `0.1`, `1`, `3.14`, `16.984025`, `25`, `976`, `1024.0` and `500000`.
 - `bigint`: a numeric data type that can represent _integers_ in the arbitrary precision format.
   Examples are `-12n`, `0n`, `4n`, and `9007199254740991n`.
 
-In contrast, in many other programming languages different numeric types can exist, for example: Integers, Floats, Doubles, or Bignums.
-
 If you require arbitrary precision or work with extremely large numbers, use the `bigint` type.
 Otherwise, the `number` type is likely the better option.

config.json

@@ -66,7 +66,7 @@
         "status": "active"
       },
       {
-        "slug": "numbers",
+        "slug": "freelancer-rates",
         "name": "Freelancer Rates",
         "uuid": "0aff2fa7-55ea-47e9-af4a-78927d916baf",
         "concepts": ["numbers"],

exercises/concept/freelancer-rates/.docs/hints.md

@@ -2,13 +2,15 @@
 
 ## 1. Calculate the day rate given an hourly rate
 
-- Use the numeric operators from Lucian's Lucious Lasagna.
+- Use the [numeric operators][ref-numeric-operators] from Lucian's Lucious Lasagna.
+
+[ref-numeric-operators]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators
 
 ## 2. Calculate the month rate, given an hourly rate and a discount
 
 - There is a global built-in function to _parse_ a `string` to a fractional number, ignoring non-numeric characters, such as the `%` (percent)-sign.
 - `100% - discount` equals the percentage after the discount is applied.
-- There is a built-in helper object called [`Math`][ref-math-object] with functions to, for example, round-down (`floor`) or round-up (`ceil`).
+- There is a built-in global object called [`Math`][ref-math-object] with functions to, for example, round-down (`floor`) or round-up (`ceil`).
 
 [ref-math-object]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math
 

exercises/concept/freelancer-rates/.docs/instructions.md

@@ -1,13 +1,13 @@
 # Instructions
 
-In this exercise you'll be writing code to help a freelancer communicate with a project manager by providing a few utilities to quickly calculate day- and month rates, optionally with a given discount.
+In this exercise you will be writing code to help a freelancer communicate with a project manager by providing a few utility functions to quickly calculate day- and month rates, optionally with a given discount.
 
 We first establish a few rules between the freelancer and the project manager:
 
 - The daily rate is 8 times the hourly rate;
 - A month has 22 billable days.
 
-The freelancer is offering to apply a discount if the project manager chooses to let the freelancer bill per month, which can come in handy if there is a certain budget the project manager has to work with.
+If the freelancer bills the project manager per month, there is a discount applied. This can be handy if the project manager has a fixed budget.
 
 Discounts are modeled as fractional numbers followed by a `%` (percentage) between `0.0%` (no discount) and `90.0%` (maximum discount).
 

exercises/concept/freelancer-rates/.docs/introduction.md

@@ -1,13 +1,11 @@
 # Introduction
 
-There are two different types of numbers in JavaScript:
+Many programming languages have specific numeric types to represent different types of numbers, but JavaScript only has two:
 
 - `number`: a numeric data type in the double-precision 64-bit floating point format (IEEE 754).
   Examples are `-6`, `-2.4`, `0`, `0.1`, `1`, `3.14`, `16.984025`, `25`, `976`, `1024.0` and `500000`.
 - `bigint`: a numeric data type that can represent _integers_ in the arbitrary precision format.
   Examples are `-12n`, `0n`, `4n`, and `9007199254740991n`.
 
-In contrast, in many other programming languages different numeric types can exist, for example: Integers, Floats, Doubles, or Bignums.
-
 If you require arbitrary precision or work with extremely large numbers, use the `bigint` type.
 Otherwise, the `number` type is likely the better option.

exercises/concept/freelancer-rates/.meta/exemplar.js

@@ -33,7 +33,7 @@ export function dayRate(ratePerHour) {
  * Calculates the rate per month
  *
  * @param {number} ratePerHour
- * @param {string} discount for example 20%
+ * @param {number} discount for example 20% written as 0.2
  * @returns {number} the rounded up monthly rate
  */
 export function monthRate(ratePerHour, discount) {
@@ -43,25 +43,25 @@ export function monthRate(ratePerHour, discount) {
 }
 
 /**
- * Calculates the number of days in a budget, rounded on one decimal
+ * Calculates the number of days in a budget, rounded down
  *
  * @param {number} budget the total budget
  * @param {number} ratePerHour the rate per hour
- * @param {string} discount the discount to apply
- * @returns {string} the number of days
+ * @param {number} discount to apply, example 20% written as 0.2
+ * @returns {number} the number of days
  */
 export function daysInBudget(budget, ratePerHour, discount) {
   const discounted = applyDiscount(dayRate(ratePerHour), discount);
-  return (budget / discounted).toFixed(1);
+  return Math.floor(budget / discounted);
 }
 
 /**
  * Applies a discount to the value
  *
  * @param {number} value
- * @param {string} percentage a percentage such as '20%'
+ * @param {number} percentage for example 20% written as 0.2
  * @returns {number} the discounted value
  */
 function applyDiscount(value, percentage) {
-  return ((100 - parseFloat(percentage)) / 100) * value;
+  return (1 - percentage) * value;
 }

exercises/concept/freelancer-rates/freelancer-rates.js

@@ -33,20 +33,20 @@ export function dayRate(ratePerHour) {
  * Calculates the rate per month
  *
  * @param {number} ratePerHour
- * @param {string} discount for example 20%
+ * @param {number} discount for example 20% written as 0.2
  * @returns {number} the rounded up monthly rate
  */
 export function monthRate(ratePerHour, discount) {
   throw new Error('Implement the monthRate function');
 }
 
 /**
- * Calculates the number of days in a budget, rounded on one decimal
+ * Calculates the number of days in a budget, rounded down
  *
  * @param {number} budget the total budget
  * @param {number} ratePerHour the rate per hour
- * @param {string} discount the discount to apply
- * @returns {string} the number of days
+ * @param {number} discount to apply, example 20% written as 0.2
+ * @returns {number} the number of days
  */
 export function daysInBudget(budget, ratePerHour, discount) {
   throw new Error('Implement the daysInBudget function');
@@ -56,7 +56,7 @@ export function daysInBudget(budget, ratePerHour, discount) {
  * Applies a discount to the value
  *
  * @param {number} value
- * @param {string} percentage a percentage such as '20%'
+ * @param {number} percentage for example 20% written as 0.2
  * @returns {number} the discounted value
  */
 function applyDiscount(value, percentage) {