🕯️ Advent of Code 2019 🕯️

function _FuelRequirement {
    Param([int]$Mass)

    [Math]::Truncate($Mass / 3) - 2
}

function Get-RocketModule {
    $Path = Join-Path $PSScriptRoot "aoc2019-1-input"

    Get-Content $Path | Select `
        @{n='Mass'; e={[int]$_}}, `
        @{n='FuelRequirement'; e={_FuelRequirement $_}}
}

(Get-RocketModule | Measure-Object -Sum FuelRequirement).Sum

function _FuelRequirement {
    Param(
        [parameter(Mandatory=$true, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true)][int]$Mass
    )

    Process {
        [Math]::Truncate($Mass / 3) - 2
    }
}

function _FuelRequirement2 {
    Param(
        [parameter(Mandatory=$true, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true)][int]$Mass
    )

    Process {
        $FuelRequirement = _FuelRequirement $Mass

        if ($FuelRequirement -lt 0) {
            0
        } else {
            $FuelRequirement + (_FuelRequirement2 $FuelRequirement)
        }
    }
}

function Get-RocketModuleMass {
    $Path = Join-Path $PSScriptRoot "aoc2019-1-input"

    Get-Content $Path
}

$RocketModuleMass = Get-RocketModuleMass

$FuelRequirement = ($RocketModuleMass | _FuelRequirement | Measure-Object -Sum).Sum
$FuelRequirement2 = ($RocketModuleMass | _FuelRequirement2 | Measure-Object -Sum).Sum

[pscustomobject]@{
    FuelRequirement=$FuelRequirement
    FuelRequirement2=$FuelRequirement2
}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import csv
import os
import math

def import_csv(filename):
    #Get data from a csv in the filepath
    dir_path = os.path.dirname(os.path.realpath(__file__))
    file_path = dir_path + "\\" + filename

    with open(file_path, newline='',encoding='utf-8') as csvfile:
        input_data = [int(row[0]) for row in csv.reader(csvfile)]

    return input_data

def calculate_fuel(lst):
    fuel_amounts = []

    for mass in lst:
        while (math.floor(mass / 3) - 2) > 0:
            fuel = math.floor(mass / 3) - 2
            fuel_amounts.append(fuel)
            mass = fuel
    
    fuel_sum = 0

    for fuel in fuel_amounts:
        fuel_sum += fuel

    return fuel_sum

def main():
    input_data = import_csv('input.csv')
    fuel_sum = calculate_fuel(input_data)

    print(fuel_sum)

if __name__ == "__main__":
    main()

   public class DayOne
    {
        private readonly List<int> _fuelInputs;

        public DayOne(IEnumerable<int> data)
        {
            _fuelInputs = data.ToList();
        }

        public DayOne()
        {
            var reader = File.ReadAllLinesAsync("input.txt").Result;
            _fuelInputs = reader.Select(int.Parse).ToList();

        }

        public int GetRequiredFuel(Stage stage)
        {
            if (stage == Stage.One)
                return _fuelInputs.Sum(DoCalculation);

            return _fuelInputs.Sum(CalculateFuel);
        }

        private int CalculateFuel(int num)
        {
            var result = 0;
            while (true)
            {
                var sum = DoCalculation(num);
                if (sum <= 0)
                    break;

                result += sum;
                num = sum;
            }
            return result;
        }

        private int DoCalculation(int num) =>
            (int)Math.Floor(((double)num / 3)) - 2;
    }

function New-FuelRequirementCalculation {
    param(
        [parameter(mandatory=$true)][int]$Mass
    )
        $FuelRequirements = ( ([math]::Floor($Mass / 3)) - 2 )       
        $Output = [pscustomobject]@{
            Mass = $Mass
            NeededFuel = $FuelRequirements
        }
    Write-Output $Output
}

((( Get-Content '.\Advent of Code\2019\input.txt' ) | 
Foreach-Object { New-FuelRequirementCalculation $_ }).NeededFuel | 
Measure-Object -Sum).Sum

function New-FuelRequirementCalculation2 {
    param(
        [parameter(mandatory=$true)][int]$Mass
    )
        Write-Verbose "Input mass: $Mass"
        $FuelRequirements = ( ([math]::Floor($Mass / 3)) - 2 )     
        
        if($FuelRequirements -lt 0){
            Write-Verbose "Calculated fuel for $Mass mass: $FuelRequirements"
            Write-Verbose "Recalculating negative fuel..."
            $Output = 0
            Write-Verbose "Fuel requirements are 0."
        }
        else{
            Write-Verbose "New fuel calculations needed. Newly calculated fuel: $FuelRequirements"
            $Output = $FuelRequirements + (New-FuelRequirementCalculation2 $FuelRequirements)
        }
    Write-Output $Output
}

((( Get-Content '.\Advent of Code\2019\input.txt' ) | 
Foreach-Object { New-FuelRequirementCalculation2 -Mass $_ -Verbose }) | 
Measure-Object -Sum).Sum

        private void button2_Click(object sender, EventArgs e)
        {
            int maxPos = 1;
            if (this.numSubTask.Value==2)
            {
                maxPos = Math.Min(100, GetIntArray(this.txtInput.Text.Trim()).Length);
            }
            for (int noun = 0; noun < maxPos; noun++)
            {
                for (int verb = 0; verb < maxPos; verb++)
                {
                    bool endedCorrectly = false;
                    int?[] values = GetIntArray(this.txtInput.Text.Trim());
                    if (this.numSubTask.Value == 2)
                    {
                        values[1] = noun;
                        values[2] = verb;
                    }
                    else
                    {
                        values[1] = 12;
                        values[2] = 2;
                    }
                    for (int i = 0; i < values.Length; i += 4)
                    {
                        if (values[i] != null && (values[i] == 1 || values[i] == 2))
                        {
                            if (values.Length > (i + 3) && values[i + 1] != null && values[i + 1] < values.Length && values[i + 2] != null && values[i + 2] < values.Length && values[i + 3] != null && values[i + 3] < values.Length)
                            {
                                int code = (int)values[i];
                                int pos1 = (int)values[i + 1];
                                int pos2 = (int)values[i + 2];
                                int toPos = (int)values[i + 3];
                                switch (code)
                                {
                                    case 1:
                                        values[toPos] = values[pos1] + values[pos2];
                                        break;
                                    case 2:
                                        values[toPos] = values[pos1] * values[pos2];
                                        break;
                                    default:
                                        break;
                                }
                            }
                            else
                            {
                                if (values[i] != null && values[i] == 99)
                                {
                                    endedCorrectly = true;
                                    break;
                                }
                                else
                                {
                                    throw new System.ArgumentException("Parameter array error");
                                }
                            }
                        }
                        else
                        {
                            if (values[i] != null && values[i] == 99)
                            {
                                endedCorrectly = true;
                                break;
                            }
                            else
                            {
                                throw new System.ArgumentException("Parameter cannot be null");
                            }
                        }
                    }
                    if (endedCorrectly)
                    {
                        switch (this.numSubTask.Value)  
                        {
                            case 1:
                                txtAnswer.Text = values[0].ToString();
                                txtInput.Text = string.Join(",", values.Select(x => x.ToString()).ToArray());
                                break;
                            case 2:
                                if (values[0]== 19690720)
                                {
                                    txtAnswer.Text = (values[1] * 100 + values[2]).ToString();
                                    txtInput.Text = string.Join(",", values.Select(x => x.ToString()).ToArray());
                                    return;
                                }
                                break;
                            default:
                                break;
                        }
                    }

                }
            }

        }
        private int?[] GetIntArray(string input)
        {
            string[] strArr = input.Split(',');
            int?[] intArr = new int?[strArr.Length];
            for (int i = 0; i < strArr.Length; i++)
            {
                intArr[i] = ToInt(strArr[i]);
            }
            return intArr;
        }

import math

mass = [int(line.rstrip('\n')) for line in open("input")]
totalFuel = 0

for i in mass:
        totalFuel += math.floor(i/3)-2
print(totalFuel)

import math

mass = [int(line.rstrip('\n')) for line in open("input")]
totalFuel = 0

for i in mass:
        fuelForFuel = 0

        while i > 0:
                i = math.floor(i/3)-2
                if i > 0:
                        fuelForFuel += i
        totalFuel += fuelForFuel

print(totalFuel)

def calcFuel(input: Int): Int = input/3-2

val sum = inputs.foldLeft(0){(acc, i) => acc + calcFuel(i)}

def massToFuel(mass: Int): Int = {
    @tailrec
    def fuelHelper(remainingMass: Int, acc: Int): Int ={
      val newFuel = calcFuel(remainingMass)
      if(newFuel <= 0) acc
      else fuelHelper(newFuel, acc+newFuel)
    }
    fuelHelper(mass, 0)
  }

use super::Solution;
use Instruction::*;

type Intcode = usize;
type Addr = Intcode;

#[derive(PartialEq,Debug)]
enum Instruction {
    Add(Addr, Addr, Addr),
    Mul(Addr, Addr, Addr),
    Halt,
}

// State required for solve day 2
pub struct State {
    memory: Vec<Intcode>,
}

pub fn solution(lines: Vec<&str>) -> Box<dyn Solution> {
    Box::new(State {
        memory: lines[0].split(",").map(|ic|ic.parse::<Intcode>().unwrap()).collect()
    })
}

fn fetch(mem: &Vec<Intcode>, ip: Addr) -> Instruction {
    let opcode = mem[ip];
    match opcode {
         1 => Add(mem[ip+1], mem[ip+2], mem[ip+3]),
         2 => Mul(mem[ip+1], mem[ip+2], mem[ip+3]),
        99 => Halt,
         _ => panic!("Invalid opcode"),
    }
}

fn exec(instr: Instruction, mem: &mut Vec<Intcode>, ip: &mut Addr) -> bool {
    let mut new_ip = *ip + 4;
    match instr {
        Add(src0, src1, dst) => mem[dst] = mem[src0] + mem[src1],
        Mul(src0, src1, dst) => mem[dst] = mem[src0] * mem[src1],
        Halt => new_ip = *ip,
    };
    *ip = new_ip;
    instr == Halt
}

fn run(memory: &Vec<Intcode>, noun: Intcode, verb: Intcode) -> Intcode {
    let mut mem = memory.clone();
    let mut ip: Addr = 0;
    // The value placed in address 1 is called the noun, and the value 
    // placed in address 2 is called the verb
    mem[1] = noun;
    mem[2] = verb;
    loop {
        let instr = fetch(&mem, ip);
        if exec(instr, &mut mem, &mut ip) {
            break
        }
    }
    // Output is value at position 0 after the program halts.
    mem[0]
}

impl Solution for State {
    fn part1(&self) -> String {
        run(&self.memory, 12, 2).to_string()
    }

    fn part2(&self) -> String {
        let wanted_output = 19690720;
        let mut noun = 0;
        let mut verb = 0;
        loop {
            noun = noun + 1;
            if noun > 99 {
                noun = 0;
                verb = verb + 1;
            }
            if run(&self.memory, noun, verb) == wanted_output {
                break;
            }
        }
        (100 * noun + verb).to_string()
    }
}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import sys

def get_started(input_data):
    input_data[1] = 12
    input_data[2] = 2

    return input_data

def run_intcode(input_data):
    def opcode_1(parameter1, parameter2):
        return parameter1 + parameter2

    def opcode_2(parameter1, parameter2):
        return parameter1 * parameter2
    
    pos = 0
    while input_data[pos] != 99:
        if input_data[pos] == 1:
            calc = opcode_1(input_data[input_data[pos+1]], input_data[input_data[pos+2]])

            input_data[input_data[pos+3]] = calc

        elif input_data[pos] == 2:
            calc = opcode_2(input_data[input_data[pos+1]], input_data[input_data[pos+2]])

            input_data[input_data[pos+3]] = calc
        else:
            print(input_data[pos])
            raise ValueError("Something went horrible wrong at pos", pos)

        pos += 4
    
    return input_data

def main_1():
    input_data = [1,0,0,3,1,1,2,3,1,3,4,3,1,5,0,3,2,1,10,19,1,19,5,23,2,23,9,27,1,5,27,31,1,9,31,35,1,35,10,39,2,13,39,43,1,43,9,47,1,47,9,51,1,6,51,55,1,13,55,59,1,59,13,63,1,13,63,67,1,6,67,71,1,71,13,75,2,10,75,79,1,13,79,83,1,83,10,87,2,9,87,91,1,6,91,95,1,9,95,99,2,99,10,103,1,103,5,107,2,6,107,111,1,111,6,115,1,9,115,119,1,9,119,123,2,10,123,127,1,127,5,131,2,6,131,135,1,135,5,139,1,9,139,143,2,143,13,147,1,9,147,151,1,151,2,155,1,9,155,0,99,2,0,14,0]

    input_data = get_started(input_data)

    output_data = run_intcode(input_data)

    print(output_data[0])

def main_2():
    for noun in range(0,100):
        for verb in range(0,100):
            test_data = [1,0,0,3,1,1,2,3,1,3,4,3,1,5,0,3,2,1,10,19,1,19,5,23,2,23,9,27,1,5,27,31,1,9,31,35,1,35,10,39,2,13,39,43,1,43,9,47,1,47,9,51,1,6,51,55,1,13,55,59,1,59,13,63,1,13,63,67,1,6,67,71,1,71,13,75,2,10,75,79,1,13,79,83,1,83,10,87,2,9,87,91,1,6,91,95,1,9,95,99,2,99,10,103,1,103,5,107,2,6,107,111,1,111,6,115,1,9,115,119,1,9,119,123,2,10,123,127,1,127,5,131,2,6,131,135,1,135,5,139,1,9,139,143,2,143,13,147,1,9,147,151,1,151,2,155,1,9,155,0,99,2,0,14,0]

            test_data[1] = noun
            test_data[2] = verb

            test_output = run_intcode(test_data)

            if test_output[0] == 19690720:
                print(100*noun + verb)
                sys.exit()

if __name__ == "__main__":
    main()

function Run-Computer {
    Param($noun, $verb)

    $InputString = Get-Content (Join-Path $PSScriptRoot "aoc2019-2-input.txt")

    [int[]]$Memory = $InputString.Split(',')

    $memory[1] = $noun
    $memory[2] = $verb

    $i_ptr = 0
    $running = $true

    while ($running) {
        $instruction = $Memory[$i_ptr++]

        switch ($instruction) {
            1 {
                # Add
                $a_ptr = $memory[$i_ptr++]
                $b_ptr = $memory[$i_ptr++]
                $out_ptr = $memory[$i_ptr++]

                $memory[$out_ptr] = $memory[$a_ptr] + $memory[$b_ptr]
            }
            2 {
                # Multiply
                $a_ptr = $memory[$i_ptr++]
                $b_ptr = $memory[$i_ptr++]
                $out_ptr = $memory[$i_ptr++]

                $memory[$out_ptr] = $memory[$a_ptr] * $memory[$b_ptr]
            }
            99 {
                # Halt
                $running = $false
            }
            default {
                throw "Unknown instruction $instruction at $i_ptr!"
            }
        }
    }

    $memory[0]
}

Run-Computer 12 2

:nounloop for ($noun = 0; $noun -lt 100; $noun++) {
    for ($verb = 0; $verb -lt 100; $verb++) {
        $result = Run-Computer $noun $verb
        if ($result -eq 19690720) {
            100 * $noun + $verb
            break nounloop
        }
    }
}

function Get-Code {
    param(
        [parameter(Mandatory=$true)]$Input
    )
    if(!$Input){$Input = "Day2.Input.txt"}
        $InstructionsList = @()
        (Get-Content $Input).Split(',') | ForEach-Object { $InstructionsList += [int]$_ }
        $CounterStart = 0
        $CounterEnd = $CounterStart + 4

        while( ($InstructionsList[$CounterStart..($CounterEnd -1)] | Select-Object -First 4).count -eq 4 ){
            
            if( $CounterStart -eq 0 ){ $OperationsSet = $InstructionsList[$CounterStart..($CounterEnd -1)] | Select-Object -First 4 }
            else{ $OperationsSet = $InstructionsList[$CounterStart..$CounterEnd] | Select-Object -First 4 }

            if( $OperationsSet[0] -eq 1 ){ 
                $InstructionsList[($OperationsSet[3])] = $InstructionsList[($OperationsSet[1])] + $InstructionsList[($OperationsSet[2])] 
            }
            elseif( $OperationsSet[0] -eq 2 ){ 
                $InstructionsList[($OperationsSet[3])] = $InstructionsList[($OperationsSet[1])] * $InstructionsList[($OperationsSet[2])]
            }
            elseif( $OperationsSet[0] -eq 99 ){ 
                $OutputObject = $InstructionsList[0]
                Return $OutputObject
            }

            $CounterStart = $CounterStart + 4
            $CounterEnd = $CounterEnd + 4
        }
        
        $OutputObject = $InstructionsList[0]
        Write-Output $OutputObject
}

Get-Code -Input "Day2.Input.txt"

function Get-CodeReversed {

    param(
        [parameter(Mandatory=$true)][int]$EndResult,
        [parameter(Mandatory=$true)]$InputFile
    )
    $Noun = 0
    $Verb = 0
    $Noun..99 | ForEach-Object { 
        $Noun++
        $Verb..99 | ForEach-Object { 
            if( $_ -ge 0 -and $_ -lt 99 ){ $Verb++ }
            else { $Verb = 0 }
            $OP = Get-Code -Input $InputFile
            if($OP.Operator -eq $EndResult){ Return ((100 * $Noun) + $Verb);break }
        }
    }
}


Get-CodeReversed -EndResult 19690720 -InputFile "Day2.Input.txt"