import codewars_test as test
# TODO Write tests
import solution # or from solution import example

# test.assert_equals(actual, expected, [optional] message)
@test.describe("Example")
def test_group():
    @test.it("test case")
    def test_case():
        test.assert_equals(1 + 1, 2)

import codewars_test as test
import random, string
# TODO Write tests
from solution import repair

def tru_repair(cur: list, pre: list):
    broken_index = [i.count("?") > 0 for i in cur].index(True)
    known_part = list(filter(lambda x: x[1] != '', enumerate(map(lambda x: x if x != "?" else "", [*cur[broken_index]]))))
    matching_pre_index = [pre.index(i) for i in pre if [(o, i) for o, i in enumerate([*i]) if (o, i) in known_part] == known_part and len(i) == len(cur[broken_index])][0]
    cur[broken_index] = pre[matching_pre_index]

    return cur

# test.assert_equals(actual, expected, [optional] message)
@test.describe("Example")
def test_group():
    @test.it("static tests")
    def _():
        test.assert_equals(repair(['line 1', '???? 2', 'line 3'], ['line 1', 'line 2']),['line 1', 'line 2', 'line 3'])
        test.assert_equals(repair(['hi', 'my name is', '????????HRUM'], ['hi my name is', 'HRUMHRUMHRUM']), ['hi', 'my name is', 'HRUMHRUMHRUM'])
        test.assert_equals(repair(['what', 'was', 'pl?????1', 'thinking', 'when', 'writing this code'], ['what was', 'playerO1', "thinking when writing this code"]), ['what', 'was', 'playerO1', 'thinking', 'when', 'writing this code'])
        test.assert_equals(repair(['boy oh boy do I LOVE f?x?n? code'], ['boy oh boy do I LOVE fixing code']), ['boy oh boy do I LOVE fixing code'])
    
    @test.it("random tests")
    def _():
        def break_str(st: str):
            return "".join(map(lambda x: x if random.getrandbits(1) else "?", [*st]))
        for i in range(1000):
            sts = ["".join(random.choices([*string.ascii_letters], k=random.randint(10, 30))) for _ in range(random.randint(10, 30))]
            broken_sts = list(map(lambda x: break_str(x), sts))
            test.assert_equals(repair(broken_sts, sts), tru_repair(broken_sts, sts))

import codewars_test as test
from solution import str_opt
import random
import string

tru_str_opt = lambda s:s if len(s) == 1 else None if len({s.count(i) for i in {*s}}) <= 1 else sorted([*s], key=lambda x: s.count(x))[0]

# test.assert_equals(actual, expected, [optional] message)
@test.describe("Example")
def test_group():
    @test.it("test cases")
    def test_case():
        test.assert_equals(str_opt("abbcc"), "a", "returns the value that repeats the least")
        test.assert_equals(str_opt("bacc"), "b", "returns the value that repeats the least and goes first")
        test.assert_equals(str_opt("aabbcc"), None, " returns None if all characters repeat equally")
        test.assert_equals(str_opt("c"), "c", "returns the value if it is the only one")
        test.assert_equals(str_opt(""), None, "if it is empty, it returns None")
        test.assert_equals(str_opt(f"{'a'*10000}{'b'*10000}c"), "c", "shall work with large numbers")
        test.assert_equals(str_opt(f"{'a'*10000}{'b'*10000}{'c'*10000}"), None, "should handle very long strings with all characters repeating")
    @test.it("random cases")
    def _():
        for i in range(500):
            testval = "".join([random.choice([*string.ascii_lowercase]) for _ in range(200)])
            test.assert_equals(str_opt(testval), tru_str_opt(testval))
            
    

import codewars_test as test
from solution import str_opt
import random

# test.assert_equals(actual, expected, [optional] message)
@test.describe("Example")
def test_group():
    @test.it("test cases")
    def test_case():
        test.assert_equals(str_opt("abbcc"), "a", "returns the value that repeats the least")
        test.assert_equals(str_opt("bacc"), "b", "returns the value that repeats the least and goes first")
        test.assert_equals(str_opt("aabbcc"), None, " returns None if all characters repeat equally")
        test.assert_equals(str_opt("c"), "c", "returns the value if it is the only one")
        test.assert_equals(str_opt(""), None, "if it is empty, it returns None")
        test.assert_equals(str_opt(f"{'a'*10000}{'b'*10000}c"), "c", "shall work with large numbers")
        test.assert_equals(str_opt(f"{'a'*10000}{'b'*10000}{'c'*10000}"), None, "should handle very long strings with all characters repeating")
            

import codewars_test as test
from solution import maxnum
import random

@test.describe('Example Tests')
def example_tests():

    @test.it('Simple Tests')
    def example_test_case():
        test.assert_equals(maxnum(4), 4)
        test.assert_equals(maxnum(21), 12)
        test.assert_equals(maxnum(110), 101)
        test.assert_equals(maxnum(4), 4)
    @test.it('random tests')
    def random_test_case():
        for i in range(1, 607):
            i = random.randint(1, 10000)
            test.assert_equals(sorted([*str(maxnum(i))]), sorted([*str(i)]), str(i))

import codewars_test as test
from solution import maxnum

@test.describe('Example Tests')
def example_tests():

    @test.it('Simple Tests')
    def example_test_case():
        test.assert_equals(maxnum(4), 4)
        test.assert_equals(maxnum(21), 12)
        test.assert_equals(maxnum(110), 101)
        test.assert_equals(maxnum(4), 4)
    @test.it('random tests')
    def random_test_case():
        for i in range(1, 1500):
            test.assert_equals(sorted([*str(maxnum(i))]), sorted([*str(i)]), str(i))

import codewars_test as test
# TODO Write tests
from solution import group

# test.assert_equals(actual, expected, [optional] message)
@test.describe("Example")
def test_group():
    @test.it("test case")
    def test_case():
        test.assert_equals(group([("yellow", 1), ("blue", 2), ("yellow", 3), ("blue", 4), ("red", 1)]), {'yellow': [1, 3], 'blue': [2, 4], 'red': [1]})

import codewars_test as test
# TODO Write tests
from solution import average # or from solution import example

tests = {
    ((10, 10, 10, 12), (30, 45, 56, 45), (81, 80, 39, 32), (1, 2, 3, 4)):[30.5, 34.25, 27.0, 23.25],
    ((12, 34, 143, 154), (34, 54, 565, 56), (6556, 675, 3554, 1209), (100, 12, 321, 0.12)):[1675.5, 193.75, 1145.75, 354.78],
    }
# test.assert_equals(actual, expected, [optional] message)
@test.describe("Example")
def test_group():
    @test.it("test case")
    def test_case():
        for i in tests:
            test.assert_equals(average(i), tests[i])