Advent of Code 2020

AikonCWD #451 Dic '20 Git Gud

Me acabo de levantar y no entiendo el enunciado. A ver si a la tarde me lo puedo leer otra vez xd

Traber #452 Dic '20

No me apetecía hacer regexp, pero tampoco iba a ser tan cutre de comparar caracteres o contarlos 1 a uno, esta es mi solución:

Day6

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

namespace Day6 {
	class Program {
		private static string[]     __Lines;
		private static List<Tuple<int, string>> __Groups = new List<Tuple<int, string>>();

	static void Main(string[] args) {
		__Init();

		long FirstSolution  = __FirstPart();
		long SecondSolution = __SecondPart();

		Console.WriteLine("First  part solution: " + FirstSolution);
		Console.WriteLine("Second part solution: " + SecondSolution);
	}

	private static long __FirstPart() {
		long UniqueAnswers = 0;
		foreach (Tuple<int, string> Group in __Groups) {
			UniqueAnswers += __UniqueString(Group.Item2).Length;
		}

		return UniqueAnswers;
	}

	private static long __SecondPart() {
		long UniqueAnswers = 0;
		foreach (Tuple<int, string> Group in __Groups) {
			Dictionary<char, int> Occurences = new Dictionary<char, int>();

			foreach(char C in Group.Item2) {
				if (!Occurences.ContainsKey(C)) {
					Occurences.Add(C, 0);
				}
				Occurences[C] += 1;
			}

			foreach(KeyValuePair<char, int> Occurence in Occurences) {
				if(Occurence.Value == Group.Item1) {
					UniqueAnswers++;
				}
			}
		}

		return UniqueAnswers;
	}

	private static void __Init() {
		__Lines = File.ReadAllLines("input.txt");

		string Buffer = string.Empty;
		int    Length = 0;
		foreach (string Line in __Lines) {
			if (Line.Trim() == string.Empty) {
				__Groups.Add(new Tuple<int, string> (Length, Buffer));
				Buffer = string.Empty;
				Length = 0;
			}
			else {
				Length++;
				Buffer = Buffer + Line;
			}
		}
		if(Buffer != string.Empty) {
			__Groups.Add(new Tuple<int, string>(Length, Buffer));
		}
	}

	private static string __UniqueString(string Input) {
		HashSet<char> UniqueChars = new HashSet<char>(Input);

		return string.Join("", UniqueChars);
	}
}
}

2 respuestas

eZpit #453 Dic '20 Juntabrackets

Hoy he visualizado el problema muy facilmente pero me he dado de ostias infinitas con el type inference de Rust.

Day 6 - Pt 1

pub fn count_number_of_unique_group_yes_answers(lines: &Vec<String>) -> usize {
    return lines
        .split(|line| line.is_empty())
        .map(|group| {
            let yes_answers = group.iter()
                .flat_map(|person| person.chars().collect::<Vec<char>>())
                .collect::<Vec<char>>();
            let unique_yes_answers = HashSet::<char>::from_iter(yes_answers);
            unique_yes_answers.len()
        })
        .sum();
}

Day 6 - Pt 2

pub fn count_number_of_unanimous_group_yes_answers(lines: &Vec<String>) -> usize {
    return lines
        .split(|line| line.is_empty())
        .map(|group|
            group.iter()
                .map(|line| HashSet::<char>::from_iter(line.chars()))
                .reduce(|a, b| a.intersection(&b).cloned().collect())
                .unwrap()
                .len()
        )
        .sum()
}

Aprecio feedback de los Rustaceans

MaSoBa #454 Dic '20 Penitente

He ido cumpliendo todos los días pero me daba un poco de vergüenza compartir el código porque llevo 4 meses sin tocar código por una baja. Pero empiezo a coger de nuevo soltura así que ahí va:

Día 6 Parte 1

const fs = require('fs');

let processedAnswers = 0;
var answers = [];
let yes = 0;

const calculateAnswers = function(line)
{
    if(line)
    {
        if(!answers[processedAnswers])
        {
            answers[processedAnswers] = new Set();
        }
       

    line.split('').forEach(item => answers[processedAnswers].add(item))
}
else
{
    processedAnswers++;
}
}

const calculateSumYes = function()
{
    answers.forEach(answer => yes += answer.size);
}

const answersInput = fs.readFileSync('input.txt',{encoding: 'utf-8'}).split('\r\n');

answersInput.forEach(line => calculateAnswers(line));

calculateSumYes();

console.log(yes);

Día 6 Parte 2

const fs = require('fs');

let processedAnswers = 0;
var answers = [];
let yes = 0;

const calculateAnswers = function(line)
{
    if(line)
    {
        if(answers[processedAnswers] == null)
        {
            answers[processedAnswers] = line;
        }
        else
        {
            let regex = new RegExp('[^' + line.split('').join('|') + ']', "g");
            answers[processedAnswers] = answers[processedAnswers].replace(regex,'');
        }
       

}
else
{
    processedAnswers++;
}
}

const calculateSumYes = function()
{
    answers.forEach(answer => yes += answer.length);
}

const answersInput = fs.readFileSync('input.txt',{encoding: 'utf-8'}).split('\r\n');

answersInput.forEach(line => calculateAnswers(line));

calculateSumYes();

console.log(yes);

LLoid #455 Dic '20

día 6 parte 1 en kotlin:

spoiler

fun solveFirstPart(): Int {
        var count = 0
        val chunks = this.input.readText().split("\r\n\r\n")
        chunks.forEach { chunk ->
            count += chunk.replace("\r\n", "").toCharArray().distinct().size
        }

    return count
}

r2d2rigo #456 Dic '20 Inocente

#452 LINQ es tu amigo.

1 respuesta

Saiko9 #457 Dic '20

Yo dejo aquí el dia 5 entero en c++ que lo acabo de hacer.

spoiler

Los findes no suelo poder tocar el ordenador, a ver si me pongo al día.

Ranthas #458 Dic '20

Bueno, ayer tocó día familiar, pero esta mañana he aprovechado y he hecho el día 5 con un cafecito y ayuda de mis gatos. A mitad del camino se me ha encendido el bombillo, si interpreto la cadena como un número binario, sale al toque. Se nota que usar Java te atrofia el cerebro, si ya leyendo el título del día 5 (Binary Boarding) tendría que haberme dado cuenta.

Haré el seis esta noche si me quedan ganas después de tanta compra navideña.

B

[Borrado] #459 Dic '20

#450 Por partes

(?:) significa non-capturing group. Es decir, creas un grupo para matchear cosas pero no te quedas con el resultado en ningun lado, si yo tengo

(?:a)(b)(c)(?:d)

y matcheo abcd, los grupos que obtendre seran "b" y "c", porque estoy descartando los otros dos.

>>> r = re.compile(r'(?:a)(b)(c)(?:d)')
m = re.match(r, 'abcd')
m.groups()
('b', 'c')

Entonces, (?:\n){2,} significa haz un non-capturing group de saltos de linea, y que haga match dos o mas veces.

Por qué dos o más veces? Porque el input es tal que

a\n
b\n
\n
c\n
d

por lo que matcheando dos o más saltos de línea matcheo de forma efectiva los separadores de los casos de input. Si hago split a partir de los matches obtendré el input en sí.

La pregunta final sería que por qué el grupo del salto de línea es non-capturing. La respuesta es que de no serlo el split me capturaría también los saltos de línea entre casos de input, por lo que usaría uno de split solamente, considera esto

import re
blank = re.compile(r'(?:\n){2,}')

re.split(blank, 'a\n\nb\nc')
['a', 'b\nc']

blank = re.compile(r'(\n){2,}')
re.split(blank, 'a\n\nb\nc')
['a', '\n', 'b\nc']

#456 eres siempre así de borde? todos tus posts son bastante cortantes.

3 respuestas

JonaN #460 Dic '20 Juntabrackets

#459 Clarísimo, no había caido en que lo que buscas son los separadores para luego hacer split, por eso no acababa de tener sentido. Gracias!

Fyn4r #461 Dic '20 Inocente

Dejo por aquí la parte 1 del día de hoy. A ver si despues de comer hago la segunda parte.

day6 part1

import os

def read_input():
    with open(os.path.join('day6','input'), 'r') as f:
        groups = f.read().split('\n\n')
        return groups

groups = read_input()


# Part 1
print('Part 1')
answers = [len(set(g.replace('\n',''))) for g in groups]
print(f'\tSolution Found: {sum(answers)}')

P.D Me estáis asustando con más regexp xDD

1 respuesta

Unrack #462 Dic '20

#461 Hay cierto gusto inexplicable por las regexp por aquí.

Mi solución oneline (tengo hecho un apaño por ahí para arreglar la última fila a ver si lo dejo más clean). Alguna sugerencia?

spoiler

data = [line.split("\n") for line in open("input.txt").read().split("\n\n")]
del data[-1][-1]
print(f"Part 1: {sum([len(set(''.join(group))) for group in data])}")
print(f"Part 2: {sum([len(set(group[0]).intersection(*group)) for group in data])}")

1 2 respuestas

Lecherito #463 Dic '20 A toda leche

Las expresiones regulares son lo mejor que existe

1 respuesta

AikonCWD #464 Dic '20 Git Gud

#463 me cago en tu calavera

1 respuesta

Lecherito #465 Dic '20 A toda leche

#464 50 euritos y te apa;o la regex que necesites hombre

1 respuesta

B

[Borrado] #466 Dic '20

#462 Este último año me he comido muchas validaciones de movidas varias en el trabajo, por eso le he pillado el vicio. Muy chulos tus onelines btw

1 1 respuesta

Unrack #467 Dic '20

#466 A mi es algo que nunca he necesitado y me da pereza ponerme a ello (entiendo que una vez pillas buen nivel está genial pero bff). No hay alguna solución tipo lenguaje natural to regexp? Igual es momento de crearlo...

1 respuesta

B

[Borrado] #468 Dic '20

#467 Las regex cuando tienes suficiente soltura adquieres mucho el proceso mental de pasar a lenguaje natural lo que lees, o de pasar a regex cualquier idea que tengas en lenguaje natural, siempre que sea lo bastante concisa y esté dentro del espectro de lo que puede modelar una regex.

ciza #469 Dic '20

#462 las soluciones one-line me producen sensaciones enfrentadas entre su belleza y el asco que me dan

1 respuesta

B

[Borrado] #470 Dic '20

#469 Para problemas así están chulas, en la vida real son una garantía de que tu yo de dentro de 8 meses se va a cagar en tu puta madre. O cualquiera que herede tu código.

Yo era muy amigo de hacerlas en los integration tests, que se hacen en Python, hasta que me volví a encontrar con uno que escribí yo fallando año y pico después.

Pero insisto, para problemas sueltos está guay y mola pensar en cómo hacerlas, si es lo que te gusta.

Traber #471 Dic '20

#459 Yo creo que es al revés, LINQ es una herramienta para manejo de colecciones de C# que es la real polla y sirve para todo, desde iterar, hacer queries sobre el contenido (como si fuera SQL prácticamente xd), modificar la colección al vuelo, etc, creo que no lo decía a malas xd.

#465 50 euritos y te cambio la mostaza del avatar por leche de la mejor calidad.

1 respuesta

JonaN #472 Dic '20 Juntabrackets

Espero también que en algún momento se conviertan en problemas de darle al coco de verdad donde la dificultad no sea parsear el input xd.

1 respuesta

Traber #473 Dic '20

#472 Son problemas que requieren una solución en forma de números o una palabra, con lo que se trata de transformar una entrada en una salida. Si esperas algo del estilo CTF creo que aquí no lo vas a encontrar.

1 respuesta

Ranthas #474 Dic '20

Pues al final he resuelto el día 6,

La primera parte es sencilla agrupando en un mapa el nº de apariciones de cada letra; así tienes que contar solo el nº de claves; para la segunda parte, agrupas los conjuntos de respuestas afirmativas de cada grupo de personas y haces la intersección entre ellos.

1 respuesta

B

[Borrado] #475 Dic '20

.

1 respuesta

NeV3rKilL #476 Dic '20 :psyduck:

#474 ¿No necesitas el número de personas de cada grupo para nada?

Estáis madrugando un cojón para hacer esta mierda. Sí que os llama lo del mod.

2 respuestas

B

[Borrado] #477 Dic '20

#476 En mi caso es porque mi gata me despierta a las 7 dejándome un calcetín en la cara a modo de regalo, a ver si así me pongo contento y le doy de comer xddd

1 respuesta

Fyn4r #478 Dic '20 Inocente

#477 que maja, la mia hace ruido y tira cosas xd

1 respuesta

B

[Borrado] #479 Dic '20

#478 Son adorables pequeños hijos de puta

desu #480 Dic '20

#475 La verdad estan siendo unos problemas aburridos.

¿Dónde me apunto?

Normas

Leaderboard privado para el pique sano

Las respuestas se postean en Spoiler + code

Usuarios habituales

Tags