Advent of Code 2024 - Queréis problemas?

Mandarino #1 23d

¿De qué va esto?

El habitual calendario de adviento, solo que en vez de comer chocolate o maquillarte pues picas código como un buen artisan.

¿Dónde me apunto?

https://adventofcode.com/

¿Cuándo empieza?

Oficialmente el 1 de diciembre, seguir el calendario o no al pie de la letra es cuestión de cada uno. Las pruebas se ponen como a las 5AM hora española, así que sin estres.

Normas

Cada día se desbloquea un problema nuevo (2 partes)
Le dedicas el tiempo que te da la gana.
Resolver problemas de la forma que quieras. Programando en el lenguaje que quieras; haciendo un trozo a mano y otro con código; ...
Cada problema tiene una caja de texto para meter la solución (suelen ser números o alguna cadena de texto pequeña)
Usar ChatGPT esta prohibido por adventofcode (para el top100 ranking). Tampoco recomiendo usarlo ya que le quita todo el sentido.

Consejos

Lo importante es pasarlo bien y aprender algo nuevo. No pasa nada si no te salen los problemas, tú decides si quieres solucionar el problema 100% por tu cuenta o buscar ayuda despues de X horas intentandolo solucionar.

Leaderboard privado para el pique sano

NSFW

Si quieres ver más estadisticas en un leaderboard recomiendo esta extensión para Chrome:
Advent of Code charts

Las respuestas o ayudas se postean en Spoiler + code (indicad el día)

Premios

El honor y satisfacción de poder completar los problemas aumenta tu confianza e indirectamente aumenta tu calidad de vida.

Ediciones anteriores

2023
2022
2021
2020
2019

5

robpike25 #2 23d

Lo he hecho en Go, aunque en cuanto metan un Tree me paso a python rapidísimo xd

1

laZAr0 #3 23d Cofarde

Ya me está dando toc por no poner el signo de apertura de interrogación en el título.

1

gonya707 #4 23d Moderador

He hecho el primero por los viejos tiempos pero en cuanto se compliquen un poco no voy a tener tiempo de hacerlos :_)

Pizzelio #5 23d

Otro año por aquí, a ver lo que se aguanta xD

desu #6 23d

Yo voy a hacer 10 ejercicios.

Solucion dia 1:

spoiler

#[allow(dead_code)]
pub fn to_slices(input: &str) -> (Box<[i64]>, Box<[i64]>) {
// NOTE: explicit pre-allocate vs re-sizing tradeoff
let line_count = input.lines().count();
let mut lefts = Vec::with_capacity(line_count);
let mut rights = Vec::with_capacity(line_count);

for line in input.lines() {
    let mut iter = line.split_whitespace();
    let left = iter.next().unwrap().parse::<i64>().unwrap();
    let right = iter.next().unwrap().parse::<i64>().unwrap();
    lefts.push(left);
    rights.push(right);
}
assert_eq!(lefts.len(), rights.len());

// NOTE: Vec<i64> vs Box<[i64]>
// https://blog.polybdenum.com/2024/01/17/identifying-the-collect-vec-memory-leak-footgun.html
(lefts.into_boxed_slice(), rights.into_boxed_slice())

}

#[allow(dead_code)]
pub fn part1(input: &str) -> i64 {
let (mut lefts, mut rights) = to_slices(input);
lefts.sort();
rights.sort();

// NOTE: not as cache friendly as [(left, right)] but the cost of building the slice of tuples
// is the same as the cost of iterating over the slices and computing the result.
// if in the other hand we had to re-use the pairs, then it would be amortized
let mut result = 0;
// NOTE: rust 2024
// warning: this method call resolves to `<&Box<[T]> as IntoIterator>::into_iter` (due to backwards compatibility),
// but will resolve to `<Box<[T]> as IntoIterator>::into_iter` in Rust 2024
for (left, right) in IntoIterator::into_iter(lefts).zip(IntoIterator::into_iter(rights)) {
    result += (left - right).abs();
}

result

}

#[allow(dead_code)]
pub fn part2(input: &str) -> i64 {
let (lefts, rights) = to_slices(input);

let mut result = 0;
for left in lefts {
    let count = rights.iter().filter(|right| left == **right).count() as i64;
    result += count * left;
}

result

}

#[allow(dead_code)]
pub fn part2_asm_comparison(input: &str) -> i64 {
let (lefts, rights) = to_slices(input);

let mut result = 0;
for i in 0..lefts.len() {
    let mut count = 0;
    for j in 0..rights.len() {
        if lefts[i] == rights[j] {
            count += 1;
        }
    }
    result += count * lefts[i];
}

result

}

#[cfg(test)]
mod tests {
use super::;
use crate::;

#[test]
fn test_1() {
    let example = read_to_string("inputs/day-1-example.txt");
    let result = part1(&example);
    assert_eq!(result, 11);

    let input = read_to_string("inputs/day-1-input.txt");
    let result = part1(&input);
    assert_eq!(result, 2580760);
}

#[test]
fn test_2() {
    let example = read_to_string("inputs/day-1-example.txt");
    let result = part2(&example);
    assert_eq!(result, 31);

    let input = read_to_string("inputs/day-1-input.txt");
    let result = part2(&input);
    assert_eq!(result, 25358365);
}

}

Notes en el dia 1:

spoiler

Un problema y error comun es tener un Vec<T> en lugar de un Box<[T]>. Cuando no lo necesitas y abusar de Vectores y collects.
Este blog lo explica muy bien: https://blog.polybdenum.com/2024/01/17/identifying-the-collect-vec-memory-leak-footgun.html
En muchos lenguajes, cuando usamos contenedores/fat pointers/slices mutables, suelen tener estos campos, el tamaño, la capacidad del array y el puntero al array por debajo. Hay muchos problemas y bugs cuando usas el metodo equivocado, por ejemplo en Java: STRING vs STRING BUILDER.
En el caso de las listas, Vec seria una ListBuilder vs Box<[]> que seria nuestra List.

Cuando pensamos en como usaremos y modelaremos los datos nos encontramos con dos alternativas:

tenemos un array de pairs, o dos pairs. el problema es que esto representa dos localizaciones en memoria, y cuando resolvamos el loop, nuestra CPU va a fallar muchas paginas para problemas grandes y sera poco eficiente.

para la parte 1, lo ideal es tener un [(left, right)], porque cada for loop, vamos a cargar en CPU tuplas y las vamos a sumar, y cuando queramos mas de memoria, las cargaremos, y asi... y esto es un patron eficiente.

si en lugar de eso, tenemos left[] y right[], la CPU tendra que ir saltando en memoria y no usaremos la cache de la CPU correctamente para almacenar los elementos.

en el caso de hoy, entre part1 y part2, como solo iteraremos una vez, nos da igual crear la estructura correcta o no, pero si esto fuese re-usable, deberiamos aplicar el cambio para tener una estructura de datos correcta y no una mierda.

    let mut result = 0;
    for left in lefts {
        let count = rights.iter().filter(|right| left == **right).count() as i64;
        result += count * left;
    }

un i64 es barato de copiar, la gente se obsesiona demasiado con la memoria cuando esta haciendo mal, el coste de copiar un registro es trivial y el asembly, que podeis mirar con:

➜ aoc24 git:(master) ✗ cargo asm --rust "aoc24::day1::part2" 0

ya sale que LLVM optimiza con SIMD y demas... no vale la pena perder mucho el tiempo, la diferencia entre part2 y part2_asm_comparison, es minima también, no es el mismo codigo pero no entrare.

lo mismo de copiar o iterar por referencias se aplica a

    for (left, right) in IntoIterator::into_iter(lefts).zip(IntoIterator::into_iter(rights)) {
        result += (left - right).abs();
    }

q esto en rust 24 van a estabilizarlo

Y me he dejado esta nota:
// NOTE: explicit pre-allocate vs re-sizing tradeoff
A veces es mejor dos for loops que alocar memoria, a veces es mejor un loop y alocar memoria.
Recomiendo y trato, prealocar memoria, porque de esta manera el comportamiento es mas predecible, iterar linealmente suele ser mas barato, y facil de entender el tradeoff lo hago explicito

Conclusion:

Problema simple, y como todos los problemas simples, muy facil cometer errores fundamentales cuando eres un mal programador o un incompetente. Si en lugar de un problema simple, fuese algo mas complejo, te pegas un tiro en el pie.

1 respuesta

Pizzelio #7 23d

#6 Muy interesantes las notas, me pierdo con rust pero esto que comentas

spoiler

Aplicaría también a otros lenguajes no?

spoiler

1 respuesta

desu #8 23d

#7 si claro, los fundamentos aplican a todos los lenguajes, si miras el assembly veras lo que haces. edit: los ejemplos son asumiendo una CPU teorica/de juguete, no una real, para que se entienda el concepto.

day 1

Aplica a otros lenguajes, aunque habria que entrar en los casos particulares y como funcionan debajo del capo. Los fundamentos basicos de programacion y arquitectura son eso, fundamentos basicos, al final todo es assembly (o byte-code) y unos y zeros no?

day 1

Conclusion: a tu pregunta, el performance de esa funcion, hacerlo de una manera optimo vs no optima, sera sobre x400 * numero de elementos. Esto en una CPU de juguete, para que se entienda el ejemplo.

spoiler

1

Flashk #9 23d

Por mi parte:

Day 1

public class HistorianHysteria {

private final List<Long> left = new ArrayList<>();
private final List<Long> right = new ArrayList<>();

public HistorianHysteria(List<String> input) {
    for(String line : input) {
        String[] split = line.split(" {3}");
        left.add(Long.valueOf(split[0]));
        right.add(Long.valueOf(split[1]));
    }
}

public Long solveA() {
    List<Long> leftSorted = left.stream().sorted().toList();
    List<Long> rightSorted = right.stream().sorted().toList();

    long result = 0L;

    for(int i  = 0; i < leftSorted.size(); i++) {
        result += Math.abs(leftSorted.get(i)-rightSorted.get(i));
    }

    return result;
}

public Long solveB() {

    long result = 0L;

    Map<Long,Long> occurrences = right.stream()
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

    for(long number : left) {
        result += number * occurrences.getOrDefault(number,0L);
    }

    return result;
}

}

Comentarios Day 1

1

Kike_Knoxvil #10 23d

Otro año más para no completarlo wiiii

Cerealfriend #11 23d

Pensaba que iba a ser una tortura con Go parsear esto, pero con la lib de strings .Fields tardas nada:

dia 1

package main

import (
"bufio"
"fmt"
"math"
"os"
"sort"
"strconv"
"strings"
)

func parse(filename string) []string {
bytes, _ := os.ReadFile(filename)
return strings.Split(string(bytes), "\n")
}

func main() {
data := parse("text.txt")
var l, r []int
for _, line := range data {
nums := strings.Fields(line)
if len(nums) == 2 {
n1, _ := strconv.Atoi(nums[0])
n2, _ := strconv.Atoi(nums[1])
l = append(l, n1)
r = append(r, n2)
}
}

sort.Ints(l)
sort.Ints(r)

totalDistance := 0
for i := range l {
	totalDistance += int(math.Abs(float64(l[i] - r[i])))
}
fmt.Println("Total distance:", totalDistance)
score := similarityScore(l, r)
fmt.Println("The total score is: ", score)

}

func similarityScore(a []int, b []int) int {
countB := make(map[int]int)
for _, v := range b {
countB[v]++
}

score := 0
for _, val := range a {
	score += val * countB[val]
}
return score

}

La segunda parte:

1 respuesta

pineda #12 22d

#11

var left, right int
fmt.Sscanf(line, "%d   %d", &left, &right)

ahorrarás mucho código en los siguientes ejercicios con Sscanf

1

wolfie6949 #13 22d

Este año creo que no lo voy a empezar porque sé que no lo voy a terminar. Suerte compañeros.

desu #14 22d

Hoy he decidio centrarme en un patron algoritmico muy habitual.

day 2

Iterar una lista, linked list, grafo donde tenemos que ir extrayendo información mientras exista.

Para ello voy a usar el type system, y este patron es usable con cualquier lenguaje con buen soporte para Options y Sum Types.

El esqueleto de mi algoritmo seria el siguiente, y fijaros como con el tipado, somos capaces de ver TODOS los casos que nuestro hot path puede tener.

fn is_safe(row: &[i64]) -> bool {
    let mut direction: Option<Direction> = None;
    let mut previous: Option<i64> = None;
    for &current in row {
        match (direction, previous) {
            (None, None) => {
                 // PRIMERA ITERACION NO TENGO NADA
            }
            (None, Some(p)) => {
               // NO DIRECCION PERO TENGO YA UN ELEMENTO
            }
            (Some(d), Some(p)) => {
                // TENGO LA DIRECCION Y ELEMENTOS
            }
            (Some(_), None) => unreachable!(), // ES IMPOSIBLE
        }
    }
    true
}

Sin entrar hoy en hacerlo rapido, ni en hacerlo eficiente, vamos a hacerlo facil. Y voy a hacer de una iteracion.

Si nuestro lenguaje no tiene soporte para estas cosas, deberemos usar nulls, nils, y hacer checks == nil, y la sintaxis no sera tan compacta.

La magia es que si me llega, [1 1 1 1 5] un monton de elementos seguidos, hasta que no llegue al 5 no podre deicdir la dirección, pero mi codigo se lo traga sin problema, y el hecho que esto ocurra en el segundo elemento, o en el 53916161 me da igual...

El codigo esta estructurado para resolver problemas, es compacto, facil de modificar y adaptar a las reglas, y ademas funciona bien.

y una version habitual si no tienes pattern matching y tal, seria algo asi.

day2

fn is_safe(row: &[i64]) -> bool {
    let mut direction: Option<Direction> = None;
    let mut previous: Option<i64> = None;

for &current in row {
    if let Some(p) = previous {
        if let Some(d) = direction {
            if !d.is_safe(p, current) {
                return false;
            }
        } else {
            direction = match Direction::new(p, current) {
                Ok(d) => Some(d),
                Err(_) => return false,
            };
        }
    }
    previous = Some(current);
}
true
}

edit: la parte 2 he querido ser listo y he tratado de hacer la solución optima antes de la fuerza bruta y he estado 1h... jaja

day 2

en lugar del tipico if else en rango, cuando tienes el tipado, range contains

fn is_increasing(previous: i64, current: i64) -> bool {
    let diff = current - previous;
    (1..=3).contains(&diff)
}

la validación la hago creando Direction, y cada direction se si es increasing o decreasing

    fn new(previous: i64, current: i64) -> anyhow::Result<Self> {
        if is_increasing(previous, current) {
            Ok(Direction::Increasing)
        } else if is_decreasing(previous, current) {
            Ok(Direction::Decreasing)
        } else {
            anyhow::bail!("Invalid direction, {previous} {current}");
        }
    }

podria guardarme el previous en la direccion, pero el codigo no es tan idiomatico como el patron que he explicado arriba de tener un Option mutable que recorres.

luego para comprobar que algo falla hay 2 alternativas:

vas haciendo slices o vectores que compruebas
simplemente sabes que indice skippear en la comprobación

parece una bobada, pero no se me ha ocurrido hasta el final

es mas simple cambiar el codigo con esto:

                if is_safe_with_skip(&row, Some(i)) {

que hacer esto para cambiar el input de is_safe:

                let new_slice = &[row[..0], row[i + 1..]].concat()

es una idea importante, se usa mucho, a veces conceptualmente queremos "REMOVER" pero es mas facil "SKIPEAR" algo, por ejemplo, cuando se trabaja en librerías de renderizado, tienes buffers, ventanas... cosas para pintar, y tienes tamaño de ventana, lo que se hace es tener el tamaño maximo alocado y tener offsets para saber que renderizar o no...

mucho mas facil sin duda y data oriented. que no haya sido mi primera idea, me dice que es un campo a mejorar y no lo tengo bien interiorizado.

1 1 respuesta

ignasi_ #15 22d

day1

defmodule Day1 do
  def input_stream() do
    File.stream!("/data/autosaved/2024_12_02/09_13_gerv/files/day1.txt")
    |> Stream.map(&String.trim/1)
    |> Stream.map(&String.split(&1, "   "))
    |> Stream.map(fn line ->
      [n1, n2] = line
      [String.to_integer(n1), String.to_integer(n2)]
    end)
    |> Stream.zip()
    |> Stream.map(&Tuple.to_list/1)
  end

  def part1() do
    input_stream()
    |> Stream.map(&Enum.sort/1)
    |> Enum.to_list()
    |> Enum.zip_reduce(0, fn els, acc ->
      [x, y] = els
      dist = abs(x - y)
      dist + acc
    end)
  end

  def part2() do
    [left, right] =
      input_stream()
      |> Enum.to_list()

freqs =
  right
  |> Enum.reduce(Map.new(), fn el, acc ->
    Map.update(acc, el, 1, fn prev ->
      prev + 1
    end)
  end)

left
|> Enum.reduce(0, fn el, acc ->
  acc + el * Map.get(freqs, el, 0)
end)
  end
end

Day1.part1()
Day1.part2()

day2

defmodule Day2 do
  def input() do
    File.stream!("/data/autosaved/2024_12_02/09_13_gerv/files/day2-2024.txt")
    |> Stream.map(&String.trim/1)
    |> Stream.map(fn line ->
      String.split(line, ~r/\s+/, trim: true)
      |> Enum.map(&String.to_integer/1)
    end)
    |> Enum.to_list()
  end

  def safe?([a, b | _]) when abs(a - b) not in 1..3, do: false
  def safe?([a, a | _]), do: false
  def safe?([a, b | rest]), do: safe?([b | rest], b - a)
  def safe?([_], _sign), do: true
  def safe?([a, b | rest], sign) do
    new_sign = b - a
    if ((new_sign * sign) <= 0 or abs(new_sign) > 3) do
      false
    else 
      safe?([b | rest], new_sign)
    end
  end

  def part1() do
    input()
    |> Enum.count(&safe?/1)
  end

  def part2() do
    input()
    |> Enum.count(fn report -> 
      Enum.any?(0..length(report), fn i -> 
        List.delete_at(report, i) 
        |> safe?()
      end)
    end)
  end
end

Day2.part1()
Day2.part2()

1 respuesta

Mandarino #16 21d

day2

Pizzelio #17 21d

#14 Voy a investigar el patrón que comentas porque me cuesta seguirte la verdad xD

La parte 2 de hoy la he hecho por fuerza bruta pero no se me ocurría una forma que

spoiler

2 respuestas

desu #18 21d

#17 pues el patron en python por ejemplo, si iteras un linked list o iteras en grafos, arboles...

previous = None
for current in row:
    if previous is not None:
        # el codigo ya esta init
   else: 
        # inicializas
       previous = current

o en una linked list que quieres ir avanzando

while node is not None:
  node = node.next

esto lo haras en todos los lenguajes ya sea comprovando un null, none, nil o teniendo un Optional/Option. Lo bueno de lo segundo y de rust es que es tan expresivo que te permitira hacer esto:

node, node.next = init()
match node, node.next:
   None, None => ... 
   Value, None => ...
   None, Value => ...
   Value, Value => ...

Y es muy facil de leer, en lenguajes funcionales es comun este patron, ahora java lo esta tratando de introducir con las switch expressions y nse no estoy muy al dia de lenguajes de porqueria.

#15 que lo esta haciendo en elixir también puede hacer patrones asi

spoiler

def safe?([a, b | _]) when abs(a - b) not in 1..3, do: false
  def safe?([a, a | _]), do: false
  def safe?([a, b | rest]), do: safe?([b | rest], b - a)
  def safe?([_], _sign), do: true
  def safe?([a, b | rest], sign) do

1 1 respuesta

Pizzelio #19 21d

#18 Vale ahora sí, gracias!

JuAn4k4 #20 21d

Y pensar que hubo un tiempo en el que tenia tiempo para hacer esto… suerte a todos los parsers

Cerealfriend #21 21d

Esta resuelto a fuerza bruta y simplemente chequeando por condiciones... en la parte 2 hago lo mismo ( #17 me diste la idea), creo slices de los que no se cumplem quitando 1 elem y comprobando si es safe con las mismas condiciones anteriores:

day 2 parte 1 y 2

package main

import (
	"fmt"
	"math"
	"os"
	"strconv"
	"strings"
)

func parse(filename string) []string {
	bytes, _ := os.ReadFile(filename)
	lines := strings.Split(strings.TrimSpace(string(bytes)), "\n")
	return lines
}

func abs(a int) int {
	return int(math.Abs(float64(a)))
}

func toNumbers(s []string) [][]int {
	result := make([][]int, len(s))
	for i, line := range s {
		numStrings := strings.Fields(line)
		nums := make([]int, len(numStrings))
		for j, numStr := range numStrings {
			nums[j], _ = strconv.Atoi(numStr)
		}
		result[i] = nums
	}
	return result
}

func safeSlice(row []int) bool {
	increasing, decreasing := true, true
	for i := 0; i < len(row)-1; i++ {
		diff := row[i+1] - row[i]
		increasing = increasing && diff > 0
		decreasing = decreasing && diff < 0
		if abs(diff) < 1 || abs(diff) > 3 || (!increasing && !decreasing) {
			return false
		}
	}
	return true
}

func resolve(numbers [][]int, tolerate bool) int {
	safeLevelCounter := 0
	for _, row := range numbers {
		if safeSlice(row) {
			safeLevelCounter++
			continue
		}

	if tolerate {
		for i := range row {
			newRow := append(append([]int{}, row[:i]...), row[i+1:]...)
			if safeSlice(newRow) {
				safeLevelCounter++
				break
			}
		}
	}
}
return safeLevelCounter
}

func main() {
	data := parse("input.txt")
	numbers := toNumbers(data)

fmt.Printf("Part 1: %d\n", resolve(numbers, false))
fmt.Printf("Part 2: %d\n", resolve(numbers, true))
}

2 1 respuesta

desu #22 21d

#21

spoiler

si quieres mejorar tu day2 esta es una optimizacion que podrias copiarte bastante tal cual en go

spoiler


fn count_violations_with_indices(row: &[i64]) -> (i32, Vec<usize>) {
    let mut direction: Option<Direction> = None;
    let mut previous: Option<i64> = None;
    let mut violations = 0;
    let mut violation_indices = Vec::new();

for (i, &current) in row.iter().enumerate() {
    if let Some(p) = previous {
        let has_violation = if let Some(d) = direction {
            !d.is_safe(p, current)
        } else {
            Direction::new(p, current).is_err()
        };

        if has_violation {
            violations += 1;
            // Include surrounding indices that might fix the violation
            if i > 1 {
                violation_indices.push(i - 2);
            }
            violation_indices.push(i - 1);
            violation_indices.push(i);
            if i + 1 < row.len() {
                violation_indices.push(i + 1);
            }
        }
        direction = Direction::new(p, current).ok();
    }
    previous = Some(current);
}

violation_indices.sort_unstable();
violation_indices.dedup();
(violations, violation_indices)
}

con esto solo tengo que genrar las violaciones... que se que una solucoin valida solo puede tener 1 o 2 violaciones, si tienes > 2 ya es imposible una solución asique no hace falta comprobar

1 1 respuesta

eZpit #23 21d Juntabrackets

Me apunto de chills con Kotlin y no pienso hacer premature optimizations ni tests, y seguramente caiga en cuanto se ponga tedioso y largo.

Day 02

fun main() {
    fun parseInput(input: List<String>) = input
        .map { line -> line.split(" ").map { it.toInt() } }

fun isSafe(report: List<Int>): Boolean {
    val distances = report.zipWithNext { a, b -> a - b }
    return (distances.all { abs(it) in 1..3 }  
      && distances.map { it.sign }.distinct().size == 1)
}

fun <T> subsetsExcludingOne(list: List<T>): List<List<T>> {
    return List(list.size) { index -> 
      list.filterIndexed { i, _ -> i != index } 
    }
}

fun part1(input: List<String>): Int = parseInput(input)
    .count { isSafe(it) }

fun part2(input: List<String>): Int = parseInput(input)
    .count {
        (listOf(it) + subsetsExcludingOne(it)).any { report ->
            isSafe(report)
        }
    }

val input = readInput("Day02")
part1(input).println()
part2(input).println()
}

desu #24 21d

Dia 3 y ya toca picarse un compilador!

Mi solución, hoy facil, creo que he estado 10 minutos:

day3

ignasi_ #25 21d

day3

defmodule Day3 do
  @mul_regex ~r/mul\(\d+,\d+\)/
  @do_regex ~r/do\(\)/
  @dont_regex ~r/don't\(\)/

  def input() do
    File.read!("/data/autosaved/2024_12_02/09_13_gerv/files/day3.txt")
  end

  defp scan_muls(s) do
    @mul_regex
    |> Regex.scan(s)
    |> List.flatten()
  end

  defp add_muls(l_muls) do
    Enum.reduce(l_muls, 0, fn mul, acc ->
      get_mul(mul) + acc
    end)
  end

  def get_mul("mul(" <> rest) do
    case String.split(rest, ",") do
      [n1, n2] ->
        with {num1, _} <- Integer.parse(n1),
             {num2, _} <- Integer.parse(String.trim_trailing(n2, ")")) do
          num1 * num2
        end
    end
  end

  def get_mul(_), do: raise("invalid format")

  def part1() do
    input()
    |> scan_muls()
    |> add_muls()
  end

  defp do_part2(s, :enabled, acc) do
    case Regex.split(@dont_regex, s, parts: 2) do
      [valid, rest] ->
        do_part2(rest, :disabled, acc + add_muls(scan_muls(valid)))

  [all_valid] ->
    acc + add_muls(scan_muls(all_valid))
end
  end

  defp do_part2(s, :disabled, acc) do
    case Regex.split(@do_regex, s, parts: 2) do
      [_invalid, rest] ->
        do_part2(rest, :enabled, acc)
      [_] ->
        IO.inspect(acc)
        acc
    end
  end

  def part2() do
    input()
    |> do_part2(:enabled, 0)
  end
end

# Day3.part1()
Day3.part2()

Me ha costado un poco, estoy poco acostumbrado a las regexs y menos en elixir. Supongo que usando capture groups hubiese sido mejor la parte 1.

Pizzelio #26 21d

Bastante amable el de hoy, en preparación de lo que se viene seguro jajaja

spoiler

Mandarino #27 21d

day3

me apetecia hacerlo parseando a pelo sin usar regex xD

lo de "line[i:i+200]" no es lo mas optimo, pero era para poder usar el startswith y olvidarme de offsets y tal.

pongo la parte2 directamente

def calc(line):
    i = 0
    n = len(line)
    ans = 0
    enabled = True
    while i < n:
        if line[i:i + 200].startswith("do()"):
            enabled = True
            i += 4
        elif line[i:i+200].startswith("don't()"):
            enabled = False
            i += 4
        elif line[i:i + 200].startswith("mul("):
            i += 4
            # number 1
            a = 0
            while i < n and line[i] in "0123456789":
                a = a * 10 + int(line[i])
                i += 1
            if i == n or line[i] != ",":
                continue
            i += 1
            # number 2
            b = 0
            while i < n and line[i] in "0123456789":
                b = b * 10 + int(line[i])
                i += 1
            if i == n or line[i] != ")":
                continue
            i += 1
            if enabled:
                ans += a * b
        else:
            i += 1
    return ans

no se porque sale indentado mal cuando hay lineas en blanco

Flashk #28 21d

day 3

Hacer ambas partes era fácil, pero tuve una liada en la parte 2 que me costó ver: estaba interpretando que el cálculo se hacía de manera independiente para cada línea, cuando había que concatenar todas juntas en un solo string y ya trabajar desde ahí.

Tenía prácticamente resuelto el puzzle y no conseguía ver por que no me daba un resultado bueno.

Tirando de Regex:

public class MullItOver {

private static final Pattern MULTIPLY_PATTERN = Pattern.compile("(mul\\(\\d*,\\d*\\))");
private static final Pattern OPERATORS_PATTERN = Pattern.compile("(\\d*),(\\d*)");
private static final Pattern IGNORE_MULTIPLICATIONS = Pattern.compile("don't\\(\\).*?do\\(\\)");
private static final String DONT = "don't()";

private final List<String> inputs;

public MullItOver(List<String> inputs) {
    this.inputs = inputs;
}

public long solve(boolean cleanMemory) {

    String input = String.join(StringUtils.EMPTY, inputs);
    String memory = cleanMemory ? clean(input) : input;

    long result = 0;
    Matcher matcher = MULTIPLY_PATTERN.matcher(memory);

    while(matcher.find()){
        result += multiply(matcher.group());
    }

    return result;
}

private String clean(String input) {
    String modifiedInput = IGNORE_MULTIPLICATIONS.matcher(input).replaceAll(StringUtils.EMPTY);
    return modifiedInput.contains(DONT) ? modifiedInput.substring(0, modifiedInput.indexOf(DONT)) : modifiedInput;
}

private long multiply(String operation) {
    Matcher matcher = OPERATORS_PATTERN.matcher(operation);
    return matcher.find() ? Long.parseLong(matcher.group(1)) * Long.parseLong(matcher.group(2)) : 0;
}
}

Cerealfriend #29 20d

Me dió tiempo a hacer la parte 1 usando tamb regex y capture groups para los values pero la segunda no me ha salido,.. osea si tengo un do habilitó las multiplicaciones y si encuentro un dont las deshabilito hasta el siguiente do cierto??? Se me ha pasado mirar si estaba haciéndolo todo en 1 string, porq paseando a línea puede estar el fallo... Mañana saco los 2 si o si.

#22 tyvm, quiero intentar todos estos puzzles, primero que me salgan y luego hacer cosas como esa, con el de regex de hoy me sirve para leerme doc y entender mejor y como aplicar regex por ejemplo

Mandarino #30 20d

day4

Problema conceptualmente fácil pero mas complicado de implementar que dias anteriores.
Perdí unos minutos en la parte1 porque estaba convirtiendo mal el input a una matriz y tardé un rato en darme cuenta xD ... y luego no cai en que XMAS podia hacer match en varias direcciones a la vez.

La parte2 la hice mas a saco y salió rapido.

WORD = "XMAS"
DIRS = [
    (x, y)
    for x in (-1, 0, 1)
    for y in (-1, 0, 1)
    if (x, y) != (0, 0)
]


def read(rawinput):
    data = []
    for line in rawinput.strip().split("\n"):
        line = line.strip()
        if not line:
            continue
        yield line
    return data


def getc(mat, y, x):
    if 0 <= y < len(mat) and 0 <= x < len(mat[0]):
        return mat[y][x]
    return "."


def check(mat, i, j):
    cnt = 0
    for dx, dy in DIRS:
        if all(c == getc(mat, i + dy * k, j + dx * k) for k, c in enumerate(WORD)):
            cnt += 1
    return cnt


def check2(mat, y, x):
    if getc(mat, y, x) != "A":
        return 0
    # c1 c2
    #   A
    # c3 c4
    c1 = getc(mat, y - 1, x - 1)
    c2 = getc(mat, y - 1, x + 1)
    c3 = getc(mat, y + 1, x - 1)
    c4 = getc(mat, y + 1, x + 1)
    if (c1, c4) in (("S", "M"), ("M", "S")) and (c2, c3) in (("S", "M"), ("M", "S")):
        return 1
    return 0


def solve(rawinput):
    mat = list(read(rawinput))
    n = len(mat)
    m = len(mat[0])
    ans = 0
    ans2 = 0
    for i in range(n):
        for j in range(m):
            ans += check(mat, i, j)
            ans2 += check2(mat, i, j)

print("PART1: ", ans)
print("PART2: ", ans2)

Advent of Code 2024 - Queréis problemas?

¿De qué va esto?

¿Dónde me apunto?

¿Cuándo empieza?

Normas

Consejos

Leaderboard privado para el pique sano

Premios

Ediciones anteriores

Usuarios habituales

Tags