🌟 Advent of Code (AoC) 2021 🌟

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func getPartOne(numbers []int) int {
	count := 0
	for i := 1; i < len(numbers); i++ {
		if numbers[i] > numbers[i-1] {
			count++
		}
	}
	return count
}

func getPartTwo(numbers []int) int {
	count := 0
	for i := 3; i < len(numbers); i++ {
		if sumNumbers(numbers[i-2:i+1]) > sumNumbers(numbers[i-3:i]) {
			count++
		}
	}
	return count
}

func sumNumbers(numbers []int) int {
	s := 0
	for _, val := range numbers {
		s += val
	}
	return s
}

func getNumbers(filename string) []int {
	file, err := os.Open(filename)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	scanner := bufio.NewScanner(file)
	numbers := []int{}
	for scanner.Scan() {
		row := scanner.Text()
		val, err := strconv.Atoi(row)
		if err != nil {
			panic(err)
		}
		numbers = append(numbers, val)
	}
	return numbers
}

func main() {
	fmt.Println("Part one: ", getPartOne(getNumbers("../input.txt")))
	fmt.Println("Part two: ", getPartTwo(getNumbers("../input.txt")))
}

def part1(args) do
    Enum.with_index(args, fn element, index -> {element, Enum.at(args, index + 1)} end)
    |> Enum.filter(&is_tuple(&1))
    |> Enum.filter(fn v -> is_number(elem(v, 1)) end)
    |> Enum.count(fn v -> elem(v, 0) < elem(v, 1) end)
  end

  def part2(args) do
    Enum.with_index(args, fn element, index ->
      {element, Enum.at(args, index + 1), Enum.at(args, index + 2)}
    end)
    |> Enum.filter(&is_tuple(&1))
    |> Enum.filter(fn v -> is_number(elem(v, 1)) && is_number(elem(v, 2)) end)
    |> Enum.map(fn v -> Enum.sum(Tuple.to_list(v)) end)
    |> part1
  end

val (hor, _, dep) = lines.foldLeft((0, 0, 0)) { case ((h, a, d), s"$command ${int(amount)}") =>
	command match {
		case "forward" => (h + amount, a, d + a * amount)
		case "up" => (h, a - amount, d)
		case "down" => (h, a + amount, d)
	}
}
println(dep * hor)

var depth = 0
var aim = 0
var horizontal = 0
for(s"$command ${int(amount)}" <- lines) {
	command match {
		case "forward" =>
			horizontal += amount
			depth += aim * amount
		case "up" => aim -= amount
		case "down" => aim += amount
	}
}
println(depth * horizontal)

import std/[strutils, sequtils, strscans]

proc part1(instructions: seq[string]): int =
  var depth, horiz: int
  for instr in instructions:
    let (success, dir, step) = scanTuple(instr, "$w $i")
    doAssert success
    if   dir == "forward": horiz += step
    elif dir == "down": depth += step
    elif dir == "up": depth -= step
    else: doAssert false, "Invalid directions: " & dir
  result = depth * horiz

proc part2(instructions: seq[string]): int =
  var depth, horiz, aim: int
  for instr in instructions:
    let (success, dir, step) = scanTuple(instr, "$w $i")
    doAssert success
    if dir == "forward":
      horiz += step
      depth += aim * step
    elif dir == "down": aim += step
    elif dir == "up": aim -= step
    else: doAssert false, "Invalid directions: " & dir
  result = depth * horiz


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

echo "Part 1: ", part1(inputs)
echo "Part 2: ", part2(inputs)

use std::str::FromStr;

pub enum Command {
    Forward(u32),
    Down(u32),
    Up(u32),
}

impl FromStr for Command {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let (command, value) = s.split_once(' ').ok_or("Felaktig instruktion")?;
        let value: u32 = value.parse().map_err(|_| "Felaktig siffra")?;
        match command {
            "forward" => Ok(Command::Forward(value)),
            "down" => Ok(Command::Down(value)),
            "up" => Ok(Command::Up(value)),
            _ => Err("Okänt kommando".into()),
        }
    }
}

#[derive(Debug, Default)]
struct Submarine {
    horizontal: u32,
    depth: u32,
    aim: u32,
}

impl Submarine {
    pub fn instruction(&mut self, command: &Command) {
        match command {
            Command::Forward(value) => self.horizontal += value,
            Command::Down(value) => self.depth += value,
            Command::Up(value) => self.depth -= value,
        }
    }

    pub fn instruction_with_aim(&mut self, command: &Command) {
        match command {
            Command::Forward(value) => {
                self.horizontal += value;
                self.depth += self.aim * value;
            }
            Command::Down(value) => self.aim += value,
            Command::Up(value) => self.aim -= value,
        }
    }

    pub fn product(&self) -> u32 {
        self.horizontal * self.depth
    }
}

fn main() {
    let input = std::fs::read_to_string("input.txt");
    let commands: Vec<Command> = input
        .unwrap()
        .lines()
        .filter_map(|s| s.parse::<_>().ok())
        .collect();

    // Part 1
    let mut submarine = Submarine::default();
    for command in commands.iter() {
        submarine.instruction(command);
    }
    println!("{}", submarine.product()); // 2027977

    //Part 2
    let mut submarine = Submarine::default();
    for command in commands.iter() {
        submarine.instruction_with_aim(command);
    }
    println!("{}", submarine.product()); // 1903644897
}

internal class Puzzle2 : Puzzle<int>
{
    private record Instruction(string Command, int Amount);
    private record Position(int HorPos = 0, int Depth = 0, int Aim = 0)
    {
        internal int FinalPosition { get => HorPos * Depth; }
    }

    private readonly List<Instruction> _instructions = File.ReadAllLines("Inputs/Puzzle2.txt")
        .Select(x =>
        {
            var parts = x.Split(' ');
            return new Instruction(parts[0], int.Parse(parts[1]));
        })
        .ToList();

    public override int One() => _instructions
        .Aggregate(new Position(), (c, i) => i.Command switch
        {
            "forward" => c with { HorPos = c.HorPos + i.Amount },
            "down" => c with { Depth = c.Depth + i.Amount },
            "up" => c with { Depth = c.Depth - i.Amount },
            _ => c
        }).FinalPosition;

    public override int Two() => _instructions
        .Aggregate(new Position(), (c, i) => i.Command switch
        {
            "forward" => c with { HorPos = c.HorPos + i.Amount, Depth = c.Depth + c.Aim * i.Amount },
            "down" => c with { Aim = c.Aim + i.Amount },
            "up" => c with { Aim = c.Aim - i.Amount },
            _ => c
        }).FinalPosition;
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

type Position struct {
	X int
	Y int
}

func getPartOne(moves []Position) int {
	var pos Position
	for _, move := range moves {
		pos.X += move.X
		pos.Y += move.Y
	}
	return pos.X * pos.Y
}

func getPartTwo(moves []Position) int {
	var pos Position
	var aim int
	for _, move := range moves {
		aim += move.Y
		pos.X += move.X
		pos.Y += aim * move.X
	}
	return pos.X * pos.Y
}

func getMoves(filename string) []Position {
	file, err := os.Open(filename)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	scanner := bufio.NewScanner(file)
	var moves []Position
	for scanner.Scan() {
		row := scanner.Text()
		fields := strings.Fields(row)
		dir := fields[0]
		val, err := strconv.Atoi(fields[1])
		if err != nil {
			panic(err)
		}
		switch dir {
		case "up":
			moves = append(moves, Position{
				Y: -1 * val,
			})
		case "down":
			moves = append(moves, Position{
				Y: val,
			})
		case "forward":
			moves = append(moves, Position{
				X: val,
			})
		}
	}
	return moves
}

func main() {
	fmt.Println("Part one: ", getPartOne(getMoves("../input.txt")))
	fmt.Println("Part two: ", getPartTwo(getMoves("../input.txt")))
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func part1(Coordinates []string) int {
	x, y := 0, 0

	for _, Coords := range Coordinates{
		splitString := strings.Fields(Coords)
		depth, _ := strconv.Atoi(splitString[1])
		switch splitString[0] {
		case "forward":
			x += depth
		case "up":
			y -= depth
		case "down":
			y += depth
		}
	}
	return x * y
}

func part2(Coordinates []string) int {
	x, y, aim := 0, 0, 0

	for _, Coords := range Coordinates{
		splitString := strings.Fields(Coords)
		depth, _ := strconv.Atoi(splitString[1])
		switch splitString[0] {
		case "forward":
			x += depth
			y += aim * depth
		case "up":
			aim -= depth
		case "down":
			aim += depth
		}
	}
	return x * y
}

func getInput() []string {
	file, _ := os.Open("input.txt")
	defer file.Close()
	scanner := bufio.NewScanner(file)
	var input []string
	for scanner.Scan() {
		input = append(input, scanner.Text())
	}
	return input
}

func main() {
	Input := getInput()
	fmt.Println("Part one:", part1(Input))
	fmt.Println("Part two:", part2(Input))
	
}

def fileReader():
    with open('inputDay2.txt') as file:
        lines = [line.split() for line in file]
        for i in range(len(lines)):
            lines[i][1] = int(lines[i][1])
    return lines

def day2_part1(lines):
    horizontal = 0
    vertical = 0
    for group in lines:
        x, y = str(group[0]), int(group[1])
        if (x == "forward"):
            horizontal = horizontal + y
        elif (x == "up"):
            vertical = vertical - y
        elif (x == "down"):
            vertical = vertical + y
    return horizontal * vertical;
    
def day2_part2(lines):
    horizontal = 0
    vertical = 0
    aim = 0
    for group in lines:
        x, y = str(group[0]), int(group[1])
        if (x == "forward"):
            horizontal = horizontal + y
            vertical = vertical + (aim * y) 
        elif (x == "up"):
            aim = aim - y
        elif (x == "down"):
            aim = aim + y
    return horizontal * vertical;

print('Day Two part 1:', day2_part1(fileReader()))
print('Day Two part 2:', day2_part2(fileReader()))

int solve(vector<string> data, bool can_aim)
{

    int result;
        
    /*
    Variable for submarine state:
    [x_pos, aim, y_pos] if can_aim == true
    [x_pos, y_pos, aim] if can_aim == false
    */
    int state[3] {0,0,0}; 

    std::string regex_string = "^(\\w+)\\s([0-9]+)$";
    regex regex(regex_string);
    smatch matches;

    for (int i = 0, n = data.size(); i < n; i++)
    {
        regex_search(data[i],matches,regex);

        string dir = matches.str(1);
        int length = stoi(matches.str(2));

        if (dir == "forward")
        {
            state[0] += length;
            state[2] += length * state[1]; //dummy value if can_aim == false
        }
        else if (dir == "up")
        {
            state[1] -= length;
        }
        else if (dir == "down")
        {
            state[1] += length;
        }
    }

    can_aim? result = state[0]*state[2] : result = state[0]*state[1];
    return result;
    
}

int task1(std::vector<std::pair<std::string,int>>& data){
    int x, y;
    for(auto& pair:data){
        if(pair.first == "forward") {
            x += pair.second;
        } else if(pair.first == "up"){
            y = std::max(0,y-pair.second);
        } else {
            y += pair.second;
        }
    }
    return x*y;
}

int task2(std::vector<std::pair<std::string,int>>& data){
    int x,y,aim;
    for(auto& pair:data){
        if(pair.first == "forward"){
            x += pair.second;
            y = std::max(0,y+pair.second*aim);
        } else if(pair.first == "up"){
            aim -= pair.second;
        } else {
            aim += pair.second;
        }
    }
    return x * y;
}

input0 = []
with open("dive.dat") as f:
    for line in f:
        line = line.rstrip('\n')
        input0.append(line)

class SubmarineAlfa:
    def __init__(self):
        self.horizontal = 0
        self.depth = 0

    def dive(self, dir, amount):
        if "forward" in dir:
            self.horizontal += amount
        elif "down" in dir:
            self.depth += amount
        elif "up" in dir:
            self.depth -= amount


    def __str__(self):
        return f"Horizontal = {self.horizontal} Depth = {self.depth}\n\
            Product = {self.horizontal * self.depth}"

class SubmarineBeta:
    def __init__(self):
        self.horizontal = 0
        self.depth = 0
        self.aim = 0

    def dive(self, dir, amount):
        if "forward" in dir:
            self.horizontal += amount
            self.depth += self.aim * amount
        elif "down" in dir:
            self.aim += amount
        elif "up" in dir:
            self.aim -= amount


    def __str__(self):
        return f"Horizontal = {self.horizontal} Depth = {self.depth} Aim = {self.aim}\n\
            Product = {self.horizontal * self.depth}"
        
yellowSubmarine = SubmarineBeta()
for data in input0:
    d2 = data.split()
    yellowSubmarine.dive(d2[0], int(d2[1]))

print(yellowSubmarine)

import { readFile } from "../utils";

interface IDirection {
  command: "up" | "down" | "forward";
  value: number;
}

function runDay2() {
  let depth = 0;
  let horizontal = 0;
  let aim = 0;
  const directions: IDirection[] = readFile(__dirname).map((s) => {
    const split = s.split(" ");
    return {
      command: split[0],
      value: parseInt(split[1], 10),
    } as unknown as IDirection;
  });
  directions.forEach((d) => {
    if (d.command === "up") {
      aim -= d.value;
    } else if (d.command === "down") {
      aim += d.value;
    } else if (d.command === "forward") {
      depth += d.value * aim;
      horizontal += d.value;
    }
  });
  console.log("Solution: " + depth * horizontal);
}

(import std)

(define main
  (do io/bind
      (<- inp (io/map unwrap! (read-file "inputs/day2.txt")))
      (let1 cmds (map parse-cmd (lines inp)))
      (display "Part 1:")
      (display (show-int (let1 [x y] (exec1 cmds)
                           (* x y))))
      (display "Part 2:")
      (display (show-int (let1 [x y _aim] (exec2 cmds)
                           (* x y))))))

(data Cmd (Forward Int) (Down Int))

(define (parse-cmd line)
  (let ((ss (words line))
        ([s1 ss] (unwrap! (next ss)))
        ([s2 _]  (unwrap! (next ss)))
        (val (unwrap! (parse-int s2))))
    (match s1
      (case "forward" (Forward val))
      (case "down" (Down val))
      (case "up" (Down (neg val)))
      (case _ (panic "unreachable")))))

(define (exec1 cmds)
  (define (go [x y])
    (fmatch (case (Forward dx) [(+ dx x) y])
            (case (Down dy) [x (+ dy y)])))
  (foldl go [0 0] cmds))

(define (exec2 cmds)
  (define (go [x y aim])
    (fmatch (case (Forward dx) [(+ dx x) (+ (* dx aim) y) aim])
            (case (Down daim)  [x        y                (+ daim aim)])))
  (foldl go [0 0 0] cmds))