def solve(self, name: str, src_model: Optional[bytes],
tgt_model: Optional[bytes]) -> SolverResult:
conn = get_shared_conn()
cur = conn.cursor()
assert name.startswith('FR')
traces = {}
energies = {}
for part in ['ZD', 'ZA']:
cur.execute(
'''
SELECT
traces.data, energy
FROM problems
JOIN traces
ON traces.problem_id = problems.id
WHERE problems.name = %s AND traces.status = 'DONE'
ORDER BY traces.energy
LIMIT 1
''', [name.replace('FR', part)])
rows = cur.fetchall()
if not rows:
return SolverResult(Pass())
[[trace, energy]] = rows
traces[part] = zlib.decompress(trace)
energies[part] = energy
R = Matrix.parse(src_model).R
assert traces['ZD'][-1] == 255
return SolverResult(
traces['ZD'][:-1] + traces['ZA'],
dict(expected_energy=energies['ZD'] - 3 * R**3 - 20 +
energies['ZA']))
def solve(self, name: str, src_model: Optional[bytes],
tgt_model: Optional[bytes]) -> SolverResult:
assert src_model is None
m = Model.parse(tgt_model)
try:
trace_data = compose_commands(self.solve_gen(m))
return SolverResult(trace_data, extra={})
except KeyboardInterrupt:
raise
except:
exc = StringIO()
traceback.print_exc(file=exc)
return SolverResult(Fail(), extra=dict(tb=exc.getvalue()))
def solve(self, name: str, src_model: Optional[bytes],
tgt_model: Optional[bytes]) -> SolverResult:
assert src_model is None
m = Model.parse(tgt_model)
trace_data = compose_commands(
solve_gen(m, self.w, self.h, low=self.low))
return SolverResult(trace_data, extra={})
def solve(self, name: str, src_model: Optional[bytes],
tgt_model: Optional[bytes]) -> SolverResult:
assert tgt_model is None
m = Model.parse(src_model)
trace = cubical(m, high=self.high)
trace_data = compose_commands(trace)
return SolverResult(trace_data, extra={})
def solve(self, name: str, src_model: Optional[bytes],
tgt_model: Optional[bytes]) -> SolverResult:
m_src = m_tgt = None
if src_model is not None:
m_src = Model.parse(src_model)
strategy = default_disassembly
if tgt_model is not None:
m_tgt = Model.parse(tgt_model)
strategy = default_assembly
if src_model is not None and tgt_model is not None:
strategy = default_reassembly
trace = strategy(m_src, m_tgt)
trace_data = compose_commands(trace)
return SolverResult(trace_data, extra={})
def solve(self, *args, **kwargs):
return SolverResult(b'123213')
def solve(self, *args, **kwargs):
return SolverResult(Fail())
def solve(self, name: str, src_model: Optional[bytes],
tgt_model: Optional[bytes]) -> SolverResult:
if src_model is not None:
src_model = Matrix.parse(src_model)
if tgt_model is not None:
tgt_model = Matrix.parse(tgt_model)
if src_model is None:
src_model = Matrix(tgt_model.R)
if tgt_model is None:
tgt_model = Matrix(src_model.R)
logger.info((src_model, tgt_model))
R = src_model.R
cur_model = Matrix(src_model)
trace = []
bot_pos = Pos(0, 0, 0)
logger.info(f'R = {R}')
while cur_model != tgt_model:
changed = False
for nd in cpp.enum_near_diffs():
p = bot_pos + nd
if not p.is_inside(R):
continue
if cur_model[p] == tgt_model[p]:
continue
if not cpp.safe_to_change(cur_model, p):
continue
if cur_model[p]:
trace.append(cpp.Void(nd))
cur_model[p] = False
else:
trace.append(cpp.Fill(nd))
cur_model[p] = True
changed = True
break
if changed:
continue
p = cpp.path_to_nearest_safe_change_point(cur_model, bot_pos,
cur_model, tgt_model)
if p is None:
return SolverResult(Pass(),
extra=dict(msg='no reachable targets'))
target, path = p
for cmd in path:
trace.append(cmd)
bot_pos += cmd.move_offset()
assert bot_pos == target
# get back
p = cpp.path_to_nearest_of(cur_model, bot_pos, [Pos(0, 0, 0)])
if p is None:
return SolverResult(Fail(),
extra=dict(msg="done but can't reach exit"))
trace.extend(p[1])
trace.append(cpp.Halt())
trace = [cmd_from_cpp(cmd) for cmd in trace]
trace = commands.compose_commands(trace)
return SolverResult(trace)