Advent of Code 2023: ChatGPT-4 turbo edition

Mandarino #91 3 Dic

#89
Pista:

NSFW

Fix:

NSFW

1 2 respuestas

CiudadanoEj #92 3 Dic

#91 era eso gracias!

Pizzelio #93 3 Dic

#90

spoiler

1 respuesta

desu #94 3 Dic

#93

spoiler

2 respuestas

Frankicia #95 3 Dic

#94 o te explicas fatal o te entiendo fatal.

Pon el codigo maestro, a ver si tienes menos complejidad que yo

1 respuesta

desu #96 3 Dic

#95 me explico fatal tranquilo.

1

Pizzelio #97 3 Dic

#94

spoiler

1 respuesta

desu #98 3 Dic

#97 en que lang lo haces, te lo pego por la tarde con varias soluciones

1 respuesta

Pizzelio #99 3 Dic

#98 Estoy dándole con python

1 respuesta

Mandarino #100 3 Dic

Creo que el advent tiene como objetivo sacar la solucion de cualquiee forma posible , no tanto hacer el mejor codigo optimo/bonito.
Para mi el objetivo 1ero es sacar las 2 estrellitas. La parte de limpiar y dejar el codigo bonito ya lo dejo como una parte opcional si uno quiere practicar esta parte.

1

B

[Borrado] #101 3 Dic

A ver esta tarde que tal. Así a ojo mi idea sería algo del estilo

spoiler

desu #102 3 Dic

#99 ah me lie, creia que tenia que quitar los que tocaban simbolos, es lo contrario . por eso los llamaba indices malos.

Mezdelex #103 3 Dic

Yo lo he hecho iterando sobre todo lo iterable. No itero sobre la web en sí porque no me he puesto a ello. En fin. Lo de los tipos de Rust definitivamente es una locura una vez se te escapa del tracking mental lo que estás usando al ponerte a modificar código. Me he pasado tranquilamente 1 hora siguiendo el flujo mentalmente para saber por qué cojones fallaba y resulta que era por los índices que no eran i32 al hacer el -1 en el x/y. Y otra cagada más lamentable... xD al estar acostumbrado al incremento ++, en el k += 1 le puse k += k y ahí me he tirado otra horita hasta que me he dado cuenta.

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

use std::collections::VecDeque;

use crate::handler::Handler;

#[derive(Debug)]
pub struct Day03;

impl Day03 {
    fn process_input() -> Vec<Vec<char>> {
        let handler = Handler::new("./src/day03/input.txt");
        let processed_input = handler
            .handle_input()
            .unwrap()
            .lines()
            .map(|line| line.chars().collect())
            .collect();

    processed_input
}

fn fill_left(
    input: &mut Vec<Vec<char>>,
    number: &mut VecDeque<char>,
    x: usize,
    y: usize,
    k: usize,
) -> bool {
    match y as i32 - k as i32 >= 0 && input[x][y - k].is_digit(10) {
        true => {
            number.push_front(input[x][y - k]);
            input[x][y - k] = '.';
            return true;
        }
        _ => return false,
    };
}

fn fill_right(
    input: &mut Vec<Vec<char>>,
    number: &mut VecDeque<char>,
    x: usize,
    y: usize,
    k: usize,
) -> bool {
    match y + k < input[x].len() && input[x][y + k].is_digit(10) {
        true => {
            number.push_back(input[x][y + k]);
            input[x][y + k] = '.';
            return true;
        }
        _ => return false,
    }
}

fn fill_number(input: &mut Vec<Vec<char>>, number: &mut VecDeque<char>, x: usize, y: usize) {
    number.push_back(input[x][y]);
    input[x][y] = '.';
    let mut k = 1;
    loop {
        if !Self::fill_left(input, number, x, y, k) {
            break;
        }
        k += 1;
    }
    k = 1;
    loop {
        if !Self::fill_right(input, number, x, y, k) {
            break;
        }
        k += 1;
    }
}

fn add_surround_numbers(
    input: &mut Vec<Vec<char>>,
    vec_of_values: &mut Vec<usize>,
    i: usize,
    j: usize,
    is_part2: bool,
) {
    let mut added_values: Vec<usize> = vec![];
    for x in i.saturating_sub(1)..=i + 1 {
        for y in j.saturating_sub(1)..=j + 1 {
            if is_part2 && added_values.len() > 2 {
                return;
            }

            if x as i32 >= 0 && y as i32 >= 0 {
                if !input[x][y].is_digit(10) {
                    continue;
                }
                let mut number: VecDeque<char> = VecDeque::new();
                Self::fill_number(input, &mut number, x, y);
                added_values.push(number.iter().collect::<String>().parse().unwrap());
            }
        }
    }

    if is_part2 {
        if added_values.len() > 1 {
            vec_of_values.push(added_values[0] * added_values[1]);
        }
    } else {
        vec_of_values.extend(added_values);
    }
}

pub fn part1() -> usize {
    let mut input = Self::process_input();
    let mut vec_of_values: Vec<usize> = vec![];
    for i in 0..input.len() {
        for j in 0..input[0].len() {
            if !input[i][j].is_digit(10) && !input[i][j].eq(&'.') {
                Self::add_surround_numbers(&mut input, &mut vec_of_values, i, j, false);
            }
        }
    }

    vec_of_values.iter().sum()
}

pub fn part2() -> usize {
    let mut input = Self::process_input();
    let mut vec_of_values: Vec<usize> = vec![];
    for i in 0..input.len() {
        for j in 0..input[0].len() {
            if input[i][j].eq(&'*') {
                Self::add_surround_numbers(&mut input, &mut vec_of_values, i, j, true);
            }
        }
    }

    vec_of_values.iter().sum()
}
}

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

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

1 1 respuesta

Pizzelio #104 3 Dic

#103 Estuve a punto de hacerlo en Rust, cada vez que leo tus soluciones me alegro de no haberlo hecho

1 respuesta

Zh3RoX #105 3 Dic

Soy retard pero de donde sacáis parte 1 y parte 2? Yo solo veo un enunciado por día.

1 respuesta

Pizzelio #106 3 Dic

#105 Al resolver ese enunciado que ves, te dan otro

1

Mezdelex #107 3 Dic

#104 A ver, también te digo, he visto código más funcional de Rust que se te cae el tanga al suelo de lo curioso que queda, no te fíes de mi código que todavía estoy viéndolas venir xD

1

Eckooo #108 3 Dic

Day 2 C#

Part1 cerdada total

static void Main(string[] args)
{
    StreamReader reader = new StreamReader("input.txt");
    string[] lines = reader.ReadToEnd().Split('\n');
    List<string> forb = new List<string>() {"13 red","14 red","15 red","16 red","17 red","18 red","19 red","20 red",
    "14 green","15 green","16 green","17 green","18 green","19 green","20 green",
    "15 blue","16 blue","17 blue","18 blue","19 blue","20 blue"};
    List<int> badgames = new List<int>();

foreach (string line in lines) 
{
    foreach (string item in forb)
    {
        if (line.Contains(item))
        {
            badgames.Add(Convert.ToInt32(line.Substring(5, 2).Replace(':', ' ')));
            break;
        }
    }
}    

Console.WriteLine(5050 - badgames.Sum());
}

Part2

static void Main(string[] args)
{
    StreamReader reader = new StreamReader("input.txt");
    string[] lines = reader.ReadToEnd().Split('\n');
    List<string> result = new List<string>();
    int total = 0;

foreach (string line in lines) 
{
    string[] aux = line.Split(':');
    string[] aux2 = aux[1].Split(';');
   
    List<int> red = new List<int>();
    List<int> green = new List<int>();
    List<int> blue = new List<int>();
    
    for (int i = 0; i < aux2.Length; i++) 
    {
        string[] aux3 = aux2[i].Split(',');
        foreach (string item in aux3)
        {
            if (item.Contains("red"))
                red.Add(Convert.ToInt32(item.Replace(" red", "").Trim()));
            else if (item.Contains("green"))
                green.Add(Convert.ToInt32(item.Replace(" green", "").Trim()));
            else if (item.Contains("blue"))
                blue.Add(Convert.ToInt32(item.Replace(" blue", "").Trim()));
        }
    }

    total += red.Max() * green.Max() * blue.Max();
                 
}

Console.WriteLine(total);
}

ignasi_ #109 3 Dic

Day 2 Elixir

spoiler

defmodule Day2 do
  def read do
    File.stream!("/data/autosaved/2023_12_02/08_16_sq4j/files/day2.txt")
    |> Stream.map(&String.trim/1)
    |> Stream.map(&String.split(&1, [":", ";"]))
    |> Enum.reduce(%{}, fn line, acc ->
      [game_str | items] = line
      [_ | game] = String.split(game_str, " ")
      {game, _} = Integer.parse(hd(game))

  game_items =
    Enum.map(items, fn s ->
      splitted = String.split(s, ",") |> Enum.map(&String.trim/1)

      Enum.reduce(splitted, %{}, fn l, acc ->
        [n_str, color] = String.split(l, " ")
        {n, _} = Integer.parse(n_str)
        Map.put(acc, color, n)
      end)
    end)

  Map.put(acc, game, game_items)
end)
  end

  def filter_game_throw(map) do
    blue = Map.get(map, "blue", 0)
    red = Map.get(map, "red", 0)
    green = Map.get(map, "green", 0)

red <= 12 && green <= 13 && blue <= 14
  end

  def count_possibles() do
    map = Day2.read()

filtered =
  :maps.filter(
    fn _, v ->
      Enum.all?(v, &Day2.filter_game_throw(&1))
    end,
    map
  )

filtered
|> Enum.reduce(0, fn {key, _value}, acc ->
  acc + key
end)
  end

  def get_mins([h | t]) do
    Enum.reduce(t, h, fn map, acc ->
      blue = Map.get(map, "blue", 0)
      red = Map.get(map, "red", 0)
      green = Map.get(map, "green", 0)
      c_blue = Map.get(acc, "blue", 0)
      c_red = Map.get(acc, "red", 0)
      c_green = Map.get(acc, "green", 0)

  new_acc =
    acc
    |> Map.put("blue", Kernel.max(blue, c_blue))
    |> Map.put("red", Kernel.max(red, c_red))
    |> Map.put("green", Kernel.max(green, c_green))

  new_acc
end)
  end

  def get_mins([]) do
    Map.new()
  end

  def count_mins() do
    Day2.read()
    |> Map.to_list()
    |> Enum.map(fn {_, list} -> list end)
    |> Enum.map(fn maps -> Day2.get_mins(maps) end)
    |> Enum.reduce(0, fn map, acc ->
      power =
        Enum.reduce(Map.values(map), 1, fn cv, acc2 ->
          acc2 * cv
        end)

  acc + power
end)
  end
end

Day 3 Elixir

spoiler

lines = String.split(input, "\n")

regex_symbol = ~r/[^\.0-9]/u
regex_nums = ~r/\d+/
regex_gears = ~r/\*/

symbols_pos =
  lines
  |> Enum.with_index()
  |> Enum.flat_map(fn {l, i} ->
    Regex.scan(regex_symbol, l, return: :index)
    |> Enum.map(fn pairs ->
      [{row, _}] = pairs
      {i, row}
    end)
  end)
  |> Enum.map(fn {col, row} -> 
  {Range.new(col - 1, col + 1), Range.new(row - 1, row + 1)}
end)

# [{n, col, row {inc, excl}}]
nums =
  lines
  |> Enum.with_index()
  |> Enum.flat_map(fn {l, i} ->
    Enum.zip(
      List.flatten(Regex.scan(regex_nums, l, return: :index)),
      List.flatten(Regex.scan(regex_nums, l))
    )
    |> Enum.map(fn {tuple, n} ->
      {start, finish} = tuple
      {n, _} = Integer.parse(n)
      {n, i, Range.new(start, finish + start - 1)}
    end)
  end)

filtered_nums = nums
 |> Enum.filter(fn {_, col, num_row_range} ->
  Enum.find(symbols_pos, fn {col_range, row_range} -> 
    Enum.member?(col_range, col) && !Range.disjoint?(num_row_range, row_range)
  end)
end)
|> Enum.reduce(0, fn n, acc ->
  num = elem(n, 0)
  acc + num
end)

# part 2 

gears_pos =
  lines
  |> Enum.with_index()
  |> Enum.flat_map(fn {l, i} ->
    Regex.scan(regex_gears, l, return: :index)
    |> Enum.map(fn pairs ->
      [{row, _}] = pairs
      {i, row}
    end)
  end)
  |> Enum.map(fn {col, row} -> 
  {Range.new(col - 1, col + 1), Range.new(row - 1, row + 1)}
end)


filtered_nums = Enum.reduce(gears_pos, 0, fn {gear_col, gear_row}, acc -> 
  adj = Enum.filter(nums, fn {_n, col, row_range} -> 
    Enum.member?(gear_col, col) && !Range.disjoint?(gear_row, row_range)
  end)
  if length(adj) >= 2 do
    acc + Enum.reduce(adj, 1, fn tupl, acc2 -> 
      num = elem(tupl,0)
      acc2 * num
    end) else  

    acc 
  end
end)

Primera vez que toco Elixir así que un poco torpe, pero bueno poco a poco.

Si alguno lo esta haciendo en Elixir, o quiere probar: https://livebook.dev/ con esto se va guay, tiene drag and drop para ficheros y todo.

R

ragnar777 #110 3 Dic

Day3 C#

se me rompe la indentación

part 1

using System;
using System.Collections.Generic;
using System.IO;

namespace day3
{
    class Program
    {
        class LineContent
        {
            public List<NumberInfo> Numbers = new List<NumberInfo>();
            public List<int> SymbolIndex = new List<int>();
        }

    struct NumberInfo
    {
        public int Value;
        public int StartIndex;
        public int EndIndex;
    }

    static void Main(string[] args)
    {
        using (var reader = new StreamReader("Input.txt"))
        {
            var line = reader.ReadLine();
            LineContent prev;
            LineContent actual = GetLineContent(line);
            line = reader.ReadLine();
            
            int sum = 0;
            sum += SumAndRemoveValidNumbers(actual, actual);

            while (line != null)
            {
                prev = actual;
                actual = GetLineContent(line);

                sum += SumAndRemoveValidNumbers(actual, actual);

                sum += SumAndRemoveValidNumbers(actual, prev);

                sum += SumAndRemoveValidNumbers(prev, actual);

                line = reader.ReadLine();
            }

            Console.WriteLine(sum);
            Console.ReadKey();
        }
    }

    static int SumAndRemoveValidNumbers(LineContent numbers, LineContent symbols)
    {
        int sum = 0;
        foreach (var symbol in symbols.SymbolIndex)
        {
            var limit = numbers.Numbers.Count;
            for (int i = 0; i < limit; i++)
            {
                var numberInfo = numbers.Numbers[i];
                if (numberInfo.StartIndex > symbol + 1)
                {
                    break; //optimization
                }

                if (symbol >= numberInfo.StartIndex - 1 && symbol <= numberInfo.EndIndex)
                {
                    sum += numberInfo.Value;
                    numbers.Numbers.RemoveAt(i);
                    i--;
                    limit--;
                }
            }
        }
        return sum;
    }

    static LineContent GetLineContent(string line)
    {
        var lineContent = new LineContent();

        for (int i = 0; i < line.Length; i++)
        {
            char character = line[i];
            if(character.Equals('.'))
            {
                continue;
            }
            if(!Char.IsNumber(character))
            {
                lineContent.SymbolIndex.Add(i);
                continue;
            }
            if(char.IsNumber(character))
            {
                var numberString = "";
                do
                {
                    numberString += character;
                    try
                    {
                        character = line[i + numberString.Length];
                    }
                    catch (Exception)
                    {
                        character = '.';
                    }
                } while (char.IsNumber(character));

                var numberInfo = new NumberInfo() { Value = int.Parse(numberString), StartIndex = i, EndIndex = i + numberString.Length };
                lineContent.Numbers.Add(numberInfo);
                i = i + numberString.Length - 1;
                continue;
            }
        }

        return lineContent;
    }
}
}

part 2

using System;
using System.Collections.Generic;
using System.IO;

namespace day3
{
    class Program
    {
        class LineContent
        {
            public List<NumberInfo> Numbers = new List<NumberInfo>();
            public List<GearInfo> Gears = new List<GearInfo>();
        }

    struct NumberInfo
    {
        public int Value;
        public int StartIndex;
        public int EndIndex;
    }

    class GearInfo
    {
        public int index;
        public List<int> adjacentNumbers = new List<int>();
    }

    static void Main(string[] args)
    {
        using (var reader = new StreamReader("Input.txt"))
        {
            var line = reader.ReadLine();
            LineContent antePenultimate;
            LineContent penultimate = GetLineContent(line);
            UpdateGears(penultimate, penultimate);
            line = reader.ReadLine();
            LineContent last = GetLineContent(line);
            UpdateGears(penultimate, last);
            UpdateGears(last, penultimate);
            UpdateGears(last, last);

            line = reader.ReadLine();

            int sum = 0;

            while (line != null)
            {
                antePenultimate = penultimate;
                sum += ValidGearsValues(antePenultimate.Gears);
                penultimate = last;
                last = GetLineContent(line);

                UpdateGears(last, last);
                UpdateGears(last, penultimate);
                UpdateGears(penultimate, last);

                line = reader.ReadLine();
            }

            sum += ValidGearsValues(penultimate.Gears);
            sum += ValidGearsValues(last.Gears);

            Console.WriteLine(sum);
            Console.ReadKey();
        }
    }

    private static int ValidGearsValues(List<GearInfo> gears)
    {
        int sum = 0;
        foreach (var gear in gears)
        {
            if (gear.adjacentNumbers.Count == 2)
            {
                sum += gear.adjacentNumbers[0] * gear.adjacentNumbers[1];
            }
        }
        return sum;
    }

    static int UpdateGears(LineContent gears, LineContent numbers)
    {
        int sum = 0;
        foreach (var gear in gears.Gears)
        {
            var limit = numbers.Numbers.Count;
            for (int i = 0; i < limit; i++)
            {
                var numberInfo = numbers.Numbers[i];
                if (numberInfo.StartIndex > gear.index + 1)
                {
                    break; //optimization
                }

                if (gear.index >= numberInfo.StartIndex - 1 && gear.index <= numberInfo.EndIndex)
                {
                    gear.adjacentNumbers.Add(numberInfo.Value);
                }
            }
        }
        return sum;
    }

    static LineContent GetLineContent(string line)
    {
        var lineContent = new LineContent();

        for (int i = 0; i < line.Length; i++)
        {
            char character = line[i];
            if (character.Equals('.'))
            {
                continue;
            }
            if (character.Equals('*'))
            {
                lineContent.Gears.Add(new GearInfo() { index = i });
                continue;
            }
            if (!Char.IsNumber(character))
            {
                continue;
            }
            if (char.IsNumber(character))
            {
                var numberString = "";
                do
                {
                    numberString += character;
                    try
                    {
                        character = line[i + numberString.Length];
                    }
                    catch (Exception)
                    {
                        character = '.';
                    }
                } while (char.IsNumber(character));

                var numberInfo = new NumberInfo() { Value = int.Parse(numberString), StartIndex = i, EndIndex = i + numberString.Length };
                lineContent.Numbers.Add(numberInfo);
                i = i + numberString.Length - 1;
                continue;
            }
        }

        return lineContent;
    }
}
}

seguro se puede mejorar con recursividad

B

[Borrado] #111 3 Dic

Parte 1

spoiler

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

read_input_matrix(Acc) ->
  case io:get_line("") of
    eof -> Acc;
    Line -> read_input_matrix([string:strip(Line) | Acc])
  end.

get_neighbor_offsets() ->
  [{X, Y} || X <- lists:seq(-1, 1), Y <- lists:seq(-1, 1), X /= 0 orelse Y /= 0].

add_neighbor_list([], _, _, Acc) -> Acc;
add_neighbor_list([{RI, RJ} | T], I, J, Acc) ->
  add_neighbor_list(T, I, J, sets:add_element({I + RI, J + RJ}, Acc)).

add_neighbors_to_marked(I, J, Acc) ->
  Neighbors = get_neighbor_offsets(),
  add_neighbor_list(Neighbors, I, J, Acc).

is_digit(X) -> X >= $0 andalso X =< $9.

process_row_for_marked(_, _, [C], Acc) when C == $\n -> Acc;
process_row_for_marked(RowId, ColId, [Cell | T], Acc) ->
  case (Cell /= $. andalso not is_digit(Cell)) of
    true ->
      process_row_for_marked(
        RowId,
        ColId + 1,
        T,
        add_neighbors_to_marked(RowId, ColId, Acc)
      );
    _ -> process_row_for_marked(RowId, ColId + 1, T, Acc)
  end.

get_marked_indices(_, [], Acc) -> Acc;
get_marked_indices(RowId, [Row | T], Acc) ->
  get_marked_indices(RowId + 1, T, process_row_for_marked(RowId, 1, Row, Acc)).

add_if_needed(MustAdd, CurrentNumber, Acc) ->
  case MustAdd of
    true -> CurrentNumber + Acc;
    _ -> Acc
  end.

get_row_numbers_sum(_, _, [C], _, MustAdd, CurrentNumber, Acc) when C == $\n ->
  add_if_needed(MustAdd, CurrentNumber, Acc);
get_row_numbers_sum(RowId, ColId, [Cell | T], Marked, MustAdd, CurrentNumber, Acc) ->
  case is_digit(Cell) of
    true ->
      get_row_numbers_sum(
        RowId,
        ColId + 1,
        T,
        Marked,
        MustAdd or sets:is_element({RowId, ColId}, Marked),
        10 * CurrentNumber + Cell - $0,
        Acc);
    _ ->
      get_row_numbers_sum(
        RowId,
        ColId + 1,
        T,
        Marked,
        false,
        0,
        add_if_needed(MustAdd, CurrentNumber, Acc)
      )
  end.

get_marked_numbers_sum(_, [], _, Acc) -> Acc;
get_marked_numbers_sum(RowId, [Row | T], Marked, Acc) ->
  get_marked_numbers_sum(
    RowId + 1,
    T,
    Marked,
    get_row_numbers_sum(RowId, 1, Row, Marked, false, 0, Acc)
  ).

main() ->
  InputMatrix = lists:reverse(read_input_matrix([])),
  MarkedIndices = get_marked_indices(1, InputMatrix, sets:new()),
  Sum = get_marked_numbers_sum(1, InputMatrix, MarkedIndices, 0),
  Sum.


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

Parte 2, siempre se me olvida que si un numero en una lista mapea a una letra en ASCII erlang te lo enseña, la de tiempo que he perdido pensando que la había liado xD

spoiler

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

read_input_matrix(Acc) ->
  case io:get_line("") of
    eof -> Acc;
    Line -> read_input_matrix([string:strip(Line) | Acc])
  end.

get_neighbor_offsets() ->
  [{X, Y} || X <- lists:seq(-1, 1), Y <- lists:seq(-1, 1), X /= 0 orelse Y /= 0].

add_neighbor_list([], _, _, Acc) -> Acc;
add_neighbor_list([{RI, RJ} | T], I, J, Acc) ->
  Coords = {I + RI, J + RJ},
  CurrentSet = maps:get(Coords, Acc, sets:new()),
  NewSet = sets:add_element({I, J}, CurrentSet),
  add_neighbor_list(T, I, J, maps:put(Coords, NewSet, Acc)).

add_neighbors_to_marked(I, J, Acc) ->
  Neighbors = get_neighbor_offsets(),
  add_neighbor_list(Neighbors, I, J, Acc).

is_digit(X) -> X >= $0 andalso X =< $9.

process_row_for_marked(_, _, [C], Acc) when C == $\n -> Acc;
process_row_for_marked(RowId, ColId, [Cell | T], Acc) ->
  case (Cell == $*) of
    true ->
      process_row_for_marked(
        RowId,
        ColId + 1,
        T,
        add_neighbors_to_marked(RowId, ColId, Acc)
      );
    _ -> process_row_for_marked(RowId, ColId + 1, T, Acc)
  end.

get_marked_indices(_, [], Acc) -> Acc;
get_marked_indices(RowId, [Row | T], Acc) ->
  get_marked_indices(RowId + 1, T, process_row_for_marked(RowId, 1, Row, Acc)).

add_number_to_origins(_, [], _, Acc) -> Acc;
add_number_to_origins(CurrentNumber, [Origin | T], MarkedToOrigins, Acc) ->
  add_number_to_origins(
    CurrentNumber,
    T,
    MarkedToOrigins,
    maps:put(Origin, sets:add_element(CurrentNumber, maps:get(Origin, Acc, sets:new())), Acc)
  ).

add_origins_for_cell(I, J, Marked, Detected) ->
  sets:union(
    Detected,
    maps:get({I, J}, Marked, sets:new())
  ).

process_numbers_in_row(_, _, [C], MarkedToOrigin, DetectedOrigins, CurrentNumber, Acc)
  when C == $\n ->
    add_number_to_origins(CurrentNumber, sets:to_list(DetectedOrigins), MarkedToOrigin, Acc);
process_numbers_in_row(
  RowId,
  ColId,
  [Cell | T],
  MarkedToOrigin,
  DetectedOrigins,
  CurrentNumber,
  Acc) ->
    case is_digit(Cell) of
      true ->
        process_numbers_in_row(
          RowId, ColId + 1, T, MarkedToOrigin,
          add_origins_for_cell(RowId, ColId, MarkedToOrigin, DetectedOrigins),
          10 * CurrentNumber + Cell - $0,
          Acc
        );
      _ ->
        process_numbers_in_row(
          RowId, ColId + 1, T, MarkedToOrigin, sets:new(), 0,
          add_number_to_origins(CurrentNumber, sets:to_list(DetectedOrigins), MarkedToOrigin, Acc)
        )
    end.

process_row(_, [], _, Acc) -> Acc;
process_row(RowId, [Row | T], MarkedToOrigin, Acc) ->
  process_row(
    RowId + 1,
    T,
    MarkedToOrigin,
    process_numbers_in_row(RowId, 1, Row, MarkedToOrigin, sets:new(), 0, Acc)
  ).


get_asterisk_to_number_list(InputMatrix, MarkedToOrigin) ->
  process_row(1, InputMatrix, MarkedToOrigin, maps:new()).


compute_answer(AsteriskToNumberList) ->
  MapLists = lists:map(fun _(X) -> sets:to_list(X) end, maps:values(AsteriskToNumberList)),
  ListsWithTwo = lists:filter(fun _(X) -> length(X) == 2 end, MapLists),
  Products = lists:map(fun _([A, B]) -> A * B end, ListsWithTwo),
  lists:foldl(fun _(A, B) -> A + B end, 0, Products).

main() ->
  InputMatrix = lists:reverse(read_input_matrix([])),
  MarkedToOrigin = get_marked_indices(1, InputMatrix, maps:new()),
  AsteriskToNumberList = get_asterisk_to_number_list(InputMatrix, MarkedToOrigin),
  Answer = compute_answer(AsteriskToNumberList),
  Answer.

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

CiudadanoEj #112 3 Dic

spoiler

from collections import defaultdict
from functools import reduce
# # Part 1
with open('day 3\input.txt') as f:
    s = f.read().splitlines()
    

def check_adjacents(i, jlist, m, n):
    posible = False
    adjacent_indices = []
    for j in jlist: 
        if i > 0: # down
            adjacent_indices.append((i-1,j))
        if i + 1 < m: # top
            adjacent_indices.append((i+1,j))
        if j > 0: # left
            adjacent_indices.append((i,j-1))
        if j + 1 < n: # right
            adjacent_indices.append((i,j+1))
        if i > 0 and j > 0: # top-left
            adjacent_indices.append((i-1,j-1))
        if i > 0 and j+1 < n: # top-right
            adjacent_indices.append((i-1,j+1))
        if i + 1 < m and j > 0: # down-left
            adjacent_indices.append((i+1,j-1))
        if i + 1 < m and j+1 < n: # down-right
            adjacent_indices.append((i+1,j+1))
    for k, l in adjacent_indices:
        if s[k][l] != '.' and s[k][l] not in '0123456789':
            posible = True
            break
    return posible

r = 0
numbers = []
for i in range(0, len(s)):
    for j in range(0, len(s[i])):
        posible = False
        jlist = []
        num = ''
        if s[i][j].isdigit():
            while j < len(s[i]) and s[i][j] in '0123456789':
                num += s[i][j]
                jlist.append(j)
                s[i] = list(s[i])
                s[i][j] = '.'
                s[i] = "".join(s[i])
                j += 1
            posible = check_adjacents(i, jlist, len(s) - 1, len(s[i]) - 1)
        if posible:
            # numbers.append(num)
            # print(num)
            r += int(num)
# print(numbers)
print(r)
######## PART 2
with open('day 3\input.txt') as f:
    s2 = f.read().splitlines()
def multiply(x, y):
    return x * y
def check_adjacents2(i, jlist, m, n, num):
    posible = False
    adjacent_indices = []
    for j in jlist: 
        if i > 0: # down
            adjacent_indices.append((i-1,j))
        if i + 1 < m: # top
            adjacent_indices.append((i+1,j))
        if j > 0: # left
            adjacent_indices.append((i,j-1))
        if j + 1 < n: # right
            adjacent_indices.append((i,j+1))
        if i > 0 and j > 0: # top-left
            adjacent_indices.append((i-1,j-1))
        if i > 0 and j+1 < n: # top-right
            adjacent_indices.append((i-1,j+1))
        if i + 1 < m and j > 0: # down-left
            adjacent_indices.append((i+1,j-1))
        if i + 1 < m and j+1 < n: # down-right
            adjacent_indices.append((i+1,j+1))
    for k, l in adjacent_indices:
        if s2[k][l] == '*':
            cnts[(k, l)].append(int(num))
            break
r = 0
numbers = []
cnts = defaultdict(list)
for i in range(0, len(s2)):
    for j in range(0, len(s2[i])):
        posible = False
        jlist = []
        num = ''
        if s2[i][j].isdigit():
            while j < len(s2[i]) and s2[i][j] in '0123456789':
                num += s2[i][j]
                jlist.append(j)
                s2[i] = list(s2[i])
                s2[i][j] = '.'
                s2[i] = "".join(s2[i])
                j += 1
            check_adjacents2(i, jlist, len(s) - 1, len(s[i]) - 1, num)
for values in cnts.values():
    if len(values) > 1:
        r += reduce(multiply, values)
print(r)

day 3

Flashk #113 3 Dic

Hay gente que dice que los de regex de días anteriores eran un rollo, pero a mi me toca más las narices cuando tengo que andar mirando celdas adyacentes en arrays bidimensionales. XD

Al final me he creado una función auxiliar para ir usándola en futuros puzzles.

Día 3

Después de hacer un código superchapuza para salir del paso, me puse a ver como hacerlo mejor.

Hay algunos detalles interesantes que no te dicen en el enunciado del problema pero que uno se da cuenta si mira el input con cuidado:

Un número puede tener 0 o 1 símbolo adyacente, nunca más.
Un símbolo puede tener de 0 a 2 números adyacentes, nunca más (si se puede dar el caso, no he conseguido verlo en mi input).

En base a esto:

Se puede generar un listado con todos los símbolos y sus respectivos números adyacentes.
La solución a la parte 1 consiste en simplemente recorrer todos los símbolos y todos los números adyacentes existentes. Nunca vas a encontrar un solapamiento que provoque que sumes un número más de una vez gracias a la premisa que menciono más arriba.
La solución a la parte 2 sería igual que para la parte 1, pero filtrando únicamente los símbolos que sean gears, y en vez de sumando, multiplicando entre si los números de cada símbolo gear (y sumando todos los símbolos entre si).

Symbol

@EqualsAndHashCode
public class Symbol {

private static final char GEAR = '*';

private final char value;

@Getter
private final Vector2 pos;

private final List<Integer> adjacentPartNumbers = new ArrayList<>();

public Symbol(char value, Vector2 pos) {
    this.value = value;
    this.pos = pos;
}

public void addAdjacentPartNumber(int partNumber) {
    this.adjacentPartNumbers.add(partNumber);
}

public boolean isGear() {
    return value == GEAR;
}

public int sumPartNumbers() {
    return adjacentPartNumbers.stream().reduce(0, Integer::sum);
}

public int gearRatio() {
    if(isGear() && adjacentPartNumbers.size() == 2) {
        return adjacentPartNumbers.get(0) * adjacentPartNumbers.get(1);
    }

    return 0;
}

}

GearRatios

public class GearRatios {

private static final char EMPTY = '.';

// Initial data structure
private final int rows;
private final int cols;
private final char[][] engine;

// Calculated symbol information
private final List<Symbol> symbols = new ArrayList<>();
private final Map<Vector2, Symbol> symbolPositions = new HashMap<>();

public GearRatios(char[][] input) {

    engine = input;
    rows = engine.length;
    cols = engine[0].length;

    processGrid();

}

public int solveA() {
    return symbols.stream().map(Symbol::sumPartNumbers).reduce(0, Integer::sum);
}

public int solveB() {
    return symbols.stream().map(Symbol::gearRatio).reduce(0, Integer::sum);
}

private void processGrid() {
    for(int row = 0; row < rows; row++) {
        int col = 0;
        while(col < cols) {
            if(Character.isDigit(engine[row][col])) {
                col = processNumber(row, col);
            } else {
                col++;
            }
        }
    }
}

private int processNumber(int row, int col) {
    
    StringBuilder number = new StringBuilder();
    int currentCol = col;

    // Find number and symbol if present
    Optional<Symbol> symbol = Optional.empty();
    while(currentCol < cols && Character.isDigit(engine[row][currentCol])) {
        number.append(engine[row][currentCol]);

        if(symbol.isEmpty()) {
            symbol = findSymbol(row, currentCol);
        }

        currentCol++;
    }

    // If current number has a symbol, update data structures
    if(symbol.isPresent()) {
        int calculatedPartNumber = Integer.parseInt(number.toString());
        saveOrUpdateSymbol(symbol.get(), calculatedPartNumber);
    }

    return currentCol;

}

private void saveOrUpdateSymbol(Symbol symbol, int calculatedPartNumber) {
    Vector2 symbolPos = symbol.getPos();

    // Symbol has been previously added
    if(symbolPositions.containsKey(symbolPos)) {
        symbolPositions.get(symbolPos).addAdjacentPartNumber(calculatedPartNumber);
    } else {
        symbol.addAdjacentPartNumber(calculatedPartNumber);
        symbolPositions.put(symbolPos, symbol);
        symbols.add(symbol);
    }
}

private Optional<Symbol> findSymbol(int row, int col) {
    List<Vector2> adjacents = GridUtil.getAdjacentsIncludingDiagonals(engine, row, col);
    return adjacents.stream().filter(this::isSymbol).findFirst().map(this::createSymbol);
}

private boolean isSymbol(Vector2 pos) {
    char value = engine[pos.getY()][pos.getX()];
    return  !Character.isDigit(value) && value != EMPTY;
}

private Symbol createSymbol(Vector2 pos) {
    char value = engine[pos.getY()][pos.getX()];
    return new Symbol(value, pos);
}
}

Kike_Knoxvil #114 3 Dic

A mi se me está resistiendo muchísimo. Llevo desde las tres con la parte uno y aún no la he sacado

Cómo se nota que es domingo

1 respuesta

Frankicia #115 3 Dic

Day 3 - C++

spoiler

#include <algorithm>
#include <stdio.h>
#include <string>
#include <iostream>
#include <vector>

std::vector<std::string> get_nums(std::vector<std::string> &matrix, int row, int col) {

std::string left  = "";
std::string right = "";
int j = col - 1;
while(j >= 0                    && isdigit(matrix[row][j])) { left  = matrix[row][j] + left ; matrix[row][j--] = '.'; }
    j = col + 1;
while(j <  matrix[row].length() && isdigit(matrix[row][j])) { right = right + matrix[row][j]; matrix[row][j++] = '.'; }

std::vector<std::string> result;
if ( isdigit(matrix[row][col]) ) {
    result.push_back(left + matrix[row][col] + right);
} else {
    if (!left .empty()) result.push_back(left );
    if (!right.empty()) result.push_back(right);
}
matrix[row][col] = '.';

return result;

}

int solve(std::vector<std::string> &matrix, int row, int col) {

#ifdef SECOND_PART
    if (matrix[row][col] != '*') return 0;
#endif
std::vector<std::string> top = get_nums(matrix, row - 1, col);
std::vector<std::string> mid = get_nums(matrix, row    , col);
std::vector<std::string> bot = get_nums(matrix, row + 1, col);

#ifdef SECOND_PART
    if (top.size() + mid.size() + bot.size() != 2) return 0;
    int sum = 1;
    for(auto &i : top) sum *= stoi(i);
    for(auto &i : mid) sum *= stoi(i);
    for(auto &i : bot) sum *= stoi(i);
#else
    int sum = 0;
    for(auto &i : top) sum += stoi(i);
    for(auto &i : mid) sum += stoi(i);
    for(auto &i : bot) sum += stoi(i);
#endif
return sum;
}

int get_sum_from_symbols(std::vector<std::string> &matrix) {

int sum = 0;
for(int i = 0; i < matrix.size(); i++) {
    for(int j = 0; j < matrix[i].length(); ++j) {
        if (matrix[i][j] != '.' && !isdigit(matrix[i][j])) sum += solve(matrix, i, j);
    }
}

return sum;
}


int main(int argc, char * argv[]){

std::vector<std::string> matrix;

std::string line;
while (getline(std::cin, line)) {
    matrix.push_back(line);
}

int sum = get_sum_from_symbols(matrix);

std::cout << "Result: " << sum << std::endl;
return 0;
}

draz1c #116 3 Dic

#114 Yo me he rendido antes incluso de escribir una sola linea. No tenia claro como hacerlo en la cabeza como para ponerlo en código.

No soy programador.gif

2 respuestas

Kike_Knoxvil #117 3 Dic

#116 Lo gracioso es que yo voy a hacer un año ya de ingeniero de software y aunque sé como estructurarlo e incluso plantear varios enfoques, no se que puñetas está fallando en el código. Sí, sigo aún con ello aunque ya me lo estoy tomando con más calma porque llevo muchas horas

Zentakki #118 3 Dic Abe Sapien

Yo creia que lo tenia pero no me sale bien el resultado. Llevo media tarde dándole vueltas pero ahora no consigo ver el problema. La parte 1 me da 510582 pero se ve que es mas.

Lo he planteado de la siguiente manera:

busco símbolo
saco el index del símbolo en la fila
con ese índice, busco en la misma fila, la anterior y la siguiente, por números que estén en posiciones adjacentes

lo probé con el texto que ponen de ejemplo y me daba bien el resultado.

me da que el fallo está cuando es la primera o última linea, no se, lo intentaré de nuevo mañana.

1 respuesta

Mezdelex #119 3 Dic

#116

spoiler

Son 3 sistemas a implementar en esencia:

La iteración principal MxN (rows x columns), véase el típico doble for que te proporcione las i y las j. ¿Y qué referencia vas a buscar para iniciar el sistema principal? Pues en la parte 1 todo caracter que no sea ni un dígito ni un '.', es decir, cualquier caracter restante.
Una vez i y j apunten al caracter en cuestión, necesitas un segundo sistema que recorra los valores adyacentes, es decir,
x x x
x - x
x x x
Para eso necesitas otro doble for, pero esta vez con la limitación de una unidad, -1 0 1 rows y -1 0 1 columns. Al ser un sistema relativo, es decir, que depende de la posición por la que hayas entrado en él (i y j) tus valores de este segundo sistema tendrán que ser relativas a i y j, rollo tu 'x' irá en relación a tu 'i' (i - 1, i - 0, i + 1) y lo mismo para la 'y' y la 'j' y sus respectivas combinaciones. Ten en cuenta que el valor 0,0 (el símbolo del que vienes) no lo tienes que tener en cuenta.
Además de esto, necesitas un tercer sistema que cuando en el segundo, encuentres un dígito adyacente, se expanda horizontalmente (a través de la row, variando el índice de las columns) hacia la izquierda y la derecha, para formar el número en cuestión hasta que encuentre un valor que no sea dígito. ¿Problema de este sistema? Que puede expandirse sobre los valores por los que el segundo sistema pasará en la siguiente iteración en el caso de que nos hayamos expandido hacia la derecha para formar un número. Por ello, necesitas una especie de memoización que guarde qué valores has visitado ya para no volver a tenerlos en cuenta. Esto que parece complicado, realmente lo puedes conseguir mutando la matriz principal, en concreto, mutando los valores que acabas de añadir al número que estás expandiendo sustituyéndolos por '.', de tal forma que así, la propia condición del sistema 1 que sólo entrará cuando no sea ni dígito ni '.' (por lo que acabas de sustituir el número) actuará de caché.

A esto súmale el controlar que no te vayas de baretas por los límites de la matriz y movidas relacionadas con el lenguaje que uses si es que es muy estricto, pero en esencia esa es una de las aproximaciones.

2 respuestas

Kike_Knoxvil #120 3 Dic

#119 Un momento, una duda que puede ser lo que esté haciendo que no funcione el programa

spoiler

1 respuesta

Usuarios habituales

Tags