Advent of Code 2022: no pato edition

def walk_dirs(idx, lines, sizes):
    size = 0
    i = idx
    while i < len(lines):
        line = lines[i]
        if line.startswith('$ cd'):
            if not line.endswith('..'):
                child_size, last_idx = walk_dirs(i + 1, lines, sizes)
                size += child_size
                i = last_idx
            else:
                break
        elif line == '$ ls':
            pass
        elif not line.startswith('dir'):
            size += int(line.split(' ', 1)[0])
        i += 1
    sizes.append(size)
    return size, i
    


if __name__ == '__main__':
    with open('in', 'r') as fp:
        lines = [line.strip() for line in fp.readlines()]
    

sizes = []
walk_dirs(0, lines, sizes)
print('part1', sum(filter(lambda size: size < 100000, sizes)))

available = 70000000
required = 30000000
used = sizes[-1]
free = available - used
to_remove = required - free
selected = min(sizes, key=lambda size: (size - to_remove) if (size > to_remove) else available)
print('part2', selected)

import anytree
from anytree import Node, RenderTree, AsciiStyle, search
import re
with open("input.txt", "r") as input:
    lineas = input.readlines()
    total_lineas = len(lineas)

# Create filesystem
linea = 0
root = Node(name = "root", parent=None, value=0 , value2=0)
current_dir = root

while linea < total_lineas:
    if re.search(r'\$\scd\s[A-Za-z0-9]+', lineas[linea]): # Change dir to specific subdir
        searched=current_dir
        current_dir = search.findall(current_dir, maxlevel=2, filter_=lambda node: node.name == lineas[linea][5:len(lineas[linea])-1])[0]
        if searched==current_dir:
            current_dir = search.findall(current_dir, maxlevel=2, filter_=lambda node: node.name == lineas[linea][5:len(lineas[linea]) - 1])[1]
    if re.search(r'\$ cd \.\.', lineas[linea]): # Change dir to previous
        current_dir = current_dir.parent
        if current_dir == None:
            current_dir = root
    if re.search(r'[0-9]+\s[A-Za-z0-9]+', lineas[linea]): # Add new file
        fichero = lineas[linea].split(' ')
        fichero[1] = fichero[1]. split('\n')[0]
        a=Node(name=fichero[1], parent=current_dir, value=fichero[0], value2=0)
    if re.search(r'dir\s[a-zA-Z]+', lineas[linea]): # Add new subdir
        subdir = lineas[linea][4:len(lineas[linea])-1]
        a=Node(name=subdir, parent=current_dir, value=0 , value2=0)
    linea+=1

# Search node values
def sum_child_values(node):
    total = 0
    for child in node.children:
        mivalor = int(child.value)
        mishijos = sum_child_values(child)
        total += mivalor #suma mi valor
        total += mishijos #suma valor de todos los hijos
        child.value2=mishijos #aplica value2 como el tamaño total de carpeta y subcarpetas
    return total
sol = sum_child_values(root)

maxsize = 70000000
ocupado = 0
for child in root.children:
    ocupado += child.value2
    ocupado += int(child.value)
needsize = +30000000 - maxsize + ocupado

carpetas = search.findall(root, filter_=lambda node: node.value2 >= needsize)
sol2 = carpetas[0].value2
for carpeta in carpetas:
    if carpeta.value2 < sol2:
        sol2 = carpeta.value2

input.close()
print(RenderTree(root, maxlevel=2))
print('Problem 2 result =', sol2)

const fs = require("fs");
const path = require("path");

class DirectoryTree {
  constructor(name, parent) {
    this.name = name;
    this.dirs = [];
    this.files = [];
    this.parent = parent;
    this.size = 0;
  }
}

const AVAILABLE_SPACE = 70000000;
const REQUIRED_SPACE = 30000000;
const REQUIRE_SPACE_IN_DISK = AVAILABLE_SPACE - REQUIRED_SPACE;

const tree = new DirectoryTree("/");
let currentDir = tree;
const nodes = [];

const getResult = () => {
  const input = fs
    .readFileSync(path.resolve(__dirname, "input.txt"), "utf8")
    .split("\n")
    .slice(1);
  input.forEach((line, index) => {
    const isChange = (l) => l.match(/\$ cd/);
    const isList = (l) => l.match(/\$ ls/);
    const isInstruction = (l) => isChange(l) || isList(l);

if (isList(line)) {
  let listDirIndex = index + 1;
  let listLine = input[listDirIndex];

  while (listLine && !isInstruction(listLine)) {
    // We discovered a new directory
    if (listLine.startsWith("dir")) {
      currentDir.dirs.push(
        new DirectoryTree(listLine.split(" ")[1], currentDir)
      );
    }
    // We discovered a new file in the current directory
    else {
      const file = listLine.split(" ");
      const size = Number(file[0]);
      const name = file[1];
      currentDir.files.push({
        name,
        size,
      });
      currentDir.size += size;
    }
    listDirIndex++;
    listLine = input[listDirIndex];
  }
}
if (isChange(line)) {
  // We change the current directory to its parent
  if (line.split(" ")[2] === "..") {
    currentDir = currentDir.parent;
  }
  // We just find for the directory we must change to
  else {
    currentDir = currentDir.dirs.find(
      (dir) => dir.name === line.split(" ")[2]
    );
  }
}
  });

  getDirsSize(tree);

  const totalSize = nodes
    .filter((d) => d.size < 100000)
    .reduce((acc, node) => acc + node.size, 0);
  const rootSize = nodes.find((n) => n.name === "/").size;
  const spaceToFreeUp = Math.abs(rootSize - REQUIRE_SPACE_IN_DISK);

  const canDeleteFolders = nodes
    .filter((node) => node.size - spaceToFreeUp >= 0)
    .sort((a, b) => a.size - b.size);

  return {
    thresholdFoldersSize: totalSize,
    minFolderSizeToDelete: canDeleteFolders[0].size,
  };
};

const getDirsSize = (node) => {
  const dirSizes = node.dirs.length
    ? node.dirs.reduce((acc, current) => acc + getDirsSize(current).size, 0)
    : 0;
  const sizeNode = {
    name: node.name,
    size: node.size + dirSizes,
  };
  nodes.push(sizeNode);
  return sizeNode;
};

console.log(getResult());

import numpy as np

def scorematrix(matrix,i,j,score=1):
    for x, y in [(-1,0), (0,-1), (1,0), (0,1)]:
        k=0
        while ((i+k*x)<m-1) & ((i+k*x)>0) & ((j+k*y)<n-1) & ((j+k*y)>0):
            k+=1
            if matrix[i+k*x][j+k*y] >= matrix[i][j]:
                break
        score*=k
    return score

input = [[int(i) for i in l.strip()] for l in open('./Input08.txt').readlines()]
[m,n] =[len(input),len(input[0])]

#Part1
visible=np.zeros([m,n])

for i in range(m):
    [L,R] = [-1,-1]
    for j in range(n):
        if input[i][j] > L:
            L=input[i][j]
            visible[i,j] = 1        

    for j in range(n-1,-1,-1):
        if input[i][j] > R:
            R=input[i][j]
            visible[i,j] = 1           

for j in range(m):
    [T,B] = [-1,-1]
    for i in range(n):
        if input[i][j] > T:
            T=input[i][j]
            visible[i,j] = 1     

    for i in range((n)-1,-1,-1):
        if input[i][j] > B:
            B=input[i][j]
            visible[i,j] = 1                                  

#Part 2
scores=np.zeros([m,n])
for i in range(m):
    for j in range(n):
        scores[i,j] = scorematrix(input,i,j)

print(np.sum(visible),np.max(scores))