🌟 Advent of Code (AoC) 2021 🌟

use crate::solution::Solution;

type ReportEntry = u32;

struct Day3 {
    report: Vec<ReportEntry>,
    zeros: Vec<u32>,
    bit_width: usize,
}

impl Solution for Day3 {
    fn part1(&self) -> String {
        power_consumption(&self.zeros, self.report.len(), self.bit_width)
            .to_string()
    }

    fn part2(&self) -> String {
        life_support_rating(&self.report, self.bit_width)
            .to_string()
    }
}

fn power_consumption(zeros: &[u32], num_reports: usize, bit_width: usize) -> ReportEntry {
    let thresh = (num_reports / 2) as ReportEntry;
    let gamma = zeros
        .iter()
        .map(|&num_zeros| (num_zeros <= thresh) as ReportEntry)
        .fold(0, |gamma, bit_value| (gamma << 1) + bit_value);
    let epsilon = !gamma & ((1 << bit_width) - 1);
    gamma * epsilon
}

fn life_support_rating(report: &[ReportEntry], bit_width: usize) -> ReportEntry {
    oxygen_generator_rating(report, bit_width) * co_scrubber_rating(report, bit_width)
}

fn oxygen_generator_rating(report: &[ReportEntry], bit_width: usize) -> ReportEntry {
    rating(report, bit_width, |num_ones, report_len| 2 * num_ones >= report_len)
}

fn co_scrubber_rating(report: &[ReportEntry], bit_width: usize) -> ReportEntry {
    rating(report, bit_width, |num_ones, report_len| 2 * num_ones < report_len)
}

fn rating(report: &[ReportEntry], bit_width: usize, cmp_fn: fn(usize, usize) -> bool) -> ReportEntry {
    let should_be_set_fn = |numbers: &[u32], bit: usize| {
        let num_ones = numbers
            .iter()
            .fold(0, |num_set, &number| num_set + is_bit_set(number, bit) as usize);
        cmp_fn(num_ones, numbers.len())
    };
    let mut numbers = report.to_vec();
    for bit in (0..bit_width).rev() {
        let should_be_set = should_be_set_fn(&numbers, bit);
        numbers = numbers
            .into_iter()
            .filter(|&number| !(is_bit_set(number, bit) ^ should_be_set))
            .collect();
        if numbers.len() == 1 {
            break
        }
    }
    numbers[0]
}

fn is_bit_set(number: u32, bit: usize) -> bool {
    ((number >> bit) & 1) != 0
}

pub fn new(input: &str) -> Box<dyn Solution> {
    let (report, zeros, bit_width) = input_parser(input);
    Box::new(Day3{
        report,
        zeros,
        bit_width,
    })
}

fn input_parser(input: &str) -> (Vec<ReportEntry>, Vec<u32>, usize) {
    let bit_width = input.find('\n').expect("Invalid input");
    let numbers = input
        .lines()
        .map(|num_str| ReportEntry::from_str_radix(num_str, 2).expect("Not a binary number"));
    let mut report = Vec::new();
    let mut zeros = vec![0; bit_width];
    for number in numbers {
        report.push(number);
        for i in 0..bit_width {
            // First bit in input is used as LSB in gamma/epsilon
            zeros[bit_width - i - 1] += is_bit_set(number, i) as u32;
        }
    }
    (report, zeros, bit_width)
}

func main() {

	fileName := ""

	if len(os.Args) == 1 {
		fileName = "input.txt"
	} else {
		fileName = os.Args[1]
	}

	input, err := helpers.ReadLines(fileName)

	if err != nil {
		panic(err)
	}

	gamma, epsilon, oxygen, co2 := Calculate(input)

	fmt.Printf("Gamma rate: %v, Epsilon rate: %v, Power Consumption: %v, Oxygen rate: %v, co2 rate: %v, Life rate: %v\n",
		gamma, epsilon, gamma*epsilon, oxygen, co2, oxygen*co2)

}

func Calculate(input []string) (int, int, int, int) {

	wordLength := len(input[0])

	count := make([]int, wordLength)

	for i := 0; i < wordLength; i++ {
		count[i], _ = calculateMostCommonBit(input, i)
	}

	gammaString := ""
	epsilonString := ""
	oxygenString := ""
	scrubberString := ""
	var err error

	for _, val := range count {
		if val < 0 {
			gammaString += "0"
			epsilonString += "1"
		} else {
			gammaString += "1"
			epsilonString += "0"
		}
	}

	oxygenString, err = calculateOxygenCo2(input, true)

	if err != nil {
		panic(err)
	}

	scrubberString, err = calculateOxygenCo2(input, false)

	if err != nil {
		panic(err)
	}

	var gamma, epsilon, oxygen, co2 int64 = 0, 0, 0, 0
	if gamma, err = strconv.ParseInt(gammaString, 2, 64); err != nil {
		panic(err)
	}
	if epsilon, err = strconv.ParseInt(epsilonString, 2, 64); err != nil {
		panic(err)
	}
	if oxygen, err = strconv.ParseInt(oxygenString, 2, 64); err != nil {
		panic(err)
	}
	if co2, err = strconv.ParseInt(scrubberString, 2, 64); err != nil {
		panic(err)
	}

	return int(gamma), int(epsilon), int(oxygen), int(co2)
}

func calculateMostCommonBit(input []string, index int) (int, rune) {
	count := 0
	for _, num := range input {
		if num[index] == '0' {
			count -= 1
		} else {
			count += 1
		}
	}

	if count < 0 {
		return count, '0'
	} else if count > 0 {
		return count, '1'
	}
	return count, ' '
}

func Filter(input []string, filter func(s string) bool) (result []string) {
	for _, num := range input {
		if filter(num) {
			result = append(result, num)
		}
	}
	return result
}

func calculateOxygenCo2(input []string, oxygen bool) (string, error) {
	var filter func(s string) bool
	length := len(input[0])

	for i := 0; i < length; i++ {

		mostCommon, char := calculateMostCommonBit(input, i)

		if oxygen {
			filter = func(s string) bool { return rune(s[i]) == char || (mostCommon == 0 && s[i] == '1') }
		} else {
			filter = func(s string) bool {
				return (rune(s[i]) != char && mostCommon != 0) || (mostCommon == 0 && s[i] == '0')
			}
		}

		input = Filter(input, filter)

		if len(input) == 1 {
			return input[0], nil
		}
	}

	return "", fmt.Errorf("could not get result from input: %s", input)
}

public class Day3
    {
        private string[] logbook = File.ReadAllLines("./input/day3.txt");
        private int BinaryToInt(string b) => Convert.ToInt32(b, 2);
        private enum Rating { OxygenRating, Co2Rating }

        public int Part1()
        {
            var gamma = string.Empty;
            var epsilon = string.Empty;

            for (var i = 0; i < 12; i++)
            {
                var ones = 0;
                var zeroes = 0;

                foreach (var log in logbook)
                {
                    ones += log[i] == '1' ? 1 : 0;
                    zeroes += log[i] == '0' ? 1 : 0;
                }

                gamma += ones > zeroes ? "1" : "0";
                epsilon += zeroes > ones ? "1" : "0";
            }

            return BinaryToInt(gamma) * BinaryToInt(epsilon);
        }

        public int Part2() => Search(Rating.OxygenRating) * Search(Rating.Co2Rating);

        private int Search(Rating rating)
        {
            var oxygenOrCO2 = rating == Rating.OxygenRating ? true : false;
            var logs = logbook.ToList();
            foreach (var i in Enumerable.Range(0, logbook[0].Length))
            {
                var logCount = logs.Count(log => log[i] == '1');
                var searchFor = (2 * logCount >= logs.Count) == oxygenOrCO2 ? '1' : '0';

                logs = logs.Where(log => log[i] == searchFor).ToList();

                if (logs.Count == 1)
                {
                    return BinaryToInt(logs[0]);
                }
            }
            return 0;
        }
    }

#include <vector>
#include <fstream>
#include <iostream>
#include "readfile.h"
#include <math.h>

using namespace std;

int main() 
{
    vector<string> logdata = readfile("input.txt");
    
    string allData{};
    for (string x : logdata)
        allData += x;

    int spacing{logdata[0].size()};

    int gammaNumber{0};
    int epsilonNumber{0};

    int bitPos{0};

    for (bitPos; bitPos< spacing; bitPos++)
    {
        int temp{0};
        for (int specificIndex{0}; specificIndex < allData.size(); specificIndex += spacing)
        {   
            temp += (allData.at(specificIndex+bitPos)-48);
        }

        if (temp < 0.5*logdata.size())
        {
            epsilonNumber += pow(2, (spacing-bitPos-1));
        }
        else
        {
            gammaNumber += pow(2, (spacing-bitPos-1));
        }
    }
    cout << "Epsilon: " << epsilonNumber << endl << "Gamma: " << gammaNumber << endl
    << "Power consumption: " << (epsilonNumber*gammaNumber) << endl;
    return 0;
}

import { Solution } from './solution.js';
import { readFile, arraySum } from './common.js';

class Square {
    value: number;
    drawn: boolean;

    constructor(value: number, drawn: boolean) {
        this.value = value;
        this.drawn = drawn;
    }
}

class Board {
    board: Square[][];
    hasWon: boolean;

    constructor(lines: string[]) {
        this.board = [];
        this.hasWon = false;

        for (let line of lines) {
            let row = line.trim()
                          .split(new RegExp("\\s+"))
                          .map(s => new Square(parseInt(s), false));
            this.board.push(row);
        }
    }

    mark(draw: number) {
        for (let row = 0; row < 5; row++) {
            for (let col = 0; col < 5; col++) {
                if (this.board[row][col].value == draw)
                    this.board[row][col].drawn = true;
            }
        }
    }

    hasBingo(): boolean {
        if (this.board.some(row => this.lineHasBingo(row)) || this.boardColumns().some(col => this.lineHasBingo(col))) {
            this.hasWon = true;
            return true;
        }

        return false;
    }

    score(lastDraw: number): number {
        // Find the sum of all unmarked numbers, then multiply by lastDraw
        return lastDraw * arraySum(this.board
                                       .flat()
                                       .filter(sq => !sq.drawn)
                                       .map(sq => sq.value));
    }

    lineHasBingo(line: Square[]): boolean {
        return line.every(square => square.drawn);
    }

    boardColumns(): Square[][] {
        // Transpose the matrix to make the columns into rows (and vice versa)
        return this.board[0].map((_,i) => this.board.map(x => x[i]));
    }

    print(draw?: number) {
        for (let row = 0; row < 5; row++) {
            for (let col = 0; col < 5; col++) {
                if (this.board[row][col].drawn)
                    process.stdout.write('\u001b[' + 41 + 'm');

                process.stdout.write(`${this.board[row][col].value}`);

                if (this.board[row][col].drawn)
                    process.stdout.write('\u001b[0m');
               process.stdout.write(" ");
            }
            process.stdout.write("\n");
        }
        if (draw !== undefined)
            console.log(`Score is: ${this.score(draw)}\n`);
    }
}

class Day4 implements Solution {
    answer() {
        readFile("data/day4.txt", (data) => {
            let [numbers, ...board_data] = data.split("\r\n\r\n");
            let boards = [];

            for (let data of board_data) {
                boards.push(new Board(data.split("\r\n")));
            }

            let winners = new Array<[Board, number]>();

            for (let drawnStr of numbers.split(",")) {
                let draw = parseInt(drawnStr);

                for (let board of boards) {
                    if (board.hasWon)
                        continue;

                    board.mark(draw);

                    if (board.hasBingo())
                        winners.push([board, draw]);
                }

                if (boards.every(b => b.hasWon))
                        break
            }

            console.log("---------- DAY 4 ----------");

            // Part 1
            console.log("First winner:");
            let [board, draw] = winners[0];
            board.print(draw);

            // Part 2
            [board, draw] = winners[winners.length - 1];
            console.log("Last winner:");
            board.print(draw);
            console.log("---------------------------");
        });
    }
}

export { Day4 }

import { Solution } from './solution.js';
import { readFile, arraySum } from './common.js';

class Square {
    value: number;
    drawn: boolean;

    constructor(value: number, drawn: boolean) {
        this.value = value;
        this.drawn = drawn;
    }
}

class Board {
    board: Square[][];
    hasWon: boolean;
    lastDraw: number;

    constructor(lines: string[]) {
        this.board = [];
        this.hasWon = false;
        this.lastDraw = -1;

        for (let line of lines) {
            let row = line.trim()
                          .split(new RegExp("\\s+"))
                          .map(s => new Square(parseInt(s), false));
            this.board.push(row);
        }
    }

    mark(draw: number) {
        this.lastDraw = draw;

        for (let row = 0; row < 5; row++) {
            for (let col = 0; col < 5; col++) {
                if (this.board[row][col].value == draw)
                    this.board[row][col].drawn = true;
            }
        }
    }

    hasBingo(): boolean {
        if (this.board.some(row => this.lineHasBingo(row)) || this.boardColumns().some(col => this.lineHasBingo(col))) {
            this.hasWon = true;
            return true;
        }

        return false;
    }

    score(): number {
        // Find the sum of all unmarked numbers, then multiply by lastDraw
        return this.lastDraw * arraySum(this.board
                                       .flat()
                                       .filter(sq => !sq.drawn)
                                       .map(sq => sq.value));
    }

    lineHasBingo(line: Square[]): boolean {
        return line.every(square => square.drawn);
    }

    boardColumns(): Square[][] {
        // Transpose the matrix to make the columns into rows (and vice versa)
        return this.board[0].map((_,i) => this.board.map(x => x[i]));
    }
}

class Day4 implements Solution {
    answer() {
        readFile("data/day4.txt", (data) => {
            let [numbers, ...board_data] = data.split("\r\n\r\n");
            let boards: Board[] = [];

            for (let data of board_data) {
                boards.push(new Board(data.split("\r\n")));
            }

            for (let drawnStr of numbers.split(",")) {
                let draw = parseInt(drawnStr);

                for (let board of boards) {
                    board.mark(draw);

                    if (board.hasBingo()) {
                        if (boards.length == board_data.length) {
                            // True if this is the first winner, as no boards have been removed from the game yet
                            console.log(`Day 4 Part 1: ${board.score()}`);
                        }
                        else if (boards.length == 1) {
                            console.log(`Day 4 Part 2: ${board.score()}`);
                        }
                        boards = boards.filter((b: Board) => b != board);
                    }
                }
            }
        });
    }
}

export { Day4 }

open System
open System.IO

type Marking = MARKED | UNMARKED
type Cell = Marking*int

type BoardId = int
type Board = BoardId*list<list<Cell>>

let hasMarking  marking (cell:Cell) =
    let (mark, _) = cell
    marking = mark

let hasBingo (board:Board) =
    let _, cells = board
    let allRowRotations = cells@(List.transpose cells)
    allRowRotations |> List.exists (List.forall (hasMarking MARKED))
    
let markCell value (board:Board) : Board =
    let markCell' cell =
        match cell with
        | UNMARKED, int when int = value -> (MARKED, int)
        | _ -> cell
    let id, cells = board 
    let newCells = cells |> List.map (List.map markCell')
    (id, newCells)
    
    
let rec playGame_1 draws boards =
    match draws with
    | [] -> None
    | draw::rest ->
        let newBoards = boards |> List.map (markCell draw)
        let boardWithBingo = List.tryFind hasBingo newBoards
        match boardWithBingo with
        | Some board -> Some(draw,board)
        | None -> (playGame_1 rest newBoards)

let rec playGame_2 draws boards =
    match draws with
    | [] -> None
    | draw::rest ->
        let newBoards = boards |> List.map (markCell draw)
        let boardsWithoutBingo = newBoards |> List.filter (hasBingo >> not)
        if (boardsWithoutBingo = []) then
            Some (draw, newBoards.Head) //assume we only have one board left when winning last
        else
            playGame_2 rest boardsWithoutBingo
            
let CalculateScore (winnerDraw:int) (winnerBoard:Board) =
    let _, cells = winnerBoard
    let unmarkedSum = cells |> List.concat |> List.filter (hasMarking UNMARKED) |> List.sumBy snd
    winnerDraw*unmarkedSum
    
let parseInput file =
    let lines = File.ReadLines file
    let draws = (lines |> Seq.head).Split (",", StringSplitOptions.TrimEntries) |> Seq.map int |> Seq.toList
    
    let rec parseBoards (lines: seq<string>) boards id =
        let parserSingleBoard (lines: seq<string>) id : Board =
            let intLines = lines |> List.ofSeq |> List.map (fun x -> (x.Split (" ", (StringSplitOptions.TrimEntries ||| StringSplitOptions.RemoveEmptyEntries)) |> Seq.toList |> List.map int))
            (id, intLines |> List.map (List.map (fun x -> (UNMARKED, x))))
        let linesToInspect = lines |> Seq.truncate 5
        if (linesToInspect |> Seq.length <> 5) then
            boards |> List.rev
        else
           parseBoards (lines |> Seq.skip 6) ((parserSingleBoard linesToInspect id)::boards)  (id+1)
    let boards = parseBoards (Seq.skip 2 lines) [] 0
    (draws, boards)
           
let draws, boards = parseInput "day4.txt"
 
let res task =
    match (task draws boards) with
    | Some(winnerDraw, board) -> CalculateScore winnerDraw board
    | None -> -1

printfn "task 1: %i"  (res playGame_1)
printfn "task 2: %i"  (res playGame_2)

use crate::solution::Solution;
use std::{
    cell::{Cell, RefCell},
    collections::HashMap,
};

struct Day4 {
    numbers: Vec<u32>,
    boards: RefCell<Vec<BingoBoard>>,
    score_last_board: Cell<u32>,
}

#[derive(Default)]
struct BingoBoard {
    board: HashMap<u32, Tile>,
    called_in_row: [u8; 5],
    called_in_col: [u8; 5],
    done: bool,
}

struct Tile {
    col: usize,
    row: usize,
    is_called: bool,
}

impl BingoBoard {
    fn add_row(&mut self, line: &str, row: usize) {
        let numbers = line
            .split_ascii_whitespace()
            .map(|num_str| num_str.parse().expect("Not a number"))
            .enumerate();
        for (col, number) in numbers {
            self.board.insert(
                number,
                Tile {
                    col,
                    row,
                    is_called: false,
                },
            );
        }
    }

    fn call_number(&mut self, number: u32) -> Option<u32> {
        if self.done {
            return None;
        }

        if let Some(mut tile) = self.board.get_mut(&number) {
            tile.is_called = true;
            self.called_in_col[tile.col] += 1;
            self.called_in_row[tile.row] += 1;
            if self.called_in_col[tile.col] == 5 || self.called_in_row[tile.row] == 5 {
                self.done = true;
                return Some(self.score(number));
            }
        }
        None
    }

    fn score(&self, number: u32) -> u32 {
        let sum = self.board.iter().fold(0, |sum, (&num, tile)| {
            if tile.is_called {
                sum
            } else {
                sum + num
            }
        });
        sum * number
    }
}

impl Solution for Day4 {
    fn part1(&self) -> String {
        self.play().to_string()
    }

    fn part2(&self) -> String {
        self.score_last_board.get().to_string()
    }
}

impl Day4 {
    fn play(&self) -> u32 {
        let mut scores = Vec::new();
        for &number in &self.numbers {
            for board in self.boards.borrow_mut().iter_mut() {
                if let Some(score) = board.call_number(number) {
                    scores.push(score);
                }
            }
        }
        self.score_last_board.set(*scores.last().unwrap());
        scores[0]
    }
}

pub fn new(input: &str) -> Box<dyn Solution> {
    let mut lines = input.lines();
    let numbers = lines.next().map(numbers_parse).expect("Missing numbers");

    let mut boards = Vec::new();
    let mut board = BingoBoard::default();
    let mut row = 0;

    for line in lines {
        if !line.is_empty() {
            board.add_row(line, row);
            row += 1;
            if row == 5 {
                boards.push(board);
                board = BingoBoard::default();
                row = 0;
            }
        }
    }

    Box::new(Day4 {
        numbers,
        boards: RefCell::new(boards),
        score_last_board: Cell::new(0),
    })
}

fn numbers_parse(line: &str) -> Vec<u32> {
    line.split(',')
        .map(|num_str| num_str.parse().expect("Not a number"))
        .collect()
}