Advent of Code 2021: Casi no llegamos edition

BeheritSp #301 Dic '21 Juntabrackets

Bueno lo dificil de hoy era entender el enunciado.

import numpy as np
process_values = {
    0 : lambda x: sum(x),
    1 : lambda x: np.prod(x),
    2 : lambda x: min(x),
    3 : lambda x: max(x),
    5 : lambda x: 1 if x[0] > x[1] else 0,
    6 : lambda x: 1 if x[0] < x[1] else 0,
    7 : lambda x: 1 if x[0] == x[1] else 0
}
def evaluate_number(transmission, i, version_sum):
    version = transmission[i:i+3]
    version_sum += int(version, 2)
    pack_type = transmission[i+3:i+6]
    i=i+6
    if int(pack_type,2) == 4:
        groups = []
        while not transmission[i] == '0':
            groups.append(transmission[i+1:i+5])
            i = i+5
        groups.append(transmission[i+1:i+5])
        return int("".join(groups),2), i+5, version_sum
    else:
        if transmission[i] == '0':
            sub_pack_len = int(transmission[i+1:i+16], 2)
            i=i+16
            starting_index = i
            values = []
            while not i-starting_index==sub_pack_len:
                number, i, version_sum = evaluate_number(transmission, i, version_sum)
                values.append(number)

        elif transmission[i] == '1':
            sub_pack_number = int(transmission[i+1:i+12], 2)
            i=i+12
            values = []
            for sub_pack in range(sub_pack_number):
                number, i, version_sum = evaluate_number(transmission, i, version_sum)
                values.append(number)
        return process_values[int(pack_type, 2)](values), i, version_sum

if __name__ == "__main__":
    hexa_string = open("input.txt").read().strip()
    hex_to_bin = {'0':'0000', '1':'0001', '2':'0010', '3':'0011', '4':'0100', '5':'0101', '6':'0110', '7':'0111', '8':'1000', '9':'1001', 'A':'1010', 'B':'1011', 'C':'1100', 'D':'1101', 'E':'1110', 'F':'1111'}
    transmission = "".join([hex_to_bin[char] for char in hexa_string])
    version_sum = 0
    print("Part 1", evaluate_number(transmission, 0, version_sum)[2])
    print("Part 2", evaluate_number(transmission, 0, version_sum)[0])

eZpit #302 Dic '21 Juntabrackets

Idem, me he atascado un poco porque he entendido mal alguna cosilla de los headers y los filling 0s

R

RsTTa #303 Dic '21

Yo tengo la parte 2 pendiente

eZpit #304 Dic '21 Juntabrackets

Vamos gente, sprint final!!
Que aunque se pone un poco más complicadillo y tedioso, no queda ya casi nada!

PaCoX #305 Dic '21 Ant queen

el primero de hoy es mates, el segundo pues a fuerza bruta y a otra cos

spoiler

Private Sub Command1_Click()
Dim vx As Integer, vy As Integer
Dim r As Integer
    Label1.Caption = Abs(y1) * Abs(y1 + 1) / 2
    For vx = 1 To x2 + 1
        For vy = y1 To -y1
            r = r + simulate(vx, vy)
        Next
    Next
    Label2.Caption = r
End Sub


Private Function simulate(ByVal vx As Integer, ByVal vy As Integer) As Integer
    Dim x As Integer, y As Integer
    

    While y > y1
        x = x + vx
        y = y + vy
        If vx > 0 Then vx = vx - 1
        vy = vy - 1
        If x1 <= x And x <= x2 And y1 <= y And y <= y2 Then
            simulate = 1
        End If
    Wend
End Function

1 respuesta

R

RsTTa #306 Dic '21

Pues si, el de hoy la primera parte con una formula sale. La segunda es posible que también, pero no he dado con una formula completa, solo para una parte de las posibilidades. Para el resto de casos he probado todas las opciones que podian ser solución y au

Flashk #307 Dic '21

#297 Al final era un bug a la hora de construir el grafo. XD el algoritmo de Dijkstra que implementé estaba bien como tal.

1 respuesta

R

RsTTa #308 Dic '21

#307 lo tipico, el fallo donde no lo esperas xD
algo asi me paso en la parte 2 del dia 16, luego solo era cambiar la condicion de un while

1

Soltrac #309 Dic '21 MV Wizard

#305 me flipa gente escribiendo aún en vb

Flashk #310 Dic '21

Pues ya está la parte B del día 15.
Me he tirado bastante tiempo debuggando porque por alguna razón con tiles de tamaño 1, 2, 3 4 funcionaba todo ok, pero con tiles de tamaño 5 petaba el grafo (me decía que ciertos nodos no existían en el grafo aunque si que existiesen).

Al final lo he volcado todo a un array, y problema resuelto. Vuela para la cantidad de datos que hay y eso que no estoy tirando de mapas auxiliares: 300-400ms.

Day 15

BeheritSp #311 Dic '21 Juntabrackets

El día 18 me ha costado la vida, dificil de entender y dificil de debugear.

spoiler

Day18, se viene monstruo

import re

def sum_numbers(num1, num2):
    if num1 == []:
        return num2
    else:
        return "".join(['['] + [num1] +[',']+ [num2] + [']'])

def check_exploding_split(line):
    count = 0
    for i, char in enumerate(line):
        if char == "[":
            count += 1
        elif char == "]":
            count -= 1
        if count > 4:
            return True, False
    if any([int(value) >= 10 for value in re.findall("\d+", line)]):
        return False, True
    return False, False

def get_first_fourth_depth(line):
    count = 0
    for i, char in enumerate(line):
        if char == "[":
            count += 1
        elif char == "]":
            count -= 1
        if count > 4:
            count = 0
            for j, char in enumerate(line[i:]):
                if char == "[":
                    count -= 1
                elif char == "]":
                    count += 1
                if count == 1:
                    return i,i+j
    return 0

def get_leftmost_index(line):
    for i, char in enumerate(reversed(line)):
        if char.isnumeric():
            return len(line)-i-1
    return 0

def get_rightmost_index(line):
    for i, char in enumerate(line):
        if char.isnumeric():
            return i
    return 0

def do_explode(line):
    i, j = get_first_fourth_depth(line)
    to_reduce = line[i:j]
    left, right =  line[:i], line[j:]
    regex = re.findall("\d+", to_reduce)
    left_regex = re.findall("\d+", left)
    right_regex = re.findall("\d+", right)
    if to_reduce.count("[") == 1 and not to_reduce[-1].isnumeric():
        result = left[:-(len(left_regex[-1])+1)]+str(int(left_regex[-1])+int(regex[0]))+",0"+right
        rightmost = get_rightmost_index(right) + len(result) - len(right)
        if result[rightmost].isnumeric():
            return result[:rightmost] + str(int(right_regex[0])+int(regex[1]))+ result[rightmost+len(right_regex[0]):]
        else:
            return result
    else:
        if to_reduce[-1].isnumeric():
            result = "0,"+str(int(regex[1])+int(regex[2]))
        else:
            result = "0,["+str(int(regex[1])+int(regex[2]))+","+regex[3]+"]"
        leftmost = get_leftmost_index(left)
        if leftmost > 0:
            subline = line[:i]
            left = subline[:(leftmost+1-len(left_regex[-1]))] + str(int(regex[0].split(',')[0])+int(left_regex[-1])) + subline[leftmost+1:]
        return left+result+right

def do_split(line):
    for i,char in enumerate(line[1:]):
        j = i+1
        if char.isnumeric() and line[j-1].isnumeric():
            number = int(line[j-1]+char)
            return line[:j-1]+"["+str(number//2)+","+str(number//2 + number%2)+"]"+line[j+1:]

def compute_sum(number_list):
    total_sum = number_list[0]
    for line in number_list[1:]:
        total_sum = sum_numbers(total_sum, line)
        is_explode, is_split = check_exploding_split(total_sum)
        while is_explode or is_split:
            if is_explode:
                total_sum = do_explode(total_sum)
            else:
                total_sum = do_split(total_sum)
            is_explode,is_split = check_exploding_split(total_sum)
    return total_sum

def to_list(this_line, i=0):
    this_list = []
    while i < len(this_line):
        char = this_line[i]
        if char == '[':
            new_list, i = to_list(this_line, i+1)
            this_list.append(new_list)
        elif char == ']':
            return this_list, i+1
        elif not char == ',':
            this_list.append(int(char))
            i += 1
        else:
            i += 1
    return this_list[0], i

def evaluate_sum(total_sum, result=0):
    for i,l in enumerate(total_sum.copy()):
        factor = 3 if i == 0 else 2
        if type(l) == list:
            result += evaluate_sum(l)*factor
        else:
            result += l*factor
    return result

def find_max_pair_sum(number_list):
    max_sum = 0
    for i,_ in enumerate(number_list):
        for j,_ in enumerate(number_list):
            if not i == j:
                this_sum = sum_numbers(number_list[i], number_list[j])
                is_explode,is_split = check_exploding_split(this_sum)
                while is_explode or is_split:
                    if is_explode:
                        this_sum = do_explode(this_sum)
                    else:
                        this_sum = do_split(this_sum)
                    is_explode,is_split = check_exploding_split(this_sum)
                max_sum = max(max_sum, evaluate_sum(to_list(this_sum)[0]))
    return max_sum

if __name__ == "__main__":
    number_list = [line for line in open('test.txt').read().splitlines()]
    total_sum = compute_sum(number_list)
    assert(total_sum=="[[[[0,7],4],[[7,8],[6,0]]],[8,1]]")

    number_list = [line for line in open('test2.txt').read().splitlines()]
    total_sum = compute_sum(number_list)
    assert(total_sum=="[[[[5,0],[7,4]],[5,5]],[6,6]]")

    assert(do_explode("[[[[[9,8],1],2],3],4])[0]==[[[[0,9],2],3],4]"))
    test_explode = do_explode("[7,[6,[5,[4,[3,2]]]]]")
    assert(test_explode=="[7,[6,[5,[7,0]]]]")
    test_explode=do_explode("[[6,[5,[4,[3,2]]]],1]")
    assert(test_explode=="[[6,[5,[7,0]]],3]")
    test_explode=do_explode("[[3,[2,[1,[7,3]]]],[6,[5,[4,[3,2]]]]]")
    assert(test_explode=="[[3,[2,[8,0]]],[9,[5,[4,[3,2]]]]]")
    test_explode=do_explode("[[3,[2,[8,0]]],[9,[5,[4,[3,2]]]]]")
    assert(test_explode=="[[3,[2,[8,0]]],[9,[5,[7,0]]]]")

    number_list = [line for line in open('test3.txt').read().splitlines()]
    total_sum = compute_sum(number_list)
    assert(evaluate_sum(to_list(total_sum)[0])==3488)

    number_list = [line for line in open('test4.txt').read().splitlines()]
    total_sum = compute_sum(number_list)
    assert(evaluate_sum(to_list(total_sum)[0])==4140)

    number_list = [line for line in open('input.txt').read().splitlines()]
    total_sum = compute_sum(number_list)
    print("Part 1", evaluate_sum(to_list(total_sum)[0]))


    number_list = [line for line in open('test4.txt').read().splitlines()]
    assert(find_max_pair_sum(number_list)==3993)

    number_list = [line for line in open('input.txt').read().splitlines()]
    print("Part 2", find_max_pair_sum(number_list))

BeheritSp #312 Dic '21 Juntabrackets

El de ayer me costó bastante tambien, este finde ha sido muy jodido ambos días.

El dia 19 lo acabe ayer por la noche y aunque fue dificil estuvo guay tener que resolver pequeños mini problemas:

spoiler

Day19

import time
import pickle
from collections import Counter

def read_input(lines_list):
    scanners = []
    for line in lines_list:
        if "scanner" in line:
            scanner=[]
        elif line == "":
            scanners.append(scanner)
        else:
            scanner.append([int(x) for x in line.split(',')])
    scanners.append(scanner)
    return scanners

def compute_orientations(position=[1,2,3]):
    orientations = []
    for i in range(len(position)):
        for factor in [1,-1]:
            facing = [x*factor if this_i == i else x for this_i, x in enumerate(position)]
            aux_i = [j for j in range(len(position)) if j != i]
            if factor == 1:
                if i==1:
                    rotations=[(2,1), (1,-2), (-2,-1), (-1,2)]
                else:
                    rotations=[(1,2), (2,-1), (-1,-2), (-2,1)]
            else:
                if i==1:
                    rotations=[(1,2), (2,-1), (-1,-2), (-2,1)]
                else:
                    rotations=[(2,1), (1,-2), (-2,-1), (-1,2)]
            for ra,rb in rotations:
                rotation = [facing[i]]
                sign_a = 1 if ra > 0 else -1
                sign_b = 1 if rb > 0 else -1
                rotation.append(sign_a*facing[aux_i[abs(ra)-1]])
                rotation.append(sign_b*facing[aux_i[abs(rb)-1]])
                orientations.append(rotation)
    return orientations

def compute_rotations(orientation, scanner):
    return [[beacon[abs(i)-1]*fact for i, fact in zip(orientation, [1 if x>0 else -1 for x in orientation])] for beacon in scanner]

def search_down(i, connecitvity_map,communication=[], previous=0):
    for j in connectivity_map[i]:
        if j == previous:
            continue
        if j==0:
            communication.append(j)
            return communication
        else:
            new_communication = communication.copy()
            new_communication.append(j)
            new_communication = search_down(j, connecitvity_map,new_communication,i)
            if 0 in new_communication:
                return new_communication
            else:
                continue
    return communication

def generate_communication_map(connecitvity_map):
    communication_map = {}
    for i in connecitvity_map.keys():
        if 0 in connecitvity_map[i]:
            communication_map[i] = [0]
        else:
            communication_map[i] = search_down(i,connectivity_map, [])
    return communication_map

def compute_connectivity(i,j,scanner,scanner_j,connectivity_map,translation_map,orientation_map):
    if i==0 or i == j:
        return connectivity_map, translation_map, orientation_map

    for orientation in orientations:
        hashed_distances = Counter()
        rotated_beacons = compute_rotations(orientation, scanner)
        for beacon_i in rotated_beacons:
            for beacon_j in scanner_j:
                distance_x = beacon_j[0]-beacon_i[0]
                distance_y = beacon_j[1]-beacon_i[1]
                distance_z = beacon_j[2]-beacon_i[2]
                hashed_distances[(distance_x, distance_y, distance_z)] += 1
                if hashed_distances[(distance_x, distance_y, distance_z)] >=12:
                    connectivity_map[i].add(j)
                    translation_map[(i,j)] = [x for x in (distance_x, distance_y, distance_z)]
                    orientation_map[(i,j)] = orientation
                    return connectivity_map, translation_map, orientation_map
    return connectivity_map, translation_map, orientation_map

start_time = time.time()
filename = "input.txt"
lines_list = open(filename).read().splitlines()
scanners = read_input(lines_list)

connectivity_map = {}
translation_map = {}
orientation_map = {}
orientations = compute_orientations()

for i,scanner in enumerate(scanners):
    connectivity_map[i] = set()
    print("Computing connecitvity for scanner {}".format(i))
    for j,scanner_j in enumerate(scanners):
        connectivity_map, translation_map, orientation_map = compute_connectivity(i,j,scanner,scanner_j,connectivity_map,translation_map,orientation_map)

communication_map = generate_communication_map(connectivity_map)
all_beacons = {(beacon[0],beacon[1],beacon[2]) for beacon in scanners[0]}
coords = [[0,0,0]]
for i_scan, scanner in enumerate(scanners[1:]):
    for beacon in scanner:
        current_connection=i_scan+1
        for next_connection in communication_map[i_scan+1]:
            translation = translation_map[(current_connection,next_connection)]
            orientation = orientation_map[(current_connection,next_connection)]
            rotated_beacon=[beacon[abs(i)-1]*fact for i, fact in zip(orientation, [1 if x>0 else -1 for x in orientation])]
            beacon=[x+y for x,y in zip(rotated_beacon, translation)]
            current_connection = next_connection
        all_beacons.add((beacon[0],beacon[1],beacon[2]))
    distance = [0,0,0]
    current_connection=i_scan+1
    for next_connection in communication_map[i_scan+1]:
        translation = translation_map[(current_connection,next_connection)]
        orientation = orientation_map[(current_connection,next_connection)]
        distance=[distance[abs(i)-1]*fact for i, fact in zip(orientation, [1 if x>0 else -1 for x in orientation])]
        distance = [x+y for x,y in zip(distance, translation)]
        current_connection = next_connection
    coords.append(distance)

print("Part 1",len(all_beacons))

max_distance = -1e6
for i in range(len(coords)):
    for j in range(len(coords)):
        max_distance = max(max_distance,sum([abs(x-y) for x,y in zip(coords[i], coords[j])]))
print("Part 2", max_distance)
print("Time", time.time()-start_time)

Hoy dia 20 bastante más asequible, muy chulo que la dificultad haya sido que

spoiler

Day20

def pretty_print(grid):
    for row in grid:
        print(''.join(row))
    print("")

def pad_image(image, mode='.', repetitions=3):
    new_image = []
    for i in range(repetitions):
        new_image.append([mode] * (len(image[0]) + 2*repetitions))
    for row in image:
        new_image.append([mode]*repetitions  + row + [mode]*repetitions )
    for i in range(repetitions):
        new_image.append([mode] * (len(image[0]) + 2*repetitions))
    return new_image

def get_neighbours(i,j):
    for m in range(i-1,i+2):
        for n in range(j-1,j+2):
            yield m,n

def copy_image(image):
    new_image = []
    for row in image:
        new_image.append(row[:])
    return new_image

def advance(input_image, mode, step):
    if step % 2 == 1:
        input_image=pad_image(input_image)
    else:
        input_image=pad_image(input_image, mode)

    new_image=copy_image(input_image)
    for i in range(len(input_image)):
        for j in range(len(input_image[i])):
                neighbours = [(m,n) for m,n in get_neighbours(i,j) if 0<=m<len(input_image) and 0<=n<len(input_image[i])]
                if len(neighbours)==9:
                    binary_number = ['0' if input_image[m][n]=='.' else '1' for m,n in neighbours]
                    int_number = int(''.join(binary_number),2)
                    new_image[i][j]=enhancement[int_number]
    if mode=='#':
        replace = '.' if step % 2 == 0 else '#'
        for i in range(len(new_image)):
            new_image[i][0]=replace
            new_image[i][len(new_image[0])-1]=replace
            new_image[0][i]=replace
            new_image[len(new_image[0])-1][i]=replace
    return new_image

def solve_problem(input_image, steps, mode):
    for step in range(steps):
        if (step+1) % 10 == 0:
            print("Step", step+1)
        input_image = advance(input_image, mode, step+1)
    return sum([row.count('#') for row in input_image])

if __name__ == "__main__":
    import time
    start_time = time.time()
    lines_list = open('input.txt').read().splitlines()
    enhancement = lines_list[0]
    input_image=[ [value for value in line] for line in lines_list[2:]]
    print("Part 1", solve_problem(input_image, 2, enhancement[0]))
    print("Part 2", solve_problem(input_image, 50, enhancement[0]))
    print("Time elapsed:", time.time() - start_time)

PaCoX #313 Dic '21 Ant queen

Day20

spoiler

Public Algo As String
Dim img() As String


Private Sub Command1_Click()
    Text2.Text = ""
    ReadInput
    ExpandeImage Text3.Text * 2
    For i = 1 To Text3.Text
        EnhanceImage
    Next
    printImage
End Sub

Private Sub ReadInput()
    Dim flag As Boolean
    Dim i As Integer
    strtext = Split(Text1.Text, vbCrLf)
    maxY = UBound(strtext)
    maxX = Len(strtext(0))
    flag = False
    For x = 0 To maxY
        If Len(strtext(x)) > 0 Then
            If flag Then
                img(i) = strtext(x)
                i = i + 1
            Else
                Algo = Algo & strtext(x)
            End If
        Else
            If Not flag Then
                ReDim img(maxY - x - 1)
                flag = True
            End If
        End If
    Next
End Sub

Private Sub ExpandeImage(expande As Integer)
Dim j As Integer
Dim imgExp() As String
    j = expande / 2
    maxY = UBound(img) + expande
    maxX = Len(img(0))
    ReDim imgExp(maxY)
    For y = 0 To maxY
        If y >= j And y <= UBound(img) + j Then
            imgExp(y) = String(j, ".") & img(y - j) & String(j, ".")
        Else
            imgExp(y) = String(maxX + expande, ".")
        End If
    Next
    img = imgExp
End Sub

Private Sub EnhanceImage()
Dim x As Integer, y As Integer
Dim s As String
Dim newImg() As String
    maxY = UBound(img)
    maxX = Len(img(0))
    ReDim newImg(UBound(img))
    For y = 0 To maxY
        For x = 0 To maxX
            s = Position(x - 1, y - 1) & Position(x, y - 1) & Position(x + 1, y - 1) & _
                Position(x - 1, y) & Position(x, y) & Position(x + 1, y) & _
                Position(x - 1, y + 1) & Position(x, y + 1) & Position(x + 1, y + 1)
            newImg(y) = newImg(y) & Mid(Algo, BinToDec(s) + 1, 1)
        Next
    Next
    img = newImg
End Sub

Public Function Position(x As Integer, y As Integer) As Long
On Error GoTo err_handler
    Position = IIf(Mid(img(y), x + 1, 1) = "#", 1, 0)
    Exit Function
err_handler:
    Position = 0
End Function

Public Function BinToDec(v As String) As Integer
    lenV = Len(v)
    For x = 0 To lenV - 1
        BinToDec = BinToDec + CInt(Mid(v, x + 1, 1)) * (2 ^ (lenV - (x + 1)))
    Next
End Function

Public Sub printImage()
Dim c As Integer
    For y = 0 To UBound(img)
        Text2.Text = Text2.Text & img(y) & vbCrLf
        c = c + UBound(Split(img(y), "#"))
    Next
    Label1 = "How many pixels are lit in the resulting image? " & c
End Sub

Day21

BeheritSp #314 Dic '21 Juntabrackets

Estos ultimos dias estan siendo bastante duros pero los estoy disfrutando bastante.

En general mis soluciones son bastante lentas, but it works.

Day21

import itertools
from functools import cache
import time

class Dice:
    def __init__(self):
        self.value = 0
        self.rolling_times = 0
    def roll(self):
        self.rolling_times += 1
        self.value += 1
        if self.value > 100:
            self.value = 1
        return self.value
    def get_rolling_times(self):
        return self.rolling_times

@cache
def play_realization(pos_i, pos_j, score_i, score_j):
    if score_i  >= 21:
        return 1, 0
    if score_j >= 21:
        return 0, 1
    wins_i, wins_j = 0,0
    for outcome_i, outcome_j in itertools.product(outcomes_counts.keys(), repeat=2):
        new_pos_i = sum_outcome(pos_i, outcome_i)
        new_pos_j = sum_outcome(pos_j, outcome_j)
        new_score_i = score_i + new_pos_i
        new_score_j = score_j + new_pos_j
        new_wins_i, new_wins_j = play_realization(new_pos_i, new_pos_j, new_score_i, new_score_j)
        product = outcomes_counts[outcome_i]*outcomes_counts[outcome_j]
        wins_i += new_wins_i*product
        wins_j += new_wins_j*product
    return wins_i, wins_j

def sum_outcome(pos, outcome):
    pos += outcome
    while pos>10:
        pos -= 10
    return pos


start_time = time.time()
lines_list = open('input.txt').read().splitlines()
player_positions = [int(line.split(":")[1].strip()) for line in lines_list]
player_scores = [0] * len(player_positions)
dice = Dice()
while not any([score>=1000 for score in player_scores]):
    for i, position in enumerate(player_positions):
        new_score = [dice.roll() for _ in range(3)]
        player_positions[i] += sum(new_score)
        while player_positions[i]>10:
            player_positions[i] -= 10
        player_scores[i] += player_positions[i]
        if player_scores[i]>=1000:
            break
print("Part 1 ", dice.get_rolling_times()*min(player_scores))


player_positions = [int(line.split(":")[1].strip()) for line in lines_list]
dice_outcomes = [i+k+j for i in range(1,4) for j in range(1,4) for k in range(1,4)]
outcomes_counts = {value:dice_outcomes.count(value) for value in dice_outcomes}
wins_i, wins_j=play_realization(player_positions[0], player_positions[1], 0, 0)

print("Part 2 ", max(wins_i//len(dice_outcomes),wins_j))
print("--- %s seconds ---" % (time.time() - start_time))

Day22

from itertools import product
import re

def check_outside(ranges):
    return ranges[0] < -50 or ranges[1] > 50 or ranges[2] < -50 or ranges[3] > 50 or ranges[4] < -50 or ranges[5] > 50

def check_inside(key1, key2, to_check1, to_check_2):
    return key1 <= to_check1 <= key2 and key1 <= to_check_2 <= key2

def check_intersect(key1, key2, to_check1, to_check_2):
    return (key1 <= to_check1 <= key2) or (key1 <= to_check_2 <= key2) or (to_check1 <= key1 <= to_check_2)

def check_cube_completely_inside(base, to_check):
    is_x_inside = check_inside(base[0], base[1], to_check[0], to_check[1])
    is_y_inside = check_inside(base[2], base[3], to_check[2], to_check[3])
    is_z_inside = check_inside(base[4], base[5], to_check[4], to_check[5])
    return is_x_inside and is_y_inside and is_z_inside

def append_split(split_axis, a, b, c, d):

    if not a==b:
        split_axis.append(tuple([a,b-1]))
    split_axis.append(tuple([b,c]))
    split_axis.append(tuple([c+1,d]))


def get_axis_ranges(range0, range1):
    split_axis =[]
    if range0[0] <= range1[0] <= range0[1] <= range1[1]:
        append_split(split_axis, range0[0], range1[0], range0[1], range1[1])
    elif range1[0] <= range0[0] <= range1[1] <= range0[1]:
        append_split(split_axis, range1[0], range0[0], range1[1], range0[1])
    elif range0[0] <= range1[0] <= range1[1] <= range0[1]:
        append_split(split_axis, range0[0], range1[0], range1[1], range0[1])
    elif range1[0] <= range0[0] <= range0[1] <= range1[1]:
        append_split(split_axis, range1[0], range0[0], range0[1], range1[1])


    split_axis = list(dict.fromkeys(split_axis))

    return split_axis

def get_ranges_from_intersecting_cubes(range0, range1):
    split_x_ranges = get_axis_ranges(range0[0:2], range1[0:2])
    split_y_ranges = get_axis_ranges(range0[2:4], range1[2:4])
    split_z_ranges = get_axis_ranges(range0[4:6], range1[4:6])
    ranges = []
    ranges.append(list(range(0, len(split_x_ranges))))
    ranges.append(list(range(0, len(split_y_ranges))))
    ranges.append(list(range(0, len(split_z_ranges))))

    return split_x_ranges, split_y_ranges, split_z_ranges, ranges

def check_intersecting(cubes, ranges_to_check, status_to_check):
    new_cubes = set()
    is_intersecting = False
    cubes_to_delete = set()
    for cube_ranges in cubes:
        is_x_intersecting = check_intersect(cube_ranges[0], cube_ranges[1], ranges_to_check[0], ranges_to_check[1]) or check_inside(cube_ranges[0], cube_ranges[1], ranges_to_check[0], ranges_to_check[1]) or check_inside(ranges_to_check[0], ranges_to_check[1], cube_ranges[0], cube_ranges[1])
        is_y_intersecting = check_intersect(cube_ranges[2], cube_ranges[3], ranges_to_check[2], ranges_to_check[3]) or check_inside(cube_ranges[2], cube_ranges[3], ranges_to_check[2], ranges_to_check[3]) or check_inside(ranges_to_check[2], ranges_to_check[3], cube_ranges[2], cube_ranges[3])
        is_z_intersecting = check_intersect(cube_ranges[4], cube_ranges[5], ranges_to_check[4], ranges_to_check[5]) or check_inside(cube_ranges[4], cube_ranges[5], ranges_to_check[4], ranges_to_check[5]) or check_inside(ranges_to_check[4], ranges_to_check[5], cube_ranges[4], cube_ranges[5])

        if is_x_intersecting and is_y_intersecting and is_z_intersecting:
            split_x_ranges, split_y_ranges, split_z_ranges, ranges = get_ranges_from_intersecting_cubes(cube_ranges, ranges_to_check)
            for i, j, k in product(*ranges):
                cube_to_add = tuple(split_x_ranges[i] + split_y_ranges[j] + split_z_ranges[k])

                if status_to_check == 'on':
                    is_in_base = check_cube_completely_inside(cube_ranges, cube_to_add)
                    if is_in_base:
                        new_cubes.add(cube_to_add)
                elif status_to_check == 'off':
                    is_in_base = check_cube_completely_inside(cube_ranges, cube_to_add)
                    is_in_candidate = check_cube_completely_inside(ranges_to_check, cube_to_add)
                    if is_in_base and not is_in_candidate:
                        new_cubes.add(cube_to_add)
            cubes_to_delete.add(cube_ranges)
            return True, new_cubes, cubes_to_delete
    return False, new_cubes,set()

def check_completely_inside(cubes, key):
    for cube_range in cubes:
        is_x_inside = check_inside(cube_range[0], cube_range[1], key[0], key[1])
        is_y_inside = check_inside(cube_range[2], cube_range[3], key[2], key[3])
        is_z_inside = check_inside(cube_range[4], cube_range[5], key[4], key[5])
        if is_x_inside and is_y_inside and is_z_inside:
            return True
    return False


def check_any_completely_inside(cubes, key):
    new_cubes = set()
    any_inside = False
    for cube_range in cubes:
        is_x_inside = check_inside(key[0], key[1], cube_range[0], cube_range[1])
        is_y_inside = check_inside(key[2], key[3], cube_range[2], cube_range[3])
        is_z_inside = check_inside(key[4], key[5], cube_range[4], cube_range[5])
        if is_x_inside and is_y_inside and is_z_inside:
            any_inside = True
            pass
        else:
            new_cubes.add(cube_range)

    return any_inside, new_cubes

def compute_volume(cube):
    return len(range(cube[0], cube[1]+1))* len(range(cube[2], cube[3]+1))*len(range(cube[4], cube[5]+1))

if __name__ == '__main__':
    import time
    start_time = time.time()

    lines_list = open('input.txt').read().splitlines()
    cube_on = set()
    for line in lines_list:
        status = line.split()[0]
        ranges =[int(value) for value in re.findall(r'-?\d+', line.split()[1])]
        if check_outside(ranges):
            continue
        for x in range(ranges[0], ranges[1]+1):
            for y in range(ranges[2], ranges[3]+1):
                for z in range(ranges[4], ranges[5]+1):
                        if status == 'on':
                            cube_on.add((x,y,z))
                        else:
                            cube_on.discard((x,y,z))
    volume_1 = len(cube_on)
    print("Part 1", len(cube_on))

    lines_list = open('input.txt').read().splitlines()
    cubes = set()
    cubes_to_check = {}
    for line in lines_list:
        status = line.split()[0]
        ranges = [int(value) for value in re.findall(r'-?\d+', line.split()[1])]
        cubes_to_check[tuple(ranges)] = status

    while len(list(cubes_to_check.keys())) > 0:
        volume = sum([len(range(cube[0], cube[1]+1))+ len(range(cube[2], cube[3]+1))+len(range(cube[4], cube[5]+1)) for cube in cubes])

        list_of_keys = list(cubes_to_check.keys())
        this_key = list_of_keys.pop(0)
        to_check_status = cubes_to_check[this_key]
        if to_check_status == 'on':
            is_this_key_completely_inside = check_completely_inside(cubes, this_key)
            if is_this_key_completely_inside:
                del cubes_to_check[this_key]
                continue
        is_any_cube_completely_inside_this_key, cubes = check_any_completely_inside(cubes, this_key)
        if is_any_cube_completely_inside_this_key:
            continue

        is_intersecting, new_cubes, cube_to_delete = check_intersecting(cubes, this_key , cubes_to_check[this_key])
        if is_intersecting:
            old_volume = 0
            for old_cube in cube_to_delete:
                cubes.remove(old_cube)
                old_volume += compute_volume(old_cube)
            new_volume = 0
            for new_cube in new_cubes:
                cubes.add(new_cube)
                new_volume += compute_volume(new_cube)
        if not is_intersecting:
            del cubes_to_check[this_key]
            if to_check_status == 'on':
                cubes.add(this_key)


    volume = sum([compute_volume(cube) for cube in cubes])
    print("Part 2", volume)
    print("Time", time.time() - start_time)

Day23-1

from itertools import product
import re

def check_outside(ranges):
    return ranges[0] < -50 or ranges[1] > 50 or ranges[2] < -50 or ranges[3] > 50 or ranges[4] < -50 or ranges[5] > 50

def check_inside(key1, key2, to_check1, to_check_2):
    return key1 <= to_check1 <= key2 and key1 <= to_check_2 <= key2

def check_intersect(key1, key2, to_check1, to_check_2):
    return (key1 <= to_check1 <= key2) or (key1 <= to_check_2 <= key2) or (to_check1 <= key1 <= to_check_2)

def check_cube_completely_inside(base, to_check):
    is_x_inside = check_inside(base[0], base[1], to_check[0], to_check[1])
    is_y_inside = check_inside(base[2], base[3], to_check[2], to_check[3])
    is_z_inside = check_inside(base[4], base[5], to_check[4], to_check[5])
    return is_x_inside and is_y_inside and is_z_inside

def append_split(split_axis, a, b, c, d):

    if not a==b:
        split_axis.append(tuple([a,b-1]))
    split_axis.append(tuple([b,c]))
    split_axis.append(tuple([c+1,d]))


def get_axis_ranges(range0, range1):
    split_axis =[]
    if range0[0] <= range1[0] <= range0[1] <= range1[1]:
        append_split(split_axis, range0[0], range1[0], range0[1], range1[1])
    elif range1[0] <= range0[0] <= range1[1] <= range0[1]:
        append_split(split_axis, range1[0], range0[0], range1[1], range0[1])
    elif range0[0] <= range1[0] <= range1[1] <= range0[1]:
        append_split(split_axis, range0[0], range1[0], range1[1], range0[1])
    elif range1[0] <= range0[0] <= range0[1] <= range1[1]:
        append_split(split_axis, range1[0], range0[0], range0[1], range1[1])


    split_axis = list(dict.fromkeys(split_axis))

    return split_axis

def get_ranges_from_intersecting_cubes(range0, range1):
    split_x_ranges = get_axis_ranges(range0[0:2], range1[0:2])
    split_y_ranges = get_axis_ranges(range0[2:4], range1[2:4])
    split_z_ranges = get_axis_ranges(range0[4:6], range1[4:6])
    ranges = []
    ranges.append(list(range(0, len(split_x_ranges))))
    ranges.append(list(range(0, len(split_y_ranges))))
    ranges.append(list(range(0, len(split_z_ranges))))

    return split_x_ranges, split_y_ranges, split_z_ranges, ranges

def check_intersecting(cubes, ranges_to_check, status_to_check):
    new_cubes = set()
    is_intersecting = False
    cubes_to_delete = set()
    for cube_ranges in cubes:
        is_x_intersecting = check_intersect(cube_ranges[0], cube_ranges[1], ranges_to_check[0], ranges_to_check[1]) or check_inside(cube_ranges[0], cube_ranges[1], ranges_to_check[0], ranges_to_check[1]) or check_inside(ranges_to_check[0], ranges_to_check[1], cube_ranges[0], cube_ranges[1])
        is_y_intersecting = check_intersect(cube_ranges[2], cube_ranges[3], ranges_to_check[2], ranges_to_check[3]) or check_inside(cube_ranges[2], cube_ranges[3], ranges_to_check[2], ranges_to_check[3]) or check_inside(ranges_to_check[2], ranges_to_check[3], cube_ranges[2], cube_ranges[3])
        is_z_intersecting = check_intersect(cube_ranges[4], cube_ranges[5], ranges_to_check[4], ranges_to_check[5]) or check_inside(cube_ranges[4], cube_ranges[5], ranges_to_check[4], ranges_to_check[5]) or check_inside(ranges_to_check[4], ranges_to_check[5], cube_ranges[4], cube_ranges[5])

        if is_x_intersecting and is_y_intersecting and is_z_intersecting:
            split_x_ranges, split_y_ranges, split_z_ranges, ranges = get_ranges_from_intersecting_cubes(cube_ranges, ranges_to_check)
            for i, j, k in product(*ranges):
                cube_to_add = tuple(split_x_ranges[i] + split_y_ranges[j] + split_z_ranges[k])

                if status_to_check == 'on':
                    is_in_base = check_cube_completely_inside(cube_ranges, cube_to_add)
                    if is_in_base:
                        new_cubes.add(cube_to_add)
                elif status_to_check == 'off':
                    is_in_base = check_cube_completely_inside(cube_ranges, cube_to_add)
                    is_in_candidate = check_cube_completely_inside(ranges_to_check, cube_to_add)
                    if is_in_base and not is_in_candidate:
                        new_cubes.add(cube_to_add)
            cubes_to_delete.add(cube_ranges)
            return True, new_cubes, cubes_to_delete
    return False, new_cubes,set()

def check_completely_inside(cubes, key):
    for cube_range in cubes:
        is_x_inside = check_inside(cube_range[0], cube_range[1], key[0], key[1])
        is_y_inside = check_inside(cube_range[2], cube_range[3], key[2], key[3])
        is_z_inside = check_inside(cube_range[4], cube_range[5], key[4], key[5])
        if is_x_inside and is_y_inside and is_z_inside:
            return True
    return False


def check_any_completely_inside(cubes, key):
    new_cubes = set()
    any_inside = False
    for cube_range in cubes:
        is_x_inside = check_inside(key[0], key[1], cube_range[0], cube_range[1])
        is_y_inside = check_inside(key[2], key[3], cube_range[2], cube_range[3])
        is_z_inside = check_inside(key[4], key[5], cube_range[4], cube_range[5])
        if is_x_inside and is_y_inside and is_z_inside:
            any_inside = True
            pass
        else:
            new_cubes.add(cube_range)

    return any_inside, new_cubes

def compute_volume(cube):
    return len(range(cube[0], cube[1]+1))* len(range(cube[2], cube[3]+1))*len(range(cube[4], cube[5]+1))

if __name__ == '__main__':
    import time
    start_time = time.time()

    lines_list = open('input.txt').read().splitlines()
    cube_on = set()
    for line in lines_list:
        status = line.split()[0]
        ranges =[int(value) for value in re.findall(r'-?\d+', line.split()[1])]
        if check_outside(ranges):
            continue
        for x in range(ranges[0], ranges[1]+1):
            for y in range(ranges[2], ranges[3]+1):
                for z in range(ranges[4], ranges[5]+1):
                        if status == 'on':
                            cube_on.add((x,y,z))
                        else:
                            cube_on.discard((x,y,z))
    volume_1 = len(cube_on)
    print("Part 1", len(cube_on))

    lines_list = open('input.txt').read().splitlines()
    cubes = set()
    cubes_to_check = {}
    for line in lines_list:
        status = line.split()[0]
        ranges = [int(value) for value in re.findall(r'-?\d+', line.split()[1])]
        cubes_to_check[tuple(ranges)] = status

    while len(list(cubes_to_check.keys())) > 0:
        volume = sum([len(range(cube[0], cube[1]+1))+ len(range(cube[2], cube[3]+1))+len(range(cube[4], cube[5]+1)) for cube in cubes])

        list_of_keys = list(cubes_to_check.keys())
        this_key = list_of_keys.pop(0)
        to_check_status = cubes_to_check[this_key]
        if to_check_status == 'on':
            is_this_key_completely_inside = check_completely_inside(cubes, this_key)
            if is_this_key_completely_inside:
                del cubes_to_check[this_key]
                continue
        is_any_cube_completely_inside_this_key, cubes = check_any_completely_inside(cubes, this_key)
        if is_any_cube_completely_inside_this_key:
            continue

        is_intersecting, new_cubes, cube_to_delete = check_intersecting(cubes, this_key , cubes_to_check[this_key])
        if is_intersecting:
            old_volume = 0
            for old_cube in cube_to_delete:
                cubes.remove(old_cube)
                old_volume += compute_volume(old_cube)
            new_volume = 0
            for new_cube in new_cubes:
                cubes.add(new_cube)
                new_volume += compute_volume(new_cube)
        if not is_intersecting:
            del cubes_to_check[this_key]
            if to_check_status == 'on':
                cubes.add(this_key)


    volume = sum([compute_volume(cube) for cube in cubes])
    print("Part 2", volume)
    print("Time", time.time() - start_time)

Day23-2

from day_23_1 import *

if __name__ == "__main__":

    start_time = time.time()

    filename = "input.txt"
    lines_list = open(filename).read().splitlines()
    extra_lines = ["#D#C#B#A#","#D#B#A#C#"]

    room_map = [ [char for char in line] for line in lines_list[1:3]]
    room_map.append(['#']*2+[char for char in extra_lines[0]]+['#']*2)
    room_map.append(['#']*2+[char for char in extra_lines[1]]+['#']*2)
    room_map.append(['#']*2+[char for char in lines_list[3][2:]]+['#']*2)

    print("Part 2", solve_dijkstra(room_map))
    print("Time", time.time()-start_time)

Por cierto @PaCoX como has hecho el de hoy? He visto que has tardado muy poco. Yo al final:

spoiler

1 respuesta

PaCoX #315 Dic '21 Ant queen

#314 yo lo hice simulando cada iteracion xD, no me tardaba mucho
el 23 y 24 a mano

BeheritSp #316 Dic '21 Juntabrackets

Yo al principio también saqué la solución "a mano" para el 24

spoiler

pero ayer conseguí hacerlo automático:

Day24

class ALU:
    def __init__(self):
        self.x = 0
        self.y = 0
        self.z = 0
        self.w = 0

    def return_value(self, a):
        if a == 'x':
            return self.x
        elif a == 'y':
            return self.y
        elif a == 'z':
            return self.z
        elif a == 'w':
            return self.w
        else:
            raise ValueError('Invalid input', a)

    def assign_value(self,a, value):
        if not isinstance(a, str):
            raise TypeError('Invalid type, expected string', type(a))
        if not isinstance(value, int):
            raise TypeError('Invalid type, expected int', type(value))
        if a == 'x':
            self.x = value
        elif a == 'y':
            self.y = value
        elif a == 'z':
            self.z = value
        elif a == 'w':
            self.w = value
        else:
            raise ValueError('Invalid input', a)

    def get_values(self, a, b):
        if isinstance(a, str):
            a = self.return_value(a)
        else:
            raise TypeError('Invalid type, expected string', type(a))
        if isinstance(b, int):
            pass
        elif isinstance(b, str):
            b = self.return_value(b)
        else:
            raise TypeError('Invalid type', type(b))
        return a, b

    def inp(self, a, b):
        if not isinstance(b, int):
            raise TypeError('Invalid type, expected int and got', type(b))
        self.assign_value(a, b)

    def add(self, a, b):
        value, b =  self.get_values(a, b)
        value += b
        self.assign_value(a, value)

    def mul(self, a, b):
        value, b =  self.get_values(a, b)
        value *= b
        self.assign_value(a, value)

    def div(self, a, b):
        value, b =  self.get_values(a, b)
        if b==0:
            raise(ZeroDivisionError)
        value //= b

        self.assign_value(a, value)

    def mod(self, a, b):
        value, b =  self.get_values(a, b)
        if value<0 or b<=0:
            raise(Exception("Wront input for mod"))
        value %= b
        self.assign_value(a, value)

    def eql(self, a, b):
        value, b =  self.get_values(a, b)
        value = int(value==b)
        self.assign_value(a, value)

def process_input(lines_list, string_to_read, alu):
    string_to_list = list(string_to_read)
    for line in lines_list:
        split_line = [int(char) if char.isnumeric() else -1*int(char.lstrip("-")) if char.lstrip("-").isdigit() else char for char in line.split()]
        if split_line[0] == 'inp':
            alu.inp(split_line[1], int(string_to_list.pop(0)))
        elif split_line[0] == 'add':
            alu.add(split_line[1], split_line[2])
        elif split_line[0] == 'mul':
            alu.mul(split_line[1], split_line[2])
        elif split_line[0] == 'div':
            alu.div(split_line[1], split_line[2])
        elif split_line[0] == 'mod':
            alu.mod(split_line[1], split_line[2])
        elif split_line[0] == 'eql':
            alu.eql(split_line[1], split_line[2])
        else:
            raise(Exception("Invalid input", split_line[0]))

    return alu.return_value('x'), alu.return_value('y'), alu.return_value('z'), alu.return_value('w')

class ReverseEngineeringALU(ALU):
    def __init__(self, mode='maximize'):
        super().__init__()
        self.constraints = {value:0 for value in range(1,15)}
        self.n_input = 0
        self.mode = mode

    def assign_value(self,a, value):
        if a == 'x':
            self.x = value
        elif a == 'y':
            self.y = value
        elif a == 'z':
            self.z = value
        elif a == 'w':
            self.w = value
        else:
            raise ValueError('Invalid input', a)

    def inp(self, a,b):
        self.w="w["+str(self.n_input)+"]"
        self.n_input += 1

    def add(self, a, b):
        value, b =  self.get_values(a, b)
        if isinstance(value, int) and isinstance(b, int):
            value  = value+b
        elif isinstance(b, int):
            if b>0:
                value = str(value)+"+"+str(b)
            elif b<0:
                value = str(value)+"-"+str(abs(b))
            else:
                value = str(value)
        elif isinstance(value, int):
            if value == 0:
                value = b
        else:
            if value == "0":
                value = str(b)
            elif b == "0":
                value = str(value)
            else:
                value = str(value)+"+"+str(b)
        self.assign_value(a, value)

    def mul(self, a, b):
        value, b =  self.get_values(a, b)
        if b == 0:
            value = 0
        elif b==1:
            value = value
        elif isinstance(value, int) and isinstance(b, int):
            value = value*b
        elif isinstance(value, str) and isinstance(b, int):
            value ="("+str(value)+")*"+str(b)
        else:
            value ="("+str(value)+")*("+str(b)+")"

        self.assign_value(a, value)

    def div(self, a, b):
        value, b =  self.get_values(a, b)
        if b == 0:
            raise(ZeroDivisionError)
        elif isinstance(value, int) and isinstance(b, int):
            value = value//b
        elif isinstance(value, str) and isinstance(b, int):
            value ="("+str(value)+")//"+str(b)
        else:
            value ="("+str(value)+")//("+str(b)+")"
        self.assign_value(a, value)

    def mod(self, a, b):
        value, b =  self.get_values(a, b)
        if b == 0:
            raise(ZeroDivisionError)
        elif isinstance(value, int) and isinstance(b, int):
            value = value%b
        elif isinstance(value, str):
            numbers = re.findall("(\+\d+|-\d+)", value)
            if isinstance(b, int):
                if len(numbers)==1 and int(numbers[0])+9 < b:
                    value = 0
                else:
                    value ="("+str(value)+")%"+str(b)
            else:
                value ="("+str(value)+")%("+str(b)+")"
        self.assign_value(a, value)

    def eql(self, a, b):
        value, b =  self.get_values(a, b)
        if isinstance(value, str) and "-" in value:
            variables = re.findall("w\[\d\]", value)
            this_w_value = self.n_input-1
            found_w, prev_w = 0, 0
            test_range = range(1,10) if self.mode == "maximize" else range(9,0,-1)
            for test_w in test_range:
                for test_prev in range(1, 10):
                    w = [test_prev for i in range(0, this_w_value)]
                    eval_value = eval(value)
                    if eval_value-test_w == 0:
                        found_w=test_w
                        prev_w = test_prev
            if found_w > 0:
                self.constraints[this_w_value+1] = found_w
                for variable in variables:
                    digit = int(re.findall("\d+", variable)[0])
                    if this_w_value == digit+1:
                        self.constraints[this_w_value] = prev_w
            value = 1
        elif isinstance(b, str):
            value = 0
        elif b == 0:
            value = int(value == 0)
        self.assign_value(a, value)

def find_first_model_number(permutations):
    for p in itertools.product(*permutations):
        string_input = "".join(p)
        x,y,z,w = process_input(lines_list, string_input, ALU())
        if z == 0:
            return string_input

if __name__ == '__main__':

    import itertools, re

    lines_list = open('input.txt').read().splitlines()

    hacker_alu = ReverseEngineeringALU(mode="maximize")
    process_input(lines_list, "66666666666666", hacker_alu)
    permutations = [str(value) if value > 0 else list("987654321") for value in hacker_alu.constraints.values()]
    print("Part 1", find_first_model_number(permutations))

    hacker_alu = ReverseEngineeringALU(mode="minimize")
    process_input(lines_list, "66666666666666", hacker_alu)
    permutations = [str(value) if value > 0 else list("123456789") for value in hacker_alu.constraints.values()]
    print("Part 2", find_first_model_number(permutations))

Y aquí el Day25!

Day25

def pretty_print(sea_map):
    for line in sea_map:
        print(''.join(line))
    print()

def copy_sea_map(sea_map):
    return [[char for char in line] for line in sea_map]

def advance_cucumbers(current_sea_map):
    horitzontal_new_map = copy_sea_map(current_sea_map)
    max_j = len(current_sea_map[0]) - 1
    for i, line in enumerate(current_sea_map):
        for j, char in enumerate(line):
            if char == '>':
                new_j = j+1 if j < max_j else 0
                if current_sea_map[i][new_j] == '.':
                    horitzontal_new_map[i][new_j] = '>'
                    horitzontal_new_map[i][j] = '.'
    vertical_new_map = copy_sea_map(horitzontal_new_map)
    max_i = len(current_sea_map) - 1
    for i, line in enumerate(horitzontal_new_map):
        for j, char in enumerate(line):
            if char == 'v':
                new_i = i+1 if i < max_i else 0
                if horitzontal_new_map[new_i][j] == '.':
                    vertical_new_map[new_i][j] = 'v'
                    vertical_new_map[i][j] = '.'
    return vertical_new_map


if __name__ == '__main__':

    lines_list = open('input.txt').read().splitlines()
    sea_map = [[char for char in line] for line in lines_list]

    are_maps_equal = False
    step = 0
    while not are_maps_equal:
        step += 1
        old_sea_map = copy_sea_map(sea_map)
        sea_map = advance_cucumbers(old_sea_map)
        are_maps_equal = old_sea_map == sea_map
    print("Part 1:", step)

La parte final de este año me ha parecido más dificil que el año pasado, o almenos a mi me ha costado bastante más. Pero en general ha estado muy chulo.

eZpit #317 Dic '21 Juntabrackets

Enhorabuena a los que habéis acabado, yo me he quedado colgado esta última semana con mi mudanza de piso, a ver si puedo hacer los días que me quedan y acabar aunque sea a posteriori

Usuarios habituales

Tags