def _eval_guess(task: Task, rules: Rules, grid: Grid, int_reporter: Reporter,
user_reporter: Reporter, grids: List[Grid],
no_steps: int) -> Tuple[Ok, Score]:
teacher_rules = parse(task.rules, task.allowed_colors)
try:
participant_rules = parse(rules, task.allowed_colors)
except pyparsing.ParseException as e:
user_reporter(f'[ERR] Napodařilo se načíst pravidla: {str(e)}')
return (False, 0)
for testgrid in grids:
student_grid = teacher_grid = testgrid
for _ in range(no_steps):
student_grid = tick(testgrid, participant_rules,
task.global_config())
teacher_grid = tick(testgrid, teacher_rules,
task.global_config())
if student_grid != teacher_grid:
user_reporter('[ERR] Vámi zadaná pravidla se nechovají stejně'
' na některé ze zadaných mřížek!')
int_reporter(f'[ERR] Selhalo na mřížce:\n {grid.charrepr()}')
return (False, 0)
user_reporter('[OK] Vámi zadaná pravidla se chovají korektně.')
compares = compares_count(rules)
user_reporter(f'[INFO] Vámi zadaná pravidla obsahují {compares} '
'porovnání.')
return (True, compares)
def eval_fire(task: Task, rules: Rules, grid: Grid, int_reporter: Reporter,
user_reporter: Reporter) -> Tuple[Ok, Score]:
rules = parse(task.rules, task.allowed_colors)
author_grid = Grid.fromstr(task.start_config)
red_present = False
for y in range(grid.height):
for x in range(grid.width):
if author_grid[y][x] == 'k' and grid[y][x] != 'k':
user_reporter(f'[ERR] Šedým polím nelze měnit barvu!')
return (False, 0)
if author_grid[y][x] == 'g' and grid[y][x] == 'k':
user_reporter(f'[ERR] Zelená pole nelze přebarvovat na šedo!')
return (False, 0)
if author_grid[y][x] == 'b' and grid[y][x] != 'b':
user_reporter(f'[ERR] Modrá pole nelze přebarvovat!')
return (False, 0)
if grid[y][x] == 'r':
if author_grid[y][x] != 'g':
user_reporter('[ERR] Na červeno lze přebarvit jen zelené '
'buňky!')
return (False, 0)
if red_present:
user_reporter('[ERR] Nejvýše jedna buňka může být '
'červená!')
return (False, 0)
red_present = True
user_reporter('[OK] Vaše konfigurace splňuje vstupní podmínky.')
i = 0
grid_start = grid
grid = tick(grid_start, rules, task.global_config())
while grid_start != grid and i < ITER_LIMIT:
grid_start = grid
grid = tick(grid_start, rules, task.global_config())
i += 1
grid = tick(grid_start, rules, task.global_config())
if grid != grid_start:
user_reporter(f'[ERR] Plán nedosáhl stabilního stavu v {ITER_LIMIT} '
'krocích!')
return (False, 0)
user_reporter(f'[OK] Plán dosáhl stabilního stavu po {i} krocích.')
k_count = 0
for y in range(grid.height):
for x in range(grid.width):
if grid[y][x] not in 'rk':
user_reporter(f'[ERR] Ve stabilním stavu nejsou všechny buňky'
' červené nebo šedé!')
return (False, 0)
if grid[y][x] == 'k':
k_count += 1
k_count -= 44
user_reporter('[OK] Počet šedých buňek ve stabilním stavu bez buňek na '
f'okraji: {k_count}.')
return (True, k_count)
def wrapper(task: Task, rules: Rules, grid: Grid, int_reporter: Reporter,
user_reporter: Reporter) -> Tuple[Ok, Score]:
try:
rules_ = parse(rules, task.allowed_colors)
except pyparsing.ParseException as e:
user_reporter(f'[ERR] Napodařilo se načíst pravidla: {str(e)}')
return (False, 0)
if _is_arithmetic_operator(rules_):
user_reporter('[ERR] Pravidla obsahují aritmetické operátory!')
return (False, 0)
return func(task, rules, grid, int_reporter, user_reporter)
def eval_same_func(task: Task, rules: Rules, grid: Grid,
int_reporter: Reporter,
user_reporter: Reporter) -> Tuple[Ok, Score]:
author_rules = parse(task.rules, task.allowed_colors)
try:
participant_rules = parse(rules, task.allowed_colors)
except pyparsing.ParseException as e:
user_reporter(f'[ERR] Napodařilo se načíst pravidla: {str(e)}')
return (False, 0)
out_grida = Grid.fromfill(3, 3)
out_gridb = Grid.fromfill(3, 3)
for grid in all_neighbors(task.allowed_colors):
tick_pos(grid, out_grida, participant_rules, (1, 1),
task.global_config())
tick_pos(grid, out_gridb, author_rules, (1, 1), task.global_config())
if out_grida[1][1] != out_gridb[1][1]:
int_reporter(f'[ERR] Selhalo na mřížce:\n {grid.charrepr()}')
return (False, 0)
return (True, 0)
def eval_line_coloring(task: Task, rules: Rules, grid: Grid,
int_reporter: Reporter,
user_reporter: Reporter) -> Tuple[Ok, Score]:
rules = parse(task.rules, task.allowed_colors)
for y in range(grid.height - 1):
for x in range(grid.width):
if grid[y][x] != 'b':
user_reporter('[ERR] Obarvili jste víc, než jen spodní řádek!')
return (False, 0)
for i in range(11):
grid = tick(grid, rules, task.global_config())
int_reporter(f'[OK] Po {i+1}. krocích v horním řádku '
f'{_red_top_count(grid)} červených buňek.')
score = _red_top_count(grid)
user_reporter(f'[OK] Počet červených buňek v horním řádku po 11. kroku:'
f' {score}.')
return (True, score)
def eval_loop(task: Task, rules: Rules, grid: Grid, int_reporter: Reporter,
user_reporter: Reporter) -> Tuple[Ok, Score]:
rules = parse(task.rules, task.allowed_colors)
grid2 = tick(grid, rules, task.global_config())
if grid2 == grid:
user_reporter('[ERR] Konfigurace po 2. kroku je stejná jako '
'počáteční konfigurace!')
return (False, 0)
grid3 = tick(grid2, rules, task.global_config())
if grid3 == grid2:
user_reporter('[ERR] Konfigurace po 3. kroku je stejná jako '
'konfigurace po 2. kroku!')
return (False, 0)
if grid3 != grid:
user_reporter('[ERR] Konfigurace po 3. kroku není stejná jako '
'počáteční konfigurace!')
return (False, 0)
user_reporter('[OK] Úloha úspěšně vyřešena.')
return (True, 0)
def eval_shades_of_grey(task: Task, rules: Rules, grid: Grid,
int_reporter: Reporter,
user_reporter: Reporter) -> Tuple[Ok, Score]:
rules = parse(task.rules, task.allowed_colors)
if _all_grey(grid):
user_reporter('[ERR] Počáteční konfigurace nebosahuje červenou buňku!')
return (False, 0)
grid_start = copy.deepcopy(grid)
i = 0
while not _all_grey(grid) and i < ITER_LIMIT:
grid = tick(grid, rules, task.global_config())
i += 1
if i == ITER_LIMIT:
user_reporter('[ERR] Automat se nezastavil ani po '
f'{ITER_LIMIT} krocích!')
return (False, 0)
user_reporter(f'[OK] Skončilo po {i} iteracích.')
score = _red_count(grid_start)
user_reporter(f'[OK] Počet červených buňek na začátku: {score}.')
return (True, score)
def _test_rule_parser():
assert parse('g', '') == 'g'
assert parse('b', 'b') == 'b'
assert parse('b', 'abcd') == 'b'
def step_guess_rules_two(task: Task, grid: Grid) -> Grid:
author_rules = parse(task.rules, task.allowed_colors)
grid = tick(grid, author_rules, task.global_config())
grid = tick(grid, author_rules, task.global_config())
return grid