A password is **compliant** when ALL of the following hold: 1. Its length is between 8 and 20 characters (inclusive). 2. It contains at least one lowercase letter, at least one uppercase letter, and at least one digit. 3. No character is repeated three or more times **consecutively** (e.g. `aaa` is not allowed). Write `solution(password)` that returns a pair `[is_valid, min_edits]` where: - `is_valid` is `True` if `password` is already compliant, otherwise `False`. - `min_edits` is the **minimum number of single-character edits** — insert, delete, or replace — needed to transform `password` into a compliant one (0 when it is already compliant). A valid corrected password can always be produced alongside `min_edits` (see the worked explanations), but because many distinct repairs achieve the same minimum, only the deterministic `[is_valid, min_edits]` pair is graded. **Algorithm.** This is an adaptation of the classic *Strong Password Checker* greedy: - If `len < 8`: every insertion both lengthens the string and can break a run or add a missing character type, so the answer is `max(8 - len, missing_types)`. - If `8 <= len <= 20`: only replacements help. A run of `L` equal chars needs `L // 3` replacements to break, and a replacement can simultaneously satisfy a missing type, giving `max(missing_types, sum(L_i // 3))`. - If `len > 20`: you must delete `len - 20` characters. Spend those deletions greedily on runs first (`run % 3 == 0` saves a replacement per 1 deletion, `== 1` per 2, `== 2` per 3), then add `max(missing_types, remaining_replacements)`. Note in this problem `missing_types` is the count of the three required character classes that are absent. **Multi-language templates** return `[isValid, minEdits]` (the non-Python templates encode `isValid` as `1/0`).