Advent of Code 2023: ChatGPT-4 turbo edition

Quizá podría haberlo modelado de tal forma que las secuencias tengan secuencias en su interior y entonces aplicar recursividad, pero la primera forma que me ha venido a la mente es tirar de Deques y hacerlo iterativo:

Clase Sequence

@Getter
public class Sequence {

private Deque<Long> values = new ArrayDeque<>();
private boolean isZero = true;

public Sequence(List<Long> historyValues) {
    values = new ArrayDeque<>(historyValues);
    isZero = false;
}

public Sequence(Deque<Long> sequenceValues) {
    Iterator<Long> historyValuesIterator = sequenceValues.iterator();
    long previousValue = historyValuesIterator.next();
    while (historyValuesIterator.hasNext()) {
        long currentValue = historyValuesIterator.next();
        long step = currentValue - previousValue;
        values.add(step);
        isZero &= (step == 0);
        previousValue = currentValue;
    }
}

public long extrapolateRight(long bottomValue) {
    values.add(values.peekLast() + bottomValue);
    return values.peekLast();
}

public long extrapolateLeft(long bottomValue) {
    values.addFirst(values.peekFirst() - bottomValue);
    return values.peekFirst();
}

}

Clase MirageMaintenance

public class MirageMaintenance {

private final List<String> inputs;

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

public long solve(boolean isLeft) {
    long result = 0;
    for(String input : inputs) {

        // Parse an input line
        String[] values = input.split(StringUtils.SPACE);
        List<Long> historyValues = Arrays.stream(values).map(Long::parseLong).toList();

        // Generate and extrapolate
        Deque<Sequence> sequences = generateSequences(historyValues);
        long extrapolation = extrapolate(sequences, isLeft);

        result += extrapolation;

    }
    return result;
}

private Deque<Sequence> generateSequences(List<Long> historyValues) {

    Sequence sequence;
    Deque<Sequence> sequences = new ArrayDeque<>();
    sequences.add(new Sequence(historyValues));

    do {
        sequence = new Sequence(sequences.peekLast().getValues());
        sequences.add(sequence);
    } while(!sequence.isZero());

    return sequences;
}


private long extrapolate(Deque<Sequence> sequences, boolean isLeft) {

    long nextValue = 0;

    while(!sequences.isEmpty()) {
        Sequence sequence = sequences.pollLast();
        if(isLeft) {
            nextValue = sequence.extrapolateLeft(nextValue);
        } else {
            nextValue = sequence.extrapolateRight(nextValue);
        }
    }
    
    return nextValue;
}

}

-module(part1).
-export([main/0]).

get_row_map(_, _, [L], Acc) when L == $\n -> Acc;
get_row_map(RowId, ColId, [H | T], Acc) ->
  get_row_map(RowId, ColId + 1, T, maps:put({RowId, ColId}, H, Acc)).

read_graph(RowId, Acc) ->
  case io:get_line("") of
    eof -> Acc;
    Line ->
      RowMap = get_row_map(RowId, 0, Line, Acc),
      read_graph(RowId + 1, RowMap)
  end.

get_pipe_directions(PipeType) ->
  case PipeType of
    $| -> [[-1, 0], [1, 0]];
    $- -> [[0, -1], [0, 1]];
    $L -> [[-1, 0], [0, 1]];
    $J -> [[-1, 0], [0, -1]];
    $7 -> [[1, 0], [0, -1]];
    $F -> [[1, 0], [0, 1]];
    _ -> []
  end.

neighbors_are_compatible(Origin, Neighbor, Graph) ->
  NeighborNeighbors = sets:from_list(get_neighbors(Neighbor, maps:get(Neighbor, Graph, "?"))),
  sets:is_element(Origin, NeighborNeighbors).

get_neighbors({I, J}, PipeType) ->
  [{I + RI, J + RJ} || [RI, RJ] <- get_pipe_directions(PipeType)].

longest_loop(Current, Start, _, First, _, Acc) when Current == Start andalso not First -> Acc;
longest_loop(Current, Start, Parent, _, Graph, Acc) ->
  PipeType = maps:get(Current, Graph),
  NextNeighbor = hd([X || X <- get_neighbors(Current, PipeType), X /= Parent]),
  case neighbors_are_compatible(Current, NextNeighbor, Graph) of
    false -> 0;
    _ -> longest_loop(NextNeighbor, Start, Current, false, Graph, 1 + Acc)
  end.


get_pipe_types() -> "|-LJ7F".

solve() ->
  Graph = read_graph(0, maps:new()),
  StartingPosition =
    hd(lists:filter(fun _(Key) -> maps:get(Key, Graph) == $S end, maps:keys(Graph))),
  Answer =
    lists:foldl(
      fun erlang:max/2, 0,
      [longest_loop(StartingPosition, StartingPosition, {-1, -1}, true, maps:put(StartingPosition, PipeType, Graph), 0)
      || PipeType <- get_pipe_types()]
    ),
  Answer.

main() ->
  R = solve(),
  io:format("~p~n", [(R + 1) div 2]).

use rayon::{iter::ParallelIterator, str::ParallelString};

use crate::handler::Handler;

#[derive(Debug)]
pub struct Day10;

impl Day10 {
    fn process_input() -> Vec<Vec<char>> {
        Handler::new("./src/day10/example.txt")
            .handle_input()
            .unwrap()
            .par_lines()
            .map(|line| line.chars().collect::<Vec<char>>())
            .collect()
    }

fn get_steps(input: &mut Vec<Vec<char>>, i: usize, j: usize, c: char) -> i32 {
    for x in i.saturating_sub(1)..=i + 1 {
        for y in j.saturating_sub(1)..=j + 1 {
            if x.abs_diff(i) == y.abs_diff(j) {
                continue;
            }
            println!("x: {:?}, y: {:?}", x, y);
            if x as i32 >= 0 && x < input.len() - 1 && y as i32 >= 0 && y < input[0].len() - 1 {
                if !input[x][y].eq(&'.') {
                    match input[x][y] {
                        '|' => {
                            if y == j {
                                match c {
                                    '|' | 'S' => {
                                        return 1 + Self::get_steps(input, x, y, input[x][y])
                                    }
                                    'L' | 'J' => {
                                        if x < i {
                                            return 1 + Self::get_steps(
                                                input,
                                                x,
                                                y,
                                                input[x][y],
                                            );
                                        }
                                    }
                                    'F' | '7' => {
                                        if x > i {
                                            return 1 + Self::get_steps(
                                                input,
                                                x,
                                                y,
                                                input[x][y],
                                            );
                                        }
                                    }
                                    _ => continue,
                                }
                            }
                        }
                        '-' => {
                            if x == i {
                                match c {
                                    '-' | 'S' => {
                                        return 1 + Self::get_steps(input, x, y, input[x][y])
                                    }
                                    'L' | 'F' => {
                                        if y > j {
                                            return 1 + Self::get_steps(
                                                input,
                                                x,
                                                y,
                                                input[x][y],
                                            );
                                        }
                                    }
                                    'J' | '7' => {
                                        if y < j {
                                            return 1 + Self::get_steps(
                                                input,
                                                x,
                                                y,
                                                input[x][y],
                                            );
                                        }
                                    }
                                    _ => continue,
                                }
                            }
                        }
                        'L' => {
                            if x > i && y == j {
                                match c {
                                    '|' | 'F' | '7' | 'S' => {
                                        return 1 + Self::get_steps(input, x, y, input[x][y]);
                                    }
                                    _ => {}
                                }
                            } else if y < j && x == i {
                                match c {
                                    '-' | 'J' | '7' | 'S' => {
                                        return 1 + Self::get_steps(input, x, y, input[x][y]);
                                    }
                                    _ => continue,
                                }
                            }
                        }
                        'J' => {
                            if x > i && y == j {
                                match c {
                                    '|' | 'F' | '7' | 'S' => {
                                        return 1 + Self::get_steps(input, x, y, input[x][y]);
                                    }
                                    _ => {}
                                }
                            } else if y > j && x == i {
                                match c {
                                    '-' | 'F' | 'L' | 'S' => {
                                        return 1 + Self::get_steps(input, x, y, input[x][y]);
                                    }
                                    _ => continue,
                                }
                            }
                        }
                        '7' => {
                            if x < i && y == j {
                                match c {
                                    '|' | 'L' | 'J' | 'S' => {
                                        return 1 + Self::get_steps(input, x, y, input[x][y]);
                                    }
                                    _ => {}
                                }
                            } else if y > j && x == i {
                                match c {
                                    '-' | 'F' | 'L' | 'S' => {
                                        return 1 + Self::get_steps(input, x, y, input[x][y]);
                                    }
                                    _ => continue,
                                }
                            }
                        }
                        'F' => {
                            if x < i && y == j {
                                match c {
                                    '|' | 'L' | 'J' | 'S' => {
                                        return 1 + Self::get_steps(input, x, y, input[x][y]);
                                    }
                                    _ => {}
                                }
                            } else if y < j && x == i {
                                match c {
                                    '-' | 'J' | '7' | 'S' => {
                                        return 1 + Self::get_steps(input, x, y, input[x][y]);
                                    }
                                    _ => continue,
                                }
                            }
                        }
                        'S' => return 0,
                        _ => {}
                    };
                }
            }
        }
    }

    0
}

fn start_maze(input: &mut Vec<Vec<char>>) -> i32 {
    for i in 0..input.len() {
        for j in 0..input[0].len() {
            match input[i][j] {
                'S' => return Self::get_steps(input, i, j, input[i][j]) / 2,
                _ => {}
            }
        }
    }

    0
}

pub fn part1() -> i32 {
    let mut input = Self::process_input();
    Self::start_maze(&mut input)
}

pub fn part2() -> i32 {
    let mut input = Self::process_input();
    Self::start_maze(&mut input)
}
}

#[test]
fn test1() {
    let expected = 8;
    assert_eq!(expected, Day10::part1());
}

#[test]
fn test2() {
    let expected = 977;
    assert_eq!(expected, Day10::part2());
}

He estado un buen rato debuggeando, porque aún y con las pistas, había un caso de test que se me escapaba, el del último fichero de pruebas:

Tras debuggear un rato, he visto que toda aquella tubería que no forme parte del loop puede dar un falso positivo con "FJ" o "L7", así que he hecho lo siguiente:

• Me he creado una copia del mapa (loopMap), en la cuál he marcado las celdas que fueran parte del loop con "#", en realidad esto ya lo tenía hecho para debuggear, pero al final me ha servido para resolver también.
• En el mapa original, tras localizar el loop, he sobreescrito todas aquellas tuberías que no sean loop por ground (".").

Finalmente, gracias a las pistas de #226 y #224, la parte que queda del algoritmo la he tratado simplemente como una cadena:

• Genero una cadena que va desde la posición del carácter + 1 hasta el final.
• Reemplazo todos los "-" por vacíos.
• Cuento todas las apariciones de "|", "FJ" y "L7" y las sumo entre si. Técnicamente un "FJ" o un "L7" es como encontrar un "|".
• Aplico módulo sobre el total: Si hay un número par de apariciones, significa que está fuera del loop, si hay un número impar, está dentro del loop.

Así, la parte 2 ha quedado mas o menos así:

public int solveB() {

    int result = 0;

    // Paint the loop
    solveA();

    // Overwrite pipes that don't belong to the loop to ground
    for(int row = 0; row < rows; row++){
        for(int col = 0; col < cols; col++) {
            if(isNotLoop(row, col)) {
                map[row][col] = GROUND;
            }
        }
    }

    // Apply ray-casting to find tiles inside the loop
    for(int row = 0; row < rows; row++) {
        for(int col = 0; col < cols; col++) {
            if(isNotLoop(row, col) && isInside(row, col)){
                result++;
            }
        }
    }

    return result;
}
private boolean isInside(int row, int col) {

    // Apply ray-casting to the right
    String line = new String(map[row]);
    String filteredLine = line.substring(col, cols).replace("-", StringUtils.EMPTY);
    int vertical = StringUtils.countMatches(filteredLine,"|");
    int fj = StringUtils.countMatches(filteredLine, "FJ");
    int l7 = StringUtils.countMatches(filteredLine, "L7");
    int total = vertical + fj + l7;

    return total % 2 != 0;

}

private void paintLoop(Vector2 position) {
    loopMap[position.getY()][position.getX()] = PipeMaze.VISITED;
}

private boolean isNotLoop(int row, int col) {
    return loopMap[row][col] != VISITED;
}

Si el primer numero es negativo, significa que no hemos empezado a poner ningun #
Si el primer numero es cero, significa que hemos acabado de poner una secuencia de # y necesitamos al menos un separador

Me preocupaba lo mismo que a ti, y estuve a punto de hacer lo que has hecho tu. Lo que hice fue "no coger mas # y parar" si ya habia llegado al valor que faltaba. Creo que estoy haciendo llamadas de más en algun lado y se puede optimizar, pero almenos me ahorré eso de x=-1 o x=0

He sufrido al principio para entender las condiciones de resultado del problema, porque casualmente te ponen un mapa que tiene exactamente un espejo vertical y otro mapa con espejo horizontal; entonces he pensado que los mapas impares solo tenían espejos verticales y los mapas pares solo tenían espejos horizontales.

Luego más adelante, he creído que salía más de un espejo, pero mirando con mucho cuidado, se veía que no coincidían exactamente.

Por lo tanto, hay algunas cosas que no te dicen en el texto pero que puedes acabar descubriendo en cuanto te pones a debuggear.

• En la parte 1 del puzzle, cada mapa tiene 1 y solo 1 espejo, nunca puede salir dos, aunque sean uno vertical y otro horizontal.
• En la parte 2 del puzzle, puede salir más de un espejo (el original + el nuevo), pero, y esto hay que leer muy bien el enunciado, no hay que tener en cuenta el espejo original para la función resultado (he perdido un buen rato comprendiendo esto).
• En la parte 2 cada mapa tiene 1 y solo 1 punto smudge.

Código:
https://github.com/Flashky/advent-of-code-2023/blob/master/src/main/java/com/adventofcode/flashk/day13/PointOfIncidence.java

la fuerza bruta en este algoritmo es para cada celda (i,j) del array, probar a cambiar su valor y ver si es solución o no. En el peor de los casos se rocorren todos los elementos (i*j) , por lo que al final si i y j son similares es O(n²).