Advent of Code 2021: Casi no llegamos edition

jilker #91 Dic '21

Me apunto! Solo aporto el segundo problema, voy a intentar hacer todo en C++
Repo:https://github.com/jilker/Advent-of-Code-2021

spoiler

#include <stdio.h>
#include <iostream>
#include <fstream>
#include <vector>
int main(int argc, char *argv[])
{
    std::fstream myfile("/home/vicquecon/AoC/day_1/data.txt", std::ios_base::in);
    std::vector<int> values;
    int counter = 0;
    int value;
    while (myfile >> value)
    {
        values.push_back(value);
        if (values.size()>3)
        {
            if (values[0]+ values[1] + values[2] < values[1]+ values[2] + values[3])
                counter++;
            values.erase(values.begin());
        }
    }
    std::cout << counter << std::endl;
}

PhDfailer #92 Dic '21

solución en python en 5 minutillos, seguro que se puede optimizar más

el segundo, el primero es igual pero sin sumatorio

def function(array):
    count = 0
    for i in range(len(array)-3):
       next = array[i+1] + array[i+2] + array[i+3]
       current = array[i] + array[i+1] + array[i+2]
       if next > current:
        count += 1
    return count

B

[Borrado] #93 Dic '21

Primera vez que me apunto a algo de esto... a ver hasta que día llego xD

Prueba 1.A

1.A

with open("input", "r") as inputfile:
    lines = inputfile.read().splitlines()

count = 0
for e in range(len(lines) - 1):
    if int(lines[e]) < int(lines[e + 1]):
        count += 1
print(count)

Prueba 1.B

1.B

with open("input", "r") as inputfile:
    lines = inputfile.read().splitlines()

count = 0
for e in range(len(lines) - 3):
    wcur = [int(v) for v in lines[e:3+e]]
    wnext = [int(v) for v in lines[e+1:3+e+1]]
    if sum(wcur) < sum(wnext):
        count += 1
print(count)

Slowbro #94 Dic '21

A ver este año hasta donde llego con Rust.

Repo

Día 1

use std::cmp::Ordering;
use std::env;
use std::fs::File;
use std::io::{self, BufRead};
use std::path::Path;

fn read_lines<P>(filename: P) -> io::Result<io::Lines<io::BufReader<File>>>
where
    P: AsRef<Path>,
{
    let file = File::open(filename)?;
    Ok(io::BufReader::new(file).lines())
}

fn monotonic_depth_cnt(k0: i32, cache: &[i32]) -> Vec<i32> {
    let acc = cache[0];
    let k1 = cache[1];

match k1.cmp(&k0) {
    Ordering::Less => vec![acc + 1, k0],
    Ordering::Greater | Ordering::Equal => vec![acc, k0],
}
}

fn monotonic_depth_wind_cnt(k0: i32, c: &[i32]) -> Vec<i32> {
    let acc = c[0];

let p: i32 = c[2..].iter().sum();
let q: i32 = c[1..].iter().sum();

match q.cmp(&(p + k0)) {
    Ordering::Less => vec![acc + 1, c[2], c[3], k0],
    Ordering::Greater | Ordering::Equal => vec![acc, c[2], c[3], k0],
}
}

fn part_1(file: &str) -> Option<i32> {
    if let Ok(lines) = read_lines(file) {
        let mut cache = vec![-1, 0];

    for line in lines {
        if let Ok(depth) = line {
            let depth: i32 = depth.parse().unwrap();
            cache = monotonic_depth_cnt(depth, &cache[..]);
        }
    }
    Some(cache[0])
} else {
    None
}
}

fn part_2(file: &str) -> Option<i32> {
    if let Ok(lines) = read_lines(file) {
        let mut cache = vec![0, -1, -1, -1]; // acc, k3, k2, k1

    for line in lines {
        if let Ok(depth) = line {
            let depth = depth.parse().unwrap();
            if cache[1] == -1 {
                cache[1] = depth;
                continue;
            } else if cache[2] == -1 {
                cache[2] = depth;
                continue;
            } else if cache[3] == -1 {
                cache[3] = depth;
                continue;
            }
            cache = monotonic_depth_wind_cnt(depth, &cache[..]);
        }
    }
    Some(cache[0])
} else {
    None
}
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let input = &args[1];

match part_1(input) {
    Some(n) => println!("Max depth counter: {}", n),
    None => eprintln!("Something failed hard :("),
}

match part_2(input) {
    Some(n) => println!("Max depth counter [3º window]: {}", n),
    None => eprintln!("Something failed hard :("),
}
}

Leos #95 Dic '21

Día uno en rust

repo

1 1 respuesta

Sleidom #96 Dic '21 Rocketeer

Dia uno en Kotlin:

spoiler

import java.io.File

fun main() {
    val input = File("src/input")
        .useLines { it.toList() }
        .map { it.toInt() }

    partOne(input)
    partTwo(input)
}

private fun partOne(input: List<Int>) {
    var previousLine = 0
    var increases = 0
    input.forEach {
        if (it > previousLine && previousLine != 0) {
            increases++
        }
        previousLine = it
    }
    println(increases)
}

private fun partTwo(input: List<Int>) {
    var convertedInput = arrayListOf<Int>()

    for (i in input.indices) {
        if ((input.size - i) > 2) {
            convertedInput.add(input[i] + input[i + 1] + input[i + 2])
        }
    }
    partOne(convertedInput)
}

1

kroaton #97 Dic '21 Le Connoisseur

A mi la parte 2 del Día 1 me lo complicó.
Pero hoy el Día 2 es fácil, tanto la parte 1 como la 2.

1

Sleidom #98 Dic '21 Rocketeer

Dia 2 en Kotlin:

spoiler

import java.io.File

fun main() {
    val input = File("src/input")
        .useLines { it.toList() }

    partOne(input)
    partTwo(input)
}

private fun partOne(input: List<String>) {
    var hPosition = 0
    var depth = 0
    input.map {
        val command = it.split(" ")
        when (command[0]) {
            "forward" -> hPosition += command[1].toInt()
            "up" -> depth -= command[1].toInt()
            "down" -> depth += command[1].toInt()
        }
    }
    println(hPosition * depth)
}

private fun partTwo(input: List<String>) {
    var hPosition = 0
    var depth = 0
    var aim = 0
    input.map {
        val command = it.split(" ")
        when (command[0]) {
            "forward" -> {
                hPosition += command[1].toInt()
                depth += command[1].toInt() * aim
            }
            "up" -> aim -= command[1].toInt()
            "down" -> aim += command[1].toInt()
        }
    }
    println(hPosition * depth)
}

Dejo el repo tambien por aqui!

spoiler

1

desu #99 Dic '21

spoiler

package days

import (
	"fmt"
	"log"
	"strconv"
	"strings"

"github.com/vrnvu/aoc21/pkg/utils"
)

type action struct {
	dir string
	val int
}

type sub struct {
	x   int
	y   int
	aim int
}

func (s *sub) move(a action) {
	switch a.dir {
	case "forward":
		s.x += a.val
		s.y += (s.aim * a.val)
	case "down":
		s.aim += a.val
	case "up":
		s.aim -= a.val
	default:
		log.Fatal(fmt.Errorf("invalid dir: %s", a.dir))
	}
}

func Day2One() {
	s := sub{}

file := utils.NewFileReader(2, false)
defer file.Close()
rows := file.GetAsSliceString()

var actions = make([]action, len(rows))
for i, r := range rows {
	is := strings.Split(r, " ")
	dir := is[0]
	val, err := strconv.Atoi(is[1])
	if err != nil {
		log.Fatal(err)
	}
	actions[i] = action{dir, val}
}

for _, a := range actions {
	s.move(a)
}

fmt.Println(s.x * s.y)
}

spoiler

cuanto os tarda?

1 respuesta

Cecos94 #100 Dic '21

Dia 2 sin pensar demasiado

spoiler

Sleidom #101 Dic '21 Rocketeer

#99
No tengo manera de ejecutar el tiempo como en Go desde Kotlin, pero haciendo el tipico System.currentTimeMillis() en inicio y fin, y restando:

Part1: Elapsed time in millis: 42
Part2: Elapsed time in millis: 46

Leyendo input en ambas ejecuciones

enin #102 Dic '21 MCU Consumer

Día 2, seguimos con python, ¿suelen ser todos los ejercicios de parsear un txt y hacer cálculos?

Ejercicio 1

import sys

def fillMapWithFile(filename):
	map = {
		"forward": [],
		"up": [],
		"down": []
	}

with open(filename) as f:            
	for line in f:
		direction = line.split(' ')[0]
		if (direction == "forward"):
			map["forward"].append(int(line.split(' ')[1]))
		elif (direction == "up"):
			map["up"].append(int(line.split(' ')[1]))
		elif (direction == "down"):
			map["down"].append(int(line.split(' ')[1]))
		
return map

def getMovement(map):
	x = 0
	y = 0

for num in map["forward"]:
	x += num
for num in map["up"]:
	y -= num
for num in map["down"]:
	y += num

return x*y

if __name__ == '__main__':
	map = fillMapWithFile(sys.argv[1])
	movement = getMovement(map)
	print('Total Movement: ' + str(movement))

Ejercicio 2

import sys

def getMovement(filename):
	x = 0
	y = 0
	aim = 0
	with open(filename) as f:            

		for line in f:
			direction = line.split(' ')[0]
			distance = int(line.split(' ')[1])

		if (direction == "forward"):
			x += distance
			y += distance * aim
		elif (direction == "up"):
			aim -= distance
		elif (direction == "down"):
			aim += distance
		
return x*y

if __name__ == '__main__':
	movement = getMovement(sys.argv[1])
	print('Total Movement: ' + str(movement))

sergioRG #103 Dic '21 Juntabrackets

Como sean así todos los problemas me va a costar adherirme, espero que no empiecen a aparecer regexs como el año pasado...

Dia2Parte1

import numpy as np
import sys

dirvecs = {
  'forward': np.array([0, 1]),
  'down': np.array([1, 0]),
  'up': np.array([-1, 0])
}

v = np.zeros(2, dtype=np.int64)

for line in sys.stdin:
  vec_name, k = line.split()
  v += dirvecs[vec_name] * int(k)

print(v[0] * v[1])

Dia2Parte2

import numpy as np
import sys

vec_functions = {
  'forward': lambda v, k: np.array([0, 1, 0]) * k + np.array([0, 0, 1]) * v[0] * k,
  'down': lambda v, k: np.array([1, 0, 0]) * k,
  'up': lambda v, k: np.array([-1, 0, 0]) * k,
}

# aim, horizontal, depth
v = np.zeros(3, dtype=np.int64)

for line in sys.stdin:
  vec_name, k = line.split()
  v += vec_functions[vec_name](v,  int(k))

print(v[1] * v[2])

1 respuesta

Flashk #104 Dic '21

Uno más yendo a la solución más simple posible:

Parte 1

public class SubmarineMove {

private Integer depth = 0;
private Integer horizontalPosition = 0;

public Integer solve(List<String> movements) {

	
	for(String movement : movements) {
		
		String[] commands = movement.split(" ");
		String action = commands[0];
		Integer value = Integer.valueOf(commands[1]);
		
		switch(action) {
			case "forward": horizontalPosition += value; break;
			case "down": depth += value; break;
			case "up": depth -= value; break;
			default: break;
		}
		
	}

	return depth * horizontalPosition;
}
}

Parte 2

public class SubmarineMoveAim {

private Integer depth = 0;
private Integer horizontalPosition = 0;
private Integer aim = 0;

public Integer solve(List<String> movements) {
	
	for(String movement : movements) {
		
		String[] commands = movement.split(" ");
		String action = commands[0];
		Integer value = Integer.valueOf(commands[1]);
		
		switch(action) {
			case "forward": {
				horizontalPosition += value;
				depth += aim * value;
			} break;
			case "down": aim += value; break;
			case "up": aim	 -= value; break;
			default: break;
		}
	}
	
	return depth * horizontalPosition;
}
}

Igual me pongo a juguetear un poco y a refactorizarlo a ver si se puede dejar más bonito.

1 respuesta

Heysen #105 Dic '21 Inocente

spoiler


f = open("input2.txt", "r").readlines()


def move():

position = [0, 0]
aim = 0
for i in f:
    if i[0] == "f":
        position[0] += int(i[8])
        position[1] += aim * int(i[8])
        print(position)
        print(aim)
    elif i[0] == "d":
        aim += int(i[5])
        print(position)
        print(aim)
    elif i[0] == "u":
        aim -= int(i[3])
        print(position)
        print(aim)

print(" ")
print(" ")
print(position)
print(position[0]* position[1])


move()

Rápido y mal hecho pero funcionando, python

PaCoX #106 Dic '21 Ant queen

prefiero comerme las chocolatinas del calendario de kinder eh.
por seguir la gracia:

interfaz en vb6

B

[Borrado] #107 Dic '21

ponedme en #1
#1551601

pineda #108 Dic '21

a que hora llegan las matrices?

Ranthas #109 Dic '21

#103 Pues de momento es exactamente lo mismo del año pasado, aunque aún es temprano para hacer muchas comparativas

JonaN #110 Dic '21 Juntabrackets

Día 2

import numpy as np
import re

text=np.array([re.findall(r'[a-z]+', x)[0] for x in open('./Input02.txt').readlines()])
number=np.array([int(re.findall(r'\d+', x)[0]) for x in open('./Input02.txt').readlines()])

#Parte 1
print(number[text=='forward'].sum() * ( number[text=='down'].sum() - number[text=='up'].sum() ))

#Parte 2
pos=[0,0,0]
for x in range(len(text)):
    if text[x]=='down':
        pos[2]+=number[x]
    elif text[x]=='up':
        pos[2]-=number[x]
    else:
        pos[0]+=number[x]
        pos[1]+=pos[2]*number[x]
print(pos[0]*pos[1])

B

[Borrado] #111 Dic '21

No se que hago mal en el 2.2 joder

4 1 respuesta

kroaton #112 Dic '21 Le Connoisseur

#111 Postéalo

1 respuesta

B

[Borrado] #113 Dic '21

#112

Dia2

 lines = [ l.strip() for l in open('res/day2.txt').readlines()]
    # lines = open('res/test2.txt').readlines()
    x=0
    y=0
    z=0
    for element in lines:
        if element[0] == 'd': z += int(element[-1])
        if element[0] == 'u': z -= int(element[-1])
        if element[0] == 'f':
            x += z
            y += z * int(element[-1])
    print(x*y)

2 respuestas

R

RsTTa #114 Dic '21

El dia dos es candidato para ser el típico que van desarrollando durante varios dias...

1

desu #115 Dic '21

#113 abro streaming y lo vemos

Flashk #116 Dic '21

#87 Le he dado una vuelta de refactorización a mi solución:

Day 2 cambios

Así ha quedado la cosa:

Day 2 - Clase abstracta

public abstract class AbstractSubmarineMove {

protected Integer depth = 0;
protected Integer horizontalPosition = 0;

private final static String COMMAND_PATTERN = "(forward|down|up) ([0-9]*)";
private Pattern pattern = Pattern.compile(COMMAND_PATTERN);

public Integer solve(List<String> movements) {

	for(String movement : movements) {
		
		Matcher matcher = pattern.matcher(movement);
		matcher.find();

		String action = matcher.group(1);
		Integer value = Integer.valueOf(matcher.group(2));
		
		switch(action) {
			case "forward": forward(value); break;
			case "down": down(value); break;
			case "up": up(value); break;
			default: break;
		}
		
	}

	return depth * horizontalPosition;
}

public Integer getDepth() {
	return depth;
}


public Integer getHorizontalPosition() {
	return horizontalPosition;
}

abstract void up(Integer value);
abstract void down(Integer value);
abstract void forward(Integer value);
}

Day 2 - Parte 1

public class SubmarineMove extends AbstractSubmarineMove {

protected void up(Integer value) {
	this.depth -= value;
}

protected void down(Integer value) {
	this.depth += value;
}

protected void forward(Integer value) {
	this.horizontalPosition += value;
}
}

Day 2 - Parte 2

public class SubmarineMoveAim extends AbstractSubmarineMove {

private Integer aim = 0;

protected void up(Integer value) {
	this.aim -= value;
}

protected void down(Integer value) {
	 this.aim += value;
}

protected void forward(Integer value) {
	this.horizontalPosition += value;
	this.depth += aim * value;
}

}

kroaton #117 Dic '21 Le Connoisseur

#113 Intentando entender tu código entiendo que te falta código aposta del final, porque te faltaría como úlitmo paso multiplicar x e y para tener el total que se pide.

Si no, yo lo veo parecido al mío aunque el lenguaje cambie:

spoiler

  LOOP AT it_tabla.
    CASE it_tabla-direccion.
      WHEN 'forward'.
        l_horizontal = l_horizontal + it_tabla-valor.
        l_depth   = l_depth + ( l_aim * it_tabla-valor ).
      WHEN 'down'.
        l_aim   = l_aim   + it_tabla-valor.
      WHEN 'up'.
        l_aim   = l_aim   - it_tabla-valor.
    ENDCASE.
  ENDLOOP.

1 respuesta

B

[Borrado] #118 Dic '21

#117 eso mismo falta este trozo

    print(x*y)

pero sigue sin irme y npi de donde esta el error con tan pocas lineas

1 respuesta

kroaton #119 Dic '21 Le Connoisseur

#118 Creo que:

x += z

Debería ser:

x += int(element[-1])

¿puede ser?

1 respuesta

B

[Borrado] #120 Dic '21

#119 era eso, gracias!

1

1.A

1.B

Usuarios habituales

Tags