Advent of Code 2023: ChatGPT-4 turbo edition

B

[Borrado] #121 Dic '23

#122 No, los dígitos no actúan como símbolo que tengas que contar, sólo aquel que no sea '.' ni dígito. Fíjate bien en el enunciado.

1 respuesta

Kike_Knoxvil #122 Dic '23

#121

spoiler

1 respuesta

CiudadanoEj #123 Dic '23

#118 echale un ojo a lo que me ha puesto aqui #91 porque quiza te pasaba lo mismo que a mi

Mandarino #124 Dic '23

Para los que les cueste el 3, quizás os resulte mas intuitiva mi forma:

NSFW

Frankicia #125 Dic '23

#122 el 4 no cuenta como simbolo. Ni ningun numero.

Ten en cuenta que las diagonales cuentan como adjacentes

. . 3
. & .
2 . .

Daria 5 como resultado

Pega el codigo y miramos que pasa

1 respuesta

Kike_Knoxvil #126 Dic '23

#125

spoiler

Voy a intentar un rato más por mi cuenta y si no puedo ya pego el código

R

RsTTa #127 Dic '23

Bastante feo me ha quedado el codigo de hoy, no me escondo xD

Una explicacion de lo que hago, que se entedera mejor que el codigo de primeras

spoiler

Dia 3 Parte 1

spoiler

def search_num_idxs(m):
    for i in range(len(m)):
        j = 0
        while j < len(m[i]):
            if '0' <= m[i][j] <= '9':
                num = 0
                prev_j = j
                while (j < len(m[i])) and ('0' <= m[i][j] <= '9'):
                    num = (num * 10) + int(m[i][j])
                    j += 1
                yield (i, prev_j, j - 1, num)
            j += 1


def check_neighs(m, row, start_col, end_col):
    range_start = max(start_col - 1, 0)
    range_end = min(end_col + 2, len(m[row]))
    

if (m[row][range_start] != '.') and (m[row][range_start] < '0' or m[row][range_start] > '9'):
    return True
if (m[row][range_end - 1] != '.') and (m[row][range_end - 1] < '0' or m[row][range_end - 1] > '9'):
    return True
    
if row > 0:
    i = row - 1
    for j in range(range_start, range_end):
        if (m[i][j] != '.') and (m[i][j] < '0' or m[i][j] > '9'):
            return True
if (row + 1) < len(m):
    i = row + 1
    for j in range(range_start, range_end):
        if (m[i][j] != '.') and (m[i][j] < '0' or m[i][j] > '9'):
            return True
return False


if __name__ == '__main__':
    with open('in.txt') as fp:
        m = [list(l.strip()) for l in fp.readlines()]
        

print(sum(
    num
    for row, start_col, end_col, num in search_num_idxs(m)
    if check_neighs(m, row, start_col, end_col)
))

Dia 3 Parte 2

spoiler

from collections import defaultdict


def search_num_idxs(m):
    for i in range(len(m)):
        j = 0
        while j < len(m[i]):
            if '0' <= m[i][j] <= '9':
                num = 0
                prev_j = j
                while (j < len(m[i])) and ('0' <= m[i][j] <= '9'):
                    num = (num * 10) + int(m[i][j])
                    j += 1
                yield (i, prev_j, j - 1, num)
            j += 1


def check_neighs(m, row, start_col, end_col):
    range_start = max(start_col - 1, 0)
    range_end = min(end_col + 2, len(m[row]))
    

idxs = set()

if m[row][range_start] == '*':
    idxs.add((row, range_start))
if m[row][range_end - 1] == '*':
    idxs.add((row, range_end - 1))
    
if row > 0:
    i = row - 1
    for j in range(range_start, range_end):
        if m[i][j] == '*':
            idxs.add((i, j))
if (row + 1) < len(m):
    i = row + 1
    for j in range(range_start, range_end):
        if m[i][j] == '*':
            idxs.add((i, j))
return idxs


if __name__ == '__main__':
    with open('in.txt') as fp:
        m = [list(l.strip()) for l in fp.readlines()]
    

gear_to_adjs = defaultdict(list)
for row, start_col, end_col, num in search_num_idxs(m):
    idxs = check_neighs(m, row, start_col, end_col)
    for t in idxs:
        gear_to_adjs[t].append(num)

print(sum((l[0] * l[1]) for l in gear_to_adjs.values() if len(l) == 2))

Nah, el foro formatea el codigo como quiere, no mantiene la indentacion xD

Kike_Knoxvil #128 Dic '23

Pues me he rendido. No sé por qué pero me está contando 1443 más de lo que debería ser mi solución y no encuentro donde falla. Sé que está contando números que no son pero no he encontrado ni cuales ni donde (tengo que mirar mañana con calma un archivo que tengo donde volqué todos los dígitos, la linea en la que está y las posiciones en x del rectangulo a analizar)
Si un alma caritativa y por aburrimiento quiere comprobar a ver que pasa es más que bienvenido:

C++

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

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

int main(){
    string superior{""}, medio{""},inferior,digitos;
    uint8_t idx{0},cola{0},st{0},fn{0};
    uint32_t sumatorio{0};
    bool flgSp{false},flgMd{false},flgIn{false};


std::ifstream entrada("input.txt");
//std::ofstream sal("output.txt");
//int t = -1;
while(std::getline(entrada, inferior)){
    //t++;
    if(""==medio){
        superior = medio;
        medio = inferior;
        continue;
    }
    for(idx = 0; 140 > idx; idx++){
        if(!isdigit(medio[idx])) continue;
        cola = idx;
        digitos="";
        while(isdigit(medio[cola])){
            digitos.push_back(medio[cola]);
            cola++;
        }
        0 >= idx ? st = 0 : st = idx-1;
        140 <= cola ? fn = 140 : fn = cola;

        for(uint8_t n = st; n<=fn; n++){
            ""==superior ? flgSp = false : flgSp = !isdigit(superior[n]) && '.' != superior[n];
            flgMd = !isdigit(medio[n]) && '.' != medio[n];
            flgIn = !isdigit(inferior[n]) && '.' != inferior[n];
            if(flgIn || flgMd || flgSp){
                sumatorio += stoi(digitos);
                //sal <<"Fila "<<t<<": "<<stoi(digitos)<<" / st: "<<int(st)<<" / fn: "<<int(fn)<<"\n";
                break;
            }
        }
        idx = cola;
    }
    superior = medio;
    medio = inferior;
}
cout<<sumatorio<<"\n";
//t++;
for(idx = 0; 140 > idx; idx++){
    if(!isdigit(medio[idx])) continue;
    cola = idx;
    digitos="";
    while(isdigit(medio[cola])){
        digitos.push_back(medio[cola]);
        cola++;
    }
    0 >= idx ? st = 0 : st = idx-1;
    140 <= cola ? fn = 140 : fn = cola;

    for(uint8_t n = st; n<=fn; n++){
        flgSp = !isdigit(superior[n]) && '.' != superior[n];
        flgMd = !isdigit(medio[n]) && '.' != medio[n];
        flgIn = false;
        if(flgIn || flgMd || flgSp){
            sumatorio += stoi(digitos);
            //sal <<"Fila "<<t<<": "<<stoi(digitos)<<"\n";
            break;
        }
    }
    idx = cola;
}
cout<<"Sumatorio de digitos: "<<sumatorio<<"\n";
return 0;
}

1 respuesta

Mandarino #129 Dic '23

.

Frankicia #130 Dic '23

#128 Te esta contando unos cuantos mas de mas.

Tienes errores en los limites:

        st = (idx > 0) ? idx -1 : 0;
        fn = (cola > 139) ? 139 : cola;

Luego cuestion de estilo, pero creo que ayudan a este lio:

0 >= idx ? st = 0 : st = idx-1;
for(idx = 0; 140 > idx; idx++){ 
""==superior ? flgSp = false : flgSp = !isdigit(superior[n]) && '.' != superior[n];

Es la primera vez que veo esto en C++

Also, usa built-ins para saber los limites.

1 respuesta

Zentakki #131 Dic '23 Abe Sapien

#119 He empezado hoy de cero el dia 3 siguiendo un poco esto que has puesto. He conseguido pasar la primera parte, ahora con la segunda

dejo mi código, no tiene mucho comentario e igual es demasiado enrevesado, pero funciona xD

Dia 3 parte 1 en python

with open("./day3puzzle.txt", "r") as file:
    text = file.read()

# test = """467..114..
# ...*......
# ..35..633.
# ......#...
# 617*......
# .....+.58.
# ..592.....
# ......755.
# ...$.*....
# .664.598.."""


def build_matrix(text: str) -> list:
    lines = text.split("\n")
    matrix = []
    for line in lines:
        charlist = [char for char in line]
        matrix.append(charlist)
    return matrix


def find_symbols_coord(matrix):
    for i in range(0, len(matrix)):
        for j in range(0, len(matrix[i])):
            if not matrix[i][j].isdigit() and matrix[i][j] != ".":
                yield (i, j)


def build_search_coord(i, j: tuple) -> list:
    return [
        (i - 1, j - 1),  # top left
        (i - 1, j),  # top center
        (i - 1, j + 1),  # top right
        (i, j - 1),  # left
        (i, j + 1),  # right
        (i + 1, j - 1),  # bottom left
        (i + 1, j),  # bottom center
        (i + 1, j + 1),  # bottom right
    ]


def find_numbers(m, i, j):
    """finds if m[i][j] is a number and returns the full number with coordinates for whole number"""
    # pass if out of bounds
    if i < 0 or i > len(m) - 1:  # rows oob
        pass
    elif j < 0 or j > len(m[i]) - 1:  # cols oob
        pass
    else:
        if m[i][j].isdigit():
            return find_whole_number(m=m, i=i, j=j)


def find_whole_number(m, i, j):
    number = []
    coordinates_to_clear = []
    for col in range(j, -1, -1):
        if m[i][col].isdigit():
            number.insert(0, m[i][col])
            coordinates_to_clear.append((i, col))
        else:
            break
    try:
        for _ in range(j + 1, len(m[i])):
            if m[i][_].isdigit():
                number.append(m[i][_])
                coordinates_to_clear.append((i, _))
            else:
                break
    except IndexError:
        return "".join(number), coordinates_to_clear

return "".join(number), coordinates_to_clear


m = build_matrix(text=text)
sym_coord = find_symbols_coord(m)
engine_nums = []

for sc in sym_coord:
    search_coord = build_search_coord(*sc)
    for c in search_coord:
        try:
            whole_number = find_numbers(m=m, i=c[0], j=c[1])[0]
            clear_whole_num_list = find_numbers(m=m, i=c[0], j=c[1])[1]
            engine_nums.append(int(whole_number))
            for r, c in clear_whole_num_list:
                m[r][c] = "."
        except TypeError:
            continue

print(sum(engine_nums))

Edit: compleatada parte 2, me ha resultado fácil, es el mismo código que mi anterior spoiler, con unas modificaciones al final para sacar el gear_ratio también

dia 3 con parte 2

with open("./day3puzzle.txt", "r") as file:
    text = file.read()

test = """467..114..
...*......
..35..633.
......#...
617*......
.....+.58.
..592.....
......755.
...$.*....
.664.598.."""


def build_matrix(text: str) -> list:
    lines = text.split("\n")
    matrix = []
    for line in lines:
        charlist = [char for char in line]
        matrix.append(charlist)
    return matrix


def find_symbols_coord(matrix):
    for i in range(0, len(matrix)):
        for j in range(0, len(matrix[i])):
            if not matrix[i][j].isdigit() and matrix[i][j] != ".":
                yield (i, j)


def build_search_coord(i, j: tuple) -> list:
    return [
        (i - 1, j - 1),  # top left
        (i - 1, j),  # top center
        (i - 1, j + 1),  # top right
        (i, j - 1),  # left
        (i, j + 1),  # right
        (i + 1, j - 1),  # bottom left
        (i + 1, j),  # bottom center
        (i + 1, j + 1),  # bottom right
    ]


def find_numbers(m, i, j):
    """finds if m[i][j] is a number and returns the full number with coordinates for whole number"""
    # pass if out of bounds
    if i < 0 or i > len(m) - 1:  # rows oob
        pass
    elif j < 0 or j > len(m[i]) - 1:  # cols oob
        pass
    else:
        if m[i][j].isdigit():
            return find_whole_number(m=m, i=i, j=j)


def find_whole_number(m, i, j):
    number = []
    coordinates_to_clear = []
    for col in range(j, -1, -1):
        if m[i][col].isdigit():
            number.insert(0, m[i][col])
            coordinates_to_clear.append((i, col))
        else:
            break
    try:
        for _ in range(j + 1, len(m[i])):
            if m[i][_].isdigit():
                number.append(m[i][_])
                coordinates_to_clear.append((i, _))
            else:
                break
    except IndexError:
        return "".join(number), coordinates_to_clear

return "".join(number), coordinates_to_clear


m = build_matrix(text=text)
sym_coord = find_symbols_coord(m)
engine_nums = []
gear_ratio = []

for sc in sym_coord:
    search_coord = build_search_coord(*sc)
    engine_nums_before = len(engine_nums)
    for c in search_coord:
        try:
            whole_number = find_numbers(m=m, i=c[0], j=c[1])[0]
            clear_whole_num_list = find_numbers(m=m, i=c[0], j=c[1])[1]
            engine_nums.append(int(whole_number))
            for r, c in clear_whole_num_list:
                m[r][c] = "."
        except TypeError:
            continue
    engine_nums_after = len(engine_nums)
    if (m[sc[0]][sc[1]] == "*") and (engine_nums_after - engine_nums_before == 2):
        gear_ratio.append(engine_nums[-2] * engine_nums[-1])

print(sum(engine_nums))
print(sum(gear_ratio))

1

Zh3RoX #132 Dic '23

Que desentrenado estoy, me sacan de alinear divs y me cago encima.

B

[Borrado] #133 Dic '23

Dia 4 parte 2, la parte 1 cambiando un poco el codigo y sumando las potencias de 2 del intersect te sale.

El parsing es honestamente muy ad-hoc y guarro, he estado por preprocesarlo con algo en python, y no descarto hacerlo si sigue siendo igual de suplicio.

spoiler

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

process_line(Line) ->
  [_, CardInfo] = string:split(string:replace(Line, "  ", " ", all), ":"),
  [Winning, Rest] =
    lists:map(
      fun _(X) -> string:split(string:trim(X), " ", all) end,
      string:split(CardInfo, "|")
    ),
  sets:size(
    sets:intersection(
      sets:from_list(Winning),
      sets:from_list(Rest)
    )
  ).

update_for_list([], _, CardCopies) -> CardCopies;
update_for_list([Card | T], CurrentCard, CardCopies) ->
  update_for_list(
    T,
    CurrentCard,
    maps:put(
      Card,
      maps:get(Card, CardCopies, 0) + maps:get(CurrentCard, CardCopies),
      CardCopies
    )
  ).

update_card_copies(CurrentCard, ComputedScore, CardCopies) ->
  update_for_list(
    lists:seq(CurrentCard + 1, CurrentCard + ComputedScore),
    CurrentCard,
    maps:put(
      CurrentCard,
      maps:get(CurrentCard, CardCopies, 0) + 1,
      CardCopies
    )
  ).

main(CurrentCard, CardCopies) ->
  case io:get_line("") of
    eof ->
      lists:foldl(
        fun _(A, B) -> A + B end,
        0,
        maps:values(CardCopies)
      );
    Line ->
      CurrentScore = process_line(Line),
      UpdatedCardCopies =
        update_card_copies(
          CurrentCard,
          CurrentScore,
          CardCopies
        ),
      main(CurrentCard + 1, UpdatedCardCopies)
  end.

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

Consejo dia 3

R

ragnar777 #134 Dic '23

Day 4 C#

parte 1

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

namespace day4
{
    class Program
    {
        static void Main(string[] args)
        {
            var winningNumbers = new HashSet<int>();
            var result = 0;
            using (var stream = new StreamReader("Input.txt"))
            {
                var line = stream.ReadLine();
                while (line != null)
                {
                    var validinputs = line.Remove(0, line.IndexOf(':') + 1);
                    var splittedInputs = validinputs.Split('|');
                    winningNumbers.Clear();
                    foreach (var winningNumber in splittedInputs[0].Split(' '))
                    {
                        try
                        {
                            winningNumbers.Add(int.Parse(winningNumber));
                        }
                        catch (Exception)
                        {
                        }
                    }
                    var winningAmount = -1;
                    foreach (var number in splittedInputs[1].Split(' '))
                    {
                        try
                        {
                            if (winningNumbers.Contains(int.Parse(number)))
                            {
                                winningAmount++;
                            }
                        }
                        catch (Exception)
                        {
                        }
                    }
                    if (winningAmount != -1)
                    {
                        result += (int)Math.Pow(2, winningAmount);
                    }
                    line = stream.ReadLine();
                }
            }
            Console.WriteLine(result);
            Console.ReadKey();
        }
    }
}

parte 2

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

namespace day4
{
    class Program
    {
        static void Main(string[] args)
        {
            var result = 0;
            var earnedCardsByCard = new Dictionary<int, int>();

        using (var stream = new StreamReader("Input.txt"))
        {
            var cards = stream.ReadToEnd().Split('\r');

            for (int cardIndex = 0; cardIndex < cards.Length; cardIndex++)
            {
                result += CheckEarnedCards(cards, cardIndex, earnedCardsByCard);
            }

            result += cards.Length;

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

    static int CheckEarnedCards(string[] cards, int index, Dictionary<int, int> earnedCardsByCard)
    {
        if(earnedCardsByCard.TryGetValue(index, out var cached))
        {
            return cached;
        }

        var line = cards[index];
        int earnedCards = 0;
        var cardScore = ParseCardAndGetScore(line);
        for (int i = 1; i < cardScore+1; i++)
        {
            if (earnedCardsByCard.TryGetValue(index + i, out var nextCardValue))
            {
                earnedCards +=  nextCardValue;
            }
            else
            {
                earnedCards += CheckEarnedCards(cards, index + i, earnedCardsByCard);
            }                        
        }
        earnedCardsByCard[index] = earnedCards + cardScore;
        return earnedCardsByCard[index];
    }

    static int ParseCardAndGetScore(string line)
    {
        var winningNumbers = new HashSet<int>();
        var validinputs = line.Remove(0, line.IndexOf(':') + 1);
        var splittedInputs = validinputs.Split('|');
        foreach (var winningNumber in splittedInputs[0].Trim().Split(' '))
        {
            if(int.TryParse(winningNumber, out var result))
            {
                winningNumbers.Add(result);
            }
        }
        var winningAmount = 0;
        foreach (var number in splittedInputs[1].Trim().Split(' '))
        {
            if(int.TryParse(number, out var result))
            {
                if(winningNumbers.Contains(result))
                {
                    winningAmount++;
                }
            }
        }
        return winningAmount;
    }
}
}

me he quitado la espinita de la recursividad de ayer con este

Pizzelio #135 Dic '23

Cuantas veces hay que procesar las copias? En mi input la tarjeta 1 se copia a sí misma por lo que no acabaría nunca

Edit: Nada ya lo entendí

1 respuesta

B

[Borrado] #136 Dic '23

#135 Si estás procesando la carta 2, y esa carta tiene una puntuación de 1, ese punto crea una copia de la carta 3. Si tuviera una puntuación de 2, crearía una copia de la carta 3 y la 4, y así sucesivamente.

A cada turno juegas un identificador únicamente. Esto es, en el primer turno juegas la carta 1, en el segundo la 2, etc

Y es únicamente en ese turno cuando generas las copias de las siguientes cartas.

El enunciado es bastante pobre y espera que lo entiendas con el ejemplo, es bastante confuso.

1 1 respuesta

Pizzelio #137 Dic '23

#136 Sí, lo entendí Nada más preguntar jaja. Gracias!

Kike_Knoxvil #138 Dic '23

#130 Cagon ros, y mira que pensé que eso lo había solucionado. Me armé la picha un lio con el str.length()-1 y contando a "mano" la longitud
Voy a maquetarlo un poco antes de seguir con la parte dos y el de hoy. ¡Muchas gracias!

PiradoIV #139 Dic '23 Brongster

Spoiler día 3

Frankicia #140 Dic '23

day 4 - C++

spoiler

#include <set>
#include <stdio.h>
#include <string>
#include <sstream>
#include <iostream>
#include <unordered_map>


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

int sum = 0;
std::unordered_map<int, int> owned_cards;
std::string line;
while (getline(std::cin, line)) {

    std::istringstream iss(line);
    std::string token;
    iss >> token >> token; // Card id:
    token.pop_back();
    
    int id_card = stoi(token);
    owned_cards[id_card]++;
    
    std::set<int> winners;
    iss >> token;
    while ( token.find('|') == std::string::npos) {
        winners.insert( stoi(token) );
        iss >> token;
    }

    int matches = 0;
    while (iss >> token)
        if (winners.count( stoi(token) )) ++matches;

    #ifdef SECOND_PART
        if (matches) {
            while(matches) {
                owned_cards[id_card + matches] += (owned_cards[id_card]);
                --matches;
            }
        }
        sum += owned_cards[id_card];
    #else
        if (matches) {
            int local_sum = 1; matches--;
            while (matches--) local_sum *= 2;
            sum += local_sum;
            
        }
    #endif
}

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

gonya707 #141 Dic '23 Moderador

dia 4 chupadisimo comparado con el 3, la verdad, tener que checkear cosas en filas y columnas adyacentes es un coñazo, a veces me dan ganas de usar matlab cuando hay cosas de esas

1 respuesta

B

[Borrado] #142 Dic '23

#141 si mal no recuerdo entre semana son bastante más facilongos y en el finde es cuando se ceban

1

B

[Borrado] #143 Dic '23

Hoy un Rust un poco más agradable a la vista que poco a poco me voy animando a hacerlo más declarativo con los "fishes" estos xD

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

use crate::handler::Handler;

#[derive(Debug)]
pub struct Day04;

impl Day04 {
    fn process_input() -> Vec<Vec<Vec<u32>>> {
        let handler = Handler::new("./src/day04/input.txt");

    handler
        .handle_input()
        .unwrap()
        .lines()
        .map(|line| {
            line.split(": ").collect::<Vec<&str>>()[1]
                .split(" | ")
                .map(|stack_of_numbers| {
                    stack_of_numbers
                        .split_whitespace()
                        .map(|number| number.parse::<u32>().unwrap())
                        .collect::<Vec<u32>>()
                })
                .collect::<Vec<Vec<u32>>>()
        })
        .collect()
}

pub fn part1() -> u32 {
    Self::process_input()
        .iter()
        .map(|pile| {
            let coincidences = pile[1]
                .iter()
                .filter(|&number| pile[0].contains(number))
                .copied()
                .collect::<Vec<u32>>()
                .len();

            if coincidences > 1 {
                return 2_u32.pow(coincidences as u32 - 1);
            }

            coincidences as u32
        })
        .sum()
}

pub fn part2() -> u32 {
    let mut extra_cards: Vec<u32> = vec![];
    Self::process_input()
        .iter()
        .map(|pile| {
            let coincidences = pile[1]
                .iter()
                .filter(|&number| pile[0].contains(number))
                .copied()
                .collect::<Vec<u32>>()
                .len();

            let mut current_extra_cards = 0;
            if !extra_cards.is_empty() {
                current_extra_cards = extra_cards[0];
                extra_cards.remove(0);
            }

            for i in 0..coincidences {
                if let Some(card_position) = extra_cards.get_mut(i) {
                    *card_position += 1 + current_extra_cards
                } else {
                    extra_cards.push(1 + current_extra_cards)
                }
            }

            1 + current_extra_cards
        })
        .sum()
}
}

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

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

R

RsTTa #144 Dic '23

Bueno, hoy bastante prueba y error para hacer la parte 2 O(N) en tiempo, todavia tengo que mirar porqué funciona xD

Dia 4 Parte 1

if __name__ == '__main__':
    ans = 0
    with open('in.txt') as fp:
        for line in fp.readlines():
            targets, candidates = (set(part.split()) for part in line.strip().split(': ', 1)[1].split(' | ', 1))
            coincidences = targets & candidates
            ans += 2**(len(coincidences) - 1) if coincidences else 0
    print(int(ans))

Dia 4 Parte 2

from collections import defaultdict

if __name__ == '__main__':
    ans = 0
    cards_to_remove_by_idx = defaultdict(int)
    extra_cards = 0
    with open('in.txt') as fp:
        for i, line in enumerate(fp.readlines()):
            targets, candidates = (set(part.split()) for part in line.strip().split(': ', 1)[1].split(' | ', 1))
            coincidences_size = len(targets & candidates)
            extra_cards -= cards_to_remove_by_idx[i]
            cards_to_remove_by_idx[i + coincidences_size + 1] += 1 + extra_cards
            ans += 1 + extra_cards
            extra_cards += 1 + extra_cards
    print(ans)

1 respuesta

desu #145 Dic '23

#144 coincidences = targets & candidates

1 respuesta

R

RsTTa #146 Dic '23

#145 igual no es el mejor naming xD

1 respuesta

desu #147 Dic '23

#146 no hombre hacer el and es toque de calidad

1 respuesta

R

RsTTa #148 Dic '23

#147 ah, yo pensaba que decías por el "coincidences"

Flashk #149 Dic '23

Day 4

Class Card

@Getter
public class Card {

private static final Pattern PATTERN_CARD_ID = Pattern.compile("Card *(\\d*):");
private static final String CARD_ID_DELIMITER = ":";
private static final String NUMBERS_DELIMITER = "\\|";
private static final String WHITESPACES = "\\s+";

private final int id;
private final Set<Integer> matchingNumbers;

public Card(String input) {

    // Card id parsing
    Matcher idMatcher = PATTERN_CARD_ID.matcher(input);
    id = idMatcher.find() ? Integer.parseInt(idMatcher.group(1)) : 0;

    // Card numbers parsing
    String numbersPart = input.substring(input.indexOf(CARD_ID_DELIMITER)+1);
    String[] numbersSplit = numbersPart.split(NUMBERS_DELIMITER);

    String[] winning = numbersSplit[0].stripLeading().split(WHITESPACES);
    String[] have = numbersSplit[1].stripLeading().split(WHITESPACES);

    Set<Integer> winningNumbers = Arrays.stream(winning).map(Integer::parseInt).collect(Collectors.toSet());
    Set<Integer> numbersYouHave = Arrays.stream(have).map(Integer::parseInt).collect(Collectors.toSet());
    matchingNumbers = numbersYouHave.stream().filter(winningNumbers::contains).collect(Collectors.toSet());
}

public int calculateWinningPoints() {
    return (int) Math.floor(Math.pow(2, (double) matchingNumbers.size()-1));
}
}

Class Scratchcards
public class Scratchcards {

private final List<Card> cards;
private final Map<Integer, Long> cardTotals;

public Scratchcards(List<String> input) {
    cards = input.stream().map(Card::new).toList();
    cardTotals = cards.stream().collect(Collectors.groupingBy(Card::getId, Collectors.counting()));
}

public int solveA() {
    return cards.stream().map(Card::calculateWinningPoints).reduce(0, Integer::sum);
}

public long solveB() {

    for (Card card : cards) {
        int size = card.getMatchingNumbers().size();
        long totalToIncrease = cardTotals.get(card.getId());
        IntStream.rangeClosed(card.getId() + 1, card.getId() + size)
                .filter(cardTotals::containsKey)
                .forEach(nextCardId -> updateTotals(nextCardId, totalToIncrease));
    }

    return cardTotals.values().stream().reduce(0L, Long::sum);
}

private void updateTotals(int cardId, long totalToIncrease) {
    cardTotals.put(cardId, cardTotals.get(cardId) + totalToIncrease);
}

}

CiudadanoEj #150 Dic '23

spoiler

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

r= 0
# s = """
# Card 1: 41 48 83 86 17 | 83 86  6 31 17  9 48 53
# Card 2: 13 32 20 16 61 | 61 30 68 82 17 32 24 19
# Card 3:  1 21 53 59 44 | 69 82 63 72 16 21 14  1
# Card 4: 41 92 73 84 69 | 59 84 76 51 58  5 54 83
# Card 5: 87 83 26 28 32 | 88 30 70 12 93 22 82 36
# Card 6: 31 18 13 56 72 | 74 77 10 23 35 67 36 11
# """
# s = s.strip().split('\n')
##################### Part 1
for i, line in enumerate(s):
    winners, game = line.split('|')
    winners = winners.split(':')[1].strip()
    game.strip()
    game = [int(number) for number in game.split()]
    winners = [int(number) for number in winners.split()]
    win_numbers = list(set(game).intersection(winners))
    card = 0
    for i in range(len(win_numbers)):
        card = 2 ** i
    r += card
print(r)
r2 = 0
card_ids, card_list= [], []
################## Part 2
for i, line in enumerate(s):
    card_id, winners = line.split(':')
    card_ids.append(card_id)
    card_list.append(1)
for i, line in enumerate(s):
    card_id, winners = line.split(':')
    winners, game = winners.split('|')
    game.strip()
    game = [int(number) for number in game.split()]
    winners = [int(number) for number in winners.split()]
    win_numbers = list(set(game).intersection(winners))
    index, old_index = card_ids.index(card_id), card_ids.index(card_id)
    for _add in range(len(win_numbers)):
        index += 1 
        card_list[index] += 1 * card_list[old_index]
        r += 1
print(sum(card_list))

me cago en dios el enunciado esta fatal explicado he empezado anadir cartas a la lista y no me acababa nunca suerte que he leido alguna pista por aqui

Usuarios habituales

Tags