🌟 Advent of Code (AoC) 2021 🌟

use std::fs;

pub fn run() {
    let data = fs::read_to_string("dec_02.txt").expect("unable to read file");

    println!("part1 {}", part1(&data));
    println!("part2 {}", part2(&data));
}

fn part1(data: &String) -> u32 {
    let mut distance = 0;
    let mut depth = 0;

    for line in data.lines() {
        let mut chars = line.chars();
        let first = chars.next();
        let num = chars.last().unwrap().to_digit(10).unwrap();

        match first {
            Some('f') => distance += num,
            Some('d') => depth += num,
            Some('u') => depth -= num,
            _ => println!("Bad data"),
        }
    }

    distance * depth
}

fn part2(data: &String) -> u32 {
    let mut distance = 0;
    let mut depth = 0;
    let mut aim = 0;

    for line in data.lines() {
        let mut chars = line.chars();
        let first = chars.next();
        let num = chars.last().unwrap().to_digit(10).unwrap();

        match first {
            Some('f') => {
                distance += num;
                depth += num * aim;
            },
            Some('d') => aim += num,
            Some('u') => aim -= num,
            _ => println!("Bad data"),
        }
    }

    distance * depth
}

input←⊃⎕nget'2.txt'1

h d←0
forward←{h+←⍵}
up←{d-←⍵}
down←{d+←⍵}
⍎¨input
h×d

h d a←0
forward←{h+←⍵ ⋄ d+←a×⍵}
up←{a-←⍵}
down←{a+←⍵}
⍎¨input
h×d

val input = Using.resource(Source.fromFile("2.txt"))(_.getLines().toList)

input
   .foldLeft((0, 0)) {
      case ((h, d), s"forward $n") => (h + n.toInt, d)
      case ((h, d), s"up $n")      => (h, d - n.toInt)
      case ((h, d), s"down $n")    => (h, d + n.toInt)
   }
   .pipe(_ * _)

input
   .foldLeft((0, 0, 0)) {
      case ((h, d, a), s"forward $n") => (h + n.toInt, d + a * n.toInt, a)
      case ((h, d, a), s"up $n")      => (h, d, a - n.toInt)
      case ((h, d, a), s"down $n")    => (h, d, a + n.toInt)
   }
   .pipe { case (h, d, _) => h * d }

import AoCUtils.test
import java.io.File

fun main() {
    data class Order(val order: String, val x: Int)

    fun part1(input: String): Int {
        val orders = input.lines().map { s -> s.split(" ") }.map { a -> Order(a[0], a[1].toInt()) }

        var position = 0
        var depth = 0
        for (order in orders) {
            when (order.order) {
                "forward" -> position += order.x
                "down" -> depth += order.x
                "up" -> depth -= order.x
            }
        }

        return position * depth

    }

    fun part2(input: String): Int {
        val orders = input.lines().map { s -> s.split(" ") }.map { a -> Order(a[0], a[1].toInt()) }

        var position = 0
        var depth = 0
        var aim = 0
        for (order in orders) {
            when (order.order) {
                "forward" -> {
                    position += order.x
                    depth += aim * order.x
                }
                "down" -> aim += order.x
                "up" -> aim -= order.x
            }
        }

        return position * depth
    }


    val testInput = "forward 5\n" +
            "down 5\n" +
            "forward 8\n" +
            "up 3\n" +
            "down 8\n" +
            "forward 2"

    val input = File("src", "Day02.txt").readText()

    part1(testInput) test Pair(150, "test 1 part 1")
    part1(input) test Pair(1714950, "part 1")

    part2(testInput) test Pair(900, "test 2 part 2")
    part2(input) test Pair(1281977850, "part 2")


}

Läs in och beräkna koordinater:
forward←{⍵ 0}
down←{0 ⍵}
up←{0 (-⍵)}
dag2←⍉↑⍎¨⊃⎕NGET'data\2021_dag2.txt'1

Del1: 
×/+/dag2

Del2: 
1⌷dag2+.×+\2⌷dag2×+/1⌷dag2

public static void main(String[] args) throws FileNotFoundException {
		Scanner scan = new Scanner(new File("aocDag1.txt"));
		ArrayList<String> list = new ArrayList<>();
		while (scan.hasNext()) {
			String s = scan.next();
			list.add(s);
		}
		scan.close();
		int counter = 0;
		for (int i = 0; i < list.size() - 3; i++) {
			int a = Integer.valueOf(list.get(i));
			int b = Integer.valueOf(list.get(i + 3));
			if (a < b) {
				counter++;
			}
		}
		System.out.println(counter);
	}

public static void main(String[] args) throws FileNotFoundException {
		Scanner scan = new Scanner(new File("aocDag2.txt"));
		int depth = 0;
		int horizontal = 0;
		int aim = 0;
		while (scan.hasNext()) {
			String s = scan.next();
			if (s.equalsIgnoreCase("forward")) {
				System.out.println(s);
				int cp = scan.nextInt();
				horizontal+=cp;
				depth+= (aim * cp);
				
			}
			else if (s.equalsIgnoreCase("down")) {
				System.out.println(s);
				aim+=scan.nextInt();
			}
			else {
				System.out.println(s);
				aim-=scan.nextInt();
			}
		}
		scan.close();
		System.out.println("depth = " + depth);
		System.out.println("horizontal = " + horizontal);
		System.out.println("aim = " + aim);
	}}

#Advent Of Code day 02
start_vert = 0
start_hori = 0

aim = 0
second_vert = 0
second_hort = 0

depth_num = []
splitted_num = []

with open('input.txt') as f:
    lines = f.read().splitlines()

    for i in lines:
    	depth_num.append(i)

    for i in depth_num:
    	splitted_num.append(i.split())

    for i in splitted_num:
    	if i[0] == "forward":
    		#first part
    		start_hori = start_hori + int(i[1])
    		#second part
    		second_hort = second_hort + int(i[1])
    		second_vert = second_vert + (aim * int(i[1]))

    	elif i[0] == "down":
    		#first part
    		start_vert = start_vert + int(i[1])
    		#second part
    		aim = (aim + int(i[1]))

    	elif i[0] == "up":
    		# first part
    		start_vert = start_vert - int(i[1])
    		# second part
    		aim = aim - int(i[1])
    		

print(start_hori * start_vert)
print (second_hort * second_vert)

object Day3 {

	val lines = readLines("3/data.txt")

	def main(args: Array[String]): Unit = {
		part1()
		part2()
	}

	def part1() = {
		val halfTotal = lines.length / 2

		val binStr = (0 until 12).map { col =>
			val ones = lines.count(_.charAt(col) == '1')
			if (ones > halfTotal) '1' else '0'
		}.mkString("")

		val gamma = Integer.parseInt(binStr, 2)
		val epsilon = ~gamma & 0xfff

		println(gamma * epsilon)
	}

	def part2() {
		val oxyStr = findBits(lines.sorted, 0, keepMajority = true)
		val oxy = Integer.parseInt(oxyStr, 2)

		val co2Str = findBits(lines.sorted, 0, keepMajority = false)
		val co2 = Integer.parseInt(co2Str, 2)

		println(oxy * co2)
	}

	def findBits(lines: Seq[String], pos: Int, keepMajority: Boolean): String = {
		if(lines.length == 1) {
			lines.head.substring(pos)
		} else {
			val middle = lines.length / 2.0
			val onesStartIndex = lines.indexWhere(_.charAt(pos) == '1')
			val onesAreMajority = onesStartIndex <= middle
			if(keepMajority == onesAreMajority) {
				"1" + findBits(lines.slice(onesStartIndex, lines.length), pos + 1, keepMajority)
			} else {
				"0" + findBits(lines.slice(0, onesStartIndex), pos + 1, keepMajority)
			}
		}
	}

}

import std/[strutils, math, sequtils, algorithm]

proc getColumn(s: seq[string], col: int): seq[int] =
  for line in s:
    result.add parseInt($line[col])

proc parseBinNumber(bin: seq[int]): int =
  let bin = bin.reversed
  for i in 0 .. bin.high:
    result += 2 ^ i * bin[i]

proc part1(lines: seq[string]): int =
  var gammaBin: seq[int]
  var epsilonBin: seq[int]
  for col in 0 .. lines[0].high:
    let nums = lines.getColumn(col)
    let gamma = round(sum(nums) / lines.len).toInt
    gammaBin.add gamma
    epsilonBin.add 1 - gamma
  let gamma = parseBinNumber(gammaBin)
  let epsilon = parseBinNumber(epsilonBin)
  result = gamma * epsilon

proc part2(lines: seq[string]): int =
  var oxygenCandidates = lines
  var co2Candidates = lines
  for col in 0 .. lines[0].high:
    let nums = oxygenCandidates.getColumn(col)
    let mostCommon = round(sum(nums) / oxygenCandidates.len).toInt
    oxygenCandidates = oxygenCandidates.filterIt($it[col] == $mostCommon)
    if oxygenCandidates.len == 1:
      break
  for col in 0 .. lines[0].high:
    let nums = co2Candidates.getColumn(col)
    let leastCommon = 1 - round(sum(nums) / co2Candidates.len).toInt
    co2Candidates = co2Candidates.filterIt($it[col] == $leastCommon)
    if co2Candidates.len == 1:
      break
  doAssert co2Candidates.len == 1 and oxygenCandidates.len == 1
  let oxygen = parseBinNumber(oxygenCandidates[0].mapIt(($it).parseInt))
  let co2 = parseBinNumber(co2Candidates[0].mapIt(($it).parseInt))
  result = oxygen * co2

let input = "input.txt".lines.toSeq

echo "Part 1: ", part1(input)

echo "Part 2: ", part2(input)

(import std)

(define main
  (do io/bind
      (<- inp (io/map unwrap! (read-file "inputs/day3.txt")))
      (let ((ls (lines inp))
            (width (string/length-bytes (iter/first! ls)))
            (mask (- (shift-l (cast 1) width) (cast 1)))
            (nums (map parse-binary ls))))
      (display (str-append "Width: " (show-nat width)))
      (display (str-append "Mask: " (show-nat mask)))
      (let1 [gamma epsilon power] (part1 width mask nums))
      (display (apps str-append
                     "Part 1: gamma = " (show-nat gamma)
                     ", epsilon = " (show-nat epsilon)
                     ", power = " (show-nat (* gamma epsilon))))
      (let1 [o2 co2] (part2 (cast width) nums))
      (display (apps str-append
                     "Part 2: o2 = " (show-nat o2)
                     ", co2 = " (show-nat co2)
                     ", life = " (show-nat (* o2 co2))))))

(define (part1 width mask nums)
  (let ((counts (foldl (fun (acc [num i])
                         (array/modify! (fun (n) (+ n (- (* 2 (index-bit i num)) 1)))
                                        (cast i)
                                        acc))
                       (array/collect (take (cast width) (repeat 0)))
                       (iter/cartesian nums (xrange 0 (cast width)))))
        (gamma (foldl (fun (acc [i n]) (set-bit (cast i) (>= n 0) acc))
                      (to-nat 0)
                      (enumerate (array/iter counts))))
        (epsilon (bit-and mask (bit-not gamma))))
    [gamma epsilon (* gamma epsilon)]))

(define (part2 width nums)
  (define (determine-rating selector i nums)
    (if (= 1 (to-int (array/length nums)))
        (to-nat (array/lookup! (to-nat 0) nums))
      (let ((nums (array/iter nums))
            (balance (bit-balance i nums)))
        (determine-rating
         selector
         (- i 1)
         (array/collect (filter (fun (n)
                                  (= (index-bit i n) (selector balance)))
                                nums))))))
  [(determine-rating (fun (balance) (if (>= balance 0) 1 0))
                     (- width 1) (array/collect nums))
   (determine-rating (fun (balance) (if (>= balance 0) 0 1))
                     (- width 1) (array/collect nums))])

;; Negative => more zeroes, positive => more ones
(define (bit-balance col-i nums)
  (sum (map (fun (n) (- (* 2 (index-bit col-i n)) 1)) nums)))

const SIZE: usize = 12;

fn main() {
    let input = std::fs::read_to_string("input.txt").unwrap();
    let input: Vec<_> = input.lines().collect();

    part1(&input);
    part2(input);
}

fn part1(data: &[&str]) {
    let gamma_rate = calc_gamma_rate(data);
    let epsilon_rate = gamma_rate ^ usize::from_str_radix(&"1".repeat(SIZE), 2).unwrap();
    println!("Part 1: {}", gamma_rate * epsilon_rate); //2595824
}

fn part2(data: Vec<&str>) {
    let oxygen_generator_rating = life_support(data.clone(), |lines, index, len| {
        let counted = count_ones(lines);
        if counted[index] >= len - counted[index] {
            '1'
        } else {
            '0'
        }
    });

    let scrubber_rating = life_support(data.clone(), |lines, index, len| {
        let counted = count_ones(lines);
        if counted[index] >= len - counted[index] {
            '0'
        } else {
            '1'
        }
    });
    println!("Part 2: {}", oxygen_generator_rating * scrubber_rating); //2135254
}

fn count_ones(data: &[&str]) -> Vec<usize> {
    data.iter().fold(vec![0usize; SIZE], |mut acc, value| {
        for (i, s) in value.chars().enumerate() {
            acc[i] += matches!(s, '1') as usize;
        }
        acc
    })
}

fn calc_gamma_rate(data: &[&str]) -> usize {
    count_ones(data).iter().fold(0usize, |mut acc, &s| {
        acc <<= 1;
        acc + (s > data.len() - s) as usize
    })
}

fn life_support(mut lines: Vec<&str>, f: impl Fn(&[&str], usize, usize) -> char) -> usize {
    for i in 0.. {
        let keep_token = f(&lines, i, lines.len());
        lines = lines
            .into_iter()
            .filter(|&c| c.chars().nth(i).unwrap() == keep_token)
            .collect();
        if lines.len() == 1 {
            break;
        }
    }
    usize::from_str_radix(lines[0], 2).unwrap()
}

internal class Puzzle3 : Puzzle<int>
{
    private readonly string[] _diagnosticReport = File.ReadAllLines("Inputs/Puzzle3.txt");
    private const int BitLength = 12;

    public override int One()
    {
        var gamma = Enumerable.Range(0, BitLength)
            .Aggregate("", (str, x) => str + FindCommonBit(_diagnosticReport, x, true));

        var gammaNumber = Convert.ToInt32(gamma, 2);
        var epsilon = ~gammaNumber & 0xfff;

        return gammaNumber * epsilon;
    }

    public override int Two() 
    {
        var oxygenGeneratorRating = CalculateRating(true);
        var co2ScrubberRating = CalculateRating(false);
        return oxygenGeneratorRating * co2ScrubberRating;
    }

    private int CalculateRating(bool mostCommonValue)
    {
        var lines = _diagnosticReport.ToList();
        foreach (var idx in Enumerable.Range(0, BitLength))
        {
            var commonBit = FindCommonBit(lines, idx, mostCommonValue);
            lines = lines.Where(line => line[idx] == commonBit).ToList();

            if (lines.Count == 1)
            {
                return Convert.ToInt32(lines[0], 2);
            }
        }
        return 0;
    }

    private static char FindCommonBit(IReadOnlyCollection<string> lines, int bitPosition, bool mostCommonValue)
    {
        var bitCount = lines.Count(line => line[bitPosition] == '1');
        return (mostCommonValue == 2*bitCount >= lines.Count) ? '1' : '0';
    }
}

#include <iostream>
#include <bitset>

#include "../utils/file_reader.cpp"

using namespace std;

bitset<12> bit_mode(vector<string> data, bool default_bit = true)
{

    bitset<12> output;
    string bin_str;
    int str_len;
    vector<int> sum_bits;
    int n_rows = data.size();

    for (int i = 0; i < n_rows; i++)
    {
        bin_str = data[i];
        if (i==0)
        {
            str_len = bin_str.length();
            sum_bits.resize(str_len,0);
        }
        for (int j = 0; j < str_len; j++)
        {
            sum_bits[j]+=stoi(bin_str.substr(j,1));
        }
    }

    //calculate if 0 or 1 has the highest prevalence
    //set corresponding bit in the bitset (note reverse ordering)
    for (int i = 0; i < str_len; i++)
    {
        int bit_pos = str_len-i-1;
        if (sum_bits[i]*2 == n_rows)
        {
            output.set(bit_pos, true);
        }
        else if (sum_bits[i] > n_rows/2.0)
        {
            output.set(bit_pos, true);
        }
        else
        {
            output.set(bit_pos, false);
        }
    }

    return default_bit == false? ~output : output;
}

bitset<12> recursive_solver(vector<string> data, bool default_bit, int bit_pos = 0)
{
    
    int n_rows = data.size();
    int n_bits = data[0].length();
    
    //base case
    if (bit_pos == n_bits || n_rows == 1)
    {
        bitset<12> remaining_bits(data[0]);
        return remaining_bits;
    }

    vector<string> data_next;

    //get the most common bits
    bitset<12> bitset_ = bit_mode(data, default_bit);

    for (int i = 0; i < n_rows; i++)
    {
        bitset<12> temp(data[i]);
        int bit_pos_reversed = n_bits-1-bit_pos;  //bit-order from right in bitset
        if (temp.test(bit_pos_reversed) == bitset_.test(bit_pos_reversed))
        {
            data_next.push_back(data[i]);
        }
    }
    
    return recursive_solver(data_next, default_bit, ++bit_pos);

}

int solve_part1(vector<string> data)
{
   
    bitset<12> gamma_rate_bits = bit_mode(data, true);
    bitset<12> epsilon_rate_bits = bit_mode(data, false);

    int gamma_rate = (int)gamma_rate_bits.to_ulong();
    int epsilon_rate = (int) epsilon_rate_bits.to_ulong();

    return gamma_rate * epsilon_rate;

}

int solve_part2(vector<string> data)
{
    bitset<12> oxgen_rate_bits = recursive_solver(data,true);
    bitset<12> co2scrub_rate_bits = recursive_solver(data,false);

    int oxgen_rate = (int)oxgen_rate_bits.to_ulong();
    int co2scrub_rate = (int) co2scrub_rate_bits.to_ulong();
   
    return oxgen_rate * co2scrub_rate;
}

int main()
{
    vector<string> data = read_file<string>("../../input/day_03.txt");

    int part_1 = solve_part1(data);
    int part_2 = solve_part2(data);

    cout << "Day 1 Part 1 solution: " << part_1 << endl;
    cout << "Day 1 Part 2 solution: " << part_2 << endl;
    
}