Advent of Code 2023: ChatGPT-4 turbo edition

eZpit #151 4 Dic Juntabrackets

Just beutiful

fun parseLine(line: String): Set<Int> = line
        .split(": ").last().split(" | ")
        .map { numbers -> numbers.trim().split("\\s+".toRegex()).map { it.toInt() }.toSet() }
        .reduce { acc, ints -> acc.intersect(ints) }

fun part1(input: List<String>): Int = input
    .map(::parseLine)
    .sumOf { line ->
        line.takeIf { it.isNotEmpty() }?.let { 2.0.pow(it.size - 1).toInt() } ?: 0
    }

fun part2(input: List<String>): Int {
    val scratchcards = input.map(::parseLine)
    fun score(index: Int): Int = 1 + (0 until scratchcards[index].size).sumOf { score(index + 1 + it) }
    return scratchcards.indices.sumOf(::score)
}

1

CiudadanoEj #152 5 Dic

alguien mas no entiende el enunciado de hoy?

2 respuestas

R

ragnar777 #153 5 Dic

#152 lo he intentado leer cuando estaba poniendo a dormir a la niña y he visto que requería toda mi atención xD lo retomaré más tarde

Frankicia #154 5 Dic

#152 lo he leido y parece bastante mal explicado para lo que es.

Segun entiendo,
te dan N semillas y M mapas. Cada mapa es, simplemente, un nivel mas de traduccion con la siguiente informacion:

mapa 1 (X to Y ):
coordenada_destino coordenada_origen longitud

Si tu X esta en [coordenada_origen, coordenada_origen+longitud), pues la traduccion es Y = coordenada_destino + (X - coordenada_origen) (te lo digo rapido, probablemente hace falta algo de tuning a la formula)
Si tu X no esta en ningun rango, la traduccion es Y = X

Cada mapa te da un output que le metes al siguiente mapa y asi hasta el mapa de location

1 respuesta

CiudadanoEj #155 5 Dic

#154 pero es que entonces no entiendo esto
50 98 2
52 50 48
The second line means that the source range starts at 50 and contains 48 values: 50, 51, ..., 96, 97. This corresponds to a destination range starting at 52 and also containing 48 values: 52, 53, ..., 98, 99. So, seed number 53 corresponds to soil number 55.

no deberia estar la seed number 53 en ese soil?

2 respuestas

desu #156 5 Dic

#155 la seed aplica identidad, identidad a = a, i.e identidad 13 = 13, si solo si, no existe un mapping.

Seed number 79 corresponds to soil number 81.
Seed number 14 corresponds to soil number 14.
Seed number 55 corresponds to soil number 57.
Seed number 13 corresponds to soil number 13.

14 y 13 no tienen mapping pues identidad. es decir, el mismo valor.

la verdad mucha fumada, advent of parsing lo hace de nuevo... que pereza

R

RsTTa #157 5 Dic

Así no dan ganas de entrar a leerlo xD

Frankicia #158 5 Dic

#155 El mapa tiene muchos soils que estan shiftados.

La linea 52 50 48 significa:
Semillas con id 50 hasta 97 [50, 50 + 48) deben ir al soil id 52 hasta 99. Y el mapping es 1 a 1.
Semilla id 50 --> soil 52,
semilla id 51 --> soil 53,
semilla id 52--> soil 54,
semilla id 53 --> 55 (52 + (53 - 50)

1

desu #159 5 Dic

Si es facil cuando lo lees. Pero que perezota de enunciados y parseos. Suerte que ese mi ultimo dia de AOC xd

Pizzelio #160 5 Dic

Tremenda pereza la verdad. No sé si lo haré hoy...

Mandarino #161 5 Dic

Reconozco que tambien me ha costado entenderlo al principio. La parte 1 es mas entenderlo porque implementarlo no es tan complicado. La parte 2 un poco al reves xD
Creo que lo que me ha liado mas es que los mappings te los dan en orden "destination source length" y no "source destination length"

parte2

spoiler

python

spoiler

sergioRG #162 5 Dic Juntabrackets

Parte 1, cuando termine de currar le doy a la parte 2. Realmente la parte 1 se puede ver como un caso concreto de la parte 2, no creo que le añada mucha dificultad.

spoiler

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

get_seed_list() ->
  [SeedLine, _] = [io:get_line(""), io:get_line("")],
  {_, [SeedNumsBin]} =
    re:run(SeedLine, "seeds: (.*)\n", [{capture, all_but_first, binary}]),
  lists:map(
    fun _(X) -> {Val, _} = string:to_integer(X), Val end,
    string:split(binary_to_list(SeedNumsBin), " ", all)
  ).

add_map(Acc, CurrentMap) ->
  case io:get_line("") of
    eof -> Acc ++ [CurrentMap];
    "\n" -> Acc ++ [CurrentMap];
    Line ->
      {_, Matches} =
        re:run(Line, "(\\d+) (\\d+) (\\d+)\n", [{capture, all_but_first, binary}]),
      [Dest, Source, Len] =
        lists:map(fun _(X) -> {Val, _} = string:to_integer(X), Val end, Matches),
      add_map(Acc, CurrentMap ++ [[Source, Source + Len - 1, Dest]])
  end.


get_map_list(Acc) ->
  case io:get_line("") of
    eof -> Acc;
    _ -> get_map_list(add_map(Acc, []))
  end.

get_next_id(CurrentId, []) -> CurrentId;
get_next_id(CurrentId, [[L, R, D] | _]) when (CurrentId >= L andalso CurrentId =< R) ->
  D + CurrentId - L;
get_next_id(CurrentId, [_ | T]) ->
  get_next_id(CurrentId, T).

iterate_seed(CurrentId, []) -> CurrentId;
iterate_seed(CurrentId, [Map | T]) ->
  NextId = get_next_id(CurrentId, Map),
  iterate_seed(NextId, T).


solve() ->
  Seeds = get_seed_list(),
  Maps = get_map_list([]),
  lists:foldl(
    fun _(A, B) -> erlang:min(A, B) end,
    23898895723587,
    lists:map(
      fun _(X) -> iterate_seed(X, Maps) end,
      Seeds
    )
  ).

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

edit, parte 2, gran hueco el de despues de comer para hacer estas cosas!

spoiler

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

get_seed_intervals([], Acc) -> Acc;
get_seed_intervals([Ls, Ds | T], Acc) ->
  [L, D] = lists:map(fun _(X) -> {Val, _} = string:to_integer(X), Val end, [Ls, Ds]),
  get_seed_intervals(T, [[L, L + D - 1, notfound] | Acc]).

get_seed_list() ->
  [SeedLine, _] = [io:get_line(""), io:get_line("")],
  {_, [SeedNumsBin]} =
    re:run(SeedLine, "seeds: (.*)\n", [{capture, all_but_first, binary}]),
  get_seed_intervals(
    string:split(binary_to_list(SeedNumsBin), " ", all),
    []
  ).

add_map(Acc, CurrentMap) ->
  case io:get_line("") of
    eof -> Acc ++ [CurrentMap];
    "\n" -> Acc ++ [CurrentMap];
    Line ->
      {_, Matches} =
        re:run(Line, "(\\d+) (\\d+) (\\d+)\n", [{capture, all_but_first, binary}]),
      [Dest, Source, Len] =
        lists:map(fun _(X) -> {Val, _} = string:to_integer(X), Val end, Matches),
      add_map(Acc, CurrentMap ++ [[Source, Source + Len - 1, Dest]])
  end.


get_map_list(Acc) ->
  case io:get_line("") of
    eof -> Acc;
    _ -> get_map_list(add_map(Acc, []))
  end.

add_nonempty_rems([], Acc) -> Acc;

add_nonempty_rems([[L, R, _] = I | T], Acc) when L =< R ->
  add_nonempty_rems(T, [I | Acc]);

add_nonempty_rems([_ | T], Acc) ->
  add_nonempty_rems(T, Acc).


replace_intervals([] , _, Acc) -> Acc;


replace_intervals([[SL, SR, _] = Seed | T1], [L, R, _] = Interval, Acc)
  when (SR < L orelse SL > R) ->
  replace_intervals(T1, Interval, [Seed | Acc]);

replace_intervals([[_, _, found] = Seed | T1], Interval, Acc) ->
  replace_intervals(T1, Interval, [Seed | Acc]);

replace_intervals([[SL, SR, notfound] | T1], [L, R, D] = Interval, Acc) ->
  [IL, IR] = [erlang:max(L, SL), erlang:min(R, SR)],
  NewInterval = [D + IL - L, D + IR - L, found],
  LeftRemainder = [SL, IL - 1, notfound],
  RightRemainder = [IR + 1, SR, notfound],
  ToAdd = add_nonempty_rems([LeftRemainder, RightRemainder], []),
  replace_intervals(
    ToAdd ++ T1,
    Interval,
    [NewInterval | Acc]
  ).

get_next_intervals(CurrentIntervals, []) ->
  [[X, Y, notfound] || [X, Y, _] <- CurrentIntervals];
get_next_intervals(CurrentIntervals, [MapInterval | T]) ->
  get_next_intervals(
    replace_intervals(CurrentIntervals, MapInterval, []),
    T
  ).

iterate_seed(CurrentIntervals, []) -> CurrentIntervals;
iterate_seed(CurrentIntervals, [Map | T]) ->
  iterate_seed(get_next_intervals(CurrentIntervals, Map), T).

solve() ->
  Seeds = get_seed_list(),
  Maps = get_map_list([]),
  Locations =
  lists:foldl(
    fun _(A, B) -> A ++ B end,
    [],
    lists:map(
      fun _(X) -> iterate_seed([X], Maps) end,
      Seeds
    )
  ),
  [MinVal, _, _] = lists:foldl(
    fun _([A, _, _], [B, _, _]) -> [erlang:min(A, B), 3, xd] end,
    [2934892358988132, 3, xd],
    Locations
  ),
  MinVal.

main() ->
  R = solve(),
  io:format("~w~n", [R]).

Dependerá de cómo lo hagáis, pero por si acaso

Bug que he metido yo por reciclar codigo

R

RsTTa #163 5 Dic

Ya me la han liado con la parte 2, muy lento el código si tiro de lo que tengo para la parte 1

Cerealfriend #164 5 Dic

El día 3 me ha costado horrores, he tenido que recurrir a ayuda en el hilo. El día 4 la parte 1 muy sencilla pero la parte 2 he estado un buen rato figurándome el enunciado.

Esta tarde le doy al 5

Mezdelex #165 5 Dic

Contra el ejemplo me funciona bien la parte 2, pero es cambiarlo al input y se me queda hiper pillado. ¿Alguien que pilote de Rust sabe si es porque se está quedando picha con la memoria o hay algo que me estoy dejando? ¿Hay algo así como el bigint en Rust?

Día 05: Parte 1 + Parte 2 [Rust]

use rayon::prelude::{IntoParallelIterator, ParallelIterator};
use regex::Regex;

use crate::handler::Handler;

#[derive(Debug)]
pub struct Day05;

impl Day05 {
    fn process_input() -> Vec<Vec<u64>> {
        Regex::new(r".+: ?")
            .unwrap()
            .split(
                &Handler::new("./src/Day05/input.txt")
                    .handle_input()
                    .unwrap(),
            )
            .skip(1)
            .map(|chunk| {
                chunk
                    .split_whitespace()
                    .map(|num| num.parse::<u64>().unwrap())
                    .collect::<Vec<u64>>()
            })
            .collect()
    }

pub fn part1() -> u64 {
    let input = Self::process_input();
    input[0]
        .iter()
        .map(|&seed| {
            let mut current = seed;
            let mut min = u64::MAX;

            for i in 0..input[1..].len() {
                for j in (0..input[1..][i].len()).step_by(3) {
                    if (input[1..][i][j + 1]..input[1..][i][j + 1] + input[1..][i][j + 2])
                        .contains(&current)
                    {
                        current = input[1..][i][j] + current - input[1..][i][j + 1];
                        break;
                    }
                }
                if i == input[1..].len() - 1 && current < min {
                    min = current;
                }
            }
            min
        })
        .min()
        .unwrap()
}

pub fn part2() -> u64 {
    let input = Self::process_input();
    input[0]
        .chunks(2)
        .map(|chunk| {
            (chunk[0]..=chunk[0] + chunk[1])
                .into_par_iter()
                .map(|seed| {
                    let mut current = seed;
                    let mut min = u64::MAX;

                    for i in 0..input[1..].len() {
                        for j in (0..input[1..][i].len()).step_by(3) {
                            if (input[1..][i][j + 1]
                                ..input[1..][i][j + 1] + input[1..][i][j + 2])
                                .contains(&current)
                            {
                                current = input[1..][i][j] + current - input[1..][i][j + 1];
                                break;
                            }
                        }
                        if i == input[1..].len() - 1 && current < min {
                            min = current;
                        }
                    }
                    min
                })
                .min()
                .unwrap()
        })
        .min()
        .unwrap()
}
}

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

#[test]
#[ignore = "brute force, too heavy to run in ci"]
fn test2() {
    let expected = 52510809;
    assert_eq!(expected, Day05::part2());
}

1 respuesta

Mandarino #166 5 Dic

#165 Has mirado los rangos que estas manejando en el input? Yo por ejemplo tengo un rango de 1532286286 a 1532286286+1115055792.
La verdad que no entiendo nada de tu codigo porque no se Rust, pero si estas guardando cada indice en memoria, para este rango en concreto solo eso seria 1115055792*128bits = _16GB. No solo es memoria si no que tienes que calcular el mapping de cada numero (1115055792 en total) solo para un seed-to-soil. Por lo que he visto en Reddit hay gente que lo ha solucionado asi a lo bruto, pero quizas lo tienen un poco mas optimo.
Yo lo que hice fue

spoiler

1 respuesta

Mezdelex #167 5 Dic

#166 Yep xDDD no es que se quedara pillado, es que el proceso es heavy de cojones como bien dices.

Ahhh cabrón, claro; lo suyo es hacer un dfs en vez de bfs, o sea, mirar cada valor hasta el final y quedarte con el que ya sabes que es el más bajo en vez de contenerlos a todos como tremendo zote.

draz1c #168 5 Dic

Yo también he ido a lo bruto y me he quedado sin memoria RAM.

sergioRG #169 5 Dic Juntabrackets

Por si os liais con la solucion con intervalos

byJoTaeFe #170 6 Dic Diamond hands

~~Estoy igual, lo he conseguido sacar con el ejemplo, pero con el input no puedo procesarlo porque he ido sacando los rangos y metiéndolos en arrays para comprobar xD~~

Arreglado, vaya tremenda gilipollez.

1 respuesta

Zentakki #171 6 Dic Abe Sapien

#170 Como has hecho?

pd: nada, ya lo conseguí

Mandarino #172 6 Dic

Dia 6: El de hoy facilito!

parte 2

spoiler

Pizzelio #173 6 Dic

Hay alguna forma de mejorar el rendimiento de la parte 2? La que imagino que primero vamos a hacer la mayoría es bastante lenta pero debe haber alguna fórmula matemática que saca el número más directo y ahorre tener que comprobar todo

Edit: Vale, ya. Soy imbécil xD

BeheritSp #174 6 Dic Juntabrackets

Yo matemáticamente lo he hecho así (es una chorrada en realidad):

Day6 Parte 2

3

Flashk #175 6 Dic

Day 6 parte 2

sergioRG #176 6 Dic Juntabrackets

Parte 1

spoiler

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

sample() -> {[7, 15, 30], [9, 40, 200]}.
input() -> {[63, 78, 94, 68], [411, 1274, 2047, 1035]}.

num_ways([], [], Acc) -> Acc;
num_ways([Time | T1], [Distance | T2], Acc) ->
  NumWays =
    length([X || X <- lists:seq(0, Time), X * (Time - X) > Distance]),
  num_ways(T1, T2, Acc * NumWays).

solve() ->
  {Times, Distances} = input(),
  num_ways(Times, Distances, 1).

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

La parte 2 la he hecho a mano, aunque luego he probado mi solución y también va bastante rápido, deberían haber puesto números mas grandes si querían evitar a la gente haciéndola a bruteforce xD

1 respuesta

desu #177 6 Dic

#176sergioRG:
deberían haber puesto números mas grandes si querían evitar a la gente haciéndola a bruteforce xD

el objetivo del advent nunca ha sido escribir codigo rapido ni eficiente

siempre ha sido mas de golfing y hacer el codigo mas bonito

2 respuestas

sergioRG #178 6 Dic Juntabrackets

#177desu:

codigo mas bonito

pues pa tu culo to mi pito venga arnaldo te faltan soft skills

Mandarino #179 6 Dic

#177 para el leaderboard es el que encuentre la solución lo antes posible, da igual si tu codigo es eficiente, lento y/o infumable. De hecho es como me lo tomo yo, hacer lo que sea para sacarlo rapido.
Para codigo eficiente ya hay leetcoce, codechef etc..
Eso si, si te da igual el leaderboard pues que cada uno lo haga como le.apetezca

Mezdelex #180 6 Dic

Pues nada, para una vez que le doy a la recursividad me tocan la moral en el punto 2.

Día 06 Parte 1 + Parte 2 [Rust]

use regex::Regex;

use crate::handler::Handler;

#[derive(Debug)]
pub struct Day06;

impl Day06 {
    fn process_input() -> Vec<Vec<u64>> {
        Handler::new("./src/day06/input.txt")
            .handle_input()
            .unwrap()
            .lines()
            .map(|line| {
                Regex::new(r"\D+")
                    .unwrap()
                    .split(&line)
                    .map(|num| num.parse::<u64>().unwrap_or_default())
                    .skip(1)
                    .collect::<Vec<u64>>()
            })
            .collect()
    }

fn get_chances(time: &u64, distance: u64, time_holding: u64) -> u64 {
    if time_holding == *time {
        return 0;
    }

    if (time - time_holding) * time_holding <= distance {
        return Self::get_chances(time, distance, time_holding + 1);
    }

    1 + Self::get_chances(time, distance, time_holding + 1)
}

pub fn part1() -> u64 {
    let input = Self::process_input();
    input[0]
        .iter()
        .enumerate()
        .map(|(idx, time)| {
            let chances = Self::get_chances(time, input[1][idx], 1);

            if chances == 0 {
                1
            } else {
                chances
            }
        })
        .product()
}

pub fn part2() -> u64 {
    let input = Self::process_input();
    let time: u64 = input[0]
        .iter()
        .map(|&num| num.to_string())
        .collect::<String>()
        .parse()
        .unwrap();
    let distance: u64 = input[1]
        .iter()
        .map(|&num| num.to_string())
        .collect::<String>()
        .parse()
        .unwrap();

    let mut chances = 0;
    for holding_time in 1..time {
        let speed = time - holding_time;
        let chance_time = time - speed;

        if speed * chance_time > distance {
            chances += 1;
        }
    }

    chances
}
}

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

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

EDIT: La verdad que admiro a la peña que es capaz de resolver este tipo de problemas en cuestión de segundos y leyendo en diagonal el enunciado. Supongo que llegará un momento en el que lo tendrás tan mecanizado y habrás grindeado tantos problemas similares que lo harás sin demasiado esfuerzo, pero en mi caso me tengo que repetir mentalmente varias veces -VARIAS veces- lo que estoy leyendo para que las neuronas me hagan conexión y muchas veces me quedo pajarito aún así.

Usuarios habituales

Tags