Advent of Code 2020

JonaN #691 Dic '20 Juntabrackets

#688 Jajajaj, en realidad tampoco es tan NMS porque no deja de ser lo mismo copypasteado 8 veces, bastante fácil de leer.

La forma de llegar a un np.array desde el input también es bastante chapucera creo, seguro que se puede hacer con 1 o 2 lineas de código.

Por qué dices lo de los números?

1 respuesta

B

[Borrado] #692 Dic '20

#691 Yo pensé eso de ti cuando vi que en otro problema llamabas delta a una variable que contenía un diferencial de otra cantidad jajajaja, la verdad es que se te nota un poco.

1

r2d2rigo #693 Dic '20 Inocente

#678 pero como que 25 minutos muyayo, que has liado.

2 respuestas

Traber #694 Dic '20

#693 pues espera que he dejado el segundo haciéndose mientras bajaba a la oficina xD

1 respuesta

r2d2rigo #695 Dic '20 Inocente

#694 acabo de ver tu solucion y jesus la que lias con tal de no usar matrices/arrays bidimensionales. Dale otra pensada cuando tengas tiempo hombre!

Ranthas #696 Dic '20

Una duda, me he sentado a hacerlo, el tema de comprobar si esta libre o no; es ¿iterativo?

Es decir, imaginemos un asiento libre por completo, como esto:

L L L
L L L
L L L

El elemento (0,0) no está ocupado, si es procedimiento es ITERATIVO, lo ocuparíamos:

X L L
L L L
L L L

Ahora el elemento (0,1) no lo ocuparíamos. Pero viendo la muestra que dan, este caso que expongo sí que se ocuparía porque no es iterativo, es decir, usan como estado inicial el que te da el problema y solo mutan el estado una vez que se han comprobado todos los asientos del estado inicial. Es decir, que no muta el estado con cada comprobación de cada asiento.

Porque si es así, tendré que ir almacenando en una copia las mutaciones que voy haciendo, para no alterar el estado inicial

1 respuesta

B

[Borrado] #697 Dic '20

#696 No, compruebas siempre contra el estado anterior, y el nuevo que vas construyendo no influye en si mismo.

1 respuesta

Ranthas #698 Dic '20

#697 Perfecto, entiendo; por tanto, desde el estado inicial, donde todos están libres, es obvio que el siguiente estado tendrá todos ocupados, que es lo que pone el ejercicio.

Bueno, ahora que está esto claro, a masillear

BeheritSp #699 Dic '20 Juntabrackets

Bastante chusta el de hoy, encima hoy tenía poco tiempo así que está guarrisimo.

Part 1 y 2

lines_list =[list(line) for line in open("input.txt").read().splitlines()]
import copy

i_length = len(lines_list) - 1
j_length = len(lines_list[0]) -1
check_occup = lambda  i,j, lines: lines[i][j] == "#"
check_found = lambda  i,j, lines: lines[i][j] == "L" or lines[i][j] =="#"
def check_if_surrounded(i, j, lines):
    is_surrounded_list = []
    if i-1 >= 0:
        is_surrounded_list.append(check_occup(i-1, j, lines))
        if j-1 >= 0:
            is_surrounded_list.append(check_occup(i-1, j-1, lines))
        if j+1 <= j_length:
            is_surrounded_list.append(check_occup(i-1, j+1, lines))
    if j-1 >= 0:
        is_surrounded_list.append(check_occup(i, j-1, lines))
    if j+1 <= j_length:
        is_surrounded_list.append(check_occup(i, j+1, lines))
    if i+1 <= i_length:
        is_surrounded_list.append(check_occup(i+1, j, lines))
        if j-1 >= 0:
            is_surrounded_list.append(check_occup(i+1, j-1, lines))
        if j+1 <= j_length:
            is_surrounded_list.append(check_occup(i+1, j+1, lines))
    return is_surrounded_list
def check_if_surrounded_2(i, j, lines):
    is_surrounded_list = []
    if i-1 >= 0:
        for i_aux in range(i-1,-1,-1):
            if check_found(i_aux, j, lines):
                    is_surrounded_list.append(check_occup(i_aux, j, lines))
                    break
        if j-1 >= 0:
            for i_aux, j_aux in zip(range(i-1,-1,-1), range(j-1,-1,-1)):
                if check_found(i_aux, j_aux, lines):
                    is_surrounded_list.append(check_occup(i_aux, j_aux, lines))
                    break
        if j+1 <= j_length:
            for i_aux, j_aux in zip(range(i-1,-1,-1), range(j+1,j_length+1)):
                if check_found(i_aux, j_aux, lines):
                    is_surrounded_list.append(check_occup(i_aux, j_aux, lines))
                    break
    if j-1 >= 0:
        for j_aux in range(j-1,-1,-1):
            if check_found(i, j_aux, lines):
                is_surrounded_list.append(check_occup(i, j_aux, lines))
                break
    if j+1 <= j_length:
        for j_aux in range(j+1,j_length+1):
            if check_found(i, j_aux, lines):
                is_surrounded_list.append(check_occup(i, j_aux, lines))
                break
    if i+1 <= i_length:
        for i_aux in range(i+1,i_length+1):
            if check_found(i_aux, j, lines):
                is_surrounded_list.append(check_occup(i_aux, j, lines))
                break
        if j-1 >= 0:
            for i_aux, j_aux in zip(range(i+1,i_length+1), range(j-1,-1,-1)):
                if check_found(i_aux, j_aux, lines):
                    is_surrounded_list.append(check_occup(i_aux, j_aux, lines))
                    break
        if j+1 <= j_length:
            for i_aux, j_aux in zip(range(i+1,i_length+1), range(j+1,j_length+1)):
                if check_found(i_aux, j_aux, lines):
                    is_surrounded_list.append(check_occup(i_aux, j_aux, lines))
                    break
    return is_surrounded_list

old_matrix = copy.deepcopy(lines_list)
new_matrix = copy.deepcopy(lines_list)
new_matrix[0][0] = "d"
while (True):
    for i, line in enumerate(old_matrix):
        for j, _ in enumerate(line):
            if old_matrix[i][j]=="L":
                is_surrounded = max(check_if_surrounded(i,j, old_matrix))
                if not is_surrounded:
                    new_matrix[i][j] = "#"
            elif old_matrix[i][j]=="#":
                is_surrounded_list = [check for check in check_if_surrounded(i,j, old_matrix) if check is True]
                if len(is_surrounded_list)>3:
                    new_matrix[i][j] = "L"
    if old_matrix==new_matrix:
        break
    old_matrix = copy.deepcopy(new_matrix)
def count_seats(new_matrix):
    return sum([1 for line in new_matrix for char in line if char=="#"])

print("Solution part 1", count_seats(new_matrix))

old_matrix = copy.deepcopy(lines_list)
new_matrix = copy.deepcopy(lines_list)
new_matrix[0][0] = "d"
while (True):
    for i, line in enumerate(old_matrix):
        for j, _ in enumerate(line):
            if old_matrix[i][j]=="L":
                is_surrounded = max(check_if_surrounded_2(i,j, old_matrix))
                if not is_surrounded:
                    new_matrix[i][j] = "#"
            elif old_matrix[i][j]=="#":
                is_surrounded_list = [check for check in check_if_surrounded_2(i,j, old_matrix) if check is True]
                if len(is_surrounded_list)>4:
                    new_matrix[i][j] = "L"
    if old_matrix==new_matrix:
        break
    old_matrix = copy.deepcopy(new_matrix)
def count_seats(new_matrix):
    return sum([1 for line in new_matrix for char in line if char=="#"])

print("Solution part 2", count_seats(new_matrix))

1 1 respuesta

S

Sarwaz #700 Dic '20

#699

1

privet #701 Dic '20

clean code al toque

S

Sarwaz #702 Dic '20

Lo inputs podrían ser un poco mas grandes obligar a hacer la solución correcta, de momento parece que todos se pueden hacer por fuerza bruta.

r2d2rigo #703 Dic '20 Inocente

11   15412  4527  *******
10   32726  9693  *************
 9   45730  1193  ***************
 8   48540  3665  *****************
 7   49193  4854  *****************
 6   65491  2013  *********************
 5   70057  1365  **********************
 4   74731  9040  *************************
 3   90829  2840  ****************************
 2  108694  3181  *********************************
 1  128797  8923  *****************************************

Drop gordo hoy, como no mejore mucho la cosa va a ser un 50% menos de participantes...

Fyn4r #704 Dic '20 Inocente

Pues personalmente me está pareciendo más fácil que el del año pasado.

Traber #705 Dic '20

#693 Aquí lo llevas xD:

spoiler

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

namespace Day11 {
	public enum SeatState {
		FLOOR,
		EMPTY,
		OCCUPIED
	}

public class Seat {
	public SeatState State;

	public Seat(char SeatChar) {
		switch (SeatChar) {
			case '.':
				this.State = SeatState.FLOOR;
				break;
			case 'L':
				this.State = SeatState.EMPTY;
				break;
			case '#':
				this.State = SeatState.OCCUPIED;
				break;
		}
	}

	public override string ToString() {
		switch (this.State) {
			case SeatState.FLOOR:
				return ".";
			case SeatState.EMPTY:
				return "L";
			case SeatState.OCCUPIED:
				return "#";
		}

		return "";
	}
}

class Program {
	private static Dictionary<int, List<Seat>> __Seats = new Dictionary<int, List<Seat>>();

	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() {
		Dictionary<int, List<Seat>> CurrentLayout = new Dictionary<int, List<Seat>>();
		Dictionary<int, List<Seat>> MutatedLayout = __CloneLayout(__Seats);

		__PrintLayout(MutatedLayout);
		do {
			CurrentLayout = __CloneLayout(MutatedLayout);
			MutatedLayout = __MutateLayout(CurrentLayout);

			__PrintLayout(MutatedLayout);
		}
		while (JObject.FromObject(CurrentLayout).ToString() != JObject.FromObject(MutatedLayout).ToString());

		return __GetOccupiedSeats(MutatedLayout);
	}

	private static void __PrintLayout(Dictionary<int, List<Seat>> Layout) {
		foreach(List<Seat> Row in Layout.Values) {
			string Line = "";
			foreach(Seat seat in Row) {
				Line = Line + seat.ToString();
			}

			Console.WriteLine(Line);
		}

		Console.WriteLine("");
	}

	private static Dictionary<int, List<Seat>> __CloneLayout(Dictionary<int, List<Seat>> SourceLayout) {
		return JObject.Parse(JObject.FromObject(SourceLayout).ToString()).ToObject<Dictionary<int, List<Seat>>>();
	}

	private static Dictionary<int, List<Seat>> __MutateLayout(Dictionary<int, List<Seat>> SourceLayout) {
		Dictionary<int, List<Seat>> MutatedLayout = __CloneLayout(SourceLayout);

		for (int i = 0; i < MutatedLayout.Count; i++) {
			for (int j = 0; j < MutatedLayout[i].Count; j++) {
				int AdyacentEmpty    = 0;
				int AdyacentOccupied = 0;
				int AdyacentFloor    = 0;

				for(int y = -1; y <= 1; y++) {
					for(int x = -1; x <= 1; x++) {
						if(y==0 && x == 0) {
							// Skip current seat!
							continue;
						}

						try {
							Seat AdyacentSeat = SourceLayout[i+y][j+x];
							switch (AdyacentSeat.State) {
								case SeatState.EMPTY:
									AdyacentEmpty++;
									break;
								case SeatState.OCCUPIED:
									AdyacentOccupied++;
									break;
								case SeatState.FLOOR:
									AdyacentFloor++;
									break;
							}
						}
						catch(Exception e) {
							// Out of bounds; lazy way to not boundaries xd
						}
					}
				}

				switch (SourceLayout[i][j].State) {
					case SeatState.FLOOR:
						// Fuck the floor!
						break;
					case SeatState.EMPTY:
						if (AdyacentOccupied == 0) {
							MutatedLayout[i][j].State = SeatState.OCCUPIED;
						}
						break;
					case SeatState.OCCUPIED:
						if (AdyacentOccupied >= 4) {
							MutatedLayout[i][j].State = SeatState.EMPTY;
						}
						break;
				}

			}
		}

		return MutatedLayout;
	}

	private static Dictionary<int, List<Seat>> __MutateLayoutAlt(Dictionary<int, List<Seat>> SourceLayout) {
		Dictionary<int, List<Seat>> MutatedLayout = __CloneLayout(SourceLayout);

		for (int i = 0; i < MutatedLayout.Count; i++) {
			for (int j = 0; j < MutatedLayout[i].Count; j++) {
				int AdyacentEmpty    = 0;
				int AdyacentOccupied = 0;
				int AdyacentFloor    = 0;

				for(int y = -1; y <= 1; y++) {
					for(int x = -1; x <= 1; x++) {
						int Offset = 1;
						if(y == 0 && x == 0) {
							// Skip current seat!
							continue;
						}

						try {
							Seat AdyacentSeat = SourceLayout[i + (y * Offset)][j + (x * Offset)];
							while(AdyacentSeat.State == SeatState.FLOOR) {
								Offset++;
								AdyacentSeat = SourceLayout[i + (y * Offset)][j + (x * Offset)];
							}

							switch (AdyacentSeat.State) {
								case SeatState.EMPTY:
									AdyacentEmpty += 1;
									break;
								case SeatState.OCCUPIED:
									AdyacentOccupied += 1;
									break;
								case SeatState.FLOOR:
									AdyacentFloor += 1;
									break;
							}
						}
						catch(Exception e) {
							// Out of bounds; lazy way to not boundaries xd
							continue;
						}
					}
				}

				switch (SourceLayout[i][j].State) {
					case SeatState.FLOOR:
						// Fuck the floor!
						break;
					case SeatState.EMPTY:
						if (AdyacentOccupied == 0) {
							MutatedLayout[i][j].State = SeatState.OCCUPIED;
						}
						break;
					case SeatState.OCCUPIED:
						if (AdyacentOccupied >= 5) {
							MutatedLayout[i][j].State = SeatState.EMPTY;
						}
						break;
				}

			}
		}

		return MutatedLayout;
	}
	private static int __GetOccupiedSeats(Dictionary<int, List<Seat>> Layout) {
		int Occupied = 0;

		foreach(List<Seat> Seats in Layout.Values) {
			foreach(Seat seat in Seats) {
				if(seat.State == SeatState.OCCUPIED) {
					Occupied++;
				}
			}
		}

		return Occupied;
	}

	private static long __SecondPart() {
		Dictionary<int, List<Seat>> CurrentLayout = new Dictionary<int, List<Seat>>();
		Dictionary<int, List<Seat>> MutatedLayout = __CloneLayout(__Seats);

		__PrintLayout(MutatedLayout);
		do {
			CurrentLayout = __CloneLayout(MutatedLayout);
			MutatedLayout = __MutateLayoutAlt(CurrentLayout);

			__PrintLayout(MutatedLayout);
		}
		while (JObject.FromObject(CurrentLayout).ToString() != JObject.FromObject(MutatedLayout).ToString());

		return __GetOccupiedSeats(MutatedLayout);
	}

	private static void __Init() {
		int LineIndex = 0;
		foreach(string Line in File.ReadAllLines("input.txt")) {
			__Seats.Add(LineIndex, new List<Seat>());
			foreach (char LineChar in Line) {
				__Seats[LineIndex].Add(new Seat(LineChar));
			}
			LineIndex++;
		}
	}
}
}

1 respuesta

r2d2rigo #706 Dic '20 Inocente

#705 pues bastante similar a como lo he hecho yo, pero me da que esa conversion de JSON que te trae entre manos es lo que esta haciendo que tarde tanto.

1 respuesta

Traber #707 Dic '20

#706 Nope, la conversión del JSON no tarda un carajo, lo que tarda es en la función "__MutateLayout" al hacer todas las mutaciones, a lo mejor si me aburro hago profiling a ver por dónde se le va la fuerza por la boca a esto.

1 respuesta

r2d2rigo #708 Dic '20 Inocente

#707 co;o claro tu sabes lo que se tarda en lanzar una excepcion? Y tu ahi regalandolas como caramelos

1 respuesta

Traber #709 Dic '20

#708 Es precisamente donde estoy metido ahora, porque creo que el problema es el overhead de capturar la exceptión en lugar de evitar que ocurra, ahora veo si es eso xd.

1 respuesta

r2d2rigo #710 Dic '20 Inocente

#709 estas corriendo el programa desde Visual Studio? La consola tiene un overhead altisimo cada vez que tiene que imprimir texto (como por ejemplo el de excepcion lanzada), prueba a correr el .exe fuera y veras como va algo mejor.

1 respuesta

Traber #711 Dic '20

#710 Nah, como imaginaba, el overhead del catch de la excepción es altísimo, ahora en unos pocos segundos las saca:

spoiler

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

namespace Day11 {
	public enum SeatState {
		FLOOR,
		EMPTY,
		OCCUPIED
	}

public class Seat {
	public SeatState State;

	public Seat(char SeatChar) {
		switch (SeatChar) {
			case '.':
				this.State = SeatState.FLOOR;
				break;
			case 'L':
				this.State = SeatState.EMPTY;
				break;
			case '#':
				this.State = SeatState.OCCUPIED;
				break;
		}
	}

	public override string ToString() {
		switch (this.State) {
			case SeatState.FLOOR:
				return ".";
			case SeatState.EMPTY:
				return "L";
			case SeatState.OCCUPIED:
				return "#";
		}

		return "";
	}
}

class Program {
	private static Dictionary<int, List<Seat>> __Seats = new Dictionary<int, List<Seat>>();

	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() {
		Dictionary<int, List<Seat>> CurrentLayout = new Dictionary<int, List<Seat>>();
		Dictionary<int, List<Seat>> MutatedLayout = __CloneLayout(__Seats);

		__PrintLayout(MutatedLayout);
		do {
			CurrentLayout = __CloneLayout(MutatedLayout);
			MutatedLayout = __MutateLayout(CurrentLayout);

			__PrintLayout(MutatedLayout);
		}
		while (JObject.FromObject(CurrentLayout).ToString() != JObject.FromObject(MutatedLayout).ToString());

		return __GetOccupiedSeats(MutatedLayout);
	}

	private static void __PrintLayout(Dictionary<int, List<Seat>> Layout) {
		foreach(List<Seat> Row in Layout.Values) {
			string Line = "";
			foreach(Seat seat in Row) {
				Line = Line + seat.ToString();
			}

			Console.WriteLine(Line);
		}

		Console.WriteLine("");
	}

	private static Dictionary<int, List<Seat>> __CloneLayout(Dictionary<int, List<Seat>> SourceLayout) {
		return JObject.Parse(JObject.FromObject(SourceLayout).ToString()).ToObject<Dictionary<int, List<Seat>>>();
	}

	private static Dictionary<int, List<Seat>> __MutateLayout(Dictionary<int, List<Seat>> SourceLayout) {
		Dictionary<int, List<Seat>> MutatedLayout = __CloneLayout(SourceLayout);

		for (int i = 0; i < MutatedLayout.Count; i++) {
			for (int j = 0; j < MutatedLayout[i].Count; j++) {
				int AdyacentEmpty    = 0;
				int AdyacentOccupied = 0;
				int AdyacentFloor    = 0;

				for(int y = -1; y <= 1; y++) {
					for(int x = -1; x <= 1; x++) {
						if(y==0 && x == 0) {
							// Skip current seat!
							continue;
						}

						try {
							if(__SeatExists(SourceLayout, i + y, j + x)) {
								Seat AdyacentSeat = SourceLayout[i+y][j+x];
								switch (AdyacentSeat.State) {
									case SeatState.EMPTY:
										AdyacentEmpty++;
										break;
									case SeatState.OCCUPIED:
										AdyacentOccupied++;
										break;
									case SeatState.FLOOR:
										AdyacentFloor++;
										break;
								}
							}
						}
						catch(Exception e) {
							// Out of bounds; lazy way to not boundaries xd
						}
					}
				}

				switch (SourceLayout[i][j].State) {
					case SeatState.FLOOR:
						// Fuck the floor!
						break;
					case SeatState.EMPTY:
						if (AdyacentOccupied == 0) {
							MutatedLayout[i][j].State = SeatState.OCCUPIED;
						}
						break;
					case SeatState.OCCUPIED:
						if (AdyacentOccupied >= 4) {
							MutatedLayout[i][j].State = SeatState.EMPTY;
						}
						break;
				}

			}
		}

		return MutatedLayout;
	}

	private static bool __SeatExists(Dictionary<int, List<Seat>> Layout, int Y, int X) {
		return
			Layout.ContainsKey(Y) &&
			(
				(X > 0)
				&&
				(X < Layout[Y].Count)
			)
		;
	}

	private static Dictionary<int, List<Seat>> __MutateLayoutAlt(Dictionary<int, List<Seat>> SourceLayout) {
		Dictionary<int, List<Seat>> MutatedLayout = __CloneLayout(SourceLayout);

		for (int i = 0; i < MutatedLayout.Count; i++) {
			for (int j = 0; j < MutatedLayout[i].Count; j++) {
				int AdyacentEmpty    = 0;
				int AdyacentOccupied = 0;
				int AdyacentFloor    = 0;

				for(int y = -1; y <= 1; y++) {
					for(int x = -1; x <= 1; x++) {
						int Offset = 1;
						if(y == 0 && x == 0) {
							// Skip current seat!
							continue;
						}

						try {
							if(__SeatExists(SourceLayout, i + (y * Offset), j + (x * Offset))) {
								Seat AdyacentSeat = SourceLayout[i + (y * Offset)][j + (x * Offset)];
								while(AdyacentSeat.State == SeatState.FLOOR) {
									Offset++;

									if(!__SeatExists(SourceLayout, i + (y * Offset), j + (x * Offset))) {
										break;
									}
									AdyacentSeat = SourceLayout[i + (y * Offset)][j + (x * Offset)];
								}

								switch (AdyacentSeat.State) {
									case SeatState.EMPTY:
										AdyacentEmpty += 1;
										break;
									case SeatState.OCCUPIED:
										AdyacentOccupied += 1;
										break;
									case SeatState.FLOOR:
										AdyacentFloor += 1;
										break;
								}
							}
						}
						catch (Exception e) {
							// Out of bounds; lazy way to not boundaries xd
							continue;
						}
					}
				}

				switch (SourceLayout[i][j].State) {
					case SeatState.FLOOR:
						// Fuck the floor!
						break;
					case SeatState.EMPTY:
						if (AdyacentOccupied == 0) {
							MutatedLayout[i][j].State = SeatState.OCCUPIED;
						}
						break;
					case SeatState.OCCUPIED:
						if (AdyacentOccupied >= 5) {
							MutatedLayout[i][j].State = SeatState.EMPTY;
						}
						break;
				}

			}
		}

		return MutatedLayout;
	}
	private static int __GetOccupiedSeats(Dictionary<int, List<Seat>> Layout) {
		int Occupied = 0;

		foreach(List<Seat> Seats in Layout.Values) {
			foreach(Seat seat in Seats) {
				if(seat.State == SeatState.OCCUPIED) {
					Occupied++;
				}
			}
		}

		return Occupied;
	}

	private static long __SecondPart() {
		Dictionary<int, List<Seat>> CurrentLayout = new Dictionary<int, List<Seat>>();
		Dictionary<int, List<Seat>> MutatedLayout = __CloneLayout(__Seats);

		__PrintLayout(MutatedLayout);
		do {
			CurrentLayout = __CloneLayout(MutatedLayout);
			MutatedLayout = __MutateLayoutAlt(CurrentLayout);

			__PrintLayout(MutatedLayout);
		}
		while (JObject.FromObject(CurrentLayout).ToString() != JObject.FromObject(MutatedLayout).ToString());

		return __GetOccupiedSeats(MutatedLayout);
	}

	private static void __Init() {
		int LineIndex = 0;
		foreach(string Line in File.ReadAllLines("input.txt")) {
			__Seats.Add(LineIndex, new List<Seat>());
			foreach (char LineChar in Line) {
				__Seats[LineIndex].Add(new Seat(LineChar));
			}
			LineIndex++;
		}
	}
}
}

R

RsTTa #712 Dic '20

#673 Bueno, ya tengo la segunda parte. Ayer no habia forma y eso que leí que habia que recorrer los valores en orden inverso, pero nada... Al final han quedado las dos partes en O(N).

Día 10

parte1

def counting_sort(joltages):
    min_joltage, max_joltage = min(joltages), max(joltages)
    available_joltages = [False for _ in range(min_joltage, max_joltage + 1)]
    offset = min_joltage
    for joltage in joltages:
        available_joltages[joltage - offset] = True
    return [(idx + offset) for idx, is_available in enumerate(available_joltages) if is_available]

if __name__ == '__main__':
    with open('input', 'r') as f:
        joltages = [int(joltage) for joltage in f.readlines()]

joltages.extend((0, max(joltages) + 3))
sorted_joltages = counting_sort(joltages)

offset = sorted_joltages[0]
joltdiff_1, joltdiff_3 = 0, 0
prev_joltage = sorted_joltages[0]
for joltage in sorted_joltages:
    if (joltage - prev_joltage) == 1:
        joltdiff_1 += 1
    elif (joltage - prev_joltage) == 3:
        joltdiff_3 += 1
    prev_joltage = joltage
print(joltdiff_1, joltdiff_3, joltdiff_1 * joltdiff_3)

parte2

def counting_sort(joltages):
    min_joltage, max_joltage = min(joltages), max(joltages)
    available_joltages = [False for _ in range(min_joltage, max_joltage + 1)]
    offset = min_joltage
    for joltage in joltages:
        available_joltages[joltage - offset] = True
    return [(idx + offset) for idx, is_available in enumerate(available_joltages) if is_available]


def dp_solve(sorted_joltages):
    dp = [0 for _ in sorted_joltages]
    dp[-1] = 1
    for idx in range(len(dp) - 2, -1, -1):
        dp[idx] = sum(dp[i] for i in range(idx+1, idx+4)
                      if (i < len(dp))
                        and ((sorted_joltages[i] - sorted_joltages[idx]) <= 3))
    return dp[0]


if __name__ == '__main__':
    with open('input', 'r') as f:
        joltages = [int(joltage) for joltage in f.readlines()]

joltages.extend((0, max(joltages) + 3))
sorted_joltages = counting_sort(joltages)
print(dp_solve(sorted_joltages))

MartiONE #713 Dic '20 El reportero de guerra sonriente

Ya estaría, menos rompecabezas de lo que esperaba:

spoiler

with open('input.txt', 'r') as file:
    map = [x.strip() for x in file.readlines()]

def get_seat(row, col, x, y, seatmap):
    if x == 0 and y == 0:
        return False
    if row + x < 0 or row + x > len(seatmap[0]) - 1:
        return False
    if col + y < 0 or col + y > len(seatmap) - 1:
        return False

    if seatmap[row+x][col+y] == ".":
        return get_seat(row+x, col+y, x, y, seatmap)
    else:
        return seatmap[row+x][col+y]


def process_adjacent(row, col, seatmap):
    adj = []
    for x in range(-1, 2):
        for y in range(-1, 2):
            seat = get_seat(row, col, x, y, seatmap)
            if seat:
                adj.append(seat)
            else:
                adj.append(".")

    return adj


def process_round(seatmap):
    new_seatmap = []
    for r, row in enumerate(seatmap):
        new_row = []
        for c, column in enumerate(row):
            if column == "L":
                if "#" not in process_adjacent(r, c, seatmap):
                    new_row.append("#")
                else:
                    new_row.append("L")
            elif column == "#":
                if process_adjacent(r, c, seatmap).count("#") >= 5:
                    new_row.append("L")
                else:
                    new_row.append("#")
            else:
                new_row.append(".")
        new_seatmap.append(new_row)
    return new_seatmap


while True:
    new_map = process_round(map)
    if map == new_map:
        print(map)
        print(sum([x.count("#") for x in map]))
        break
    else:
        map = new_map

R

RsTTa #714 Dic '20

Día 11. En la segunda para para obtener los primeros valores visibles no me ha quedado muy bonito. He hecho 2 comprobaciones para las filas (superiores e inferiores), 2 para las columnas y 4 para las diagionales xD

parte1

def get_adjacent_values(row, col, grid):
    adjacent_values = []
    for curr_row in range(max(0, row-1), min(row+2, len(grid))):
        for curr_col in range(max(0, col-1), min(col+2, len(grid[curr_row]))):
            if (row, col) != (curr_row, curr_col):
                adjacent_values.append(grid[curr_row][curr_col])
    return adjacent_values


def transform_grid(grid):
    tmp_grid = [[v for v in row] for row in grid]
    changes = 0
    for idx_row, row in enumerate(grid):
        for idx_col, val in enumerate(row):
            if val == 'L' and all(v in ('L', '.') for v in get_adjacent_values(idx_row, idx_col, grid)):
                tmp_grid[idx_row][idx_col] = '#'
                changes += 1
            elif val == '#' and sum(v == '#' for v in get_adjacent_values(idx_row, idx_col, grid)) >= 4:
                tmp_grid[idx_row][idx_col] = 'L'
                changes += 1

return changes, tmp_grid


if __name__ == '__main__':
    with open('input', 'r') as f:
        grid = [list(line.strip()) for line in f.readlines()]

while t := transform_grid(grid):
    changes, grid = t
    if not changes:
        break
print(len([v for row in grid for v in row if v == '#']))

parte2

def get_first_visible_values(row, col, values, grid):
    visible_values = []

# rows
for curr_row in range(row-1, -1, -1):
    if (val := grid[curr_row][col]) in values:
        visible_values.append(val)
        break
for curr_row in range(row+1, len(grid)):
    if (val := grid[curr_row][col]) in values:
        visible_values.append(val)
        break

# cols
for curr_col in range(col-1, -1, -1):
    if (val := grid[row][curr_col]) in values:
        visible_values.append(val)
        break
for curr_col in range(col+1, len(grid[row])):
    if (val := grid[row][curr_col]) in values:
        visible_values.append(val)
        break

# diagonals
curr_row, curr_col = row-1, col-1
while (curr_row >= 0) and (curr_col >= 0):
    if (val := grid[curr_row][curr_col]) in values:
        visible_values.append(val)
        break
    curr_row, curr_col = curr_row - 1, curr_col - 1
curr_row, curr_col = row + 1, col + 1
while (curr_row < len(grid)) and (curr_col < len(grid[curr_row])):
    if (val := grid[curr_row][curr_col]) in values:
        visible_values.append(val)
        break
    curr_row, curr_col = curr_row + 1, curr_col + 1
curr_row, curr_col = row - 1, col + 1
while (curr_row >= 0) and (curr_col < len(grid[curr_row])):
    if (val := grid[curr_row][curr_col]) in values:
        visible_values.append(val)
        break
    curr_row, curr_col = curr_row - 1, curr_col + 1
curr_row, curr_col = row + 1, col - 1
while (curr_row < len(grid)) and (curr_col >= 0):
    if (val := grid[curr_row][curr_col]) in values:
        visible_values.append(val)
        break
    curr_row, curr_col = curr_row + 1, curr_col - 1

return visible_values


def transform_grid(grid):
    values = {'L', '#'}
    tmp_grid = [[v for v in row] for row in grid]
    changes = 0
    for idx_row, row in enumerate(grid):
        for idx_col, val in enumerate(row):
            if val == 'L' and all(v == 'L' for v in get_first_visible_values(idx_row, idx_col, values, grid)):
                tmp_grid[idx_row][idx_col] = '#'
                changes += 1
            elif val == '#' and sum(v == '#' for v in get_first_visible_values(idx_row, idx_col, values, grid)) >= 5:
                tmp_grid[idx_row][idx_col] = 'L'
                changes += 1
    return changes, tmp_grid


if __name__ == '__main__':
    with open('input', 'r') as f:
        grid = [list(line.strip()) for line in f.readlines()]

while t := transform_grid(grid):
    changes, grid = t
    if not changes:
        break
print(len([v for row in grid for v in row if v == '#']))

eZpit #715 Dic '20 Juntabrackets

Al final he hecho un método para las dos partes del día 11.
Hoy me he pegado un poco con el usize de Rust, que no puede ser negativo y me ha obligado a hacer unas cuantas conversiones algo feas, pero bueno. Acepto sugerencias si alguien sabe hacerlo un poco más elegante.

Day 11 Rust

fn iterate_until_stable(map: &Array2D<Seat>, search_visible: bool, threshold: i32) -> Array2D<Seat> {
    let directions: Vec<(i32, i32)> = vec![
        (-1, 1), (0, 1), (1, 1),
        (-1, 0),         (1, 0),
        (-1,-1), (0,-1), (1,-1),
    ];

let mut seat_map = map.clone();

let valid_x = 0..seat_map.num_columns() as i32;
let valid_y = 0..seat_map.num_rows() as i32;

loop {
    let mut changed = false;

    let initial_seat_map = seat_map.clone();

    for x in 0..initial_seat_map.num_columns() {
        'outer: for y in 0..initial_seat_map.num_rows() {

            let occupied = if let Some(occ) = initial_seat_map[(y, x)] {
                occ
            } else {
                continue
            };

            let mut occupied_seats = 0;

            for direction in &directions {
                let mut distance = 1;
                loop {
                    let target_x = x as i32 + (direction.0 * distance);
                    if !valid_x.contains(&target_x) { break }

                    let target_y = y as i32 + (direction.1 * distance);
                    if !valid_y.contains(&target_y) { break }

                    let target_index = (target_y as usize, target_x as usize);

                    let target_seat = initial_seat_map[target_index];

                    if let Some(visible_seat_occupied) = target_seat {
                        if visible_seat_occupied {
                            occupied_seats += 1;

                            if occupied && occupied_seats >= threshold {
                                seat_map[(y, x)] = Some(false);
                                changed = true;
                                continue 'outer;
                            }
                        }
                        break
                    }

                    if search_visible {
                        distance += 1
                    } else {
                        break
                    }
                }
            }

            if !occupied && occupied_seats == 0 {
                seat_map[(y, x)] = Some(true);
                changed = true;
            }
        }
    }

    if !changed {
        break
    }
}

seat_map
}

Fyn4r #716 Dic '20 Inocente

Dia 11 listo. No pude dedicarle tiempo en casi todo el día asi que la segunda parte es un copy paste de la primera bastante basto xD

Leos #717 Dic '20

https://github.com/Leos1113/Advent-of-code-2020/tree/main/day3

Soy el más lento del hilo, peor ya he superado al año pasado que solo hice 2 xD a ver si este finde le meto más caña y adelanto unos cuantos dias xD

1 1 respuesta

JuAn4k4 #718 Dic '20

#717 ¿ No te lo habrás copiado no ?

Yo lo dejé ya, en el día 9 creo, fue un mal día y ya paré del todo. Tener que estar todos los días programando en la hora que tengo libre para sentarme en el sofá sin hacer nada se hace algo pesado la verdad.

1 respuesta

QuitCat #719 Dic '20 Gafe

El de hoy es más difícil de entender que de hacer, principalmente la segunda parte.
Y espero que no haya que reutilizar porque lo tengo bastante guarro

B

[Borrado] #720 Dic '20

Me estoy muriendo de la puta pereza con este de los barquitos jajajajajaja

De momento la parte 1

spoiler

import sys

dir_vecs = {
	'N': lambda v, k: [1, 0],
	'S': lambda v, k: [-1, 0],
	'E': lambda v, k: [0, 1],
	'W': lambda v, k: [0, -1],
	'F': lambda v, k: v,
	'R90': lambda v, k: [-v[1], v[0]],
	'R': lambda v, k: dir_vecs['R90'](v, k) if k == 90
						else dir_vecs['R'](dir_vecs['R90'](v, k), k - 90),
	'L': lambda v, k: dir_vecs['R'](v, 360 - k)
}

lines = [(x[0], int(x[1:])) for x in open(sys.argv[1]).readlines()]

pos = [0, 0]
direction = [0, 1]

for (op, val) in lines:
	dir_vec = dir_vecs[op](direction, val)
	if op not in ['L', 'R']:
		pos = [pos[0] + val * dir_vec[0], pos[1] + val * dir_vec[1]]
	else:
		direction = dir_vec

print(abs(pos[0]) + abs(pos[1]))

Parte 2

spoiler

import sys

dir_vecs = {
	'N': lambda v, k: [v[0] + k, v[1]],
	'S': lambda v, k: [v[0] - k, v[1]],
	'E': lambda v, k: [v[0], v[1] + k],
	'W': lambda v, k: [v[0], v[1] - k],
	'F': lambda v, k: v,
	'R90': lambda v, k: [-v[1], v[0]],
	'R': lambda v, k: dir_vecs['R90'](v, k) if k == 90
						else dir_vecs['R'](dir_vecs['R90'](v, k), k - 90),
	'L': lambda v, k: dir_vecs['R'](v, 360 - k)
}

lines = [(x[0], int(x[1:])) for x in open(sys.argv[1]).readlines()]

pos = [0, 0]
direction = [1, 10]

for (op, val) in lines:
	if op == 'F':
		pos = [pos[0] + val * direction[0], pos[1] + val * direction[1]]
	else:
		direction = dir_vecs[op](direction, val)
	print(pos)

print(abs(pos[0]) + abs(pos[1]))

Lo de rotar los vectores ha sido porque mi vision espacial solo me daba para imaginarme como se rotaban 90 grados y no queria pensar mas, la verdad.

1 respuesta

¿Dónde me apunto?

Normas

Leaderboard privado para el pique sano

Las respuestas se postean en Spoiler + code

Usuarios habituales

Tags