Advent of Code 2021: Casi no llegamos edition

Pizzelio #181 Dic '21

#2 Me acabo de meter al leaderboard, nick en aoc: jorgeorvaz

Gracias!

fehnd #182 Dic '21

Guau, el 3 hecho, la parte B me ha dado por saco, y al final no he aprovechado la parte del first en pos de hacerlo recursivo, pero bueno (es un aborto, pero va)

Codigo1


import re

def return_lines():
    file1 = open('input.txt', 'r')
    Lines = file1.readlines()
    return Lines

def first(Lines=return_lines()):
    gamma_rate = 0
    epsilon_rate = 0
    results_array = []
    common_string = ""
    least_string = ""
    example_line = Lines[0].replace("\n","")
    elements = len(example_line)
    for index in range(elements):
        results_array.append("")

for line in Lines:
    line_formatted = line.replace("\n", "")
    line_list = list(line_formatted)
    for idx, character in enumerate(line_list):
        results_array[idx]+=character

for result in results_array:
    number_of_zeros = result.count("0")
    number_of_ones = result.count("1")
    if number_of_ones > number_of_zeros:
        common_string += "1"
        least_string += "0"
    elif number_of_ones < number_of_zeros:
        common_string += "0"
        least_string += "1"

gamma_rate = int(common_string, 2)
epsilon_rate = int(least_string, 2)
print("RESULT IS = {}".format(gamma_rate*epsilon_rate))

Codigo2

def calculate_common(array=[], position=0):
    results_array = ""
    example_line = array[0].replace("\n","")
    elements = len(example_line)

for line in array:
    line_formatted = line.replace("\n", "")
    line_list = list(line_formatted)
    results_array += line_list[position]

number_of_zeros = results_array.count("0")
number_of_ones = results_array.count("1")
if number_of_ones > number_of_zeros:
    return "1"
elif number_of_ones < number_of_zeros:
    return "0"
elif number_of_ones == number_of_zeros:
    return "1"

def calculate_least(array=[], position=0):
    results_array = ""
    example_line = array[0].replace("\n","")

for line in array:
    line_formatted = line.replace("\n", "")
    line_list = list(line_formatted)
    results_array += line_list[position]
        
number_of_zeros = results_array.count("0")
number_of_ones = results_array.count("1")
if number_of_ones > number_of_zeros:
    return "0"
elif number_of_ones < number_of_zeros:
    return "1"
elif number_of_ones == number_of_zeros:
    return "0"

def determine_rating(array=[], index=0, type=""):

if len(array) == 1:
    return array[0].replace("\n", "")
else:
    value = ""
    if type == "common":
        value = calculate_common(array, index)
    elif type == "least":
        value = calculate_least(array, index)
    else:
        return ("FIAL")

    new_index = index + 1
    array_new_values = []
    
    for element in array:
        if element[index] == value:
            array_new_values.append(element)

    return determine_rating(array_new_values, new_index, type)

def second(Lines=return_lines()):
    oxygen_rating = ""
    CO2_scrubber_rating = ""

oxygen_rating = determine_rating(list(Lines),0,"common")
CO2_scrubber_rating = determine_rating(list(Lines),0, "least")

oxygen_rating_decimal = int(oxygen_rating, 2)
CO2_scrubber_rating_decimal = int(CO2_scrubber_rating, 2)

print("RESULT IS = {}".format(oxygen_rating_decimal*CO2_scrubber_rating_decimal))

B

[Borrado] #183 Dic '21

Prueba 3.A

3.A

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

lines = zip(*lines)
gamma = int(''.join(('1' if line.count('1') > line.count('0') else '0' for line in lines)), 2)
epsilon = gamma ^ 0xFFF
print(gamma * epsilon)

Prueba 3.B

3.B

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

def get_rating(data, e, lower):
    num_lines = len(data)
    if num_lines > 1:
        half_lines = num_lines / 2
        count_bits = 0
        for line in data:
            count_bits += int(line[e])
        bitval = (lower and '0' or '1') if count_bits >= half_lines else (lower and '1' or '0')
        return list(filter(lambda x: x[e] == bitval, data))
    return data
    

ogr_lines = lines[:]
csr_lines = lines[:]
numbits = 12
for e in range(numbits):
    # Oxygen Generation Rating
    ogr_lines = get_rating(ogr_lines, e, False)
    # CO2 Scrubber Rating
    csr_lines = get_rating(csr_lines, e, True)

ogr = int(ogr_lines[0], 2)
csr = int(csr_lines[0], 2)

print(ogr * csr)

Pizzelio #184 Dic '21

Joder la segunda parte me ha costao bastante sacarla hoy. Alguien lo ha hecho con java? Por ver otras formas, yo he acabado haciendo una ñapa brutal...

Sleidom #185 Dic '21 Rocketeer

Un poco tarde pero dia3 en Kotlin, curiosamente me ha quedado mucho mejor la parte 2 que la 1 xd

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>) {
    val matrix = convertListToMatrix(input)
    val res = findPowerConsumption(matrix)
    println(res)
}

private fun convertListToMatrix(input: List<String>) : Array<IntArray> {
    val matrix = Array(input.size) { IntArray(input[0].length) }
    for( i in input.indices) {
        matrix[i] = input[i].map{ it.toString().toInt() }.toIntArray()
    }
    return matrix
}

private fun findPowerConsumption(matrix: Array<IntArray>): Int {
    var gammaRate = ""
    var epsilonRate = ""

for (i in matrix[0].indices) {
    var ones = 0
    var zeros = 0
    for (j in matrix.indices) {
        if (matrix[j][i] == 0) zeros++
        else ones++
    }
    if (zeros > ones) {
        gammaRate += "0"
        epsilonRate += "1"
    } else {
        gammaRate += "1"
        epsilonRate += "0"
    }
}

val gammaRateDec = Integer.parseInt(gammaRate, 2)
val epsilonRateDec = Integer.parseInt(epsilonRate, 2)
return gammaRateDec * epsilonRateDec
}

private fun partTwo(input: List<String>) {
    val compFunc1 = { a: List<String>, b: List<String> -> a.size >= b.size }
    val compFunc2 = { a: List<String>, b: List<String> -> b.size > a.size }
    val oxygenRating = findRating(input, 0, compFunc1)
    val co2Rating = findRating(input, 0, compFunc2)
    println(oxygenRating * co2Rating)
}

private fun findRating(input: List<String>, pos: Int, comparison: (List<String>, List<String>) -> Boolean) : Int{
    if (input.size == 1) return Integer.parseInt(input[0], 2)

    val ones = input.filter { it[pos].toString().toInt() == 1 }
    val zeros =input.filter { it[pos].toString().toInt() == 0 }

    val newPos = pos + 1

    if (comparison(ones, zeros)) return findRating(ones, newPos, comparison)
    return findRating(zeros, newPos, comparison)
}

kroaton #186 Dic '21 Le Connoisseur

Día 4

Sleidom #187 Dic '21 Rocketeer

Bingo en Kotlin, un poco aborto el codigo pero ahi va xD

spoiler

import java.io.File

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

val bingoNumbers = input.removeAt(0)
val matrixs = ArrayList<Array<IntArray>>(0)
var currentMat = -1
var row = 0
var col = 0
val regex = "\\s+".toRegex()
input.forEach {
    val str = it.trim()
    if (str != "") {
        str.split(regex).forEach {
            matrixs[currentMat][row][col] = it.toInt()
            col++
        }
        row++
        col = 0
    } else {
        matrixs.add(Array(5) { IntArray(5) })
        currentMat++
        row = 0
        col = 0
    }
}

val resOne = playBingo(bingoNumbers.split(",").map { it.toInt() }, matrixs, true)
val resTwo = playBingo(bingoNumbers.split(",").map { it.toInt() }, matrixs, false)
println(resOne)
println(resTwo)
}

fun checkBingo(matrix: Array<IntArray>): Boolean {
    var winH = true
    var winV = true
    for (i in matrix.indices) {
        winH = true
        winV = true
        for (j in matrix[0].indices) {
            if (matrix[i][j] != -1) {
                winH = false
            }
            if (matrix[j][i] != -1) {
                winV = false
            }
        }
        if (winH || winV) return true
    }
    return winH || winV
}

fun calculateRes(matrix: Array<IntArray>, num: Int): Int {
    var sum = 0
    for (i in matrix.indices) {
        for (j in matrix[0].indices) {
            if (matrix[i][j] != -1) {
                sum += matrix[i][j]
            }
        }
    }
    return sum * num
}

fun playBingo(bingoNumbers: List<Int>, matrixs: ArrayList<Array<IntArray>>, stopOnWin: Boolean): Int {
    var bingos = IntArray(matrixs.size)
    bingoNumbers.forEach { num ->
        matrixs.forEachIndexed { index, actualMat ->
            for (i in actualMat.indices) {
                for (j in actualMat[0].indices) {
                    if (actualMat[i][j] == num) {
                        actualMat[i][j] = -1
                        if (checkBingo(actualMat)) {
                            bingos[index]++
                            if (stopOnWin || bingos.none { it == 0 })
                                return calculateRes(actualMat, num)
                        }
                    }
                }
            }
        }
    }
    return -1
}

BeheritSp #188 Dic '21 Juntabrackets

Mi solución en python

Day 4

def generate_boards_list(boards_lines):
    boards_list = []
    board = {}
    i=0
    for line in boards_lines:
        if line == '':
            boards_list.append(board)
            board={}
            i=0
        else:
            for j, number in enumerate(line.split()):
                board[(i,j)] = [int(number), False]
            i += 1
    boards_list.append(board)
    return boards_list

def check_if_someone_won(boards_list):
    for board in boards_list:
        #check rows
        for i in range(5):
            if min(board[(i,j)][1] for j in range(5)):
                return board
        #check cols
        for j in range(5):
            if min(board[(i,j)][1] for i in range(5)):
                return board
    return None

def check_all_winners(boards_list):
    winners = []
    for board in boards_list:
        #check rows
        for i in range(5):
            if min(board[(i,j)][1] for j in range(5)) and board not in winners:
                winners.append(board)
                break
        #check cols
        for j in range(5):
            if min(board[(i,j)][1] for i in range(5)) and board not in winners:
                winners.append(board)
                break
    return winners

def set_matching_key(board, number):
    for key in board.keys():
        if board[key][0] == number:
            board[key][1] = True
            return board
    return board

if __name__ == "__main__":
    lines_list = open("input.txt").read().splitlines()
    random_numbers = [int(number) for number in lines_list[0].split(",")]
    boards_lines = lines_list[2:]
    boards_list = generate_boards_list(boards_lines)
    for number in random_numbers:
        for board in boards_list:
            board = set_matching_key(board, number)
        winner = check_if_someone_won(boards_list)
        if winner is not None:
            break
    print("Part 1", number*sum(value[0] for value in winner.values() if not value[1]))

    boards_list = generate_boards_list(boards_lines)
    for number in random_numbers:
        for board in boards_list:
            board = set_matching_key(board, number)
        winners = check_all_winners(boards_list)
        if len(winners) > 0:
            if len(boards_list) > 1:
                for winner in winners:
                    boards_list.remove(winner)
            else:
                break
    winner = winners[0]
    print("Part 2", number*sum(value[0] for value in winner.values() if not value[1]))

Fyn4r #189 Dic '21 Inocente

Dia 4 con threads, uno por cartón xd

https://github.com/Fynardo/AoC2k21/blob/main/day4/bingo.py

1 respuesta

B

[Borrado] #190 Dic '21

#189 yo si necesitas hablar MP y lo que quieras

Dia 4 partes 1 y 2, parte 1 es el primer numero printado, parte 2 el ultimo

spoiler

import numpy as np
import sys

marked_sequence = map(int, sys.stdin.readline().split(','))
cartoncikos = []

for line in sys.stdin:
  cartoncillo = np.zeros((5, 5), dtype=np.uint32)
  for i in range(5):
    cartoncillo[i, :] = \
      list(map(int, sys.stdin.readline().strip().split()))
  cartoncikos.append(cartoncillo)

# Part 1
already_marked = set()

for cur in marked_sequence:
  already_marked.add(cur)
  winner_cartoncetes = [
    (i, x) for i, x in enumerate(cartoncikos) if
    any(
      all(x[i, j] in already_marked for j in range(5)) or
      all(x[j, i] in already_marked for j in range(5))
      for i in range(5)
    )
  ]
  if winner_cartoncetes:
    cartonbanks = winner_cartoncetes[0][1]
    print(sum(x for x in cartonbanks.flatten() if x not in already_marked) * cur)
  winner_indices = set([x[0] for x in winner_cartoncetes])
  cartoncikos = [cartoncikos[i] for i in range(len(cartoncikos)) if i not in winner_indices]

B

[Borrado] #191 Dic '21

Not the best, pero aqui estamos.

day4

# return [a,b] with boolean true a if we win the bingo and the board winner b or just a false
def check(bin_cards):
    for idx,bingo_card in enumerate(bin_cards):
        for bingo_line in bingo_card:
            if(bingo_line.count(-1)==5):
                return[1,idx]
    return [0,0]

def calculateResult(winner_number, card):
    print('\n###  We won, let\'s calculate the result  ###')
    print('Winner number is: '+ winner_number)
    print('Card result is: ')
    print( card)
    sum=0
    for bingo_line in card:
       for element in bingo_line:
           if int(element) > 0:
               sum+= int(element)
    print(sum*int(winner_number))

def part1():
    raw_lines = [ l.strip() for l in open('res/test4.txt').readlines()]
    nm = raw_lines.pop(0)
    raw_lines.append('')
    bin_lines=[]
    bin_cards= []
    for line in raw_lines[1:]:
        if line == '':
            bin_cards.append(bin_lines)
            bin_lines = []
        else:
            bin_lines.append(line.split())
    print(bin_cards)
    # print(bin_lines)
    nm=nm.split(',')
    success=[]
    winner_number = 0
    for idx,element in enumerate(nm):
        for bingo_card in bin_cards:
            for bingo_line in bingo_card:
                for idx,num in enumerate(bingo_line):
                    if element == num:
                        # print(bingo_line, element)
                        bingo_line[idx] = -1

    success = check(bin_cards)
    if(success[0]==1):
        winner_number = element
        break
calculateResult(winner_number,bin_cards[success[1]])

def checkForLoser(winner_list,bin_cards,no_of_cards):
    trasposedbingo = []
    for element in bin_cards:
        trasposedbingo.append(list(map(list, zip(*element))))
    idx=0
    for bingo_card,bingo_card_trasposed in zip(bin_cards,trasposedbingo):
        if idx in winner_list:
            pass
        else:
            for bingo_line,bingo_line_trasposed in zip(bingo_card,bingo_card_trasposed):

            if bingo_line.count(-1) == 5 or bingo_line_trasposed.count(-1) == 5:
                if len(winner_list)  == no_of_cards:
                    print(winner_list)
                    return [1, idx]
                else:
                    if idx not in winner_list:
                        winner_list.append(idx)
    idx+=1
return [0,winner_list]

def part2():
    raw_lines = [ l.strip() for l in open('res/day4.txt').readlines()]
    nm = raw_lines.pop(0)
    raw_lines.append('')
    bin_lines=[]
    bin_cards= []
    for line in raw_lines[1:]:
        if line == '':
            bin_cards.append(bin_lines)
            bin_lines = []
        else:
            bin_lines.append(line.split())
    nm=nm.split(',')
    success=[]
    winner_number = 0
    winner_list=[]
    no_of_cards = len(bin_cards)
    for idx,element in enumerate(nm):
        for bingo_card in bin_cards:
            for bingo_line in bingo_card:
                for idx,num in enumerate(bingo_line):
                    if element == num:
                        bingo_line[idx] = -1
        success = checkForLoser(winner_list,bin_cards,no_of_cards)
        winner_list = success[1]
        if(success[0]==1):
            winner_number = element
            break
    print(bin_cards)
    calculateResult(winner_number,bin_cards[success[1]])

part2()

hda #192 Dic '21 Agujeros negros ( ͡° ͜ʖ ͡°)

#133

Leos #193 Dic '21

Voy con retraso, pero no he tenido tiempo de ponerme antes XD

Aquí va el segundo día
https://github.com/Leos1113/Advent-of-code-2021/blob/main/day2/src/main.rs

Sleidom #194 Dic '21 Rocketeer

Dia 5 hecho, no he conseguido reutilizar la parte del 1 y de hecho repito bastante codigo pero bueno...
Igual mas tarde lo mejoro y lo subo por aqui

#2 @Fyn4r cuando tengas un rato, añademe a la lista, mi user en AoC es Sleidom

BeheritSp #195 Dic '21 Juntabrackets

Dia 5

spoiler

from collections import defaultdict

def process_vent_1(diagram, line):
    pos1,pos2 = line.split('->')
    x1,y1 = (int(pos) for pos in pos1.split(','))
    x2,y2 = (int(pos) for pos in pos2.split(','))
    if x2==x1: # vertical
        dif = 1 if y2 > y1 else -1
        pos = y1
        while not pos == y2:
            diagram[(x1,pos)] += 1
            pos += dif
        diagram[(x1,pos)] += 1
    elif y2==y1: # horizontal
        dif = 1 if x2 > x1 else -1
        pos = x1
        while not pos == x2:
            diagram[(pos,y1)] += 1
            pos += dif
        diagram[(pos,y1)] += 1

def process_vent_2(diagram, line):
    pos1,pos2 = line.split('->')
    x1,y1 = (int(pos) for pos in pos1.split(','))
    x2,y2 = (int(pos) for pos in pos2.split(','))
    dif_y = 1 if y2 > y1 else -1 if y1 > y2 else 0
    dif_x = 1 if x2 > x1 else -1 if x1 > x2 else 0
    pos_x,pos_y = x1,y1
    while not (pos_x == x2 and pos_y == y2):
        diagram[(pos_x,pos_y)] += 1
        pos_x += dif_x
        pos_y += dif_y
    diagram[(pos_x,pos_y)] += 1


if __name__ == '__main__':
    lines_list = open('input.txt', 'r').read().splitlines()
    diagram = defaultdict(lambda: 0)
    for line in lines_list:
        process_vent_1(diagram, line)
    print("Part 1", sum(value>=2 for value in diagram.values()))

    diagram = defaultdict(lambda: 0)
    for line in lines_list:
        process_vent_2(diagram, line)

    print("Part 2", sum(value>=2 for value in diagram.values()))

B

[Borrado] #196 Dic '21

Dia 5 partes 1 y 2, si llamas al programa poniendo un 1 te hace la parte 1, si lo llamas con un 0 te hace la parte 2

spoiler

import re
import sys
from collections import Counter

is_part_1 = int(sys.argv[1])

point_re = re.compile(r'(\d+),(\d+) \-> (\d+),(\d+)')

point_count = Counter()

for line in sys.stdin:
  x1, y1, x2, y2 = map(int, re.match(point_re, line).groups())
  if not is_part_1 or (x1 != x2) ^ (y1 != y2):
    point_count[(x1, y1)] += 1
    while (x1 != x2) or (y1 != y2):
      x1 += 1 if x2 > x1 else -1 if x2 < x1 else 0
      y1 += 1 if y2 > y1 else -1 if y2 < y1 else 0
      point_count[(x1, y1)] += 1

print(sum((val > 1) for val in point_count.values()))

Flashk #197 Dic '21

Me ha molado mucho el ejercicio de hoy:

spoiler

Day 05

Para el modelo de datos, he modelado varias clases responsables de almacenar coordenadas y direcciones, así como la realización de transformaciones de coordenadas:

Clase Vent

@Getter
public class Vent {

private Position startPos;
private Position endPos;
private Direction direction;

public Vent(Position startPos, Position endPos) {
	
	this.startPos = startPos;
	this.endPos = endPos;
	this.direction = new Direction(startPos, endPos);
	
}


}

Clase Position

@Getter
@AllArgsConstructor
public class Position {

private int x;
private int y;

public void transform(Direction direction) {
	this.x += direction.getX();
	this.y += direction.getY();
}

@Override
public boolean equals(Object obj) {
	if (this == obj)
		return true;
	if (obj == null)
		return false;
	if (getClass() != obj.getClass())
		return false;
	Position other = (Position) obj;
	if (x != other.x)
		return false;
	if (y != other.y)
		return false;
	return true;
}
}

Clase Direction

@Getter
public class Direction {

private int x;
private int y;

public Direction(Position startPos, Position endPos) {
	
	// Calculations to obtain an unitary vector to define the direction
	Integer xSubstraction = endPos.getX() - startPos.getX();
	Integer ySubstraction = endPos.getY() - startPos.getY();
	
	x = (xSubstraction != 0) ? (xSubstraction / Math.abs(xSubstraction)) : 0;
	y = (ySubstraction != 0) ? (ySubstraction / Math.abs(ySubstraction)) : 0;
	
}

boolean isDiagonal() {
	return (x != 0) && (y != 0);
}

}

Y finalmente, la clase directora que gestiona todo, incluye un booleano para determinar si debe procesar diagonales o no:

HydrothermalVenture

public class HydrothermalVenture {

private final static String COORDINATES_PATTERN = "([0-9]*),([0-9]*) -> ([0-9]*),([0-9]*)";
private final static Pattern PATTERN = Pattern.compile(COORDINATES_PATTERN);
private final static Integer OVERLAPPING_SATURATION = 2;

private Integer[][] heatMap;
private List<Vent> vents = new ArrayList<>();
private int totalOverlapCount = 0;

public HydrothermalVenture(List<String> inputs) {
	
	int maxX = 0;
	int maxY = 0;
	
	for(String input : inputs) {
		
		Matcher matcher = PATTERN.matcher(input);
		matcher.find();
		
		Integer x1 = Integer.valueOf(matcher.group(1));
		Integer y1 = Integer.valueOf(matcher.group(2));
		Integer x2 = Integer.valueOf(matcher.group(3));
		Integer y2 = Integer.valueOf(matcher.group(4));
		
		// Update max x and y to define array limits
		maxX = Math.max(x1, Math.max(x2, maxX));
		maxY = Math.max(y1, Math.max(y2, maxY));

		// Add vent data
		Position startPos = new Position(x1,y1);
		Position endPos = new Position(x2, y2);
		vents.add(new Vent(startPos, endPos));
		
	}
	
	// Initialize overlapping map
	heatMap = new Integer[maxX+1][maxY+1];
	
	for(int i = 0; i < heatMap.length; i++) {
		for(int j = 0; j < heatMap[i].length; j++) {
			heatMap[i][j] = 0;
		}
	}
}

public int solve(boolean includeDiagonals) {
	
	totalOverlapCount = 0;
	
	if(includeDiagonals) {
		vents.stream().forEach(this::calculateOverlaps);
	} else {
		vents.stream().filter(vent -> !vent.getDirection().isDiagonal()).forEach(this::calculateOverlaps);
	}
	
	return totalOverlapCount;
	
}

private void calculateOverlaps(Vent vent) {
	
	boolean traversed = false;
	Position currentPos = vent.getStartPos();
	
	do {
		
		Integer currentHeat = ++heatMap[currentPos.getX()][currentPos.getY()];
	
		if(currentHeat == OVERLAPPING_SATURATION) {
			totalOverlapCount++;
		}
		
		if(currentPos.equals(vent.getEndPos())) {
			traversed = true;
		} else {
			currentPos.transform(vent.getDirection());
		}
		
	} while(!traversed);
}

JuAn4k4 #198 Dic '21

¿Que sentido tiene hacer abortos de código? Los primeros días suelen ser muy fáciles, es mejor hacer las cosas un poco mejor y reusarlo para los siguientes días

2 respuestas

hda #199 Dic '21 Agujeros negros ( ͡° ͜ʖ ͡°)

#198 ver los ingenios de los demás. La forma canónica, sea la que fuere, posiblemente resulte en la más eficiente. Pero ver la creatividad de otros puede darle ideas a uno.

Por lo menos así lo veo yo, y es lo que más allá del reto en sí me atrae de estos juegos, intentar entender vuestras aproximaciones.

2

Fyn4r #200 Dic '21 Inocente

#198 el de hoy aun no lo miré, pero soy súper fan del intcode computer de hacee un par de años, yo firmaba algo así siempre xd

P.D Creo que he actualizado más o menos a todos, pero lo de siempre, con que estéis en el leaderboard propio del AoC es lo que cuenta

Fyn4r #201 Dic '21 Inocente

Dobleposteo porue el hilo me pertenece, odio las putas matrices

B

[Borrado] #202 Dic '21

Voy con retraso (a mayores del que ya llevo de serie), más tarde me pongo con el 5.

Prueba 4.A

4.A

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

# width = height
CARD_DIM = 5
CARD_SIZE = CARD_DIM ** 2

def get_card_pos_info(index):
    card_num = int(index / CARD_SIZE)
    start_index = card_num * CARD_SIZE
    return (card_num, start_index)

def get_card_sums(index, card, card_u):
    card_num, start_index = get_card_pos_info(index)
    sums = [0, 0]
    for e in range(CARD_SIZE):
        index = start_index + e
        sums[int(card_u[index])] += int(card[index])
    return sums

def mark_cards(card, num, card_u):
    for index,card_num in enumerate(card):
        if card_num == num:
            card_u[index] = True
            if check_card(index, card_u):
                return index
    return -1
            

def check_card(index, card_u):
    card_num, start_index = get_card_pos_info(index)
    offset = index % CARD_SIZE
    offset_y = int(offset / CARD_DIM)
    offset_x = offset % CARD_DIM
    start_index_y = start_index + offset_x
    start_index_x = start_index + CARD_DIM * offset_y
    has_hor = True
    has_ver = True
    for e in range(CARD_DIM):
        if not card_u[start_index_x + e]:
            has_hor = False
        if not card_u[start_index_y + e * CARD_DIM]:
            has_ver = False
        if not has_hor and not has_ver:
            break
    return has_hor or has_ver

numbers = lines[0].split(",")
card_numbers = [num for line in lines[2:] for num in line.split(" ") if num]
card_numbers_used = [False] * len(card_numbers)
cards_count = len(card_numbers) / CARD_DIM

for num in numbers:
    card_done_index = mark_cards(card_numbers, num, card_numbers_used)
    if card_done_index != -1:
        unused_sum, used_sum = get_card_sums(card_done_index, card_numbers, card_numbers_used)
        print(unused_sum * int(num))
        break

Prueba 4.B

4.B

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

# width = height
CARD_DIM = 5
CARD_SIZE = CARD_DIM ** 2

def get_card_pos_info(index):
    card_num = int(index / CARD_SIZE)
    start_index = card_num * CARD_SIZE
    return (card_num, start_index)

def get_card_sums(index, card, card_u):
    card_num, start_index = get_card_pos_info(index)
    sums = [0, 0]
    for e in range(CARD_SIZE):
        index = start_index + e
        sums[int(card_u[index])] += int(card[index])
    return sums

def mark_cards(card, num, card_u, checked):
    has_win = False
    for index,card_num in enumerate(card):
        card_index, _ = get_card_pos_info(index)
        if card_num == num and card_index not in checked:
            card_u[index] = True
            if check_card(index, card_u):
                checked.append(card_index)
                has_win = True
    return has_win
            

def check_card(index, card_u):
    card_num, start_index = get_card_pos_info(index)
    offset = index % CARD_SIZE
    offset_y = int(offset / CARD_DIM)
    offset_x = offset % CARD_DIM
    start_index_y = start_index + offset_x
    start_index_x = start_index + CARD_DIM * offset_y
    has_hor = True
    has_ver = True
    for e in range(CARD_DIM):
        if not card_u[start_index_x + e]:
            has_hor = False
        if not card_u[start_index_y + e * CARD_DIM]:
            has_ver = False
        if not has_hor and not has_ver:
            break
    return has_hor or has_ver

numbers = lines[0].split(",")
card_numbers = [num for line in lines[2:] for num in line.split(" ") if num]
card_numbers_used = [False] * len(card_numbers)
cards_count = len(card_numbers) / CARD_DIM

checked = []
sel_num = 0
for num in numbers:
    if mark_cards(card_numbers, num, card_numbers_used, checked):
        sel_num = num
if any(checked):
    unused_sum, used_sum = get_card_sums(checked[-1] * CARD_SIZE, card_numbers, card_numbers_used)
    print(unused_sum * int(sel_num))

B

[Borrado] #203 Dic '21

Pongo aquí mi código en java del día 5 en spoiler:

Ejercicio 5a

import java.io.*;

 

public class Day5a {
 

public static void main(String[] args) throws Exception
{
 
    File file = new File("C:\\Users\\supervisor\\Documents\\AdventofCode5.txt");
    BufferedReader br = new BufferedReader(new FileReader(file));       
    int[][] Array = new int[1000][1000];
    String[][] Coords= new String[500][4];
    String nuevo;
    int i = 0,suma = 0, aux;

    
    while ((nuevo = br.readLine()) != null) {
       	Coords[i] = nuevo.replace(" -> ",",").split(",");
       	i++;
    }
    br.close();

    for (int x = 0; x <500; x++) {
    	for (int n = 0; n<=1; n++) {
        	if (Coords[x][n].equals(Coords[x][n+2])) {
       			aux = (Integer.valueOf(Coords[x][1-n]) - Integer.valueOf(Coords[x][3-n]))/Math.abs(Integer.valueOf(Coords[x][1-n]) - Integer.valueOf(Coords[x][3-n]));
        		for (int a = Integer.valueOf(Coords[x][1-n]); a!=(Integer.valueOf(Coords[x][3-n])-aux); a-=aux) {
        				if (n == 0) {Array[Integer.valueOf(Coords[x][n])][a] +=1;} 
        				else {Array[a][Integer.valueOf(Coords[x][n])] +=1;}
        		}
        	}
    	}
    }
    
    for (int x = 0; x <1000; x++) {
    	for (int y = 0; y <1000; y++) {
    		if (Array[x][y]>1) {suma++;}
    	}
    }
    System.out.println(suma);
}
}

Ejercicio 5b

import java.io.*;
 

public class Day5b {
 

public static void main(String[] args) throws Exception
{
 
    File file = new File("C:\\Users\\supervisor\\Documents\\AdventofCode5.txt");
    BufferedReader br = new BufferedReader(new FileReader(file));       
    int[][] Array = new int[1000][1000];
    String[][] Coords= new String[500][4];
    String nuevo;
    int i = 0,suma = 0, aux, auxy;

    
    while ((nuevo = br.readLine()) != null) {
       	Coords[i] = nuevo.replace(" -> ",",").split(",");
       	i++;
    }
    br.close();


    for (int x = 0; x <500; x++) {
    	for (int n = 0; n<=1; n++) {
        	if (Coords[x][n].equals(Coords[x][n+2])) {
       			aux = (Integer.valueOf(Coords[x][1-n]) - Integer.valueOf(Coords[x][3-n]))/Math.abs(Integer.valueOf(Coords[x][1-n]) - Integer.valueOf(Coords[x][3-n]));
        		for (int a = Integer.valueOf(Coords[x][1-n]); a!=(Integer.valueOf(Coords[x][3-n])-aux); a-=aux) {
        				if (n == 0) {Array[Integer.valueOf(Coords[x][n])][a] +=1;} 
        				else {Array[a][Integer.valueOf(Coords[x][n])] +=1;}
        		}
        	}
        	else if (n == 0 && Math.abs(Integer.valueOf(Coords[x][n])-Integer.valueOf(Coords[x][n+2])) == Math.abs(Integer.valueOf(Coords[x][n+1]) - Integer.valueOf(Coords[x][n+3]))){ // oblicuo abajo derecha, arriba izq
				aux = (Integer.valueOf(Coords[x][n]) - Integer.valueOf(Coords[x][n+2]))/Math.abs(Integer.valueOf(Coords[x][n]) - Integer.valueOf(Coords[x][n+2]));
				auxy = (Integer.valueOf(Coords[x][n+1]) - Integer.valueOf(Coords[x][n+3]))/Math.abs(Integer.valueOf(Coords[x][n+1]) - Integer.valueOf(Coords[x][n+3]));
	        		for (int a = Integer.valueOf(Coords[x][n]); a!=(Integer.valueOf(Coords[x][n+2])-aux); a-=aux) {
	        			Array[a][Integer.valueOf(Coords[x][n+1])-auxy*Math.abs(Integer.valueOf(Coords[x][n])-a)] +=1;
					}
        	}
    	}
    }
    
    for (int x = 0; x <1000; x++) {
    	for (int y = 0; y <1000; y++) {
    		if (Array[x][y]>1) {suma++;}
    	}
    }
    System.out.println(suma);
}
}

BeheritSp #204 Dic '21 Juntabrackets

Muy chulo el de hoy

Day 6

class LanternFish:
    def __init__(self, timer=8):
        self.timer = timer
        self.number_of_fishes = 1
    def decrease(self):
        self.timer -= 1
    def reset_timer(self):
        self.timer = 6
    def get_timer(self):
        return self.timer
    def __len__(self):
        return self.number_of_fishes

class GroupOfFishes(LanternFish):
    def __init__(self, number_of_fishes):
        self.timer = 8
        self.number_of_fishes = number_of_fishes

def simulate_days(days, fishes):
    for day in range(days):
        to_add = 0
        for fish in fishes:
            if fish.get_timer() == 0:
                fish.reset_timer()
                to_add += len(fish)
            else:
                fish.decrease()
        if to_add > 0:
            fishes.add(GroupOfFishes(to_add))
    return fishes

if __name__ == '__main__':

    fishes = {LanternFish(int(value)) for value in open('input.txt').read().splitlines()[0].split(',')}
    print("Part 1", sum(len(fish) for fish in simulate_days(80, fishes)))
    print("Part 2", sum(len(fish) for fish in simulate_days(256, fishes)))

1 respuesta

Fyn4r #205 Dic '21 Inocente

Sí que está guapo el de hoy

#204 Por casualidad? Cuánto te tarda?

2 respuestas

Sleidom #206 Dic '21 Rocketeer

Dia 6, muy chulo si!
No tarda ni 1 sec utilizando mapas, inicialmente cai en la trampa de la lista y para la parte 2 me quedaba sin memoria xD

spoiler

import java.io.File

fun main() {
    val input = File("src/input")
        .readText()
        .split(Regex("\\D+"))
        .map { it.toInt() }
        .groupBy { it }
        .map { (k, v) -> k to v.size.toLong() }
        .toMap()

val res = calculateFishes(input.toMutableMap(), 80)
println(res)
val res2 = calculateFishes(input.toMutableMap(),256)
println(res2)
}

fun calculateFishes(input: MutableMap<Int, Long>, maxDays: Int): Long {
    repeat(maxDays) {
        val newHashMap = mutableMapOf<Int, Long>()
        input.forEach { (key, value) ->
            if (key == 0) {
                newHashMap[8] = newHashMap[8]?.plus(value) ?: value
                newHashMap[6] = newHashMap[6]?.plus(value) ?: value
            } else {
                newHashMap[key - 1] = newHashMap[key - 1]?.plus(value) ?: value
            }
        }
        input.clear()
        input.putAll(newHashMap)
    }

    return input.values.sum()
}

B

[Borrado] #207 Dic '21

#205 Usando un counter te lo hace insta, piensa que estas haciendo en total num_dias * 9 iteraciones como mucho, da igual el input que te den.

Dia6

import sys
from collections import Counter

part_num, num_days = map(int, sys.argv[1:])
fishes =  Counter([x for x in map(int, sys.stdin.readline().split(','))])

for _ in range(num_days):
  new_fishes = Counter()
  new_fishes[8] = fishes[0]
  for i in range(1, 9):
    new_fishes[i - 1] = fishes[i]
  new_fishes[6] += fishes[0]
  fishes = new_fishes

print(sum(fishes.values()))

El ejemplo del enunciado se nota que está pensadísimo para liar a la gente a que lo haga con listas y se coma un mojón luego jajaja

1 1 respuesta

Fyn4r #208 Dic '21 Inocente

#207 de hecho tengo eso mismo pero con una lista de 9 posiciones, me gusta lo del counter xd

1 respuesta

B

[Borrado] #209 Dic '21

#208 para 9 posiciones encima contiguas una lista es más que de sobra en realidad, lo del counter es por inercia y proximidad semántica del nombre del objeto a lo que quiero hacer

B

[Borrado] #210 Dic '21

Primero hecho a pelo, despues hecho con un dict, se puede optimizar seguro, pero va muy rapido.

day6

class glowfish():
    def __init__(self,starting_days=None):
        if starting_days is None:
            self.days_to_hatch = 9
        else:
            self.days_to_hatch = starting_days
    def __str__(self):
        return str(self.days_to_hatch)

def daypass(self):
    self.days_to_hatch-=1
    if self.ishatching():
        return 1
    else:
        return 0

def ishatching(self):
    if self.days_to_hatch < 0:
        self.days_to_hatch = 6
        return 1


class BedOfGlowfish():
    def __init__(self, starting_days=None):
        self.glowfish_grouped = {}
        for i in range(9):
            self.glowfish_grouped[i] = 0

def classify_glowfish(self, list_of_glowfish):
    for element in list_of_glowfish:
        if int(element) not in self.glowfish_grouped:
            self.glowfish_grouped[int(element)] = 1
        else:
            self.glowfish_grouped[int(element)] += 1

def day_passed(self):
    temp = self.glowfish_grouped[0]
    for i,j in zip(range(9),range(9)[1:]):
        self.glowfish_grouped[i] = self.glowfish_grouped[j]
    self.glowfish_grouped[6] += temp
    self.glowfish_grouped[8] = temp

def print_group(self):
    for i in self.glowfish_grouped:
        print (i, self.glowfish_grouped[i])
def print_solution(self):
    solution =0
    for i in self.glowfish_grouped:
        solution += self.glowfish_grouped[i]
    print(solution)
def print_list(list):
    for element in list:
        print(element)

def part1():
    line =  open('res/day6.txt').readline()
    start=line.split(',')
    list_of_glowfish = []
    for number in start:
        list_of_glowfish.append(glowfish(int(number)))
    for i in range(50):
        for element in list_of_glowfish:
            if(element.daypass()):
                list_of_glowfish.append(glowfish())

print(len(list_of_glowfish))

def part2():
    line = open('res/day6.txt').readline()
    start = line.split(',')

bof=BedOfGlowfish()
bof.classify_glowfish(start)
for i in range(256):
    bof.day_passed()
bof.print_solution()
part2()

3.A

3.B

4.A

4.B

Usuarios habituales

Tags