Advent of Code 2020

Axtrix #61 Dic '20 Diamond hands

#59 que pereza usar fs, yo me lo puse en una variable y a correr

desu #62 Dic '20

Podriamos explicar la solucion no? Repasando para hacer la parte 2 si que he hecho la solucion optima, filter hace un short circuit.

veo cosas muy raras y es el primer ejercicio xd

(ns aocl.1
  (:gen-class)
  (:require [aocl.core :refer [read-file]]))

(def input (clojure.string/split-lines (read-file "1.txt")))

(defn make-hm [input]
  (zipmap (map #(- 2020 %) input) input))

(defn find-values [input] 
  (let [hm (make-hm input)
        v1 (nth (filter #(contains? hm %) input) 0)
        v2 (get hm v1)]
    (* v1 v2)))

(def part1 (str "part1: " (find-values (map #(Integer/parseInt %) input))))

(defn -main [& args] (run! println [part1]))

part 1

Tienes una lista de elementos e [1 2 3 4 5] y un numero objetivo N

Creas un hasmap poniendo como key N - e y como valor e, para cada e en tu lista de inputs O(N)

Iteras una segunda vez tu lista de inputs y buscas e. O (N)

si la encuentras ya has encontrado N = a + b, tansolo tienes que consultar el hashmap O(1)

coste en tiempo y espacio N.

El one liner en pseudocodigo.

input 
  /> generarHashMap
  => buscarPair
  => devolverMultiplacionDelPair

edit: con la part2, ha sido facil, 1 minuto adaptar el codigo

(ns aocl.1
  (:gen-class)
  (:require [aocl.core :refer [read-file]]))

(def input (clojure.string/split-lines (read-file "1.txt")))

(defn make-hm [input]
  (zipmap (map #(- 2020 %) input) input))

(defn find-values [input] 
  (let [hm (make-hm input)
        v1 (nth (filter #(contains? hm %) input) 0)
        v2 (get hm v1)]
    (* v1 v2)))

(defn make-hm2 [input]
  (zipmap (map #(- 2020 (first %) (second %)) input) input))

(defn find-values2 [input] 
  (let [all-pairs (for [x input y input] (vector x y))
        pairs (filter #(not= (first %) (second %)) all-pairs)
        hm (make-hm2 pairs)
        v1 (nth (filter #(contains? hm %) input) 0)
        v2 (first (get hm v1))
        v3 (second (get hm v1))]
    (* v1 v2 v3)))

(def part1 (str "part1: " (find-values (map #(Integer/parseInt %) input))))
(def part2 (str "part2: " (find-values2 (map #(Integer/parseInt %) input))))

(defn -main [& args] (run! println [part1 part2]))

Leos #63 Dic '20

Yo hasta la noche no me podré poner, al final creo que lo haré en Rust para no sentir que me rindo con el lenguaje, espero que me salga tan fácil como a todos

NeV3rKilL #64 Dic '20 :psyduck:

Ya hice el primero a lo guarro con 3 fors para no complicarme la vida con accumulates, mientras compute aceptablemente paso de optimizar.

Es muy sencillo y no parece ser de los que se van a encadenar en futuros días.

Me creé ya la típica funcion para leer el input rápido, la metí en un archivo pese a que en el spoiler la meto, por si en otro día se complica la lectura del input no enmerdar.

Python

from read_input import read_input

def read_input(filename: str) -> list():
    f = open(filename,"r",encoding="UTF8")
    return  f.read().split("\n")

if __name__ == "__main__":
    input = read_input("I1-1.txt")
    int_input = [int(x) for x in input]
    for number1 in int_input:
        for number2 in int_input:
            for number3 in int_input:
                if 2020 == number1 + number2 + number3:
                    print(number1*number2*number3)
                    exit()

La parte 1 simplemente es quitar el for del number3.

Axtrix #65 Dic '20 Diamond hands

spoiler

import { data } from './data';

const result = data.split(/\r\n|\r|\n/g).map(i => Number(i));

let pairs: [number, number] = [0, 0];

result.forEach((entry1, index) => {
  result.slice(index + 1).forEach(entry2 => {
    if (entry1 + entry2 === 2020) {
      pairs = [entry1, entry2];
    }
  });
});

export const part1 = {
  pairs,
  sum: pairs[0] * pairs[1],
};

let triples: [number, number, number] = [0, 0, 0];

result.forEach((entry1, index) => {
  result.slice(index + 1).forEach(entry2 => {
    result.slice(index + 2).forEach(entry3 => {
      if (entry1 + entry2 + entry3 === 2020) {
        triples = [entry1, entry2, entry3];
      }
    });
  });
});

export const part2 = {
  triples,
  sum: triples[0] * triples[1] * triples[2],
};

///////////////Output:
Day 1
{ pairs: [ 586, 1434 ], sum: 840324 }
{ triples: [ 910, 207, 903 ], sum: 170098110 }

NeV3rKilL #66 Dic '20 :psyduck:

Because of an outage during the day 1 puzzle unlock, day 1 is worth no points.

Puta bida.

Lecherito #67 Dic '20 A toda leche

#55 En Rust puedes configurar varios ejecutables que puedes ejecutar con cargo run asi que lo puedes tener todo en el mismo proyecto con day1.rs day2.rs

Y si esto no te gusta, puedes tener workspaces, que son basicamente varios proyectos con uno padre que los une: https://doc.rust-lang.org/cargo/reference/workspaces.html#the-workspace-section

Asi te quitas el day1::result() que me da cosa xD

2 respuestas

Unrack #68 Dic '20

Hoy me apetecía no pensar mucho y he tirado de >itertools.combinations

Bendita librería estándar de python!

1 respuesta

aren-pulid0 #69 Dic '20

Parte 1

spoiler

numbers = []

with open('input.txt', 'r') as num_input:
    for num in num_input.readlines():
        numbers.append(int(num))

multiplied_2020_sums = 0

for i in range(len(numbers)):
    sums_of_2020 = list(filter(lambda x: numbers[i] + x == 2020, numbers[i+1:]))
    if sums_of_2020:
        multiplied_2020_sums = numbers[i] * sums_of_2020[0]
        break

Explicación

spoiler

Parte 2

spoiler

for i in range(len(numbers)):
    sumd_list = list(map(lambda x: x + numbers[i], numbers[i+1:]))
    for j in range(len(sumd_list)):
        sums_of_2020 = list(filter(lambda x: sumd_list[j] + x == 2020, numbers[j+1:]))
        if sums_of_2020:
            multiplied_2020_sums = numbers[i] * (sumd_list[j] - numbers[i]) * sums_of_2020[0]
            break
    if multiplied_2020_sums:
        break

Explicación

spoiler

bornex #70 Dic '20

#67 la verdad es que estaba buscando como modularizar el código y al final lo he hecho así, me gusta la idea de tener el código separado por directorios y ponerlos cada dia en un directorio distinto. Voy a mirar lo de los workspaces a ver que tal, acabo de empezar con Rust xD ten paciencia conmigo, aunque ya que estamos te voy a preguntar

1 respuesta

Lecherito #71 Dic '20 A toda leche

#70 Por eso te he dicho lo que se suele hacer, en vez de llamarte retrasado que no sabes lol. Simplemente vi que se puede mejorar

Heysen #72 Dic '20 Inocente

Primer ejercicio resuelto con Appian, que es con lo que estoy trabajando ahora

spoiler

a!forEach(
  items: ri!input,
  expression: union(
    if(
      fv!item + ri!input = 2020,
      fv!item * ri!input,
      ""
    ),
    if(
      fv!item + ri!input = 2020,
      fv!item * ri!input,
      ""
    )
  )
)

ciza #73 Dic '20

alexilarduya en AoC

A ver cuanto duro, suelo ser mas bien poco constante... Por otra parte, supongo que es como una kata de cualquier web random con la (gran) diferencia de que aqui no tienes máximo de tiempo de ejecución.

1 respuesta

Fyn4r #74 Dic '20 Inocente

Actualicé la tabla de #1 , ahora está ordenada por orden alfabético y fui completando los datos que fui viendo por el hilo. Si alguien quiere que le ponga el repo o algo que me cite que igual no me enteré, no me esperaba tal aceptación xD

P.D Yo aún ni lo miré, a ver si esta tarde

#73 tiempo de ejecución no hay, pero recuerdo algún problema del año pasado que como quisieras sacarlo por fuerza bruta ibas a estar ejecutando aún ahora xD

1 respuesta

Jorgvt_ESP #75 Dic '20

#68 Amén!

desu #76 Dic '20

#74 si quieres puedes meter mis datos.

a ver cuantos de este hilo llegamos a la mitad, al final no llega nadie xd

B

[Borrado] #77 Dic '20

Bastante fácil el primero de momento, mi solución en C++ del paleolitico aquí

https://github.com/srgrr/aoc20202/blob/main/1/main.cc

Tiempo O(nlogn), espacio O(n)

Ire actualizando según los vaya sacando

Segundo problema

https://github.com/srgrr/aoc20202/blob/main/1_2/main.cc

O(n² logn), espacio O(n), se puede hacer en n² con two pointers si mal no recuerdo, pero que palo xd

Lo mismo pero en n² (expected) usando hashmaps

https://github.com/srgrr/aoc20202/blob/main/1_2/main_hashing.cc

Mi intención es hacerlos en lo que más me convenga, pero probablemente será java, python, c++, go, bash o algo así.

QuitCat #78 Dic '20 Gafe

No tengo muy fresco el tema de las complejidades, pero diría que el acceso mediante diccionario/map es O(1), por lo que se podría tener en O(n) el primer apartado.
En sucio y hecho guarramente en la consola del browser

const f = (a, n) => {
  const m = new Map();
  for(i=0; i<a.length;i++) {
    const v = a[i];
    const r = n-v;
    if(m.has(r)) {
      return v*r;
    }
    m.set(v, true)
  }
  return null;
}

f(array, 2020)

#59 Te habría fallado ese código si hubiera estado el valor 1010 en el array

1 2 respuestas

B

[Borrado] #79 Dic '20

#78 Yep, realmente lo he hecho así porque empece a hacerlo con un vector y ya me dio palo cambiarlo, pero tienes toda la razón del mundo.

edit: puedes explicar lo del 1010? no se mucho js pero no veo la razón
edit2: porque daría que sí con un mismo número repetido, nvm

1 respuesta

QuitCat #80 Dic '20 Gafe

#79 Esta comprobando el mismo nº dos veces

[a, b, c]
Coge "a" y busca candidatos en [a, b, c], cuando en verdad solo debería buscar en [b, c]

Ejemplo donde obtendría un falso valor:

[1010, 3, 5]
Él obtendría que la suma de 1010 y 1010 cumple los requisitos, pero es incorrecto, puesto que el 1010 solo esta una vez en el array.

1

Traber #81 Dic '20

No se si es lo más elegante, pero funciona:

Day 1

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

namespace Day1 {
    class Program {
        static void Main(string[] args) {
            long First  = FirstPart();  // 1010299
            long Second = SecondPart(); // 42140160
        }

    public static long FirstPart() {
        long[] Input = File.ReadAllText("input.txt").Split(Environment.NewLine).Select(t => Convert.ToInt64(t)).ToArray();

        for (int i = 0; i < Input.Length; i++) {
            for (int j = i; j < Input.Length; j++) {
                if (i == j) {
                    continue;
                }

                if (Input[i] + Input[j] == 2020) {
                    return Input[i] * Input[j];
                }
            }
        }

        return 0;
    }

    public static long SecondPart() {
        long[] Input = File.ReadAllText("input.txt").Split(Environment.NewLine).Select(t => Convert.ToInt64(t)).ToArray();

        for (int i = 0; i < Input.Length; i++) {
            for (int j = i; j < Input.Length; j++) {
                for (int k = i; k < Input.Length; k++) {
                    if (i == j || i == k || j == k) {
                        continue;
                    }

                    if (Input[i] + Input[j] + Input[k] == 2020) {
                        return Input[i] * Input[j] * Input[k];
                    }
                }
            }
        }

        return 0;
    }
}
}

MartiONE #82 Dic '20 El reportero de guerra sonriente

Done, apuntame fynardo

1 respuesta

Ranthas #83 Dic '20

Oye cuack, ya tengo esto hecho de la manera más masillera posible, a ver si pongo el GitHub

1 respuesta

Fyn4r #84 Dic '20 Inocente

#82 apuntao

#83 no nos cuentes tu vida, cuentanos tus cotas superiores

1 respuesta

Ranthas #85 Dic '20

#84 A que te rajo

https://github.com/ranthas90/advent-of-code-2020

Apunta eso si te atreves

1

B

[Borrado] #86 Dic '20

#78 ¿Por?

1 respuesta

pineda #87 Dic '20

venga me uno...

edit no soy capaz de formatearlo bien

package main

import (
	"fmt"
	"io/ioutil"
	"strconv"
	"strings"
)

func main() {
	content, err := ioutil.ReadFile("input.txt")
	checkErr(err)

lines := strings.Split(string(content), "\n")

val := calculateMadafaka(lines, 2020, 1, 0, 0, 1)
fmt.Println(val)
val = calculateMadafaka(lines, 2020, 2, 0, 0, 1)
fmt.Println(val)
}

func calculateMadafaka(lines []string, expectedValue int, stepsLeft int, currentIndex, currentSum int, currentPlus int) int {
	for i:=currentIndex;i<len(lines);i++ {
		firstNum := parseNum(lines[i])
		if stepsLeft > 0 {
			if tmpValue := calculateMadafaka(lines, expectedValue, stepsLeft-1, i, currentSum + firstNum, currentPlus * firstNum); tmpValue != 0 {
				return tmpValue
			}
		} else {
			if currentSum + firstNum == expectedValue {
				return currentPlus * firstNum
			}
		}
	}
	return 0
}

func parseNum(input string) int {
	num, _ := strconv.Atoi(strings.Split(input, "\r")[0])
	return num
}

func checkErr(err error) {
	if err != nil {
		panic(err)
	}
}

mecmec #88 Dic '20

Estaría guay que algún ducho en matemáticas explicara el tema de las cotas para dividir series de números, porque hacerlo a lo animal con tres bucles creo que está al alcance de cualquiera xD.

1 respuesta

B

[Borrado] #89 Dic '20

#88 a qué te refieres?

1 respuesta

T

TroyaProgram #90 Dic '20

Me uno al reto lo hice con javascript, pero intentare practicar GO.

spoiler

function day1_1(data, total, index){

    const dataMap = new Map();
    for(let i = index; i < data.length; i++){
            const rest = total - parseInt(data[i])
            if(dataMap.has(rest.toString())){
                    return parseInt(data[i])*rest;
            }
            dataMap.set(data[i],1)
    }

    return -1;
}

function day1_2(data, total, index){

    for(let i = index; i < data.length-1; i++){
            const rest = total - parseInt(data[i]);
            const resultPair = day1_1(data, rest, i+1);
            if (resultPair != -1){
                    return resultPair*data[i];
            }
    }

    return -1;
}

¿Dónde me apunto?

Normas

Leaderboard privado para el pique sano

Las respuestas se postean en Spoiler + code

Usuarios habituales

Tags