Advent of Code 2022: no pato edition

R

RsTTa #301 Dic '22

Uhh 63 y 53 min, poca broma el de hoy entonces. Estoy con la parte 2 del día 18, a ver si lo saco. De parecer muy fáciles, a que no me salgan xD

gonya707 #302 Dic '22 Moderador

Yo el de ayer llegue a sacarlo, pero hoy otro problema de heuristica, asi que inviable para mi. Supongo que ya a partir de ahora seran todos la muerte xD. Bueno, al menos estoy orgulloso de haberlo llevado al dia hasta que me ha resultado completamente imposible por dificultad

1

B

[Borrado] #303 Dic '22

He estado varios dias fuera asi que toca recuperar, dia 17. El codigo es parte del problema pero no lo resuelve inmediatamente

spoiler

import sys
import numpy as np



rock_templates = [
  np.array([[0, 0], [0, 1], [0, 2], [0, 3]], dtype=np.int32),
  np.array([[0, 1], [1, 0], [1, 1], [1, 2], [2, 1]], dtype=np.int32),
  np.array([[0, 2], [1, 2], [2, 0], [2, 1], [2, 2]], dtype=np.int32),
  np.array([[0, 0], [1, 0], [2, 0], [3, 0]], dtype=np.int32),
  np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=np.int32)
]

dirs = {
  '<': np.array([+0, -1], dtype=np.int32),
  '>': np.array([+0, +1], dtype=np.int32),
  'D': np.array([+1, +0], dtype=np.int32)
}

rocks = [np.array([[0, x] for x in range(7)], dtype=np.int32)]
all_coords = set()
for coords in rocks[0]:
  all_coords.add(tuple(coords))

num_rocks = int(sys.argv[1])
sequence = input().strip()


def _get_new_rock(idx):
  min_x = min([x for rock in rocks for [x, y] in rock]) - 4
  ret = rock_templates[idx]
  max_x = max([x for [x, y] in ret])
  diff = max_x - min_x
  ret = rock_templates[idx] + \
        np.array([-diff, 2], dtype=np.int32)
  return ret


def _trim_rocks(rocks):
  return rocks


def _rock_is_valid(rock):
  boundaries = all(0 <= y < 7 for _, y in rock)
  if not boundaries:
    return False
  for coords in rock:
    if tuple(coords) in all_coords:
      return False
  return True


def _get_md_rock(rock, mov):
  next_rock = rock + dirs[mov]
  if _rock_is_valid(next_rock):
    return next_rock
  return rock


def _get_down_rock(rock):
  return rock + dirs['D']


def _max_rock_height(rock):
  return min(x for [x, y] in rock)


dir_idx, rock_idx, max_height = 0, 0, 0

d = {}


while len(rocks) <= num_rocks:
  current_rock = _get_new_rock(rock_idx)
  rock_idx = (rock_idx + 1) % len(rock_templates)

  while True:
    md_rock = _get_md_rock(current_rock, sequence[dir_idx])
    dir_idx = (dir_idx + 1) % len(sequence)
    down_rock = _get_down_rock(md_rock)
    if _rock_is_valid(down_rock):
      current_rock = down_rock
    else:
      current_rock = md_rock
      break

  max_height = min(max_height, _max_rock_height(current_rock))

  if len(d.get((rock_idx, dir_idx), [])) > 2:
    print(f'{d[(rock_idx, dir_idx)]}')

  d.setdefault((rock_idx, dir_idx), []).append((len(rocks), max_height))
  for coords in current_rock:
    all_coords.add(tuple(coords))

  rocks.append(current_rock)
  rocks = _trim_rocks(rocks)

print(max_height)

spoiler

thenanox #304 Dic '22 Virconita

joder yo me veo lejos, me quede el 11

gonya707 #305 Dic '22 Moderador

Yo el dia 20 lo veo facilisimo y me sale el test clavado paso por paso pero luego con los datos valor equivocado, ya no se que probar

B

[Borrado] #306 Dic '22

Dia 18, la cota superior en realidad se puede sacar con la propia info del problema pero soy un vago de mierda

spoiler

import sys
import numpy as np
from itertools import product
from collections import Counter, deque
sys.setrecursionlimit(912481294)

cubes = set()

for line in sys.stdin:
  cubes.add(
    tuple(map(int, line.strip().split(',')))
  )

dirs = list(t for t in product([-1, 0, 1], repeat=3) if t.count(0) == 2)


free_edges = {}

for x, y, z in cubes:
  for dx, dy, dz in dirs:
    sx, sy, sz = x + dx, y + dy, z + dz
    if not (sx, sy, sz) in cubes:
      free_edges.setdefault((x, y, z), []).append((sx, sy, sz))

ans_1 = sum(len(x) for x in free_edges.values())

print(ans_1)

# part 2
ans_2 = ans_1


def _free(root, vis):
  if root in vis or root in cubes:
    return False
  if max([abs(x) for x in root]) >= 50:
    return True
  vis.add(root)
  ret = False
  x, y, z = root
  for dx, dy, dz in dirs:
    sx, sy, sz = x + dx, y + dy, z + dz
    ret = ret or _free((sx, sy, sz), vis)
  return ret


for edge_list in free_edges.values():
  for edge in edge_list:
    if not _free(edge, set()):
      ans_2 -= 1

print(ans_2)

B

[Borrado] #307 Dic '22

Dia 19, se me acumula la faena

spoiler

import sys
import re



def _solve(ore_r_ore, clay_r_ore, obs_r_ore, obs_r_clay, geode_r_ore, geode_r_obs):

  st = {}
  best_solution = 0

  def _backtrack(t, ore, clay, obs, geo, ore_res, clay_res, obs_res, geo_res):
    nonlocal best_solution
    state = (t, ore, clay, obs, geo, ore_res, clay_res, obs_res, geo_res)

if state in st:
  return st[state]
if t == 0:
  best_solution = max(best_solution, geo_res)
  return geo_res

rec = 0

if ore >= geode_r_ore and obs >= geode_r_obs:
  return geo_res + geo * t + t * (t + 1) // 2


def _prune():
  max_geo = geo_res + geo * t + t * (t + 1) // 2
  return max_geo < best_solution


if ore_res >= geode_r_ore and obs_res >= geode_r_obs:
  rec_ore, rec_clay, rec_obs, rec_geo = \
    (ore_res - geode_r_ore + ore,
    clay_res + clay,
    obs_res - geode_r_obs + obs,
    geo_res + geo)
  rec = max(rec, _backtrack(t - 1, ore, clay, obs, geo + 1, rec_ore, rec_clay, rec_obs, rec_geo))
  st[state] = rec
  return rec

if ore_res >= obs_r_ore and clay_res >= obs_r_clay and not _prune():
  rec_ore, rec_clay, rec_obs, rec_geo = \
    (ore_res - obs_r_ore + ore,
    clay_res - obs_r_clay + clay,
    obs_res + obs,
    geo_res + geo)
  rec = max(rec, _backtrack(t - 1, ore, clay, obs + 1, geo, rec_ore, rec_clay, rec_obs, rec_geo))
  if obs == 0:
    st[state] = rec
    return rec

if ore_res >= clay_r_ore and not _prune():
  rec_ore, rec_clay, rec_obs, rec_geo = \
    (ore_res - clay_r_ore + ore,
    clay_res + clay,
    obs_res + obs,
    geo_res + geo)
  rec = max(rec, _backtrack(t - 1, ore, clay + 1, obs, geo, rec_ore, rec_clay, rec_obs, rec_geo))

if ore_res >= ore_r_ore and not _prune():
  rec_ore, rec_clay, rec_obs, rec_geo = \
    (ore_res - ore_r_ore + ore,
    clay_res + clay,
    obs_res + obs,
    geo_res + geo)
  rec = max(rec, _backtrack(t - 1, ore + 1, clay, obs, geo, rec_ore, rec_clay, rec_obs, rec_geo))

rec_ore, rec_clay, rec_obs, rec_geo = \
  (ore_res + ore,
  clay_res + clay,
  obs_res + obs,
  geo_res + geo)
rec = max(rec, _backtrack(t - 1, ore, clay, obs, geo, rec_ore, rec_clay, rec_obs, rec_geo))

st[state] = rec
return st[state]


  return _backtrack(
    int(sys.argv[1]), # t
    1, # ore robots
    0, # clay robots
    0, # obsidian robots
    0, # geode robots
    0, # ore resource
    0, # clay resource
    0, # obsidian resource
    0, # geo resource
  )

ans = 0


for line in sys.stdin:
  bp_id, ore_r_ore, clay_r_ore, obs_r_ore, obs_r_clay, geode_r_ore, geode_r_obs = \
    map(int, re.match(r'Blueprint (\d+): Each ore robot costs (\d+) ore. Each clay robot costs (\d+) ore. Each obsidian robot costs (\d+) ore and (\d+) clay. Each geode robot costs (\d+) ore and (\d+) obsidian.', line.strip()).groups())
  max_geodes = _solve(ore_r_ore, clay_r_ore, obs_r_ore, obs_r_clay, geode_r_ore, geode_r_obs)
  print(f'BP ID: {bp_id} creates {max_geodes} ({bp_id * max_geodes})')
  ans += bp_id * max_geodes

print(ans)

Observaciones random

spoiler

B

[Borrado] #308 Dic '22

Dia 20, soy consciente de que atras = adelante n - atras veces, pero preferia ser verbose por si acaso

spoiler

import sys

key = 811589153


class Node(object):
  def __init__(self, val):
    self.prev, self.next = None, None
    self.val = val


linked = []


for line in sys.stdin:
  val = int(line.strip()) * key
  node = Node(val)
  linked.append(node)


for i in range(len(linked)):
  linked[i].prev = linked[i - 1]
  linked[i].next = linked[(i + 1) % len(linked)]


def _move_forward(root, k):

  for _ in range(k):
    prv = root.prev
    nxt = root.next
    nxt_nxt = nxt.next

prv.next = nxt
nxt.prev = prv

nxt.next = root
root.prev = nxt

root.next = nxt_nxt
nxt_nxt.prev = root


def _move_backwards(root, k):

  # prvprv prv root nxt
  # prvprv root prv nxt


  for _ in range(k):
    nxt = root.next
    prv = root.prev
    prvprv = prv.prev

prvprv.next = root
root.prev = prvprv

root.next = prv
prv.prev = root

prv.next = nxt
nxt.prev = prv

for _ in range(10):
  for node in linked:
    if node.val >= 0:
      _move_forward(node, node.val % (len(linked) - 1))
    else:
      _move_backwards(node, -node.val % (len(linked) - 1))

cur = linked[0]

for i in range(len(linked)):
  print(cur.val)
  cur = cur.next

cur = next(n for n in linked if n.val == 0)

print('----------')

ans = 0

for i in range(3001):
  if i in [1000, 2000, 3000]:
    print(cur.val)
    ans += cur.val
  cur = cur.next

print(ans)

B

[Borrado] #309 Dic '22

Dia 21, codigo guarro pero funciona

spoiler

import re
import sys

monkeys = {}

class operation(object):
  def __init__(self, name, val=None, left=None, operand=None, right=None):
    self.name = name
    self.val = val
    self.left = left
    self.operand = operand
    self.right = right


  def eval(self):
    opers = {
      '+': lambda x, y: x.eval() + y.eval(),
      '-': lambda x, y: x.eval() - y.eval(),
      '*': lambda x, y: x.eval() * y.eval(),
      '/': lambda x, y: x.eval() // y.eval()
    }
    if self.val is not None:
      return self.val
    ret = opers[self.operand](monkeys[self.left], monkeys[self.right])
    return ret

for line in sys.stdin:
  val_match = re.match(r'(.*): (\d+)', line)
  oper_match = re.match(r'(.*): (.*) (.*) (.*)', line)

  if val_match is not None:
    name, val = val_match.groups()
    monkeys[name] = operation(name, val=int(val))
  else:
    name, left, oper, right = oper_match.groups()
    monkeys[name] = operation(name, left=left, operand=oper, right=right)


print(monkeys['root'].eval())

left, right = monkeys['root'].left, monkeys['root'].right


def _can_find_humn(root):
  if root == 'humn':
    return True
  node = monkeys[root]
  if node.val is not None:
    return False
  return _can_find_humn(node.left) or _can_find_humn(node.right)


if _can_find_humn(right):
  left, right = right, left


monkeys['humn'].val = int(sys.argv[1])

lval, rval = monkeys[left].eval(), monkeys[right].eval()

print(lval, rval)

l, r = -2 ** 50, 2 ** 50

while l <= r:
  h = (l + r) // 2
  monkeys['humn'].val = h
  lval = monkeys[left].eval()
  if lval == rval:
    print(h)
    exit(0)
  if lval > rval:
    l = h + 1
  else:
    r = h - 1

print(lval, rval)

spoiler

gonya707 #310 Dic '22 Moderador

Bueno esto se ha acabado pero me ha gustado mucho la experiencia. Me da mucha rabia no haber podido completar la mayoría de los últimos 10 dias por falta de conocimientos de algoritmica y tal, siempre he programado a saco, y viendo los códigos de gente de por aqui, mi modo de programar es siempre a bajisimo nivel a pesar de haber usado python, haber programado en C tantos años me ha pasado factura.

Deberes para el año que viene:
-Aprender de algoritmos con nombre, no tengo ni zorra y llega un punto en el que los problemas se me han hecho cuesta arriba por no saber hacer cosas medio básicas. Había pensado en seguir la guía de computer science de Roadmap donde listan unos cuantos, y de paso empaparme de todas estas cosas que no te enseñan en teleco
-Aprender a pythonear mucho mejor, usar las herramientas que me brinda el lenguaje para hacer más bucles en una sola linea, las lambdas y decorators siguen siendo un wtf para mi, etc.

Enhorabuena yusent por terminar todo y estar 1º en nuestro ranking, yo a golpe de insistencia he terminado 4º y me parece inmerecido totalmente con la de gente buena que hay aquí. Nos vemos el año que viene más fuertes

1

B

[Borrado] #311 Dic '22

A mi me ha pillado con un par de viajes de por medio, a ver si acabo los últimos cuatro días

nobody1 #312 Dic '22

Enhorabuena a los que habéis continuado, la dificultad de los últimos 10 días y las vacaciones hicieron mella, voy a intentar acabarlos o al menos entenderlos para aprender algo de cara al año que viene.

Usuarios habituales

Tags