Day 4: Giant Squid

Solution was straightforward... it was just a matter of reading the board and performing the appropriate operations. One trick I used to make checking for BINGO easier was to mark cells with -1 and then I could just sum up the row or column and check if it was -5 to see if there was BINGO.

# Constants

ROWS = 5
COLS = 5
MARK = -1

# Functions

def read_boards():
    while sys.stdin.readline():
        try:
            yield [list(map(int, sys.stdin.readline().split())) for _ in range(ROWS)]
        except (IOError, ValueError):
            break

def mark_board(board, number):
    for rindex, row in enumerate(board):
        for cindex, cell in enumerate(row):
            if cell == number:
                board[rindex][cindex] = MARK

def check_board(board):
    return any(sum(row) == ROWS * MARK for row in board) or \
           any(sum(board[row][col] for row in range(ROWS)) == COLS * MARK for col in range(COLS))

def dump_board(board):
    for row in board:
        print(' '.join(map(str, row)))

def sum_board(board):
    return sum(
        sum(number for number in row if number >= 0) for row in board
    )

# Main Execution

def main():
    numbers = [int(n) for n in sys.stdin.readline().split(',')]
    boards  = list(read_boards())
    winner  = None

    while numbers and winner is None:
        number = numbers.pop(0)

        for board in boards:
            mark_board(board, number)
            if check_board(board):
                winner = board

    total = sum_board(winner)
    print(number*total)

Only my main function changes here. Instead of looking for the first board, I simply remove boards as they win and just keep track of the last winner.

def main():
    numbers = [int(n) for n in sys.stdin.readline().split(',')]
    boards  = list(read_boards())
    winner  = None

    while numbers and boards:
        number = numbers.pop(0)

        active = []
        for board in boards:
            mark_board(board, number)
            if check_board(board):
                winner = board
            else:
                active.append(board)
        boards = active

    total = sum_board(winner)
    print(number*total)

class Board
  def initialize(rows)
    @rows = rows
    @hits = Set.new
  end

  def mark(number)
    @hits += [number]
  end

  def win?
    return false unless @hits.size >= 5

    @rows.size.times do |i|
      # check if every number in row i is in @hits
      return true if @hits.superset? @rows[i].to_set

      # check if every number in column i is in @hits
      return true if @hits.superset? @rows.reduce([]) { |column, row| column << row[i] }
                                          .to_set
    end

    return false
  end

  def unmarked_numbers
    @rows.flatten.to_set - @hits
  end
end

def compute_p1(input)
  numbers = input
              .lines
              .first
              .chomp
              .split(',')
              .map(&:to_i)

  boards = input
             .split("\n\n")
             .drop(1)
             .map { |l| l.split("\n")
                         .map { _1.split(' ').map(&:to_i) } }
             .map { Board.new(_1) }

  winner = nil
  number = nil

  until numbers.empty?
    number = numbers.shift
    boards.each { _1.mark(number) }

    break if (winner = boards.select { _1.win? }.first)
  end

  winner.unmarked_numbers.sum * number
end

def compute_p2(input)
  numbers = input
              .lines
              .first
              .chomp
              .split(',')
              .map(&:to_i)

  boards = input
             .split("\n\n")
             .drop(1)
             .map { |l| l.split("\n")
                         .map { _1.split(' ').map(&:to_i) } }
             .map { Board.new(_1) }

  last_board = nil
  number = nil

  until numbers.empty? || last_board&.win?
    number = numbers.shift
    boards.each { _1.mark(number) }

    boards = boards.filter { ! _1.win? }
    last_board = boards.first if boards.size == 1
  end

  last_board.unmarked_numbers.sum * number
end

This is pretty inefficient, Part 2 is especially slow (~0.2s on my machine). I think a lot of that is in how I'm checking for wins on each board. Right now I'm always revisiting all the rows to find the numbers in each column, and then making a Set out of them. If performance was a bigger issue I might do something like pre-compute the numbers in each row/column, or actually remove numbers from the board once they get marked so that we have fewer things to check as the process goes on.

I struggled a bit with getting check boards to work. I was trying to get all() to work for a while, but eventually just gave up and chained some == together. I also forgot to multiply my indices at first, so that made my horizontal check break. Also as I mentioned before I implemented diagonals. That fucked me up for a bit.

The hoz_check, diag_check, vert_check aren't used. They're remnants of an earlier attempt. I realized they weren't really saving any time or space

#data = test_data
data = real_data
data = data.split('\n\n')

numbers = data[0].split(',')

boards = data[1:]

hoz_check = [0,1,2,3,4]
vert_check = [0,5,10,15,20]
diag_check = [[0, 6, 12, 18, 24], [20, 16, 12, 8, 4]]

def check_board(b_l):
    for i in range(5):
        if b_l[0+(i*5)] == b_l[1+(i*5)] == b_l[2+(i*5)] == b_l[3+(i*5)] == b_l[4+(i*5)] ==  "X":
            return True
        if b_l[0+i] == b_l[5+i] == b_l[10+i] == b_l[15+i] == b_l[20+i] ==  "X":
            return True
    #if b_l[0+i] == b_l[6+i] == b_l[12+i] == b_l[18+i] == b_l[24+i] ==  "X":
    #        return True
    #if b_l[20+i] == b_l[16+i] == b_l[12+i] == b_l[8+i] == b_l[4+i] ==  "X":
    #        return True
    return False

def print_board(board):
    print(board[0:5],"\n",board[5:10],"\n",board[10:15],"\n",board[15:20],"\n",board[20:25],"\n")

def score(b_l, c_n):
    b_l = [x for x in b_l if x != "X"]
    b_l = [int(x) for x in b_l]
    #print(sum(b_l))
    #print(c_n)
    return sum(b_l) * int(c_n)
          
board_scores = []
turns_remaining = []
for board in boards:
    #print("---------------------------------")
    board_list = []
    numbers_copy = list(numbers)
    
    for row in board.split("\n"):
        board_list = board_list + row.split()
    complete = False
    while not complete and len(numbers_copy) >= 1:
        called_number = numbers_copy.pop(0)
        board_list = ["X" if s==called_number else s for s in board_list]
        complete = check_board(board_list)
    if complete:
        turns_remaining.append(len(numbers_copy))
        board_scores.append(score(board_list, called_number))
    #print_board(board_list)
print(turns_remaining)
print(board_scores)

max_value = max(turns_remaining)
max_value_index = turns_remaining.index(max_value)
print(board_scores[max_value_index])

• Make sure to read the descript of the problem. In this case it doesn't do diagonals which can cause problems.

• You'll need to think about how to store the data for a given board in a way you can work with it. Fortunately boards are all a fixed size and the ways they can win are fixed

• For me building a function that let me visualize the status of a given board was very useful in debugging

use std::env;
use std::io::{self};

const CARDSIZE: usize = 5;

#[derive(Clone)]
struct BingoCard {
    pub card: Vec<Vec<usize>>,
    pub marked: Vec<Vec<bool>>,
    pub won: bool,
}
impl From<&str> for BingoCard {
    fn from(s: &str) -> Self {
        let mut card: Vec<Vec<usize>> = Vec::new();
        for row in s.split("\n") {
            card.push(row.split_ascii_whitespace().map(|x| x.parse::<usize>().unwrap()).collect());
        }
        Self { card: card, marked: vec![vec![false;5];5], won: false }
    }
}
impl BingoCard {
    pub fn validate(&mut self) -> bool {
        /*for i in 0..CARDSIZE {
            if self.marked[i][..].iter().all(|&x| x) { self.won = true; return true; }
            if self.marked[..][i].iter().all(|&x| x) { self.won = true; return true; }
        }*/
        for row in 0..CARDSIZE {
            let mut bingo = true;
            for col in 0..CARDSIZE {
                if !self.marked[row][col] { bingo = false; }
            }
            if bingo { self.won = true; }
        }
        for col in 0..CARDSIZE {
            let mut bingo = true;
            for row in 0..CARDSIZE {
                if !self.marked[row][col] { bingo = false; }
            }
            if bingo { self.won = true; }
        }
        self.won
    }
    pub fn score(&self) -> usize {
        let mut score = 0;
        for row in 0..CARDSIZE {
            for col in 0..CARDSIZE {
                if !self.marked[row][col] { score += self.card[row][col]; }
            }
        }
        if self.won { score } else { 0 }
    }
    pub fn mark_number(&mut self, number: usize) {
        'outer: for (i,row) in self.card.iter().enumerate() {
            for (j,col) in row.iter().enumerate() {
                if col == &number {
                    self.marked[i][j] = true;
                    break 'outer;
                }
            }
        }

    }
}

fn day04(input: &str) -> io::Result<()> {
    // Input
    let input_str = std::fs::read_to_string(input).unwrap();
    let input_str = input_str.trim();
    let input: Vec<_> = input_str.split("\n\n").collect();
    
    // Get Bingo numbers and cards
    let drawn: Vec<_> = input[0].split(",").map(|x| x.parse::<usize>().unwrap()).collect();
    let mut cards: Vec<_> = input[1..].into_iter().map(|x| BingoCard::from(*x)).collect();
    let num_bingo_cards = cards.len();

    // Play Bingo
    let mut bingos = 0;
    'bingo_loop: for number in drawn {
        //println!("Drawing: {}", number);
        for card in &mut cards {
            if card.won { continue; }
            card.mark_number(number);
            if card.validate() {
                bingos += 1;
                if bingos == 1 {
                    println!("Part 1: {}", number * card.score()); // 89001
                } else if bingos == num_bingo_cards {
                    println!("Part 2: {}", number * card.score()); // 7296
                    break 'bingo_loop;
                }
            }
        }
    }
    Ok(())
}

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

use nom::{
    bytes::complete::tag, character::complete::multispace1, character::complete::newline,
    character::complete::space0, character::complete::space1, multi::separated_list1, IResult,
};

struct Board {
    numbers: Vec<Vec<i64>>,
    marks: Vec<Vec<bool>>,
    won: bool,
}

struct Bingo {
    numbers: Vec<i64>,
    boards: Vec<Board>,
}

const BOARD_WIDTH: usize = 5;
const BOARD_HEIGHT: usize = 5;

fn parse_chosen_numbers(input: &str) -> IResult<&str, Vec<i64>> {
    separated_list1(tag(","), nom::character::complete::i64)(input)
}

fn parse_board_line(input: &str) -> IResult<&str, Vec<i64>> {
    let (input, _) = space0(input)?;
    separated_list1(space1, nom::character::complete::i64)(input)
}

fn parse_board(input: &str) -> IResult<&str, Board> {
    let (input, numbers) = separated_list1(newline, parse_board_line)(input)?;

    Ok((
        input,
        Board {
            numbers,
            marks: vec![vec![false; BOARD_WIDTH]; BOARD_HEIGHT],
            won: false,
        },
    ))
}

fn parse_boards(input: &str) -> IResult<&str, Vec<Board>> {
    let (input, _) = multispace1(input)?;
    separated_list1(multispace1, parse_board)(input)
}

fn parse_input(input: &str) -> Bingo {
    let (input, numbers) = parse_chosen_numbers(input).unwrap();
    let (_, boards) = parse_boards(input).unwrap();

    Bingo { numbers, boards }
}

fn board_won(b: &Board) -> bool {
    // Rows
    for y in 0..BOARD_HEIGHT {
        let mut num_marked = 0;
        for x in 0..BOARD_WIDTH {
            if b.marks[y][x] {
                num_marked += 1;
            }
        }

        if num_marked == BOARD_WIDTH {
            return true;
        }
    }

    // Columns
    for x in 0..BOARD_WIDTH {
        let mut num_marked = 0;
        for y in 0..BOARD_HEIGHT {
            if b.marks[y][x] {
                num_marked += 1;
            }
        }

        if num_marked == BOARD_HEIGHT {
            return true;
        }
    }

    false
}

fn mark(b: &mut Board, number: i64) {
    for y in 0..BOARD_HEIGHT {
        for x in 0..BOARD_WIDTH {
            if b.numbers[y][x] == number {
                b.marks[y][x] = true;
            }
        }
    }
}

fn calculate_score(b: &Board) -> i64 {
    let mut sum = 0;
    for y in 0..BOARD_HEIGHT {
        for x in 0..BOARD_WIDTH {
            if !b.marks[y][x] {
                sum += b.numbers[y][x];
            }
        }
    }

    sum
}

fn solve(input: &str) -> i64 {
    let mut bingo = parse_input(input);

    for number in bingo.numbers {
        for b in bingo.boards.iter_mut() {
            mark(b, number);
            if board_won(&b) {
                return calculate_score(&b) * number;
            }
        }
    }

    0
}

fn main() {
    println!("{}", solve(include_str!("../../input-04.txt")));
}

fn solve(input: &str) -> i64 {
    let mut bingo = parse_input(input);
    let mut remaining_boards = bingo.boards.len();

    for number in bingo.numbers {
        for b in bingo.boards.iter_mut() {
            mark(b, number);

            if !b.won && board_won(&b) {
                b.won = true;
                remaining_boards -= 1;

                if remaining_boards == 0 {
                    return number * calculate_score(&b);
                }
            }
        }
    }

    0
}

fn main() {
    println!("{}", solve(include_str!("../../input-04.txt")));
}

Bad programmers worry about the code. Good programmers worry about data structures and their relationships.

• Linus Torvalds

Racket has classes but for AoC if I need to maintain state I'll generaly use a struct.
So my bingo card is:

(struct card (grid [marked #:mutable] [winner? #:mutable]) #:transparent)

The Racket compiler automatically generates a bunch of useful procedures for structs.
e.g.field selectors (card-grid, card-marked, ...) and mutators if any fields or the struct is marked #:mutable ( set-card-marked!, set-card-winner?!)

Scheme has a convention where mutator procedures end in "!" and procedures returning a boolean end in "?. It pleases me too much use ? for boolean fields too so I get procedure names like set-card-winner?! ...yeah I'm easily amused.

Input parsing.
Racket's iterators are built on for forms and sequences.

After extracting the game numbers, I removed blank lines and grabbed the card definitions.

(define (parse-bingo input)
  (define game
    (for/list ([n (string-split (first input) ",")])
      (string->number n)))
  (define grids
    (for/list ([line (rest input)]
               #:unless (string=? line ""))
      line))
  (values game
          (for/list ([grid (in-slice 5 grids)])
            (parse-grid grid))))

in-slice is an iterator that groups a sequence by a specific count.

(sequence->list (in-slice 3 (range 10)))
;; '((0 1 2) (3 4 5) (6 7 8) (9))

Nice! saves me that drudgery.

The only thing left is to convert the numbers into a card.
card-grid is a hash table from number -> grid co-ordinate to help check for a bingo later.
The co-ordinates are generated using in-indexed - like Python's enumerate.

(define (parse-grid numbers)
  (for*/fold ([grid (hash)]
              #:result (card grid null #f))
            ([(row i) (in-indexed numbers)]
             [(column j) (in-indexed (string-split row))])
    (define n (string->number column))
    (define co-ord (list i j))
    (hash-set grid n co-ord)))

for/first returns the value when the body first returns anything that isn't #f - false.

(define (part-01 input)
  (define-values (game cards) (parse-bingo input))
  (for*/first ([n game]
              [c cards]
              #:when (bingo? (mark-card! n c)))
    (score n c)))

The card struct has a list of the numbers called that are on the card.

(define (mark-card! n c)
  (when (hash-ref (card-grid c) n #f)
    (set-card-marked! c (cons n (card-marked c))))
  c)

That way it's easy to sum them and subtract from the card's total.

(define (score n c)
  (* n (- (apply + (hash-keys (card-grid c)))
          (apply + (card-marked c)))))

The only thing left is to check for a line of matched numbers.
I extract the co-ordinates of the marked numbers and group them by row and by column.
If any group has 5 members I mark the card as a winner and return #t.
(I only added the winner? field after I read part 2.)

(define (bingo? c)
  (match-define (card grid marked _) c)
  (define co-ords
    (for/list ([mark marked]
               #:when (hash-ref grid mark #f))
      (hash-ref grid mark)))
  (define winning-row?
    (for/first ([row (group-by first co-ords)]
                #:when (= 5 (length row)))
      row))
  (define winning-column?
    (for/first ([column (group-by second co-ords)]
                #:when (= 5 (length column)))
      column))
  (define winner? (or winning-row? winning-column?))
  (when winner? (set-card-winner?! c #t))
  winner?)

I added the winner? field to the struct after reading Part 2 and set it when bingo? is true, which made it trivial. All I do is ignore complete cards and instead of using
for/first I use for/last

(define (part-02 input)
  (define-values (game cards) (parse-bingo input))
  (for*/last ([n game]
             [c cards]
              #:unless (card-winner? c)
              #:when (bingo? (mark-card! n c)))
    (score n c)))

from collections import defaultdict
from itertools import chain

lines = [i.strip() for i in open("input.txt")]

boards = defaultdict(list)
b = 0

for i in range(2, len(lines)):
    if not lines[i]:
        b += 1
        continue

    boards[b].append(list(map(int, lines[i].split())))

for board in boards:
    boards[board] += list(zip(*boards[board]))

numbers = list(map(int, lines[0].split(",")))


def task(boards: list) -> list:
    scores = list()
    marked = numbers[:4]
    for number in numbers[4:]:
        marked.append(number)
        for board in list(boards):
            for b in boards[board]:
                if set(b).issubset(marked):
                    scores.append(sum(set(chain(*boards[board])) - set(marked)) * marked[-1])
                    boards.pop(board)
    return scores


print("Part One:", task(boards.copy())[0])
print("Part Two:", task(boards.copy())[-2])

const fs = require('fs');
const readline = require('readline');

let inputArr = [];

async function openFileForReading(file) {
	const fileStream = fs.createReadStream(file);

	const rl = readline.createInterface({
		input: fileStream,
		crlfDelay: Infinity
	});

	for await (const line of rl) {
		try {
			inputArr.push(line);
		} catch(e) {
			console.error(e);
		}
	}
}

function parseBingoCard(bingoCardText) {
	let bingoCardArray = [];
	let rows = bingoCardText.split('\n');
	for (const row of rows) {
		let regex = /(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/;
		let found = row.match(regex);
		let rowArray = [found[1],found[2],found[3],found[4],found[5]];
		bingoCardArray.push(rowArray);
	}
	return bingoCardArray;
}

function splitBingoCards() {
	let splitArray = [];
	let currentBingoCardArray = [];
	// skip the first two lines, bingo cards start on line 3
	let bingoCardArray = inputArr.slice(2);
	for (const line of bingoCardArray) {
		// on blank line, reset accumulated line and send for parsing
		if (line.trim().length === 0) {
			splitArray.push(parseBingoCard(currentBingoCardArray.join('\n')));
			currentBingoCardArray = [];
		} else {
			currentBingoCardArray.push(line);
		}
	}
	// flushing the buffer, in case the last line is not newline-terminated
	if (currentBingoCardArray.length != 0) {
		splitArray.push(parseBingoCard(currentBingoCardArray.join('\n')));
	}
	return splitArray;
}

function findBingo(bingoCard, numbersCalled) {
	// look for horizontal bingos
	for (const row of bingoCard) {
		let horizontalBingo = true;
		for (const number of row) {
			if (!numbersCalled.includes(parseInt(number))) {
				horizontalBingo = false;
				break;
			}
		}
		if (horizontalBingo === true) {
			return true;
		}
	}
	// look for vertical bingos
	for (let colIndex = 0; colIndex < bingoCard[0].length; colIndex++) {
		let verticalBingo = true;
		for (const row of bingoCard) {
			if (!numbersCalled.includes(parseInt(row[colIndex]))) {
				verticalBingo = false;
				break;
			}
		}
		if (verticalBingo === true) {
			return true;
		}
	}
	return false;
}

function findBingoScore(bingoCard, numbersCalled) {
	let pointSpaces = [];
	for (const row of bingoCard) {
		for (const num of row) {
			if (!numbersCalled.includes(parseInt(num))) {
				pointSpaces.push(parseInt(num));
			}
		}
	}
	return (pointSpaces.reduce((a,b) => a+b) * numbersCalled[numbersCalled.length-1]);
}

(async function mainExecution() {
	await openFileForReading('input.txt');
	let numbersToCall = inputArr[0].split(',').map(e => parseInt(e));
	console.log("DEBUG: numbersToCall = " + numbersToCall);
	let bingoCardArray = splitBingoCards();
	let numberCalledIndex = 0;
	let numbersCalled = [];
	let winningBoard = [];
	while (winningBoard.length === 0) {
		// call new number
		numberCalledIndex++;
		numbersCalled = numbersToCall.slice(0,numberCalledIndex);

		// check for win
		for (bingoCard of bingoCardArray) {
			if (findBingo(bingoCard,numbersCalled)) {
				winningBoard = bingoCard;
				break;
			}
		}
	}
	console.log("DEBUG: winningBoard =\n" + winningBoard.join('\n'));
	console.log("DEBUG: numbersCalled = " + numbersCalled);
	console.log("Answer found! " + findBingoScore(winningBoard,numbersCalled));
})();

const fs = require('fs');
const readline = require('readline');

let inputArr = [];

async function openFileForReading(file) {
	const fileStream = fs.createReadStream(file);

	const rl = readline.createInterface({
		input: fileStream,
		crlfDelay: Infinity
	});

	for await (const line of rl) {
		try {
			inputArr.push(line);
		} catch(e) {
			console.error(e);
		}
	}
}

function parseBingoCard(bingoCardText) {
	let bingoCardArray = [];
	let rows = bingoCardText.split('\n');
	for (const row of rows) {
		let regex = /(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/;
		let found = row.match(regex);
		let rowArray = [found[1],found[2],found[3],found[4],found[5]];
		bingoCardArray.push(rowArray);
	}
	return bingoCardArray;
}

function splitBingoCards() {
	let splitArray = [];
	let currentBingoCardArray = [];
	// skip the first two lines, bingo cards start on line 3
	let bingoCardArray = inputArr.slice(2);
	for (const line of bingoCardArray) {
		// on blank line, reset accumulated line and send for parsing
		if (line.trim().length === 0) {
			splitArray.push(parseBingoCard(currentBingoCardArray.join('\n')));
			currentBingoCardArray = [];
		} else {
			currentBingoCardArray.push(line);
		}
	}
	// flushing the buffer, in case the last line is not newline-terminated
	if (currentBingoCardArray.length != 0) {
		splitArray.push(parseBingoCard(currentBingoCardArray.join('\n')));
	}
	return splitArray;
}

function findBingo(bingoCard, numbersCalled) {
	// look for horizontal bingos
	for (const row of bingoCard) {
		let horizontalBingo = true;
		for (const number of row) {
			if (!numbersCalled.includes(parseInt(number))) {
				horizontalBingo = false;
				break;
			}
		}
		if (horizontalBingo === true) {
			return true;
		}
	}
	// look for vertical bingos
	for (let colIndex = 0; colIndex < bingoCard[0].length; colIndex++) {
		let verticalBingo = true;
		for (const row of bingoCard) {
			if (!numbersCalled.includes(parseInt(row[colIndex]))) {
				verticalBingo = false;
				break;
			}
		}
		if (verticalBingo === true) {
			return true;
		}
	}
	return false;
}

function findBingoScore(bingoCard, numbersCalled) {
	let pointSpaces = [];
	for (const row of bingoCard) {
		for (const num of row) {
			if (!numbersCalled.includes(parseInt(num))) {
				pointSpaces.push(parseInt(num));
			}
		}
	}
	return (pointSpaces.reduce((a,b) => a+b) * numbersCalled[numbersCalled.length-1]);
}

(async function mainExecution() {
	await openFileForReading('input.txt');
	let numbersToCall = inputArr[0].split(',').map(e => parseInt(e));
	console.log("DEBUG: numbersToCall = " + numbersToCall);
	let bingoCardArray = splitBingoCards();
	let numberCalledIndex = 0;
	let numbersCalled = [];
	let winningBoards = [];
	while (winningBoards.length < bingoCardArray.length) {
		// call new number
		numberCalledIndex++;
		numbersCalled = numbersToCall.slice(0,numberCalledIndex);

		// check for wins
		for (let i=0; i<bingoCardArray.length; i++) {
			if (!winningBoards.includes(i)) {
				if (findBingo(bingoCardArray[i], numbersCalled)) {
					winningBoards.push(i);
				}
			}
		}
	}
	console.log("DEBUG: last winningBoard =\n" + bingoCardArray[winningBoards[winningBoards.length-1]].join('\n'));
	console.log("DEBUG: numbersCalled = " + numbersCalled);
	console.log("Answer found! " + findBingoScore(bingoCardArray[winningBoards[winningBoards.length-1]],numbersCalled));
})();

I=[*map(str.strip,open(0))]
N=I.pop(0).split(',')
B=[[*map(str.split,I[i:i+5])]for i in range(1,len(I),6)]
R=*range(5),
m=lambda b,n:[[''if b[r][c]==n else b[r][c]for c in R]for r in R]
k=lambda b:any([not any(r)for r in b]+[not any([b[r][c]for r in R])for c in R])
for i in range(len(N)):
 B=[m(b,N[i])for b in B]
 w=[k(b)for b in B]
 if any(w):break
W=B[w.index(1)]
print(sum([sum([int(W[r][c])for c in R if W[r][c]])for r in R])*int(N[i]))

I=[*map(str.strip,open(0))]
N=I.pop(0).split(',')
B=[[*map(str.split,I[i:i+5])]for i in range(1,len(I),6)]
R=*range(5),
m=lambda b,n:[[''if b[r][c]==n else b[r][c]for c in R]for r in R]
k=lambda b:any([not any(r)for r in b]+[not any([b[r][c]for r in R])for c in R])
for i in range(len(N)):
 B=filter(None,B);B=[m(b,N[i])for b in B];w=[k(b)for b in B]
 if any(w)and len(B)-1:
  for j in range(sum(w)):t=w.index(1);B[t]=w[t]=0
 elif w[0]:break
W=B[w.index(1)]
print(sum([sum([int(W[r][c])for c in R if W[r][c]])for r in R])*int(N[i]))

use crate::lib::aoc;

#[derive(Clone, Copy, Debug)]
struct Row(u32, u32, u32, u32, u32);

#[derive(Clone, Copy, Debug)]
struct Board(Row, Row, Row, Row, Row);

impl Row {
    fn new(row: String) -> Self {
        let row = row.trim().split_whitespace().collect::<Vec<_>>();
        if row.len() != 5 {
            panic!("Tried to read a row with len != 5");
        }

        Row(
            row[0]
                .parse::<u32>()
                .expect("Error reading row 0 (somewhere)"),
            row[1]
                .parse::<u32>()
                .expect("Error reading row 1 (somewhere)"),
            row[2]
                .parse::<u32>()
                .expect("Error reading row 2 (somewhere)"),
            row[3]
                .parse::<u32>()
                .expect("Error reading row 3 (somewhere)"),
            row[4]
                .parse::<u32>()
                .expect("Error reading row 4 (somewhere)"),
        )
    }

    fn check_for_num(&mut self, num: u32) {
        if self.0 == num {
            self.0 = 0;
        }
        if self.1 == num {
            self.1 = 0;
        }
        if self.2 == num {
            self.2 = 0;
        }
        if self.3 == num {
            self.3 = 0;
        }
        if self.4 == num {
            self.4 = 0;
        }
    }

    fn get_score(&mut self) -> u32 {
        self.0 + self.1 + self.2 + self.3 + self.4
    }
}

impl Board {
    fn new(rows: Vec<String>) -> Self {
        if rows.len() != 5 {
            panic!("Tried to read a board with len != 5");
        }

        Board(
            Row::new(rows[0].to_owned()),
            Row::new(rows[1].to_owned()),
            Row::new(rows[2].to_owned()),
            Row::new(rows[3].to_owned()),
            Row::new(rows[4].to_owned()),
        )
    }

    fn check_for_num(&mut self, num: u32) {
        self.0.check_for_num(num);
        self.1.check_for_num(num);
        self.2.check_for_num(num);
        self.3.check_for_num(num);
        self.4.check_for_num(num);
    }

    fn check_diags(&mut self) -> bool {
        if self.0 .0 + self.1 .1 + self.2 .2 + self.3 .3 + self.4 .4 == 0
            || self.0 .4 + self.1 .3 + self.2 .2 + self.3 .1 + self.4 .4 == 0
        {
            true
        } else {
            false
        }
    }

    fn check_verticals(&mut self) -> bool {
        if self.0 .0 + self.1 .0 + self.2 .0 + self.3 .0 + self.4 .0 == 0
            || self.0 .1 + self.1 .1 + self.2 .1 + self.3 .1 + self.4 .1 == 0
            || self.0 .2 + self.1 .2 + self.2 .2 + self.3 .2 + self.4 .2 == 0
            || self.0 .3 + self.1 .3 + self.2 .3 + self.3 .3 + self.4 .3 == 0
            || self.0 .4 + self.1 .4 + self.2 .4 + self.3 .4 + self.4 .4 == 0
        {
            true
        } else {
            false
        }
    }

    fn has_won(&mut self) -> bool {
        if self.0.get_score() == 0
            || self.1.get_score() == 0
            || self.2.get_score() == 0
            || self.3.get_score() == 0
            || self.4.get_score() == 0
            || self.check_diags()
            || self.check_verticals()
        {
            return true;
        }

        false
    }

    fn get_score(&mut self) -> u32 {
        self.0.get_score()
            + self.1.get_score()
            + self.2.get_score()
            + self.3.get_score()
            + self.4.get_score()
    }
}

impl PartialEq for Row {
    fn eq(&self, other: &Self) -> bool {
        self.0 == other.0
            && self.1 == other.1
            && self.2 == other.2
            && self.3 == other.3
            && self.4 == other.4
    }
}

impl Eq for Row {}

impl PartialEq for Board {
    fn eq(&self, other: &Self) -> bool {
        self.0 == other.0
            && self.1 == other.1
            && self.2 == other.2
            && self.3 == other.3
            && self.4 == other.4
    }
}

impl Eq for Board {}

pub fn run4() {
    let lines = aoc::get_lines("./inputs/day4.in");

    // Split the numbers off
    let numbers = lines[0]
        .split(",")
        .map(|number| {
            number
                .parse::<u32>()
                .expect("Unable to read some number as a u32")
        })
        .collect::<Vec<_>>();

    // Get just the boards
    let lines = lines
        .get(2..)
        .expect("Did you forget to include boards in the input?");
    let mut boards: Vec<Board> = Vec::new();
    for i in (0..lines.len()).step_by(6) {
        boards.push(Board::new(
            lines
                .get(i..(i + 5))
                .expect("There was an issue slicing your board!")
                .to_vec(),
        ));
    }

    let mut first_win = false;
    let mut winning_number: u32 = 0;
    let mut winning_score: u32 = 0;
    let mut losing_number: u32 = 0;
    let mut losing_score: u32 = 0;
    // TODO: Is there a way to make this loop more idiomatic?
    for number in numbers {
        let mut winning_boards: Vec<Board> = Vec::new();
        for board in &mut boards {
            board.check_for_num(number);

            if board.has_won() {
                if !first_win {
                    first_win = true;
                    winning_number = number;
                    winning_score = board.get_score();
                }
                winning_boards.push(*board);
            }
        }

        boards.retain(|board| !winning_boards.contains(board));

        if boards.is_empty() {
            losing_number = number;
            losing_score = winning_boards[0].get_score();
        }

        if losing_score > 0 {
            break;
        }
    }

    aoc::output(
        4,
        "score",
        (winning_number * winning_score) as i32,
        (losing_number * losing_score) as i32,
    );
}