🌟 Advent of Code (AoC) 2022 🌟

else
    {
        var dirName = currentLocation == "/" ? "/" : $"{currentLocation}/";
        var fileName = currentLocation == "/" ? $"/{output[1]}" : $"{currentLocation}/{output[1]}";
        
        if(!seenDirectories.Contains(dirName))
            seenDirectories.Add(dirName);
        
        if (seenFiles.Keys.Contains(fileName))
            continue;
        
        if (int.TryParse(output[0], out var result))
        {
            if (directories.ContainsKey(dirName))
            {
                directories[dirName] += result;
                seenFiles.Add(fileName, result);
            }
            else
            {
                directories[dirName] = result;
                seenFiles.Add(fileName, result);
            }
        }
    }

      for (let i = 0; i < currFolders.length; i++) {
        // / a e
        const folderName = currFolders.slice(0, i+1).join('');
        if (!hash[folderName]) hash[folderName] = num;
        else hash[folderName] += num;
      }

using Day7;
using var sr = new StreamReader("input.txt");

var root = new ElfDir() { Name = "/", Files = new(), Subdirs = new() };
var cd = root;
sr.ReadLine();
while (!sr.EndOfStream)
{
    var line = sr.ReadLine()!.Split();
    switch (line[0])
    {
        case "$":
            if (line[1] == "cd")
            {
                if (line[2] == "..")
                {
                    cd = cd.Parent!;
                }
                else
                {
                    cd = cd!.Subdirs.Find(cd => cd.Name == line[2]);
                }
            }
            break;
        case "dir":
            cd!.Subdirs.Add(new() { Name = line[1], Parent = cd, Subdirs = new() });
            break;
        default:
            cd!.Files += int.Parse(line[0]);
            break;
    }
}
int pt1 = root.AllSubdirs.Where(x => x.Size < 100000).Sum(d => d.Size);
int pt2_goal = 30000000 - (70000000 - root.Size);
var pt2 = root.AllSubdirs.Where(x => x.Size > pt2_goal).OrderBy(x => x.Size).First().Size;

Console.WriteLine("Part 1: " + pt1);
Console.WriteLine("Part 2: " + pt2);

namespace Day7
{
    internal class ElfDir
    {
        public ElfDir? Parent { get; set; }
        public string Name { get; set; } = string.Empty;
        public List<ElfDir> Subdirs { get; set; } = new();
        public int Files { get; set; } = new();

        public int Size => Subdirs.Sum(x => x.Size) + Files;
        public (string, int) Info => (Name, Size);
        public List<ElfDir> AllSubdirs
        {
            get
            {
                List<ElfDir> retval = new();
                retval.AddRange(Subdirs);
                foreach (var item in Subdirs)
                {
                    retval.AddRange(item.AllSubdirs);
                }
                return retval;
            }
        }
    }
}

public sealed class Directories : Puzzle<int>
{
    public override int A(string data)
    {
        Directory dir = BuildStructure(data);
        return CalculateTotal(dir, 100000);
    }

    public override int B(string data)
    {
        const int updateSize = 30000000;
        Directory dir = BuildStructure(data);
        var freeSpace = 70000000 - dir.GetDirectorySize();
        var requiredSize = updateSize - freeSpace;
        return FindSmallestDirectory(dir, requiredSize);
    }

    private Directory BuildStructure(string input)
    {
        var root = new Directory("/", null);
        Directory current = root;
        foreach (var line in input.Split("\r\n").Skip(1))
        {
            if (line[0] == '$')
            {
                if (line[2..4] != "cd") continue;
                current = line[5..6] switch
                {
                    "." => current.Parent!,
                    "/" => root,
                    _ => current.Directories.First(d => d.Name == line.Split(" ")[2])
                };
            }
            else if (line[..3] == "dir")
            {
                current.Directories.Add(new Directory(line.Split(" ")[1], current));
            }
            else
            {
                var parts = line.Split(" ");
                current.Files.Add(new File(parts[1], int.Parse(parts[0])));
            }
        }

        return root;
    }
    
    private int CalculateTotal(Directory root, int maxSize)
    {
        var dirs = new Stack<Directory>();
        dirs.Push(root);
        int sum = 0;
        while (dirs.Count > 0)
        {
            Directory d = dirs.Pop();
            sum += d.GetDirectorySize(maxSize);
            foreach (Directory subDir in d.Directories)
            {
                dirs.Push(subDir);
            }
        }
    
        return sum;
    }
    
    private int FindSmallestDirectory(Directory root, int requestedSpace)
    {
        var directories = new Stack<Directory>();
        var candidates = new List<int>();
        directories.Push(root);
        while (directories.Count > 0)
        {
            Directory d = directories.Pop();
            var size = d.GetDirectorySize();
            if (size >= requestedSpace)
            {
                candidates.Add(size);
            }

            foreach (Directory subDir in d.Directories)
            {
                directories.Push(subDir);
            }
        }

        return candidates.MinBy(d => d);
    }

    private struct File
    {
        public string Name;
        public int Size;

        public File(string name, int size)
        {
            Name = name;
            Size = size;
        }
    }

    private sealed class Directory
    {
        public readonly string Name;
        public readonly Directory? Parent;
        public readonly List<Directory> Directories = new();
        public readonly List<File> Files = new();

        public Directory(string name, Directory? parent)
        {
            Name = name;
            Parent = parent;
        }
        
        public int GetDirectorySize(int? limit = null)
        {
            int sums = 0;
            Stack<Directory> dirs = new Stack<Directory>();
            dirs.Push(this);

            while (dirs.Count > 0)
            {
                var d = dirs.Pop();
                sums += d.Files.Sum(f => f.Size);
                foreach (Directory dir in d.Directories)
                {
                    dirs.Push(dir);
                }
            }

            if (limit == null || sums <= limit)
                return sums;

            return 0;
        }
    }
}

class Directory:
    def __init__(self, name, parent=None):
        self.name = name
        self.parent = parent
        self.size = 0
        self.subdirectories = []

    def calculate_size(self, total_size):
        calculated_size = self.size

        for sub in self.subdirectories:
            result = sub.calculate_size(total_size)
            calculated_size += result[0]
            total_size = result[1]

        if calculated_size <= 100000:
            total_size += calculated_size

        return calculated_size, total_size

    def find_smallest_to_delete(self, space_req, smallest):
        calculated_size = self.size

        for sub in self.subdirectories:
            result = sub.find_smallest_to_delete(space_req, smallest)
            calculated_size += result[0]
            smallest = result[1]

        if space_req <= calculated_size < smallest:
            smallest = calculated_size

        return calculated_size, smallest


def day7():
    input_list = open("data\\day7.txt").read().split("\n")
    root = Directory("root")
    active = root

    for line in input_list:
        if line == "$ cd /":
            active = root
        elif line == "$ cd ..":
            active = active.parent
        elif line.startswith("$ cd "):
            for sub in active.subdirectories:
                if sub.name == line[5:]:
                    active = sub
                    break
        elif line[0].isdigit():
            active.size += int(line[:line.index(" ")])
        elif line.startswith("dir"):
            active.subdirectories.append(Directory(line[4:], active))

    result = root.calculate_size(0)
    space_req = 30000000 - (70000000 - result[0])
    result2 = root.find_smallest_to_delete(space_req, result[0])

    print(result[1])
    print(result2[1])

import {readFileSync} from 'fs';

const root = { childDirs:{}, files:{}};
let currentDir = root;
const dirSizes = [];

function processCommand(line){
    if(line[1] === 'cd') { // we ignore ls
        if (line[2]=== ".."){
            currentDir = currentDir.parent;
        } else {
            currentDir = currentDir.childDirs[line[2]];
        }
    }
}

function parseInput(){
    allLines.shift(); //easier to assume currentDir starts as root
    allLines.forEach(line => {
        if(line[0] === "$"){ // anything starting with $ is a command
            processCommand(line);
        } else if(Number.isNaN(Number(line[0]))){ // if it's not a number and it's not a line starting with $ then it's a dir
            currentDir.childDirs[line[1]] = { childDirs:{}, files:{}, parent: currentDir };
        } else { // only files left in the format SIZE NAME
            currentDir.files[line[1]] = Number(line[0]);
        }
    });
}

function calculateSizes(myCurrentDir){
    myCurrentDir.size = Object.values(myCurrentDir.childDirs).reduce( (acc, childDir) => acc + calculateSizes(childDir), 0 );
    myCurrentDir.size += Object.values(myCurrentDir.files).reduce( (acc, currentFile) => acc + currentFile, 0 );
    dirSizes.push(myCurrentDir.size);
    return myCurrentDir.size;
}

const allLines = readFileSync("07data","utf8").split("\n").map(line => line.split(" "));

parseInput();
calculateSizes(root);

console.log("Part 1:", dirSizes.filter( (size) => size <= 100000 ).reduce((acc,cur) => acc + cur));

const needsToFind = -70000000 + 30000000 + root.size;

console.log("Part 2:",dirSizes
    .sort( (a,b) => a-b )
    .find( (dirsize) => dirsize > needsToFind ));

Console.WriteLine("Mickur's Advent of Code 2022 - Day 7!");

// Setup
var input = File.ReadAllLines("input.txt");

var rootDir = new CustomDirectory("root");
var currentDir = rootDir;

foreach (var line in input)
{
    // Ignore these lines
    if (line == "$ ls")
        continue;

    if (line.StartsWith("dir "))
        continue;

    // Changing directory
    if (line.StartsWith("$ cd "))
    {
        var output = line.Split(' ');
        
        switch (output[2])
        {
            case "/":
                currentDir = rootDir;
                continue;
            
            case "..":
                currentDir = currentDir.parent;
                continue;
            
            default:
                // Check if it already exists
                if (currentDir.subdirs.Exists(x => x.name == output[2]))
                    currentDir = currentDir.subdirs.First(x => x.name == output[2]);
                else
                {
                    var newDir = new CustomDirectory($"{output[2]}", currentDir);
                    currentDir.subdirs.Add(newDir);
                    currentDir = newDir;
                }
                
                continue;
        }
    }
    
    // Output
    else
    {
        var output = line.Split(' ');
        
        if (long.TryParse(output[0], out var result))
        {
            currentDir.files.Add(output[1], result);;
        }
    }
}

var answerA = rootDir.GetTotalBelow(100000);

var rootSize = rootDir.GetTotalFileSize();
var needToFree = -70000000 + 30000000 + rootSize;

var answerB = rootDir.FindDirectoriesAbove(needToFree).Min();

Console.WriteLine(answerA);
Console.WriteLine(answerB);

class CustomDirectory
{
    public string name;
    public Dictionary<string, long> files = new ();
    public CustomDirectory parent;
    public List<CustomDirectory> subdirs = new();

    public CustomDirectory(string name, CustomDirectory parent = null)
    {
        this.name = name;
        this.parent = parent;
    }

    public long GetTotalFileSize()
    {
        long value = 0;

        foreach (var subDir in subdirs)
        {
            value += subDir.GetTotalFileSize();
        }

        foreach (var file in files)
        {
            value += file.Value;
        }

        return value;
    }

    public long GetTotalBelow(long max)
    {
        long value = 0;
        long dirSize = 0;
        
        // Keep value from subdirs
        foreach (var subDir in subdirs)
        {
            value += subDir.GetTotalBelow(max);
        }

        // Add to value if we have a total below max
        foreach (var subDir in subdirs)
        {
            dirSize += subDir.GetTotalFileSize();
        }
        foreach (var file in files)
        {
            dirSize += file.Value;
        }

        if (dirSize <= max)
            value += dirSize;
        
        return value;
    }

    public List<long> FindDirectoriesAbove(long minSize)
    {
        long dirSize = 0;
        var sizes = new List<long>();
        
        // Keep sizes from subdirs
        foreach (var subDir in subdirs)
        {
            sizes.AddRange(subDir.FindDirectoriesAbove(minSize));
        }

        // Add to sizes if we have a total above min
        foreach (var subDir in subdirs)
        {
            dirSize += subDir.GetTotalFileSize();
        }
        foreach (var file in files)
        {
            dirSize += file.Value;
        }

        if (dirSize >= minSize)
            sizes.Add(dirSize);
        
        return sizes;
    }
}

fn main() {
    let input = include_str!("./input.txt");
    let v0 = vec![];
    let v1 = vec!['L', 'N', 'W', 'T', 'D'];
    let v2 = vec!['C', 'P', 'H'];
    let v3 = vec!['W', 'P', 'H', 'N', 'D', 'G', 'M', 'J'];
    let v4 = vec!['C', 'W', 'S', 'N', 'T', 'Q', 'L'];
    let v5 = vec!['P', 'H', 'C', 'N'];
    let v6 = vec!['T', 'H', 'N', 'D', 'M', 'W', 'Q', 'B'];
    let v7 = vec!['M', 'B', 'R', 'J', 'G', 'S', 'L'];
    let v8 = vec!['Z', 'N', 'W', 'G', 'V', 'B', 'R', 'T'];
    let v9 = vec!['W', 'G', 'D', 'N', 'P', 'L'];
    let mut v = vec![v0, v1, v2, v3, v4, v5, v6, v7, v8, v9];

    let crane_model = "9001";

    for line in input.lines() {
        let split: Vec<&str> = line.split(" ").collect();
        let amount = split[1].parse::<usize>().unwrap();
        let from = split[3].parse::<usize>().unwrap();
        let to = split[5].parse::<usize>().unwrap();

        if crane_model.eq("9000") {
            for _i in 0..amount {
                let current_crate = v[from].pop().unwrap();
                v[to].push(current_crate);
            }
        } else if crane_model.eq("9001") {
            let mut temp_v = vec![];
            for _i in 0..amount {
                let current_crate = v[from].pop().unwrap();
                temp_v.push(current_crate);
            }
            v[to].append(&mut temp_v.into_iter().rev().collect());
        }
    }

    println!("{:?}", v[1]);
    println!("{:?}", v[2]);
    println!("{:?}", v[3]);
    println!("{:?}", v[4]);
    println!("{:?}", v[5]);
    println!("{:?}", v[6]);
    println!("{:?}", v[7]);
    println!("{:?}", v[8]);
    println!("{:?}", v[9]);

    print!("Solution 2: ");
    print!("{}", v[1].last().unwrap());
    print!("{}", v[2].last().unwrap());
    print!("{}", v[3].last().unwrap());
    print!("{}", v[4].last().unwrap());
    print!("{}", v[5].last().unwrap());
    print!("{}", v[6].last().unwrap());
    print!("{}", v[7].last().unwrap());
    print!("{}", v[8].last().unwrap());
    print!("{}", v[9].last().unwrap());
    println!("");
}

fn find_marker(input: &str, len: usize) -> usize {
    let mut found;
    for i in 13..input.len() {
        found = true;
        for j in 0..len {
            for k in j..len {
                if j != k {
                    if input.chars().nth(i - j).unwrap() == input.chars().nth(i-k).unwrap() {
                        found = false;
                    }
                }
            }
        }
        if found {
            return i + 1;
        }
    }
    return 0;
}


fn main() {
    let input = include_str!("./input.txt");
    println!("Start-of-packet marker: {}", find_marker(input, 4));
    println!("Start-of-message marker: {}", find_marker(input, 14));
}

use std::collections::HashMap;

fn main() {
    let input = include_str!("./input.txt");

    let mut filesystem = HashMap::new();
    filesystem.insert("".to_string(), 0);
    let mut current_path = vec![""];

    for line in input.lines() {
        let command: Vec<&str> = line.split(" ").collect();
        if command[0].eq("$") {
            if command[1].eq("cd") && command[2].eq("/") {
                current_path = vec![""];
            } else if command[1].eq("cd") && command[2].eq("..") {
                current_path.pop();
            } else if command[1].eq("cd") {
                current_path.push(command[2]);
                filesystem.insert(current_path.join("/"), if filesystem.contains_key(&current_path.join("/")) { filesystem[&current_path.join("/")] } else {0});
            }
        } else if command[0].eq("dir") { /* ignore */         
        } else {
            let mut temp_current_path = current_path.clone();
            for _i in 0..temp_current_path.len() {
                *filesystem.get_mut(&temp_current_path.join("/")).unwrap() +=
                    command[0].parse::<u32>().unwrap();
                temp_current_path.pop();
            }
        }
    }

    let mut size_for_part_1: u32 = 0;
    let mut folder_size = vec![];

    for (_dir, size) in &filesystem {
        folder_size.push(*size);
        if *size <= 100000 {
            size_for_part_1 += size;
        }
    }
    
    println!("Sum for part 1: {}", size_for_part_1);

    let free_space = 70000000 - filesystem[""];
    let minimum_to_delete = 30000000 - free_space;
    folder_size.sort();
    for i in 0..folder_size.len() {
        if folder_size[i] >= minimum_to_delete {
            println!("Delete folder with size: {}", folder_size[i]);
            break;
        }
    }
}

#include "../AoCHelper/AoCHelper.h"
#include <vector>

struct Directory
{
    std::string name;
    Directory *parent;
    std::vector<Directory> subDirectories;
    std::vector<std::pair<std::string, size_t>> files;
    size_t total_size{0};
};

std::vector<Directory> findAllDirectoriesWithSizeLargerThan(std::vector<Directory> &directories, size_t size)
{
    std::vector<Directory> directoriesWithSizeLargerThan;
    for (Directory directory : directories)
    {
        if (directory.total_size > size)
        {
            directoriesWithSizeLargerThan.push_back(directory);
        }
        std::vector<Directory> subDirectoriesWithSizeLargerThan = findAllDirectoriesWithSizeLargerThan(directory.subDirectories, size);
        directoriesWithSizeLargerThan.insert(directoriesWithSizeLargerThan.end(), subDirectoriesWithSizeLargerThan.begin(), subDirectoriesWithSizeLargerThan.end());
    }
    return directoriesWithSizeLargerThan;
}

size_t findAllDirectoriesWithSizeLessThan(std::vector<Directory> &directories, size_t size)
{
    size_t total{0};
    for (Directory directory : directories)
    {
        if (directory.total_size <= size)
        {
            total += directory.total_size;
        }
        total += findAllDirectoriesWithSizeLessThan(directory.subDirectories, size);
    }
    return total;
}

size_t getDirectorySize(Directory &directory)
{
    size_t size{0};
    for (std::pair<std::string, size_t> file : directory.files)
    {
        size += file.second;
    }
    for (Directory subDirectory : directory.subDirectories)
    {
        size += getDirectorySize(subDirectory);
    }
    return size;
}

void updateAllTotalSizes(Directory &directory)
{
    directory.total_size = getDirectorySize(directory);
    for (Directory &subDirectory : directory.subDirectories)
    {
        updateAllTotalSizes(subDirectory);
    }
}

void puzzle(std::vector<std::string> input)
{
    size_t answer{};
    Directory root{"/", nullptr, {}, {}, 0};
    Directory *currentDirectory = &root;
    for (int i = 0; i < input.size(); i++)
    {
        std::string row = input[i];
        if (row == "$ cd /")
        {
            currentDirectory = &root;
        }
        else if (row == "$ cd ..")
        {
            currentDirectory = currentDirectory->parent;
        }
        else if (row.substr(0, 4) == "$ cd")
        {
            std::string directoryName = myLib::split(row, ' ')[2];
            if (std::any_of(currentDirectory->subDirectories.begin(), currentDirectory->subDirectories.end(), [directoryName](Directory directory)
                            { return directory.name == directoryName; }))
            {
                for (Directory &directory : currentDirectory->subDirectories)
                {
                    if (directory.name == directoryName)
                    {
                        currentDirectory = &directory;
                    }
                }
            }
            else
            {
                Directory newDirectory{directoryName, currentDirectory, {}, {}, 0};
                currentDirectory->subDirectories.push_back(newDirectory);
                currentDirectory = &newDirectory;
            }
        }
        else if (row == "$ ls")
        {
            size_t j = i + 1;
            while (input[j].substr(0, 1) != "$")
            {
                if (input[j].substr(0, 4) == "dir ")
                {
                    std::string subDirectoryName = myLib::split(input[j], ' ')[1];
                    if (std::none_of(currentDirectory->subDirectories.begin(), currentDirectory->subDirectories.end(), [subDirectoryName](Directory directory)
                                     { return directory.name == subDirectoryName; }))
                    {
                        Directory newDirectory{subDirectoryName, currentDirectory, {}, {}, 0};
                        currentDirectory->subDirectories.push_back(newDirectory);
                    }
                }
                else
                {
                    std::string fileName = myLib::split(input[j], ' ')[1];
                    size_t fileSize = std::stoi(myLib::split(input[j], ' ')[0]);
                    currentDirectory->files.push_back(std::make_pair(fileName, fileSize));
                }
                if (j == input.size() - 1)
                {
                    break;
                }
                j++;
            }
        }
    }

    updateAllTotalSizes(root);

    answer = findAllDirectoriesWithSizeLessThan(root.subDirectories, 100000);

    std::cout << "Puzzle one: " << answer << std::endl;
    int freeSpace = 70000000 - root.total_size;

    int neededSpace = 30000000;
    int spaceToBeFreed = neededSpace - freeSpace;
    std::vector<Directory> directoriesWithSizeLargerThan = findAllDirectoriesWithSizeLargerThan(root.subDirectories, spaceToBeFreed);
    std::sort(directoriesWithSizeLargerThan.begin(), directoriesWithSizeLargerThan.end(), [](Directory a, Directory b)
              { return a.total_size < b.total_size; });
    int answerTwo = directoriesWithSizeLargerThan[0].total_size;
    std::cout << "Puzzle two: " << answerTwo << std::endl;
}

int main()
{
    std::vector<std::string> exampleInput{
        "$ cd /",
        "$ ls",
        "dir a",
        "14848514 b.txt",
        "8504156 c.dat",
        "dir d",
        "dir g",
        "$ cd a",
        "$ ls",
        "dir e",
        "29116 f",
        "2557 g",
        "62596 h.lst",
        "$ cd e",
        "$ ls",
        "584 i",
        "$ cd ..",
        "$ cd ..",
        "$ cd d",
        "$ ls",
        "4060174 j",
        "8033020 d.log",
        "5626152 d.ext",
        "7214296 k",
        "dir a", // had to add extra example data to find a bug in my program
        "$ cd a",
        "$ ls",
        "10203 abc",
        "$ cd /",
        "$ cd g",
        "$ ls",
        "2000 b.txt",
        "1000 c.dat",
        "dir k"
        "$ cd k",
        "$ ls",
        "5000 b.txt"};
    AoCHelper a1{"2022", "7"};
    std::vector<std::string> result = a1.get_input();
    puzzle(result);
}

Löper igenom alla rader och bygger på och tar bort från "sökvägen" under tiden. Sparar ner alla fil- och mapp-strängar på deras sökväg i en map. 

Hittar sedan storleken på varje mapp på ett rekursivt och ineffektivt sätt och sparar i en map. 

val structureMap = mutableMapOf<List<String>, MutableList<String>>()
val path = mutableListOf<String>()

for (line in input.lines().map { it.trim() }) {
	if (line.subSequence(0, 4) == "$ cd") {
		val secondPart = line.substring(5)
		if(secondPart == "..")
			path.removeLast()
		else
			path.add(secondPart)
	}
	else if (!line.contains("\$ ls")) {
		structureMap.getOrPut(path.toList()) { mutableListOf() }.add(line)
	}
}

val sizeMap = structureMap.keys.associateWith { sizeSubstructure(it, structureMap) }

println(sizeMap.filter { it.value < 100000 }.values.sum()) // Part 1

val minDelete = sizeMap.values.max() - (70000000 - 30000000)
println(sizeMap.filter { it.value > minDelete }.values.minOf { it }) // Part 2

}

fun sizeSubstructure(path: List<String>, structure: Map<List<String>, List<String>>): Int = structure[path]!!.sumOf {
if(it.contains("dir"))
	sizeSubstructure(path + listOf(it.split(" ")[1]), structure)
else
	it.split(" ")[0].toInt() }

val dirStack = mutableListOf<Int>()
val finishedDirs = mutableListOf<Int>()

for (line in input.lines()) {
	if (line.substring(0, 4) == "$ cd")
		if (line.contains(".."))
			finishedDirs.add(dirStack.removeLast())
		 else
			dirStack.add(0)
	dirStack.replaceAll { it + (line.split(" ").first().toIntOrNull()?: 0) }
}
finishedDirs.addAll(dirStack)

println(finishedDirs.filter { it < 100000 }.sum()) // Part 1
println(finishedDirs.filter { it > finishedDirs.max() - 40000000 }.min()) // Part 2

func BenchmarkDay7_parsing(b *testing.B) {
	input := parseInput(7)
	for n := 0; n < b.N; n++ {
		parseFilesystem(input)
	}
}

func BenchmarkDay7_part1(b *testing.B) {
	fs := parseFilesystem(parseInput(7))
	for n := 0; n < b.N; n++ {
		fs.sumSizeWithLimit(100000)
	}
}

func BenchmarkDay7_part2(b *testing.B) {
	fs := parseFilesystem(parseInput(7))
	for n := 0; n < b.N; n++ {
		fs.bestFitForCap(70000000, 30000000)
	}
}

$ go test -bench Day7 .  
goos: darwin
goarch: arm64
pkg: aoc2022
BenchmarkDay7_parsing-8    	    3466	    329109 ns/op
BenchmarkDay7_part1-8      	  218112	      5434 ns/op
BenchmarkDay7_part2-8      	  220860	      5375 ns/op
PASS
ok  	aoc2022	3.766s

import itertools
st = []
dir_sizes = []
for cmd in itertools.chain(open('day7.txt').readlines(), itertools.cycle(['$ cd ..'])):
    p = cmd.strip().split()
    if p[0] == '$' and p[1] == 'cd':
        if p[2] == '..':
            top = st.pop()
            dir_sizes.append(top)
            if len(st) == 0:
                break
            st[-1] = st[-1] + top
        else:
            st.append(0)
    elif p[0].isnumeric():
        st[-1] = st[-1] + int(p[0])
print(sum(filter(lambda sz: sz <= 100000, dir_sizes)))
additional_space = 30000000 - (70000000 - dir_sizes[-1])
print(min(filter(lambda sz: sz >= additional_space, dir_sizes)))

Console.WriteLine("Mickur's Advent of Code 2022 - Day 8!");

var input = File.ReadAllLines("input.txt");

var treeGrid = new List<List<int>>();
var counter = 0;
long bestBAnswer = 0;

foreach (var line in input)
{
    var currRow = new List<int>();

    for (var i = 0; i < line.Length; i++)
    {
        currRow.Add(line[i]);
    }
    
    treeGrid.Add(currRow);
}

var height = treeGrid.Count - 1;
var width = treeGrid[0].Count - 1;

for (var currY = 0; currY < treeGrid.Count; currY++)
{
    for (var currX = 0; currX < treeGrid[currY].Count; currX++)
    {
        var canBeSeenFromTop = true;
        var canBeSeenFromRight = true;
        var canBeSeenFromBottom = true;
        var canBeSeenFromLeft = true;
        
        // Check up and down
        var currValue = treeGrid[currY][currX];

        // A: Check top
        for (var top = 0; top < currY; top++)
        {
            var checkValue = treeGrid[top][currX];
            if (checkValue >= currValue)
            {
                canBeSeenFromTop = false;
                break;
            }
        }
        
        // A: Check right
        for (var right = width; right > currX; right--)
        {
            var checkValue = treeGrid[currY][right];
            if (checkValue >= currValue)
            {
                canBeSeenFromRight = false;
                break;
            }
        }
        
        // A: Check bottom
        for (var bottom = height; bottom > currY; bottom--)
        {
            var checkValue = treeGrid[bottom][currX];
            if (checkValue >= currValue)
            {
                canBeSeenFromBottom = false;
                break;
            }
        }
        
        // A: Check left
        for (var left = 0; left < currX; left++)
        {
            var checkValue = treeGrid[currY][left];
            if (checkValue >= currValue)
            {
                canBeSeenFromLeft = false;
                break;
            }
        }
        
        if (canBeSeenFromTop || canBeSeenFromRight || canBeSeenFromBottom || canBeSeenFromLeft)
            counter++;
        
        
        // B: Check top
        var tempY = currY - 1;
        var topSight = 0;
        while (tempY >= 0)
        {
            if (currValue <= treeGrid[tempY][currX])
            {
                topSight++;
                break;
            }
            
            if (currValue > treeGrid[tempY][currX])
                topSight++;
            else
                break;
            tempY--;
        }
        
        // B: Check bottom
        tempY = currY + 1;
        var bottomSight = 0;
        while (tempY <= height)
        {
            if (currValue <= treeGrid[tempY][currX])
            {
                bottomSight++;
                break;
            }
            
            if (currValue > treeGrid[tempY][currX])
                bottomSight++;
            else
                break;
            tempY++;
        }
        
        // B: Check left
        var tempX = currX - 1;
        var leftSight = 0;
        while (tempX >= 0)
        {
            if (currValue <= treeGrid[currY][tempX])
            {
                leftSight++;
                break;
            }
            
            if (currValue > treeGrid[currY][tempX])
                leftSight++;
            else
                break;
            tempX--;
        }
        
        // B: Check right
        tempX = currX + 1;
        var rightSight = 0;
        while (tempX <= width)
        {
            if (currValue <= treeGrid[currY][tempX])
            {
                rightSight++;
                break;
            }
            
            if (currValue > treeGrid[currY][tempX])
                rightSight++;
            else
                break;
            tempX++;
        }

        long bValue = topSight * rightSight * bottomSight * leftSight;

        if (bValue > bestBAnswer)
            bestBAnswer = bValue;
    }
}

Console.WriteLine(counter);
Console.WriteLine(bestBAnswer);

	val intTreeGrid = treeGrid.lines().map { it.map { it.digitToInt() } }
val directions = listOf(Pair(-1, 0), Pair(1, 0), Pair(0, -1),	Pair(0, 1))

println(intTreeGrid.indices.maxOf { y ->  intTreeGrid[y].indices.maxOf {
		x-> directions.fold(1) { acc, pair -> acc*treeView(Pair(y, x), intTreeGrid, pair, intTreeGrid[y][x]) }}})

println(intTreeGrid.indices.sumOf { y ->  intTreeGrid[y].indices.count { x -> !directions.none { isVisible(Pair(y, x), intTreeGrid, it, intTreeGrid[y][x]) }}})
}

fun isVisible(position: Pair<Int, Int>, grid: List<List<Int>>, direction: Pair<Int, Int>, height: Int): Boolean{
var newPosition = Pair(position.first + direction.first, position.second + direction.second)
while (newPosition.first in grid.indices
	&& newPosition.second in grid.first().indices) {
	if (grid[newPosition.first][newPosition.second] >= height)
		return false
	newPosition = Pair(newPosition.first + direction.first, newPosition.second + direction.second)
}
return true
}


fun treeView(position: Pair<Int, Int>, grid: List<List<Int>>, direction: Pair<Int, Int>, height: Int): Int {
var distance = 0
var newPosition = Pair(position.first + direction.first, position.second + direction.second)

while (newPosition.first in grid.indices && newPosition.second in grid.first().indices && grid[newPosition.first][newPosition.second] < height) {
	distance ++
	newPosition = Pair(newPosition.first + direction.first, newPosition.second + direction.second)
}
if (newPosition.first in grid.indices && newPosition.second in grid.first().indices)
	distance++

return distance
}