Advent of Code 2020

Cecos94 #811 Dic '20

Todavia no he sido capaz de resolver la parte dos de ayer, entiendo que solo un indice corresponde a cada campo pero algo me esta bailando por ahi porque no consigo hacerle funcionar. Ultimamente se me estan complicando las segundas partes

1 respuesta

ciza #812 Dic '20

#811

pista

El problema de hoy es bastante parecido al de los asientos del avión pero añadiendo dimensiones basicamente.

QuitCat #813 Dic '20 Gafe

Hechos los dos de hoy. Mañana vuelvo al curro, a ver si saco tiempo para seguir al día hasta donde la dificultad me lo permita

spoiler

BeheritSp #814 Dic '20 Juntabrackets

En la parte 1 me ha costado entender el ejemplo porque estaba asumiendo que el (0,0) siempre estaba en el medio.

spoiler

Main Part 1 y 2

lines_list =[list(line) for line in open("input.txt").read().splitlines()]

pocket = [lines_list]

iterations = 6
for iteration in range(iterations):
    pocket = increase_dimension(pocket)
    new_pocket = copy.deepcopy(pocket)
    for z, z_slice in enumerate(pocket):
        for y, y_slice in enumerate(z_slice):
            for x, x_slice in enumerate(y_slice):
                if x_slice == '#':
                    if len([check for check in check_if_surrounded(x,y,z, pocket) if check is True]) not in [2,3]:
                        new_pocket[z][y][x] = '.'
                elif x_slice == '.':
                    if len([check for check in check_if_surrounded(x,y,z, pocket) if check is True]) == 3:
                        new_pocket[z][y][x] = '#'
    pocket = copy.deepcopy(new_pocket)

print("Part 1", count_cubes(pocket))

pocket = [[lines_list]]
for iteration in range(iterations):
    pocket = hyper_increase_dimension(pocket)

    new_pocket = copy.deepcopy(pocket)
    for w, w_slice in enumerate(pocket):
        for z, z_slice in enumerate(w_slice):
            for y, y_slice in enumerate(z_slice):
                for x, x_slice in enumerate(y_slice):
                    if x_slice == '#':
                        if len([check for check in hyper_check_if_surrounded(x,y,z,w,pocket) if check is True]) not in [2,3]:
                            new_pocket[w][z][y][x] = '.'
                    elif x_slice == '.':
                        if len([check for check in hyper_check_if_surrounded(x,y,z,w,pocket) if check is True]) == 3:
                            new_pocket[w][z][y][x] = '#'
    pocket = copy.deepcopy(new_pocket)

print("Part 2", hyper_count_cubes(pocket))

Funciones

import math, copy

def get_current_z0(pocket):
    return len(pocket)//2
def increase_dimension(pocket):
    for z_slice in pocket:
        current_len = len(z_slice[0])
        for y_slice in z_slice:
            y_slice.insert(0,'.')
            y_slice.append('.')
        z_slice.insert(0, ['.' for _ in range(current_len+2)])
        z_slice.append(['.' for _ in range(current_len+2)])
    pocket.insert(0, [['.' for _ in range(current_len+2)] for _ in range(current_len+2)])
    pocket.append([['.' for _ in range(current_len+2)] for _ in range(current_len+2)])
    return pocket

def count_cubes(pocket):
    return sum([1 for z_slice in pocket for y_slice in z_slice for x_slice in y_slice if x_slice=="#"])

def check_if_surrounded(i, j, k, lines):
    is_surrounded_list = [check_occup(i+delta_i, j+delta_j, k+delta_k, lines) for delta_i in [-1,0,1] for delta_j in [-1,0,1] for delta_k in [-1,0,1] if not abs(delta_i)+abs(delta_j)+abs(delta_k)==0 and check_range(i+delta_i,j+delta_j,k+delta_k, lines)]
    return is_surrounded_list

check_occup = lambda  i,j,k,lines: lines[k][j][i] == "#"
check_range = lambda  i,j,k,lines: k in range(0, len(lines)) and j in range(0, len(lines[0])) and i in range(0, len(lines[0][0]))

def hyper_increase_dimension(pocket):
    current_len = len(pocket[0][0])
    current_z = len(pocket[0])
    for w_slice in pocket:
        increase_dimension(w_slice)
    pocket.insert(0, [[['.' for _ in range(current_len+2)] for _ in range(current_len+2)] for _ in range(current_z+2)])
    pocket.append([[['.' for _ in range(current_len+2)] for _ in range(current_len+2)] for _ in range(current_z+2)])
    return pocket

def hyper_check_if_surrounded(i, j, k, w, lines):
    is_surrounded_list = [hyper_check_occup(i+delta_i, j+delta_j, k+delta_k, w+delta_w, lines) for delta_i in [-1,0,1] for delta_j in [-1,0,1] for delta_k in [-1,0,1] for delta_w in [-1,0,1] if not abs(delta_i)+abs(delta_j)+abs(delta_k)+abs(delta_w)==0 and hyper_check_range(i+delta_i,j+delta_j,k+delta_k, w+delta_w, lines)]
    return is_surrounded_list

hyper_check_occup = lambda  i,j,k,w,lines: lines[w][k][j][i] == "#"
hyper_check_range = lambda  i,j,k,w,lines: w in range(0, len(lines)) and k in range(0, len(lines[0])) and j in range(0, len(lines[0][0])) and i in range(0, len(lines[0][0][0]))

def hyper_count_cubes(pocket):
    return sum([1 for w_slice in pocket for z_slice in w_slice for y_slice in z_slice for x_slice in y_slice if x_slice=="#"])

1 respuesta

B

[Borrado] #815 Dic '20

Dia 17, Codigo para ambas partes, lo más optimizado que se me ocurre

spoiler

import sys
from itertools import product
from collections import Counter


def get_next_state(cubes, ndim=3):
    active_neighbors = Counter()
    for c in cubes:
        for d in product([-1, 0, 1], repeat=ndim):
            active_neighbors[tuple(b + o for b, o in zip(c, d))] += 1
    next_state = set()
    for c in active_neighbors:
        adj = active_neighbors[c]
        if (c in cubes and adj in [3, 4]) or (c not in cubes and adj == 3):
            next_state.add(c)
    return next_state


grid = [x.strip() for x in open(sys.argv[1], 'r').readlines()]
ndim = int(sys.argv[2])

active_cubes = \
    set(
        [
            tuple([x, y] + [0] * (ndim - 2))
            for x,y in
            product(range(len(grid)), range(len(grid[0]))) if grid[x][y] == '#'
        ]
    )

for _ in range(6):
    active_cubes = get_next_state(active_cubes, ndim)

print(len(active_cubes))

1 respuesta

QuitCat #816 Dic '20 Gafe

Explicación de mi solución:

spoiler

1 1 respuesta

JonaN #817 Dic '20 Juntabrackets

#814 Te has puesto tibio a crear funciones xdd. No sería más sencillo, sabiendo que en cada turno como mucho vas a necesitar 2 columnas y 2 filas extra, crear una matriz vacía desde el principio con los R,C iniciales +2*turnos? Salvo que esté malinterpretando lo que has hecho, que sólo lo he mirado de pasada.

Día 17

import numpy as np

def input2array(input):
    m=len(input)
    output=np.zeros((m,m))
    for i in range(m):
        for j in range(m):
            output[i,j]=int( input[i][j] )
    return output,m

def calcadjacent(layout):
    w,n,r,c= layout.shape
    adj=np.zeros((w,n,r,c))
    for z in range(w):
        for k in range(n):
            for i in range(r):
                for j in range(c):
                    adj[z,k,i,j]=sum(sum(sum(sum(layout[max(0,z-1):min(w,z+2),max(0,k-1):min(n,k+2),max(i-1,0):min(r,i+2),max(j-1,0):min(c,j+2)]))))-layout[z,k,i,j]
    return adj 

input=[x.strip().replace('.','0').replace('#','1') for x in open('C:/Users/z003kpaw/Desktop/input1.txt', 'r').readlines()]
[input,m]=input2array(input)

t=6
layout=np.zeros((1+2*t,1+2*t,m+2*t,m+2*t))
layout[t][t][t:t+m,t:t+m]=input

while t>=1:
    adj=calcadjacent(layout)
    layout[(layout==1) & (adj!=2) & (adj!=3)]=0
    layout[(layout==0) & (adj==3)]=1
    t-=1
print(sum(sum(sum(sum(layout)))))

1 respuesta

S

Seyfel #818 Dic '20

#817 Tu solucion es la mas sencilla,y es correcta, solo que hace muchos mas calculos de los necesarios, es posible que haya algun input que no se extienda mas de la zona inicial, o que se muevan solo en una direccion. Si hubiesen pedido simular muchos turnos no solo estarias calculando muchas celdas que nunca se van a activar, si no que lo estarias repitiendo cada vez.

2 respuestas

BeheritSp #819 Dic '20 Juntabrackets

#818 Si a esto me refería.

spoiler

JonaN #820 Dic '20 Juntabrackets

#818 pues para eso creas el array final vacio, pero en vez de iterar de principio a fin en cada turno, iteras de A a B en cada dimensión, y en cada turno expandes el rango en 1.

Entiendo que es más eficiente hacer allocate 1 vez y luego ir variando el rango de iteración en cada dimensión, que tener que hacer un slice cada turno y meterlo en un array más grande.

1 respuesta

S

Seyfel #821 Dic '20

#820 Aun mejor que eso es hacer una matriz dispersa y guardarte solamente los activos en un map, no es necesario el array entero.

MartiONE #822 Dic '20 El reportero de guerra sonriente

Una pregunta que estoy un poco estancado visualizando el problema.

si z=0 empieza asi

.#.
..#
###

con la normas del enunciado, porque acaba en en primer ciclo asi?

#.#
.##
.#.

si por ejemplo la coordenada [0, 0] no tiene 3 activos adyacentes?

1 respuesta

juanmaroni #823 Dic '20 Let's Go! Mew

#822
Porque han cambiado la visualización sin decir nada.

Yo lo he entendido con esto:

1 1 respuesta

MartiONE #824 Dic '20 El reportero de guerra sonriente

#823 Virgen santisima ya lo entiendo, muchas gracias macho menuda mierda de output se han marcado

1 respuesta

BeheritSp #825 Dic '20 Juntabrackets

#824 A mi me pasó lo mismo que a ti, pero siendo justos , el enunciado pone claramente:

Simulating a few cycles from this initial state produces the following configurations, where the result of each cycle is shown layer-by-layer at each given z coordinate (and the frame of view follows the active cells in each cycle)

Nada intuitivo, pero lo dicen xD

1

R

RsTTa #826 Dic '20

Día 17. Había pensando en usar itertools, pero he acabo anidando bucles. Al principio habia representado los valores en un dict, pero he visto que con un set era suficiente. Aun asi la parte 2 se va a 5 segundos mas o menos.

https://github.com/NovelleP/AdventOfCode2020/tree/main/day17

MartiONE #827 Dic '20 El reportero de guerra sonriente

La verdad que hoy bastante sencillo, de los mas sencillos en dias diria yo

B

[Borrado] #828 Dic '20

Mi parte 2 del dia 18, la parte 1 era algo asi pero haciendo cambios de nada, imagino que todos hemos hecho esto o un equivalente.

spoiler

import sys
from functools import reduce


def _update_mul_stack(mul_stack, val, oper):
  if oper is None or oper == '*':
    mul_stack.append(val)
  else:
    mul_stack[-1] += val


def _eval_expr(line, i):
  mul_stack, oper = [], None
  while i < len(line) and line[i] != ')':
    current_char = line[i]
    if current_char.isdigit():
      val = int(current_char)
      _update_mul_stack(mul_stack, val, oper)
    elif current_char in ['+', '*']:
      oper = current_char
    else:
      val, new_i = _eval_expr(line, i + 1)
      _update_mul_stack(mul_stack, val, oper)
      i = new_i
    i += 1
  retval = reduce(int.__mul__, mul_stack)
  return retval, i


def eval_expr(line):
  return _eval_expr(line, 0)


print(sum(eval_expr('(' + line.strip().replace(' ', '') + ')')[0] for line in open(sys.argv[1]).readlines()))

Yo he estado un rato intentando hacerlo poniendo parentesis adicionales, por ejemplo, convertir

1 + 2 * 3 + 4

en

(1 + 2) * (3 + 4)

pero no conseguia cerrar bien la expresion, una pena porque de conseguirlo haces un eval() y ya funciona todo jaja

S

Seyfel #829 Dic '20

Yo viendo que los ultimos problemas no escalaba mucho de la parte 1 a la parte 2, he hecho el primero a lo bruto, pero al final me ha tocado rehacerlo bien para la parte 2, con la pereza que me daba

Parte 1

spoiler

func eval(e string) (int, error) {
res := 0

operand1 := -1
operand2 := -1
operation := -1
i := 0
for i < len(e) {
	if e[i] == ' ' {
		i++
		continue
	}
	if e[i] == '(' {
		closingsNeeded := 1
		j := i + 1
		for j < len(e) {
			if e[j] == ')' {
				closingsNeeded--
				if closingsNeeded == 0 {
					break
				}
			}
			if e[j] == '(' {
				closingsNeeded++
			}
			j++
		}

		if j == len(e) {
			return 0, errors.New("Malformed expression")
		}

		v, err := eval(e[i+1 : j])
		if err != nil {
			return 0, err
		}

		e = e[:i] + fmt.Sprint(v) + e[j+1:]
		continue
	}
	if e[i] == '+' {
		operation = 1
		i++
		continue
	}
	if e[i] == '*' {
		operation = 2
		i++
		continue
	}

	// Now e[i] must be a number
	j := i + 1
	for j < len(e) {
		if e[j] == ' ' {
			break
		}
		j++
	}

	n, err := strconv.Atoi(e[i:j])
	if err != nil {
		return 0, nil
	}

	if operation == -1 {
		operand1 = n
		i = j
		continue
	} else {
		operand2 = n
	}

	// Full operation with both operands is available now
	if operation == 1 {
		res = operand1 + operand2
	} else if operation == 2 {
		res = operand1 * operand2

	}
	operand1 = res
	operation = -1
	operand2 = -1
	i = j
}

return res, nil

}

Parte 2

spoiler

// Converts an expresion in infix notation into rpn
func parseExpr(e string, precedence map[string]int, associativity map[string]int) ([]string, error) {
output := make([]string, 0)
stack := make([]string, 0)

tokens := strings.Split(e, " ")
for _, t := range tokens {
	_, err := strconv.Atoi(t)
	if err == nil {
		output = append(output, t)
		continue
	}

	if t == "(" {
		stack = append(stack, t)
		continue
	}

	if t == ")" {
		i := len(stack) - 1
		for ; i >= 0; i-- {
			if stack[i] == "(" {
				break
			} else {
				output = append(output, stack[i])
			}
		}
		if i == -1 {
			return nil, errors.New("Mismatched parentheses")
		}
		stack = stack[:i]
		continue
	}

	// t is an operator (+ or *)
	i := len(stack) - 1
	for ; i >= 0; i-- {
		if stack[i] == "(" {
			break
		}
		if precedence[stack[i]] > precedence[t] ||
			(precedence[stack[i]] == precedence[t] && associativity[t] == -1) {
			output = append(output, stack[i])
		} else {
			break
		}
	}
	stack = stack[:i+1]
	stack = append(stack, t)
}

for i := len(stack) - 1; i >= 0; i-- {
	output = append(output, stack[i])
}

return output, nil

}

func evalRPN(rpn []string) int {
stack := make([]string, 0)
for _, t := range rpn {
if t == "+" {
v1, _ := strconv.Atoi(stack[len(stack)-2])
v2, _ := strconv.Atoi(stack[len(stack)-1])
stack = append(stack[:len(stack)-2], fmt.Sprint(v1+v2))
} else if t == "" {
v1, _ := strconv.Atoi(stack[len(stack)-2])
v2, _ := strconv.Atoi(stack[len(stack)-1])
stack = append(stack[:len(stack)-2], fmt.Sprint(v1v2))
} else {
stack = append(stack, t)
}
}

v, _ := strconv.Atoi(stack[0])
return v

}

B

[Borrado] #830 Dic '20

Vale, ya he conseguido hacer la parte 2 en un oneliner usando la idea de #828 , no se como me he podido liar tanto

spoiler

import sys

print(sum(eval('(' + line.strip().replace('*', ')*(') + ')') for line in open(sys.argv[1]).readlines()))

1 1 respuesta

JonaN #831 Dic '20 Juntabrackets

#830 qué cabrón, ahora me da vergüenza postear mi parte 2 con todos los loops

QuitCat #832 Dic '20 Gafe

Intentaré ponerme esta tarde. ¿Podéis resumir de que va la parte 2? Y así ahorro tiempo en la parte 1

1 respuesta

B

[Borrado] #833 Dic '20

#832 Evaluar la expresión de tal forma que la suma tenga prioridad sobre la multiplicación (al revés lo habitual).

1 respuesta

QuitCat #834 Dic '20 Gafe

#833 ¿Esa no es ya la parte 1?

2 respuestas

B

[Borrado] #835 Dic '20

#834 La 1 es evaluar la expresión con ambos operadores al mismo nivel de prioridad

1

MartiONE #836 Dic '20 El reportero de guerra sonriente

#834 la 2 es igual, pero cambiando que las sumas van antes que las multiplicaciones

1

R

RsTTa #837 Dic '20

Día 18. He empezado pensando en hacer un algoritmo para evaluar las expresion, pero al final he visto una forma para usar eval.

explicacion

Parte 1

class Integer:
    def __init__(self, n):
        self.n = n
    def __add__(self, integer):
        return Integer(self.n + integer.n)
    def __sub__(self, integer):
        return Integer(self.n * integer.n)
    def __str__(self):
        return str(self.n)


def is_int(val):
    try:
        int(val)
        return True
    except:
        return False


def change_sign(val):
    return '-' if val == '*' else val


if __name__ == '__main__':
    with open('input', 'r') as f:
        exprs = [''.join(f'Integer({val})' if is_int(val) else change_sign(val) for val in line) for line in f.read().strip().splitlines()]

print(sum(eval(expr).n for expr in exprs))

parte 2

class Integer:
    def __init__(self, n):
        self.n = n
    def __add__(self, integer):
        return Integer(self.n * integer.n)
    def __mul__(self, integer):
        return Integer(self.n + integer.n)
    def __str__(self):
        return str(self.n)


def is_int(val):
    try:
        int(val)
        return True
    except:
        return False


def change_sign(val):
    return '+' if val == '*' else '*' if val == '+' else val


if __name__ == '__main__':
    with open('input', 'r') as f:
        exprs = [''.join(f'Integer({val})' if is_int(val) else change_sign(val) for val in line) for line in f.read().strip().splitlines()]

print(sum(eval(expr).n for expr in exprs))

2 1 respuesta

B

[Borrado] #838 Dic '20

#837 Muy buena también! No se me había pasado por la cabeza, la verdad.

BeheritSp #839 Dic '20 Juntabrackets

Yo he ido a lo bruto como de costumbre y he implementado un evaluate_string():

spoiler

Main

lines_list =open("input.txt").read().splitlines()
print("Part 1", sum(int(evaluate_string(line, part_1_operator)) for line in lines_list))
print("Part 2", sum(int(evaluate_string(line, part_2_operator)) for line in lines_list))

Funciones

def evaluate_string(line, line_operator):
    open_index = line.find("(")
    if open_index != -1:
        close_index = find_next_closing_index(line[open_index:]) + open_index
    else:
        return line_operator(line)
    result = evaluate_string(line[(open_index+1):(close_index-1)], line_operator)
    while not result.isdigit():
        result = evaluate_string(result, line_operator)
    return evaluate_string(line.replace(line[(open_index):(close_index)], result), line_operator)

def find_next_closing_index(line):
    next_open_index = line[1:].find("(") + 1
    close_index = line.find(")") + 1
    if next_open_index < close_index  and not next_open_index < 0:
        close_index = find_next_closing_index(line[close_index:]) + close_index
    return close_index

def part_1_operator(line):
    operation = line.split(" ")
    result = int(operation[0])
    i = 1
    while (i < len(operation)):
        if operation[i] == '+':
            result += int(operation[i+1])
        elif operation[i] == '*':
            result *= int(operation[i+1])
        i += 2
    return str(result)

def part_2_operator(line):
    if "*" in line:
        operation = line.split("*")
        result = 1
        for value in operation:
            if not value.isdigit():
                value = int(evaluate_string(value, part_2_operator))
            result *= value
        return str(result)
    else:
        operation = [int(char) for char in line.split("+")]
        return str(sum(operation))

eZpit #840 Dic '20 Juntabrackets

Bueno, resuelto primero copy-pasteando, pero luego he combinado ambas soluciones en un único método:

Day 18 combined

enum Precedence {
    None,
    Addition,
}

fn eval_expression(precedence: &Precedence, chars: &mut Chars) -> u64 {
    let mut acc = 0_u64;
    let mut op: fn(u64, u64) -> u64 = |a, b| a + b;
    let mut val = 0_u64;
    while let Some(char) = chars.next() {
        match char {
            '(' => val = eval_expression(precedence, chars),
            ' ' => {
                if val != 0 {
                    acc = op(acc, val);
                    op = |a, b| a + b;
                    val = 0;
                }
            }
            '+' => op = |a, b| a + b,
            '*' => match precedence {
                Precedence::None => op = |a, b| a * b,
                Precedence::Addition => 
                    return acc * eval_expression(precedence, chars),
            },
            ')' => return op(acc, val),
            char => val = val * 10 + char.to_digit(10).unwrap() as u64,
        }
    }
    op(acc, val)
}

¿Dónde me apunto?

Normas

Leaderboard privado para el pique sano

Las respuestas se postean en Spoiler + code

Usuarios habituales

Tags