diff --git a/9-regular-expressions/11-regexp-groups/01-test-mac/task.md b/9-regular-expressions/11-regexp-groups/01-test-mac/task.md
@@ -1,20 +1,20 @@
-# Check MAC-address

-[MAC-address](https://en.wikipedia.org/wiki/MAC_address) of a network interface consists of 6 two-digit hex numbers separated by a colon.

-For instance: `subject:'01:32:54:67:89:AB'`.

-Write a regexp that checks whether a string is MAC-address.

-Usage:
```js
let regexp = /your regexp/;

alert( regexp.test('01:32:54:67:89:AB') ); // true

-alert( regexp.test('0132546789AB') ); // false (no colons)

-alert( regexp.test('01:32:54:67:89') ); // false (5 numbers, must be 6)

-alert( regexp.test('01:32:54:67:89:ZZ') ) // false (ZZ at the end)
```
diff --git a/9-regular-expressions/11-regexp-groups/02-find-webcolor-3-or-6/solution.md b/9-regular-expressions/11-regexp-groups/02-find-webcolor-3-or-6/solution.md
@@ -1,12 +1,12 @@
-A regexp to search 3-digit color `#abc`: `pattern:/#[a-f0-9]{3}/i`.

-We can add exactly 3 more optional hex digits. We don't need more or less. The color has either 3 or 6 digits.

-Let's use the quantifier `pattern:{1,2}` for that: we'll have `pattern:/#([a-f0-9]{3}){1,2}/i`.

-Here the pattern `pattern:[a-f0-9]{3}` is enclosed in parentheses to apply the quantifier `pattern:{1,2}`.

-In action:

```js run
let regexp = /#([a-f0-9]{3}){1,2}/gi;
@@ -16,7 +16,7 @@ let str = "color: #3f3; background-color: #AA00ef; and: #abcd";
alert( str.match(regexp) ); // #3f3 #AA00ef #abc
```

-There's a minor problem here: the pattern found `match:#abc` in `subject:#abcd`. To prevent that we can add `pattern:\b` to the end:

```js run
let regexp = /#([a-f0-9]{3}){1,2}\b/gi;

diff --git a/9-regular-expressions/11-regexp-groups/02-find-webcolor-3-or-6/task.md b/9-regular-expressions/11-regexp-groups/02-find-webcolor-3-or-6/task.md
@@ -1,8 +1,8 @@
-# Find color in the format #abc or #abcdef

-Write a RegExp that matches colors in the format `#abc` or `#abcdef`. That is: `#` followed by 3 or 6 hexadecimal digits.

-Usage example:
```js
let regexp = /your regexp/g;

@@ -11,4 +11,4 @@ let str = "color: #3f3; background-color: #AA00ef; and: #abcd";
alert( str.match(regexp) ); // #3f3 #AA00ef
```

-P.S. This should be exactly 3 or 6 hex digits. Values with 4 digits, such as `#abcd`, should not match.
diff --git a/9-regular-expressions/11-regexp-groups/03-find-decimal-numbers/solution.md b/9-regular-expressions/11-regexp-groups/03-find-decimal-numbers/solution.md
@@ -1,6 +1,6 @@
-A positive number with an optional decimal part is: `pattern:\d+(\.\d+)?`.

-Let's add the optional `pattern:-` in the beginning:

```js run
let regexp = /-?\d+(\.\d+)?/g;

diff --git a/9-regular-expressions/11-regexp-groups/03-find-decimal-numbers/task.md b/9-regular-expressions/11-regexp-groups/03-find-decimal-numbers/task.md
@@ -1,8 +1,8 @@
-# Find all numbers

-Write a regexp that looks for all decimal numbers including integer ones, with the floating point and negative ones.

-An example of use:

```js
let regexp = /your regexp/g;

diff --git a/9-regular-expressions/11-regexp-groups/04-parse-expression/solution.md b/9-regular-expressions/11-regexp-groups/04-parse-expression/solution.md
@@ -1,44 +1,44 @@
-A regexp for a number is: `pattern:-?\d+(\.\d+)?`. We created it in the previous task.

-An operator is `pattern:[-+*/]`. The hyphen `pattern:-` goes first in the square brackets, because in the middle it would mean a character range, while we just want a character `-`.

-The slash `/` should be escaped inside a JavaScript regexp `pattern:/.../`, we'll do that later.

-We need a number, an operator, and then another number. And optional spaces between them.

-The full regular expression: `pattern:-?\d+(\.\d+)?\s*[-+*/]\s*-?\d+(\.\d+)?`.

-It has 3 parts, with `pattern:\s*` between them:
-1. `pattern:-?\d+(\.\d+)?` - the first number,
-1. `pattern:[-+*/]` - the operator,
-1. `pattern:-?\d+(\.\d+)?` - the second number.

-To make each of these parts a separate element of the result array, let's enclose them in parentheses: `pattern:(-?\d+(\.\d+)?)\s*([-+*/])\s*(-?\d+(\.\d+)?)`.

-In action:

```js run
let regexp = /(-?\d+(\.\d+)?)\s*([-+*\/])\s*(-?\d+(\.\d+)?)/;

alert( "1.2 + 12".match(regexp) );
```

-The result includes:

-- `result[0] == "1.2 + 12"` (full match)
-- `result[1] == "1.2"` (first group `(-?\d+(\.\d+)?)` -- the first number, including the decimal part)
-- `result[2] == ".2"` (second group`(\.\d+)?` -- the first decimal part)
-- `result[3] == "+"` (third group `([-+*\/])` -- the operator)
-- `result[4] == "12"` (forth group `(-?\d+(\.\d+)?)` -- the second number)
-- `result[5] == undefined` (fifth group `(\.\d+)?` -- the last decimal part is absent, so it's undefined)

-We only want the numbers and the operator, without the full match or the decimal parts, so let's "clean" the result a bit.

-The full match (the arrays first item) can be removed by shifting the array `result.shift()`.

-Groups that contain decimal parts (number 2 and 4) `pattern:(.\d+)` can be excluded by adding  `pattern:?:` to the beginning: `pattern:(?:\.\d+)?`.

-The final solution:

```js run
function parse(expr) {

diff --git a/9-regular-expressions/11-regexp-groups/04-parse-expression/task.md b/9-regular-expressions/11-regexp-groups/04-parse-expression/task.md
@@ -1,23 +1,23 @@
-# Parse an expression

-An arithmetical expression consists of 2 numbers and an operator between them, for instance:

- `1 + 2`
- `1.2 * 3.4`
- `-3 / -6`
- `-2 - 2`

-The operator is one of: `"+"`, `"-"`, `"*"` or `"/"`.

-There may be extra spaces at the beginning, at the end or between the parts.

-Create a function `parse(expr)` that takes an expression and returns an array of 3 items:

-1. The first number.
-2. The operator.
-3. The second number.

-For example:

```js
let [a, op, b] = parse("1.2 * 3.4");