Advent of Code 2023: ChatGPT-4 turbo edition

Soltrac #61 1 Dic MV Wizard

La que estáis liando para el día 1.....por el 30 entonces q?

1 respuesta

Kike_Knoxvil #62 1 Dic

Putos solapamientos. No sabía que era lo que estaba pasando hasta que entré aquí

spoiler

C++

#include <iostream>
#include <cstdint>
#include <fstream>
#include <string>

int main(){
    std::string linea, copia;
    std::string digitos{""};
    uint64_t sumatorio{0};
    std::string numer[] = {"one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
    std::size_t encont;

std::ifstream entrada("input.txt");
while(std::getline(entrada, linea)){
    copia = linea;
    /********PARTE DOS*******************/
    for(int i = 0; i < 9; i++){
        encont = linea.find(numer[i]);
        while(encont!=std::string::npos){
            copia.replace(encont+1, 1, std::to_string(i+1));
            encont = linea.find(numer[i], encont+1);
        }
    }
    /***********************************/
    for(char n : copia){
        if(isdigit(n)){
            digitos += n;
            break;
        }
    }
    for(auto ch = copia.rbegin(); ch != copia.rend(); ch++){
        if(isdigit(*ch)){
            digitos += *ch;
            break;
        }
    }
    sumatorio += stoi(digitos);
    digitos="";
}
std::cout<<"Sumatorio total: "<<sumatorio<<"\n";
return 0;
}

DrakaN #63 1 Dic

Putavida leí mal el ejercicio y me he tirado una hora como un gilipollas preguntando que hacia mal sumando todos los pares, veo que solo es el inicial y el último...

Flashk #64 1 Dic

#61 por el 30 nada porque solo hay 25 xD

1

Mandarino #65 1 Dic

Ostras es verdad que hoy es 1 de diciembre. Hecho el 1ero y apuntado al leaderboard de mediavida!

Por cierto el año pasado en mi trabajo crearon un leaderboard también, y se instalaron esta extension de chrome que muestra mas estadisticas del leaderboard:

https://chromewebstore.google.com/detail/advent-of-code-charts/ipbomkmbokofodhhjpipflmdplipblbe

day1 python:

spoiler

maps = {
    "one": 1,
    "two": 2,
    "three": 3,
    "four": 4,
    "five": 5,
    "six": 6,
    "seven": 7,
    "eight": 8,
    "nine": 9,
}
ans = 0
part2 = True
with open("1.txt", "r") as f:
    for line in f:
        line = line.strip()
        digits = []
        for i, c in enumerate(line):
            if c.isdigit():
                digits.append(int(c))
            if part2:
                for s, x in maps.items():
                    if line[i:].startswith(s):
                        digits.append(x)
        ans += int(f"{digits[0]}{digits[-1]}")
print(ans)

2 2 respuestas

Bachoqueto #66 1 Dic

Yo por cambiar un poco lo he hecho con Powershell xD

spoiler

$InputTxT = Get-Content -Path ".\input.txt"
$ValorFinal = 0
$SumaTotal = 0
Foreach ($TxT in $InputTxT)
{
    $CharArrayTxT = $TxT.ToCharArray()
    $Continue = $true
    $Num = 0
    Foreach ($Char in $CharArrayTxT)
    {
        If($Char -match "^[\d\.]+$")
        {
            $Num += 1
            $ValorFinal = $Char
            $ValorFinal += $ValorFinal
        }
    }
    If($Num -eq 1)
    {
        $Continue = $false
    }

If($Continue)
{
    For ($i = 0; $i -lt $CharArrayTxT.Length; $i++)
    { 
        If($($CharArrayTxT[$i]) -match "^[\d\.]+$")
        {
            $ValorFinal = $($CharArrayTxT[$i])
            break
        }
    }

    For($i = $CharArrayTxT.Length - 1; $i -ge 0; $i--){
        If($($CharArrayTxT[$i]) -match "^[\d\.]+$")
        {
            $ValorFinal += $($CharArrayTxT[$i])
            break
        }
    }
}

$ValorFinal
$SumaTotal = $SumaTotal + $ValorFinal
}

$SumaTotal

Y en la parte 2 solo he cambiado esto al inicio:

spoiler

$InputTxT = Get-Content -Path ".\input.txt"
$TRUEInputTxT = @()
Foreach ($TxT in $InputTxT)
{
    $TRUEInputTxT += $TxT.Replace("one","one1one").Replace("two","two2two").Replace("three","three3three").Replace("four","four4four").Replace("five","five5five").Replace("six","six6six").Replace("seven","seven7seven").Replace("eight","eight8eight").Replace("nine","nine9nine")
}

Si, he sido muy cutre también con los replaces como ya habéis comentado varios xDDD

Mandarino #67 2 Dic

dia2:
mas tiempo parseando el input que otra cosa xd

desu #68 2 Dic

dia2:
es una lista de listas de k,v
>> mas tiempo parseando el input que otra cosa xd

1 respuesta

Mandarino #69 2 Dic

#68 me refiero a que la mayor parte de codigo es parsear el input porque lo demas es trivial , no que sea dificil parsearlo

eXtreM3 #70 2 Dic

Day2: 2x conseguidas.

Pizzelio #71 2 Dic

Cómo habéis parseado? A mí me ha costado más de lo que esperaba pero igual me pasé de bruto, seguramente había una forma mejor de procesar las líneas y dejarlas con un formato que fuera más manejable después para los cálculos.

spoiler

CiudadanoEj #72 2 Dic

sol 2: he tardado un monton en darme cuenta que estaba pillando mal el id estaba accediendo a la ultima posicion nada mas y solo me pillaba un numero y luego tmb he estado probando todo el rato con green > 12 hasta que me he dado cuenta despues de 20 min o asi

spoiler

# # Part 1
with open('day 2\input.txt') as f:
    s = f.read()
# s = """
# Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green
# Game 2: 1 blue, 2 green; 3 green, 4 blue, 1 red; 1 green, 1 blue
# Game 3: 8 green, 6 blue, 20 red; 5 blue, 4 red, 13 green; 5 green, 1 red
# Game 4: 1 green, 3 red, 6 blue; 3 green, 6 red; 3 green, 15 blue, 14 red
# Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green
# """
ids = 0
######### PART 1
for i in s.strip().split("\n"):
    id, g = i.split(":")
    id = int(id.split(" ")[1])
    # print(id)
    big = False
    blue, red, green = 0, 0, 0
    for y,l in enumerate(g):
        # print(g[y::])
        if g[y::].startswith('blue'):
            blue = int(g[y-3] + g[y-2])
        elif g[y::].startswith('red'):
            red = int(g[y-3] + g[y-2])
        elif g[y::].startswith('green'):
                green = int(g[y-3] + g[y-2])
        if red > 12 or green > 13 or blue > 14:
            big = True
            break
    if not big:
        ids += id
print(ids)
# #### ###Part 2
ids_2 = 0
for i in s.strip().split("\n"):
    id, g = i.split(":")
    id = int(id.split(" ")[1])
    big = False
    blue, red, green = 0, 0, 0
    for y,l in enumerate(g):
        if g[y::].startswith('blue'):
            if int(g[y-3] + g[y-2]) > blue:
                blue = int(g[y-3] + g[y-2])
        elif g[y::].startswith('red'):
            if int(g[y-3] + g[y-2]) > red:
                red = int(g[y-3] + g[y-2])
        elif g[y::].startswith('green'):
            if int(g[y-3] + g[y-2]) > green:
                green = int(g[y-3] + g[y-2])
    # print((red * green * blue))
    ids_2 += (red * green * blue)
print(ids_2)

Mezdelex #73 2 Dic

La parseada padre. Los tipos en Rust son una liada cuando aún no sabes cómo va el festejo.

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

use std::collections::HashMap;

use regex::Regex;

use crate::handler::Handler;

#[derive(Debug)]
pub struct Day02 {
    pub red: u32,
    pub green: u32,
    pub blue: u32,
}

impl Day02 {
    fn new(red: u32, green: u32, blue: u32) -> Self {
        Day02 { red, green, blue }
    }

fn process_input() -> Vec<Vec<HashMap<String, u32>>> {
    let handler = Handler::new("./src/Day02/input.txt");
    let processed_input = handler
        .handle_input()
        .unwrap()
        .lines()
        .map(|line| {
            let isolated_grabs = Regex::new(r"Game \d+: ")
                .unwrap()
                .split(line)
                .collect::<Vec<&str>>()[1];

            let vec_of_grabs: Vec<&str> =
                Regex::new("; ").unwrap().split(isolated_grabs).collect();

            let processed_line = vec_of_grabs
                .iter()
                .map(|grab| {
                    let values_and_keys: Vec<&str> =
                        Regex::new("[, ]+").unwrap().split(&grab).collect();
                    let mut grab_map: HashMap<String, u32> = HashMap::new();
                    values_and_keys.chunks(2).for_each(|chunk| {
                        grab_map.insert(chunk[1].to_string(), chunk[0].parse().unwrap());
                    });

                    grab_map
                })
                .collect();

            processed_line
        })
        .collect();

    processed_input
}

pub fn part1() -> usize {
    let max_values = Self::new(12, 13, 14);
    let input = Self::process_input();
    input
        .iter()
        .enumerate()
        .map(|(game, vec_of_grabs)| {
            match vec_of_grabs.iter().any(|grab| {
                grab.get("red").unwrap_or(&0) > &max_values.red
                    || grab.get("green").unwrap_or(&0) > &max_values.green
                    || grab.get("blue").unwrap_or(&0) > &max_values.blue
            }) {
                true => 0,
                false => game + 1,
            }
        })
        .sum()
}

pub fn part2() -> u32 {
    let input = Self::process_input();
    input
        .iter()
        .map(|vec_of_grabs| {
            let mut min_values = Self::new(1, 1, 1);
            vec_of_grabs.iter().for_each(|grab| {
                if let Some(&value) = grab.get("red") {
                    if value > min_values.red || min_values.red.eq(&1) {
                        min_values.red = value;
                    }
                }
                if let Some(&value) = grab.get("green") {
                    if value > min_values.green || min_values.green.eq(&1) {
                        min_values.green = value;
                    }
                }
                if let Some(&value) = grab.get("blue") {
                    if value > min_values.blue || min_values.blue.eq(&1) {
                        min_values.blue = value;
                    }
                }
            });

            min_values.red * min_values.green * min_values.blue
        })
        .sum()
}
}

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

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

1

Flashk #74 2 Dic

#65 mola mil la extensión por lo que muestras en la foto pero... instalo la extensión y nada pasa en mi Chrome ¿Hace falta hacer algo en particular?

Por mi parte día 2:

day 2

CubeConundrum

public class CubeConundrum {

private final List<Game> games;

public CubeConundrum(List<String> inputs) {
    games = inputs.stream().map(Game::new).toList();
}

public int solveA(int redCubes, int greenCubes, int blueCubes) {
    return games.stream()
            .filter(g -> g.getMaxRedCubes() <= redCubes)
            .filter(g -> g.getMaxGreenCubes() <= greenCubes)
            .filter(g -> g.getMaxBlueCubes() <= blueCubes)
            .map(Game::getId)
            .reduce(0, Integer::sum);
}

public int solveB() {
    return games.stream().map(Game::getPower).reduce(0, Integer::sum);
}
}

Game

@Getter
public class Game {

private static final Pattern PATTERN = Pattern.compile("Game (\\d+)");
private static final String TURN_DELIMITER = ";";

private final int id;
private final int maxRedCubes;
private final int maxGreenCubes;
private final int maxBlueCubes;
private final int power;

public Game(String input) {

    // Game id
    Matcher matcher = PATTERN.matcher(input);
    id = matcher.find() ? Integer.parseInt(matcher.group(1)) : 0;

    // Game turns
    String[] inputTurns = input.split(TURN_DELIMITER);
    List<GameTurn> turns = Arrays.stream(inputTurns).map(GameTurn::new).toList();

    // Game calculations
    maxRedCubes = turns.stream().map(GameTurn::getRedCubes).max(Integer::compareTo).orElse(0);
    maxGreenCubes = turns.stream().map(GameTurn::getGreenCubes).max(Integer::compareTo).orElse(0);
    maxBlueCubes = turns.stream().map(GameTurn::getBlueCubes).max(Integer::compareTo).orElse(0);
    power = maxRedCubes * maxGreenCubes * maxBlueCubes;

}

}

GameTurn

@Getter
public class GameTurn {

private static final Pattern RED_PATTERN = Pattern.compile("(\\d+) r");
private static final Pattern BLUE_PATTERN = Pattern.compile("(\\d+) b");
private static final Pattern GREEN_PATTERN = Pattern.compile("(\\d+) g");

private final int redCubes;
private final int greenCubes;
private final int blueCubes;

public GameTurn(String input) {

    // Red
    Matcher redMatcher = RED_PATTERN.matcher(input);
    redCubes = redMatcher.find() ? Integer.parseInt(redMatcher.group(1)) : 0;

    // Green
    Matcher greenMatcher = GREEN_PATTERN.matcher(input);
    greenCubes = greenMatcher.find() ? Integer.parseInt(greenMatcher.group(1)) : 0;

    // Blue
    Matcher blueMatcher = BLUE_PATTERN.matcher(input);
    blueCubes = blueMatcher.find() ? Integer.parseInt(blueMatcher.group(1)) : 0;

}
}

1 respuesta

gonya707 #75 2 Dic Moderador

Dia 2: Muy facilito, uno de esos que habiendo parseado a fondo el input en la primera parte la segunda ha sido añadir 5 lineas despues. El de ayer me dio mas por culo con los solapamientos

Frankicia #76 2 Dic

Dia2 C++

spoiler

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

#define BLUE_pos 0
#define RED_pos  1
#define GREEN_pos 2

int get_pos(std::string color) {
    if (color == "red"  ) return RED_pos;
    if (color == "blue" ) return BLUE_pos;
    if (color == "green") return GREEN_pos;

return 0;
}

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

// 12 red cubes, 13 green cubes, and 14 blue cubes
std::vector<int> current_balls = {14, 12, 13};

int sum = 0;
std::string line;
while (getline(std::cin, line)) {
    bool valid = true;
    std::replace( line.begin(), line.end(), ':', ' '); // Remove ':'
    std::replace( line.begin(), line.end(), ',', ' '); // Remove ','
    std::replace( line.begin(), line.end(), ';', ' '); // Remove ';'

    std::istringstream iss(line);
    std::string id;
    iss >> id >> id; // Game id

    int num_balls;
    std::string color;
    #ifdef SECOND_PART
        std::vector<int> max_balls = {0, 0, 0};
    #endif
    while(iss >> num_balls >> color) {
        std::cout << id << " " << num_balls << " " << color << std::endl;
        int color_pos = get_pos(color);
        #ifdef SECOND_PART
            valid = false;
            max_balls[color_pos] = std::max(max_balls[color_pos], num_balls);
        #endif
        if (num_balls > current_balls[get_pos(color)]) valid = false;
    }

    if (valid) sum += stoi(id);
    #ifdef SECOND_PART
        sum += max_balls[0] * max_balls[1] * max_balls[2];
    #endif
}

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

Mandarino #77 2 Dic

#74 Tienes que ir al leaderboard privado del equipo

NSFW

y luego haces scroll hacia abajo

1 respuesta

Flashk #78 2 Dic

#77 Gracias! pensaba que saldría arriba y no probé a hacer scroll hasta abajo del todo!

1 respuesta

Pizzelio #79 2 Dic

#78 ya somos dos xD

1

Flashk #80 2 Dic

Aporto otra extensión de Chrome interesante que encontré mientras instalaba la de #65

Advent of Code to Markdown

Para a lo que os guste volcar el texto de cada puzzle a un README.md para dejarlo en vuestros repositorios, esta extensión os permite generar el README.md automáticamente a partir del HTML.

Kike_Knoxvil #81 2 Dic

El de hoy me ha parecido más sencillote que el de ayer la verdad

C++ Dia 02

#include <iostream>
#include <cstdint>
#include <string>
#include <fstream>

using std::string;
using std::cout;

bool bajoLimites(string lin, string colorBuscado, uint8_t maximo){
    std::size_t encont;
    string digitos;

encont = lin.find(colorBuscado);
while(encont!=string::npos){
    digitos = "";
    if(isdigit(lin[encont-4])) digitos += lin[encont-4];
    if(isdigit(lin[encont-3])) digitos += lin[encont-3];
    digitos += lin[encont-2];
    if(stoi(digitos)>maximo) return false;
    encont = lin.find(colorBuscado,encont+1);
}

return true;
}

uint8_t max(string lin,string color){
    uint8_t maximo{0};
    std::size_t encont;
    string digitos;

encont = lin.find(color);
while(encont!=string::npos){
    digitos = "";
    if(isdigit(lin[encont-4])) digitos += lin[encont-4];
    if(isdigit(lin[encont-3])) digitos += lin[encont-3];
    digitos += lin[encont-2];

    if(stoi(digitos)>maximo) maximo = stoi(digitos);
    encont = lin.find(color,encont+1);
}
return maximo; 
}

int main(){
    string linea;
    uint32_t potencias{0};
    uint8_t rojo{0};
    uint8_t verde{0};
    uint8_t azul{0};
    uint32_t validos{0};
    uint8_t i{1};
    bool flgRed{false};
    bool flgGre{false};
    bool flgBlu{false};

const uint8_t M_RED{12};
const uint8_t M_GRE{13};
const uint8_t M_BLU{14};

std::ifstream entrada("input.txt");
while(std::getline(entrada, linea)){
    rojo = 0;
    verde = 0;
    azul = 0;
    flgRed = false;
    flgGre = false;
    flgBlu = false;

    flgRed = bajoLimites(linea,"red",M_RED);
    if(flgRed) flgGre = bajoLimites(linea,"green",M_GRE);
    if(flgRed && flgGre) flgBlu = bajoLimites(linea,"blue",M_BLU);
    if(flgBlu && flgGre && flgRed) validos += i;
    i++;
    rojo = max(linea,"red");
    if(0 < rojo) verde = max(linea,"green");
    if(0 < rojo && 0 < verde) azul = max(linea,"blue");
    potencias += rojo * verde * azul;
}

cout<<"Sumatorio de juegos validos: " <<validos<<"\n";
cout<<"Sumatorio de potencias: " <<potencias<<"\n";
return 0;
}

B

[Borrado] #82 2 Dic

Acabo de llegar a casa, vamos a darle al parsent of code

Dia 2 parte 1, a esta gente les patrocina alguna startup de crawlers o algo? que fijación con el parsing xD

spoiler

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

get_game_map([], Acc) -> Acc;
get_game_map([NumColor | T], Acc) ->
  [BinaryNum, Color] = string:split(NumColor, " ", all),
  Num = list_to_integer(binary_to_list(BinaryNum)),
  get_game_map(T, maps:put(binary_to_list(Color), Num, Acc)).

% only 12 red cubes, 13 green cubes, and 14 blue cubes?
color_limits() -> #{"red" => 12, "green" => 13, "blue" => 14}.

valid(Game) ->
  ColorLimits = color_limits(),
  GameCount = get_game_map(string:split(Game, ", ", all), maps:new()),
  lists:all(
    fun _(Key) -> maps:get(Key, GameCount, 0) =< maps:get(Key, ColorLimits) end,
    ["red", "green", "blue"]
  ).

process_game(GameId, GameList) ->
  ListOfGames = string:split(GameList, "; ", all),
  AllGamesAreFine =
    lists:all(
      fun _(X) -> valid(X) end,
      ListOfGames
    ),
  case AllGamesAreFine of
    true -> GameId;
    _ -> 0
  end.

main(Accm) ->
  case io:get_line("") of
    eof -> Accm;
    Line ->
      {_, [GameId, GameList]} = re:run(Line, "Game (\\d+): (.*)", [{capture, all_but_first, binary}]),
      main(Accm + process_game(list_to_integer(binary_to_list(GameId)), GameList))
  end.

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

Parte 2

spoiler

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

get_game_map([], Acc) -> Acc;
get_game_map([NumColor | T], Acc) ->
  [BinaryNum, Color] = string:split(NumColor, " ", all),
  Num = list_to_integer(binary_to_list(BinaryNum)),
  get_game_map(T, maps:put(binary_to_list(Color), Num, Acc)).

maximap([], _, _, Acc) -> Acc;
maximap([Key | T], A, B, Acc) ->
  M = maps:put(
      Key,
      erlang:max(maps:get(Key, A, 0), maps:get(Key, B, 0)),
      Acc
    ),
  maximap(T, A, B, M).

mapmaxi(A, B) ->
  maximap(["red", "green", "blue"], A, B, maps:new()).

process_game(GameList) ->
  ListOfGames = string:split(GameList, "; ", all),
  MaxiMap =
    lists:foldl(
      fun _(A, B) -> mapmaxi(A, B) end,
      maps:new(),
      lists:map(
        fun _(X) -> get_game_map(string:split(X, ", ", all), maps:new()) end,
        ListOfGames
      )
    ),
  lists:foldl(
    fun _(A, B) -> A * B end,
    1,
    maps:values(MaxiMap)
  ).

main(Accm) ->
  case io:get_line("") of
    eof -> Accm;
    Line ->
      {_, [_, GameList]} = re:run(Line, "Game (\\d+): (.*)", [{capture, all_but_first, binary}]),
      main(Accm + process_game(GameList))
  end.

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

2

byJoTaeFe #83 2 Dic Diamond hands

Me uno también a esta vaina, los haré en JS ya que es lo que estoy estudiando ahora mismo

JS - Dia 01

/* --- Day 1: Trebuchet?! --- */

const text = `PUZZLE INPUT`

/* --- Part One --- */

const textToArray1 = text.split("\n")
let sum1 = 0

for (let i = 0; i < textToArray1.length; i++) {

const row = textToArray1[i].split("")

let firstNum = row.find(num => /\d/.test(num))
let secondNum = row.reverse().find(num => /\d/.test(num))

let twoDigit = 0
twoDigit = parseInt(`${firstNum}${secondNum}`, 10)

sum1 += twoDigit
}

console.log(sum1)


/* --- Part Two --- */

const formatText = text.replace(/one/g, "one1one").replace(/two/g, "two2two").replace(/three/g, "three3three")
    .replace(/four/g, "four4four").replace(/five/g, "five5five").replace(/six/g, "six6six")
    .replace(/seven/g, "seven7seven").replace(/eight/g, "eight8eight").replace(/nine/g, "nine9nine");

const textToArray2 = formatText.split("\n")
let sum2 = 0

for (let i = 0; i < textToArray2.length; i++) {

const row = textToArray2[i].split("")

let firstNum = row.find(num => /\d/.test(num))
let secondNum = row.reverse().find(num => /\d/.test(num))

let twoDigit = 0
twoDigit = parseInt(`${firstNum}${secondNum}`, 10)

sum2 += twoDigit
}

console.log(sum2)

En la 2ª parte no sabia qué pasaba hasta que os he leído con lo de los solapamientos, y he usado el formato de algunos de vosotros

JS - Dia 02

/* --- Day 2: Cube Conundrum--- */

const text = `PUZZLE INPUT`

/* --- Part One --- */

const textToArray1 = text.split("\n")
let sum1 = 0

for (let i = 0; i < textToArray1.length; i++) {

let game = { id: 0, red: 0, green: 0, blue: 0 }

game.id = textToArray1[i].match(/Game\s(\d+):/)[1]

textToArray1[i].match(/\d+\sred/g).map(num => {
    const color = parseInt(num.match(/\d+/g))
    if (color >= game.red) game.red = color
})

textToArray1[i].match(/\d+\sgreen/g).map(num => {
    const color = parseInt(num.match(/\d+/g))
    if (color >= game.green) game.green = color
})

textToArray1[i].match(/\d+\sblue/g).map(num => {
    const color = parseInt(num.match(/\d+/g))
    if (color >= game.blue) game.blue = color
})

if (game.red <= 12 && game.green <= 13 && game.blue <= 14) {
    sum1 += parseInt(game.id)
}
}

console.log(sum1)


/* --- Part Two --- */

const textToArray2 = text.split("\n")
let sum2 = 0

for (let i = 0; i < textToArray2.length; i++) {

let game = { id: 0, red: 0, green: 0, blue: 0 }

game.id = textToArray2[i].match(/Game\s(\d+):/)[1]

textToArray2[i].match(/\d+\sred/g).map(num => {
    const color = parseInt(num.match(/\d+/g))
    if (color >= game.red) game.red = color
})

textToArray2[i].match(/\d+\sgreen/g).map(num => {
    const color = parseInt(num.match(/\d+/g))
    if (color >= game.green) game.green = color
})

textToArray2[i].match(/\d+\sblue/g).map(num => {
    const color = parseInt(num.match(/\d+/g))
    if (color >= game.blue) game.blue = color
})

sum2 += game.red * game.blue * game.green
}

console.log(sum2)

Kike_Knoxvil #84 3 Dic

Dejo el del día uno con la versión de MATLAB porque me aburría esperando a que descargase un juego

MATLAB Dia 01

%% AdventOfCode 2023 - Dia 01

archivo = fopen("input.txt",'r');
datos = textscan(archivo,'%s');
datos = datos{1,1};

%% Primer caso
primer = char(datos);
longPrimer = length(primer);
izq = num2str(zeros(length(primer),1));
der = num2str(zeros(length(primer),1));
for n = 1:longPrimer
    linea = primer(n,:);
    longLinea = length(linea);
    for d = 1:longLinea
        if isstrprop(linea(d),"digit")
            izq(n)=linea(d);
            break
        end
    end
    for d = longLinea:-1:1
        if isstrprop(linea(d),"digit")
            der(n)=linea(d);
            break
        end
    end
end
digitosChar = strcat(izq,der);
digitos = str2num(digitosChar);

total = sum(digitos)

%% Segundo caso
primer = char(datos);
longPrimer = length(primer);
izq = num2str(zeros(length(primer),1));
der = num2str(zeros(length(primer),1));
mapa = containers.Map({'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'}, {'1', '2', '3', '4', '5', '6', '7', '8', '9'});
keys = mapa.keys;
for n = 1:longPrimer
    linea = primer(n,:);
    copia = linea;
    longLinea = length(linea);
    for i = 1:length(keys)
        key = keys{i};
        idx = strfind(linea, key);
        if ~isempty(idx)
            for j = 1:length(idx)
                copia(idx(j)) = mapa(key);
            end
        end
    end
    for d = 1:longLinea
        if isstrprop(copia(d),"digit")
            izq(n)=copia(d);
            break
        end
    end
    for d = longLinea:-1:1
        if isstrprop(copia(d),"digit")
            der(n)=copia(d);
            break
        end
    end
end
digitosChar = strcat(izq,der);
digitos = str2num(digitosChar);

total2 = sum(digitos)

Estoy pensando en subir estos códigos al GitHub, pero no sé si hacerlo ahora o esperar a que pase la competición tras pegarles una limpieza y dejarlos más bonitos

1 respuesta

B

[Borrado] #85 3 Dic

#84 nadie te va a juzgar por subir bodrios a github, github sin bodrios no seria rentable tan solo

2

R

RsTTa #86 3 Dic

Va va otro año mas, regexs desde el dia 1 xD
Dejo por aqui codigo en Python

Dia 1 parte 1 (forzando el oneliner)

spoiler

if __name__ == '__main__':
    with open('in.txt') as fp:
        print(sum(
            int(''.join((
                next(c for c in line if c.isdigit()),
                next(c for c in line[::-1] if c.isdigit())
                )))
                for line in fp.readlines()
        ))

Dia 2 parte 2

spoiler

import re

d = {
    'one': '1',
    'two': '2',
    'three': '3',
    'four': '4',
    'five': '5',
    'six': '6',
    'seven': '7',
    'eight': '8',
    'nine': '9',
    'one'[::-1]: '1',
    'two'[::-1]: '2',
    'three'[::-1]: '3',
    'four'[::-1]: '4',
    'five'[::-1]: '5',
    'six'[::-1]: '6',
    'seven'[::-1]: '7',
    'eight'[::-1]: '8',
    'nine'[::-1]: '9'
}

r = re.compile('|'.join((*d, *d.values())))

if __name__ == '__main__':
    total = 0
    with open('in.txt') as fp:
        for line in fp.readlines():
            n1 = r.search(line).group()
            n2 = r.search(line[::-1]).group()
            total += int(d.get(n1, n1) + d.get(n2, n2))
    print(total)

Dia 2 parte 1 (complicando la regex para poder tirar de oneliner xD)

spoiler

import re

gameid_re = re.compile('(?<=^Game )[0-9]+')
cubes_re = re.compile('(?:(?:(?:1[3-9])|(?:[2-9][0-9]+)) red)|(?:(?:(?:1[4-9])|(?:[2-9][0-9]+)) green)|(?:(?:(?:1[5-9])|(?:[2-9][0-9]+)) blue)')

if __name__ == '__main__':
    with open('in.txt') as fp:
        print(sum(int(gameid_re.search(line).group()) for line in fp.readlines() if not cubes_re.search(line)))

Dia 2 parte 2

spoiler

import re
import functools

LIMITS = {'red': 12, 'green': 13 , 'blue': 14}

gameid_re = re.compile('(?<=^Game )[0-9]+')
cubes_re = re.compile('([0-9]+) (' + '|'.join(LIMITS) + ')')

if __name__ == '__main__':
    ans = 0
    with open('in.txt') as fp:
        for line in fp.readlines():
            color_to_mxcount = dict(sorted({(t[1], int(t[0])) for t in cubes_re.findall(line)}))
            ans += functools.reduce(lambda acc, curr: acc * curr, color_to_mxcount.values())
    print(ans)

1

Mandarino #87 3 Dic

Dia 3
El problema me ha gustado mas que el de los 2 dias anteriores

spoiler

Pizzelio #88 3 Dic

A mí también me ha gustado bastante y me lo esperaba más cabroncete después de leer el enunciado. Quizá tuve suerte con el input pero no había apenas casos límite que tener en cuenta, lástima no haberlo mirado antes y hacerlo como si los hubiera jajaja.

Lo que tengo que ver es como hacer mejor este tipo de ejercicios porque siempre monto unos pifostios para mirar índices, filas y demás que tela...

CiudadanoEj #89 3 Dic

a ver si alguien puede echarme un cable porque no consigo ver el error xD
con el codigo muestra me da bien y yo debugando me coge los numeros correctos pero el resultado final no me da

spoiler

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, l in enumerate(s):
    for j, symbol in enumerate(l):
        posible = False
        jlist = []
        num = ''
        if s[i][j].isdigit():
            while s[i][j].isdigit() and j < len(l) - 1:
                num += s[i][j]
                jlist.append(j)
                l = list(l)
                l[j] = '.'
                l = "".join(l)
                s[i] = l
                j += 1
            posible = check_adjacents(i, jlist, len(s) - 1, len(l) - 1)
        if posible:
            numbers.append(num)
            print(num)
            r += int(num)
print(numbers)
print(r)

1 respuesta

desu #90 3 Dic

3 pt 1

1 respuesta

Usuarios habituales

Tags