🕯️ Advent of Code 2019 🕯️

private void CalculateButton_Click(object sender, EventArgs e)
{
    string[] modules = InputTextBox.Text.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
    double totalFuel = 0;

    foreach (string module in modules)
    {
        totalFuel += CalculateFuel(double.Parse(module));                
    }

    ResultTextBox.Text = totalFuel.ToString();
}

private double CalculateFuel(double mass)
{
    double fuel = Math.Floor(mass / 3) - 2;
            
    if (fuel > 0)
    {
        return fuel + CalculateFuel(fuel);
    }      
    return 0;            
}

use super::Solution;
use num_derive::FromPrimitive;
use num_traits::FromPrimitive;
use Instruction::*;

type Intcode = i32;

#[derive(Debug, FromPrimitive)]
enum Instruction {
    Add = 1,
    Mul = 2,
    In = 3,
    Out = 4,
    JmpIfTrue = 5,
    JmpIfFalse = 6,
    LessThan = 7,
    Equals = 8,
    Halt = 99,
}

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

fn run(memory: &Vec<Intcode>, input: &mut dyn Iterator<Item = Intcode>) -> Vec<Intcode> {
    let mut mem = memory.clone();
    let mut ip: usize = 0;
    let mut output = Vec::new();
    loop {
        let mut st = None;
        {
            let opcode = mem[ip];
            let is_imm = [
                false,
                opcode / 100 % 10 != 0,
                opcode / 1000 % 10 != 0,
                opcode / 10000 % 10 != 0,
            ];
            let ld_imm = |offset| mem[ip + offset as usize];
            let ld = |offset| {
                if is_imm[offset] {
                    ld_imm(offset)
                } else {
                    mem[ld_imm(offset) as usize]
                }
            };
            ip = match FromPrimitive::from_i32(opcode % 100).expect("Invalid instruction") {
                Add => {
                    st = Some((ld(1) + ld(2), ld_imm(3)));
                    ip + 4
                }
                Mul => {
                    st = Some((ld(1) * ld(2), ld_imm(3)));
                    ip + 4
                }
                In => {
                    st = Some((input.next().unwrap(), ld_imm(1)));
                    ip + 2
                }
                Out => {
                    output.push(ld(1));
                    ip + 2
                }
                JmpIfTrue => {
                    if ld(1) != 0 {
                        ld(2) as usize
                    } else {
                        ip + 3
                    }
                }
                JmpIfFalse => {
                    if ld(1) == 0 {
                        ld(2) as usize
                    } else {
                        ip + 3
                    }
                }
                LessThan => {
                    st = Some((if ld(1) < ld(2) { 1 } else { 0 }, ld_imm(3)));
                    ip + 4
                }
                Equals => {
                    st = Some((if ld(1) == ld(2) { 1 } else { 0 }, ld_imm(3)));
                    ip + 4
                }
                Halt => {
                    return output;
                }
            }
        }
        // All immutable borrows must go out of scope before it is OK to store
        // to 'mem', so this kind of simulates "write-back" step in a CPU...
        if let Some((val, addr)) = st {
            mem[addr as usize] = val;
        }
    }
}

impl Solution for State {
    fn part1(&self) -> String {
        let input: Vec<Intcode> = vec![1];
        run(&self.memory, &mut input.into_iter())
            .last()
            .unwrap()
            .to_string()
    }

    fn part2(&self) -> String {
        let input: Vec<Intcode> = vec![5];
        run(&self.memory, &mut input.into_iter())
            .last()
            .unwrap()
            .to_string()
    }
}

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

private void RunProgramButton_Click(object sender, EventArgs e)
{
    IntCodeComputer computer = new IntCodeComputer();
            
    computer.Memory = Array.ConvertAll(InputTextBox.Text.Split(','), Convert.ToInt32);
    computer.RunProgram();
            
    ResultTextBox.Text = computer.Memory[0].ToString();
}

private void FindValuesButton_Click(object sender, EventArgs e)
{            
    IntCodeComputer computer = new IntCodeComputer();

    for (int noun = 0; noun <= 99; noun++)
    {
        for (int verb = 0; verb <= 99; verb++)
        {
            computer.Memory = Array.ConvertAll(InputTextBox.Text.Split(','), Convert.ToInt32);
            computer.Memory[1] = noun;
            computer.Memory[2] = verb;
            computer.RunProgram();

            if (computer.Memory[0] == 19690720)
            {
                ResultTextBox.Text = (100 * noun + verb).ToString();
                return;
            }
        }
    }
}

class IntCodeComputer
{
    public int[] Memory { set; get; }

    public void RunProgram()
    {
        int instructionPointer = 0;
        while (Memory[instructionPointer] != 99)
        {
            switch (Memory[instructionPointer])
            {
                case 1:
                    Memory[Memory[instructionPointer + 3]] = Memory[Memory[instructionPointer + 1]] + Memory[Memory[instructionPointer + 2]];
                    instructionPointer += 4;
                    break;

                case 2:
                    Memory[Memory[instructionPointer + 3]] = Memory[Memory[instructionPointer + 1]] * Memory[Memory[instructionPointer + 2]];
                    instructionPointer += 4;
                    break;

                default:
                    throw new Exception("Unknown opcode. Aborting.");
            }                
        }
    }
}

$StartNumber = 171309
$EndNumber = 643603

$DoubbleNumberArray = @()

[int]$StartNumber..[int]$EndNumber | ForEach-Object -Parallel {

    $Checker = $_.ToString().ToCharArray()

    ## Does password include a doubble?
    if( $_ -match "11|22|33|44|55|66|77|88|99|00" -and
        ($Checker[5] -ge $Checker[4]) -and 
        ($Checker[4] -ge $Checker[3]) -and 
        ($Checker[3] -ge $Checker[2]) -and 
        ($Checker[2] -ge $Checker[1]) -and 
        ($Checker[1] -ge $Checker[0]) ) { 
        
        Write-Output $_
        $DoubbleNumberArray += $Checker
    }
} 

$DoubbleNumberArray.Count

$NewNumberArray = @()   
    $Index = 0
    $DoubbleNumberArray | ForEach-Object {

        $Digicount0 = ((($_.ToString()).ToCharArray()) | ? {$_ -eq '0'} | Measure-Object -ErrorAction SilentlyContinue).Count
        $Digicount1 = ((($_.ToString()).ToCharArray()) | ? {$_ -eq '1'} | Measure-Object -ErrorAction SilentlyContinue).Count
        $Digicount2 = ((($_.ToString()).ToCharArray()) | ? {$_ -eq '2'} | Measure-Object -ErrorAction SilentlyContinue).Count
        $Digicount3 = ((($_.ToString()).ToCharArray()) | ? {$_ -eq '3'} | Measure-Object -ErrorAction SilentlyContinue).Count
        $Digicount4 = ((($_.ToString()).ToCharArray()) | ? {$_ -eq '4'} | Measure-Object -ErrorAction SilentlyContinue).Count
        $Digicount5 = ((($_.ToString()).ToCharArray()) | ? {$_ -eq '5'} | Measure-Object -ErrorAction SilentlyContinue).Count
        $Digicount6 = ((($_.ToString()).ToCharArray()) | ? {$_ -eq '6'} | Measure-Object -ErrorAction SilentlyContinue).Count
        $Digicount7 = ((($_.ToString()).ToCharArray()) | ? {$_ -eq '7'} | Measure-Object -ErrorAction SilentlyContinue).Count
        $Digicount8 = ((($_.ToString()).ToCharArray()) | ? {$_ -eq '8'} | Measure-Object -ErrorAction SilentlyContinue).Count
        $Digicount9 = ((($_.ToString()).ToCharArray()) | ? {$_ -eq '9'} | Measure-Object -ErrorAction SilentlyContinue).Count
        $NewNumberArray += [pscustomobject]@{
            Index = $index
            Number = 0
            Count = [pscustomobject]@{ "0" = $Digicount0;"1" = $Digicount1;"2" = $Digicount2;"3" = $Digicount3;"4" = $Digicount4;"5" = $Digicount5;"6" = $Digicount6;"7" = $Digicount7;"8" = $Digicount8;"9" = $Digicount9 }
            IncomingValue = $_
        }
        
        $Index++
    }
    
    $FinalNumberList = $NewNumberArray | Where-Object { $_.Count.0 -eq 2 -or
                                                        $_.Count.1 -eq 2 -or
                                                        $_.Count.2 -eq 2 -or
                                                        $_.Count.3 -eq 2 -or
                                                        $_.Count.4 -eq 2 -or
                                                        $_.Count.5 -eq 2 -or
                                                        $_.Count.6 -eq 2 -or
                                                        $_.Count.7 -eq 2 -or
                                                        $_.Count.8 -eq 2 -or
                                                        $_.Count.9 -eq 2 }
    $FinalNumberList.Count

        public Dictionary<string,string> GetPaths(Dictionary<string,string> comDaughter)
        {
            Dictionary<string, string> daughterPath = new Dictionary<string, string>();
            foreach (KeyValuePair<string, string> item in comDaughter)
            {
                bool hasParent = true;
                string path = item.Value + Path.DirectorySeparatorChar + item.Key;
                string curParent = item.Value;
                while (hasParent)
                {
                    if (comDaughter.ContainsKey(curParent))
                    {
                        curParent = comDaughter[curParent];
                        path = curParent + Path.DirectorySeparatorChar + path;
                    }
                    else
                    {
                        hasParent = false;
                    }
                }
                daughterPath.Add(item.Key, path);

            }
            return daughterPath;
        }
        public Dictionary<string, string> GetParents(List<string> lines)
        {
            Dictionary<string, string> comDaughter = new Dictionary<string, string>();
            foreach (string line in lines)
            {
                string com = line.Split(')')[0];
                string daughter = line.Split(')')[1];
                comDaughter.Add(daughter, com);
            }
            return comDaughter;
        }
        private OrbitalMap GetOrbitalMap(Dictionary<string,string> daughterPaths)
        {
            OrbitalMap orbitalMap = new OrbitalMap();
            foreach (KeyValuePair<string,string> item in daughterPaths)
            {
                orbitalMap.Add(item.Value);
            }
            return orbitalMap;
        }

        private void button6_Click(object sender, EventArgs e)
        {
            System.Diagnostics.Stopwatch watch = System.Diagnostics.Stopwatch.StartNew();
            List<string> lines = GetLines(txtInput.Text);
            Dictionary<string, string> comDaughter = GetParents(lines);
            Dictionary<string, string> daughterPaths = GetPaths(comDaughter);
            OrbitalMap orbitalMap = GetOrbitalMap(daughterPaths);
            if (this.numSubTask.Value==1)
            {
                txtAnswer.Text = orbitalMap.OrbitCount.ToString();
            }
            else
            {
                txtInput.AppendText(System.Environment.NewLine + orbitalMap.GetPath("YOU"));
                txtInput.AppendText(System.Environment.NewLine + orbitalMap.GetPath("SAN"));
                int distance = orbitalMap.GetDistance("YOU", "SAN");
                txtAnswer.Text = distance.ToString();
            }

            watch.Stop();
            Int64 elapsedMs = watch.ElapsedMilliseconds;
            label1.Text = elapsedMs.ToString();

        }
    public class BodyOfMass
    {
        private string _ID = String.Empty;
        private string _Parent = String.Empty;
        private string _Path = String.Empty;
        public BodyOfMass(string path)
        {
            string[] parts = path.Split(Path.DirectorySeparatorChar);

            string parentPath = String.Empty;
            if (parts.Length>1)
            {
                parentPath = path.Substring(0, path.Length - path.Length);
            }
            string id = parts[parts.Length - 1];
            this._ID = id;
            _Parent = String.Empty;
            _Path = path;
            if (!String.IsNullOrEmpty(parentPath))
            {
                _Parent = parentPath.Split(Path.DirectorySeparatorChar)[parentPath.Split(Path.DirectorySeparatorChar).Length-1];
            }
        }
        public int DistanceFromCOM
        {
            get
            {
                return _Path.Split(Path.DirectorySeparatorChar).Length - 1;
            }
        }
        public string ID
        {
            get
            {
                return _ID;
            }
        }
        public string OrbitalPath
        {
            get
            {
                return _Path;
            }
        }
        public string Parent
        {
            get
            {
                return _Parent;
            }
        }
    }
    public class OrbitalMap
    {
        Dictionary<string, BodyOfMass> _mine;
        public OrbitalMap()
        {
            _mine = new Dictionary<string, BodyOfMass>();
        }
        public void Add(String path)
        {
            string[] parts = path.Split(Path.DirectorySeparatorChar);
            string curPath = string.Empty;
            for (int i = 0; i < parts.Length; i++)
            {
                if (i == 0)
                {
                    curPath = parts[0];
                }
                else
                {
                    curPath = curPath + Path.DirectorySeparatorChar + parts[i];
                }
                if (!_mine.ContainsKey(parts[i]))
                {
                    BodyOfMass newPlanet = new BodyOfMass(curPath);
                    _mine.Add(parts[i],newPlanet);
                }
            }
        }
        public int Count
        {
            get
            {
                return _mine.Count;
            }
        }
        public int OrbitCount
        {
            get
            {
                int i = 0;
                foreach (KeyValuePair<string,BodyOfMass> item in _mine)
                {
                    i = i + item.Value.DistanceFromCOM;
                }
                return i;
            }
        }
        public string GetPath(string id)
        {
            return _mine[id].OrbitalPath;
        }
        public int GetDistance(string id1, string id2)
        {
            string path1 = _mine[id1].OrbitalPath;
            string path2 = _mine[id2].OrbitalPath;
            string[] pathParts1 = path1.Split(Path.DirectorySeparatorChar);
            string[] pathParts2 = path2.Split(Path.DirectorySeparatorChar);

            Dictionary<string, int> idLevel1 = new Dictionary<string, int>();
            for (int i = 0; i < pathParts1.Length; i++)
            {
                idLevel1.Add(pathParts1[i], i);
            }
            Dictionary<string, int> idLevel2 = new Dictionary<string, int>();
            for (int i = 0; i < pathParts2.Length; i++)
            {
                idLevel2.Add(pathParts2[i], i);
            }
            int curLevel1 = pathParts1.Length - 1;
            int curLevel2 = pathParts2.Length - 1;
            bool foundInterSection = false;
            while (curLevel1>-1 && !foundInterSection)
            {
                if (idLevel2.ContainsKey(pathParts1[curLevel1]))
                {
                    foundInterSection = true;
                    curLevel2 = idLevel2[pathParts1[curLevel1]];
                }
                else
                {
                    curLevel1 = curLevel1 - 1;
                }
            }
            int distance = pathParts1.Length - 1 + pathParts2.Length - 1 - curLevel1 - curLevel2 - 2;
            return distance;
        }
    }

use super::Solution;
use num_derive::FromPrimitive;
use num_traits::FromPrimitive;
use permutohedron::LexicalPermutation;
use Instruction::*;
use ProgState::*;

type Intcode = i32;
const NUM_AMPS: usize = 5;

#[derive(Debug, FromPrimitive, PartialEq)]
enum Instruction {
    Add = 1,
    Mul = 2,
    In = 3,
    Out = 4,
    JmpIfTrue = 5,
    JmpIfFalse = 6,
    LessThan = 7,
    Equals = 8,
    Halt = 99,
}

#[derive(Copy, Clone, Debug)]
enum ProgState {
    Resume(usize),
    Done,
}

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

fn opcode_to_instr(opcode: Intcode) -> Instruction {
    FromPrimitive::from_i32(opcode % 100).expect("Invalid instruction")
}

fn run(
    mem: &mut Vec<Intcode>,
    input: &mut dyn Iterator<Item = Intcode>,
    first_ip: usize,
    last_output: Intcode,
) -> (Intcode, ProgState) {
    let mut ip: usize = first_ip;
    loop {
        let mut st = None;
        {
            let opcode = mem[ip];
            let is_imm = [
                false,
                opcode / 100 % 10 != 0,
                opcode / 1000 % 10 != 0,
                opcode / 10000 % 10 != 0,
            ];
            let ld_imm = |offset| mem[ip + offset as usize];
            let ld = |offset| {
                if is_imm[offset] {
                    ld_imm(offset)
                } else {
                    mem[ld_imm(offset) as usize]
                }
            };
            ip = match opcode_to_instr(opcode) {
                Add => {
                    st = Some((ld(1) + ld(2), ld_imm(3)));
                    ip + 4
                }
                Mul => {
                    st = Some((ld(1) * ld(2), ld_imm(3)));
                    ip + 4
                }
                In => {
                    st = Some((input.next().unwrap(), ld_imm(1)));
                    ip + 2
                }
                Out => return (ld(1), Resume(ip + 2)),
                JmpIfTrue => {
                    if ld(1) != 0 {
                        ld(2) as usize
                    } else {
                        ip + 3
                    }
                }
                JmpIfFalse => {
                    if ld(1) == 0 {
                        ld(2) as usize
                    } else {
                        ip + 3
                    }
                }
                LessThan => {
                    st = Some((if ld(1) < ld(2) { 1 } else { 0 }, ld_imm(3)));
                    ip + 4
                }
                Equals => {
                    st = Some((if ld(1) == ld(2) { 1 } else { 0 }, ld_imm(3)));
                    ip + 4
                }
                Halt => return (last_output, Done),
            }
        }
        // All immutable borrows must go out of scope before it is OK to store
        // to 'mem', so this kind of simulates "write-back" step in a CPU...
        if let Some((val, addr)) = st {
            mem[addr as usize] = val;
        }
    }
}

fn amplifiers(program: &Vec<Intcode>, phases: &[Intcode; NUM_AMPS]) -> Intcode {
    let mut mems: Vec<Vec<Intcode>> = phases.iter().map(|_| program.clone()).collect();
    let mut ips = [Resume(0); NUM_AMPS];
    let mut outputs = [0; NUM_AMPS];
    let mut result = 0;
    let mut first = true;
    'terminated: loop {
        for (idx, &phase) in phases.iter().enumerate() {
            if let Resume(ip) = ips[idx] {
                let input = if first {
                    vec![phase, result]
                } else {
                    vec![result]
                };
                let res = run(&mut mems[idx], &mut input.into_iter(), ip, outputs[idx]);
                result = res.0;
                ips[idx] = res.1;
                outputs[idx] = result;
            } else {
                break 'terminated;
            }
        }
        first = false;
    }
    result
}

fn run_with_phases(program: &Vec<Intcode>, phases: &mut [Intcode; NUM_AMPS]) -> Intcode {
    let mut thrusters_signal = Vec::new();
    loop {
        thrusters_signal.push(amplifiers(program, phases));
        if !phases.next_permutation() {
            break;
        }
    }
    thrusters_signal.into_iter().max().unwrap()
}

impl Solution for State {
    fn part1(&self) -> String {
        run_with_phases(&self.memory, &mut [0, 1, 2, 3, 4]).to_string()
    }

    fn part2(&self) -> String {
        run_with_phases(&self.memory, &mut [5, 6, 7, 8, 9]).to_string()
    }
}

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

import itertools
import Queue
import threading
import operator

program = [3,8,1001,...,9,99] # No need to post this junk, get it from AOC

args = { 0 : lambda m, pc : (m[m[pc + 1]], m[m[pc + 2]]),
         1 : lambda m, pc : (m[pc + 1], m[m[pc + 2]]),
         10 : lambda m, pc : (m[m[pc + 1]], m[pc + 2]),
         11 : lambda m, pc : (m[pc + 1], m[pc + 2]) }

op = [None, operator.add, operator.mul, None, None, None, None, operator.lt, operator.eq]

def binop(pc, m, iq, oq):
    a1, a2 = args[m[pc] / 100](m, pc)
    m[m[pc + 3]] = op[m[pc] % 100](a1, a2)
    return pc + 4

def input(pc, m, iq, oq):
    m[m[pc + 1]] = iq.get()
    return pc + 2

def output(pc, m, iq, oq):
    a1, _ = args[m[pc] / 100](m, pc)
    oq.put(a1)
    return pc + 2

def condjump(pc, m, iq, oq): 
    a1, a2 = args[m[pc] / 100](m, pc)
    return a2 if a1 == (m[pc] % 100 == 5) else pc + 3

instr = [None, binop, binop, input, output, condjump, condjump, binop, binop]
    
def intcode(p, iq, oq):
    m = list(p)
    pc = 0
    while m[pc] != 99:
        pc = instr[m[pc] % 100](pc, m, iq, oq)

def amps(phase):
    # Set up the ring
    qs = [Queue.Queue(),Queue.Queue(),Queue.Queue(),Queue.Queue(),Queue.Queue()]
    ts = []
    for i in range(5):
        ts.append(threading.Thread(target=intcode, args=(program, qs[i], qs[(i + 1) % 5])))
        ts[i].start()
        qs[i].put(phase[i])
    # Insert the Input value to Amp A
    qs[0].put(0)
    # Wait for Amp A to terminate
    ts[0].join()
    # We can now pick up the output valre from Amp E
    return qs[0].get()

# Part one
print max([amps(perm) for perm in itertools.permutations([0,1,2,3,4])])
# Part two
print max([amps(perm) for perm in itertools.permutations([5,6,7,8,9])])

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

import os
import sys

def generate_input():
    dir_path = os.path.dirname(os.path.realpath(__file__))
    file_path = dir_path + "\\input.txt"

    with open(file_path) as inputfile:    
        raw_instructions = [line.split(",") for line in inputfile.readlines()]
        instructions = [int(num) for num in raw_instructions[0]]

    return instructions

def run_intcode(instructions, input_value):
    def opcode_1(term1, term2):
        total_sum = term1 + term2
        return total_sum

    def opcode_2(factor1, factor2):
        product = factor1 * factor2
        return product

    def parameter_modes(parameters):
        parameter_list = list(parameters)

        while len(parameter_list) < 3:    
            parameter_list.insert(0,"0")

        parameter_list.reverse()

        return parameter_list

    pos = 0
    opcode = None
    while opcode != "99":
        opcode = "".join(str(instructions[pos])[-2:])

        if opcode == "01" or opcode == "1":
            print("Running OPC1")
            parameters = parameter_modes(str(instructions[pos])[:-2])   

            if parameters[0] == "0":      
                term1 = instructions[instructions[pos + 1]]
            else:
                term1 = instructions[pos + 1]

            if parameters[1] == "0":      
                term2 = instructions[instructions[pos + 2]]
            else:
                term2 = instructions[pos + 2]

            if parameters[2] == "0":      
                output = instructions[pos + 3]
            else:
                output = pos + 3

            instructions[output] = opcode_1(term1, term2)

            pos += 4

        elif opcode == "02" or opcode == "2":
            print("Running OPC2")
            parameters = parameter_modes(str(instructions[pos])[:-2])   

            if parameters[0] == "0":      
                factor1 = instructions[instructions[pos + 1]]
            else:
                factor1 = instructions[pos + 1]

            if parameters[1] == "0":      
                factor2 = instructions[instructions[pos + 2]]
            else:
                factor2 = instructions[pos + 2]

            if parameters[2] == "0":      
                output = instructions[pos + 3]
            else:
                output = pos + 3

            instructions[output] = opcode_2(factor1, factor2)
            pos += 4

        elif opcode == "03" or opcode == "3":
            print("Running OPC3")
            output = instructions[pos + 1]

            instructions[output] = input_value

            pos += 2

        elif opcode == "04" or opcode == "4":
            print("Running OPC4")
            print(instructions[instructions[pos+1]])
            pos += 2

        elif opcode == "05" or opcode == "5":
            print("Running OPC5")
            parameters = parameter_modes(str(instructions[pos])[:-2])   

            if parameters[0] == "0":      
                parameter1 = instructions[instructions[pos + 1]]
            else:
                parameter1 = instructions[pos + 1]

            if parameters[1] == "0":      
                parameter2 = instructions[instructions[pos + 2]]
            else:
                parameter2 = instructions[pos + 2]

            if parameter1 != 0:
                pos = parameter2
            else:
                pos += 3

        elif opcode == "06" or opcode == "6":
            print("Running OPC6")

            parameters = parameter_modes(str(instructions[pos])[:-2])   

            if parameters[0] == "0":      
                parameter1 = instructions[instructions[pos + 1]]
            else:
                parameter1 = instructions[pos + 1]

            if parameters[1] == "0":      
                parameter2 = instructions[instructions[pos + 2]]
            else:
                parameter2 = instructions[pos + 2]

            if parameter1 == 0:
                pos = parameter2
            else:
                pos += 3

        elif opcode == "07" or opcode == "7":
            print("Running OPC7")
            parameters = parameter_modes(str(instructions[pos])[:-2])   

            if parameters[0] == "0":      
                parameter1 = instructions[instructions[pos + 1]]
            else:
                parameter1 = instructions[pos + 1]

            if parameters[1] == "0":      
                parameter2 = instructions[instructions[pos + 2]]
            else:
                parameter2 = instructions[pos + 2]

            if parameters[2] == "0":      
                output = instructions[pos + 3]
            else:
                output = pos + 3

            if parameter1 < parameter2:
                instructions[output] = 1
            else:
                instructions[output] = 0

            pos += 4

        elif opcode == "08" or opcode == "8":
            print("Running OPC8")
            parameters = parameter_modes(str(instructions[pos])[:-2])   

            if parameters[0] == "0":      
                parameter1 = instructions[instructions[pos + 1]]
            else:
                parameter1 = instructions[pos + 1]

            if parameters[1] == "0":      
                parameter2 = instructions[instructions[pos + 2]]
            else:
                parameter2 = instructions[pos + 2]

            if parameters[2] == "0":      
                output = instructions[pos + 3]
            else:
                output = pos + 3

            if parameter1 == parameter2:
                instructions[output] = 1
            else:
                instructions[output] = 0

            pos += 4

        elif opcode == "99":
            print("Quitting program")
            sys.exit()
        else:
            print("ERROR")
            raise ValueError(f"Something went horrible wrong at position {pos} with value {instructions[pos]}")

    return instructions

def main():
    instructions = generate_input()
    user_input = 5 #input("Which test would you like to run?: ")        
    output = run_intcode(instructions, user_input)
    print(output[0])

if __name__ == "__main__":
    main()

        private void button7_Click(object sender, EventArgs e)
        {
            System.Diagnostics.Stopwatch watch = System.Diagnostics.Stopwatch.StartNew();
            Dictionary<int, int[]> sequenceList;
            if (this.numSubTask.Value==2)
            {
                sequenceList = GetSequenceList("56789");
            }
            else
            {
                sequenceList = GetSequenceList("01234");
            }
            Dictionary<string, int> stringRef = new Dictionary<string, int>();
            foreach (KeyValuePair<int,int[]> item in sequenceList)
            {
                string seqStr = String.Empty;
                for (int i = 0; i < item.Value.Length; i++)
                {
                    seqStr = seqStr + item.Value[i].ToString();
                }
                stringRef.Add(seqStr, item.Key);
            }
            int maxOutPut = 0;
            int maxSequenceId = -1;
            for (int i = 0; i < sequenceList.Count; i++)
            {
                int testThrust = GetThrusterValue(sequenceList[i]);
                if (testThrust>maxOutPut)
                {
                    maxSequenceId = i;
                    maxOutPut = testThrust;
                }
            }
            txtAnswer.Text =string.Join(",", sequenceList[maxSequenceId]) +  "¤" + maxOutPut.ToString();
            watch.Stop();
            Int64 elapsedMs = watch.ElapsedMilliseconds;
            label1.Text = elapsedMs.ToString();
        }
        private int GetThrusterValue(int[] sequence)
        {
            int thrust = 0;
            //int lastThrust = 0;
            int i = 0;
            bool keepGoing= true;
            IntCode[] amplifier = { new IntCode(), new IntCode(), new IntCode(), new IntCode(), new IntCode() };
            while (keepGoing)
            {
                int[] inputs = new int[2];
                inputs[0] = sequence[i]; 
                inputs[1] = thrust;
                //IntCode computer = new IntCode(this.txtInput.Text, inputs);
                if (!amplifier[i].isInitialized)
                {
                    amplifier[i].Init(this.txtInput.Text, inputs);
                }
                int? outputs = amplifier[i].Compute();
                //int resCount = outputs.Count;
                if (outputs==null)
                {
                    keepGoing=false;
                }
                else
                {
                    thrust = (int)outputs;
                    i++;
                    if (i>(sequence.Length-1))
                    {
                        i = 0;
                    }
                    if (!amplifier[i].isInitialized)
                    {
                        inputs[0] = sequence[i];
                        inputs[1] = thrust;
                        amplifier[i].Init(this.txtInput.Text, inputs);
                    }
                    else
                    {
                        amplifier[i].AddInput(thrust);
                    }
                }
            }
            return thrust;

        }
        private Dictionary<int,int[]> GetSequenceList(string phases ="01234")
        {
            Dictionary<int, int[]> combos = new Dictionary<int, int[]>();
            List<int> baseList = new List<int>();
            int[] phase = new int[phases.Length];
            for (int i = 0; i < phases.Length; i++)
            {
                phase[i] = ToSafeInt(phases.Substring(i,1));
            }
            for (int i = 0; i < 5; i++)
            {
                baseList.Add(i);
            }
            int sequenceNumber = 0;
            for (int i1 = 0; i1 < 5; i1++)
            {
                List<int> val2List = baseList.ToList();
                val2List.Remove(i1);
                for (int i2 = 0; i2 < 4; i2++)
                {
                    int i2val = val2List.ElementAt(i2);
                    List<int> val3List = val2List.ToList();
                    val3List.Remove(i2val);
                    for (int i3 = 0; i3 < 3; i3++)
                    {
                        int i3val = val3List.ElementAt(i3);
                        List<int> val4List = val3List.ToList();
                        val4List.Remove(i3val);
                        for (int i4 = 0; i4 < 2; i4++)
                        {
                            int i4val = val4List.ElementAt(i4);
                            List<int> val5List = val4List.ToList();
                            val5List.Remove(i4val);
                            int i5val = val5List.ElementAt(0);
                            int[] curSeq = new int[5];
                            curSeq[0] = phase[i1];
                            curSeq[1] = phase[i2val];
                            curSeq[2] = phase[i3val];
                            curSeq[3] = phase[i4val];
                            curSeq[4] = phase[i5val];
                            combos.Add(sequenceNumber, curSeq);
                            sequenceNumber++;
                        }
                    }
                }
            }
            return combos;
        }
    public class IntCode
    {
        private bool endedCorrectly = false;
        public bool EndedCorrectly
        {
            get
            {
                return endedCorrectly;
            }
        }
        public bool isInitialized = false;
        int currentPosition = 0;
        int inputstep = 0;
        private string _program;
        private Dictionary<OpCode, int> parameterCount = new Dictionary<OpCode, int>();
        private Dictionary<int, int> _outputs = new Dictionary<int, int>();
        public int[] data;
        private Dictionary<int,int> _inputs = new Dictionary<int, int>();
        public enum OpCode
        {
            Add=1,
            Mul=2,
            In=3,
            Out=4,
            JiT=5,
            JiF=6,
            Les=7,
            Eq=8,
            End=99
        }
        public enum ParamMode
        {
            Ref=0,
            Val=1
        }
        public void AddInput(int input)
        {
            int nextInpPos = _inputs.Count;
            _inputs.Add(nextInpPos, input);
        }
        public IntCode(string program, int? input=null)
        {
            _program = program;
            if (input!=null)
            {
                AddInput((int)input);
            }
            Initialize();
        }
        public IntCode()
        {

        }
        public void Init(string program, int[] inputs = null)
        {
            _program = program;
            if (inputs != null)
            {
                foreach (int item in inputs)
                {
                    AddInput(item);
                }
            }
            Initialize();
        }

        private void Initialize()
        {
            parameterCount.Clear();
            parameterCount.Add(OpCode.Add, 3);
            parameterCount.Add(OpCode.Mul, 3);
            parameterCount.Add(OpCode.In, 1);
            parameterCount.Add(OpCode.Out, 1);
            parameterCount.Add(OpCode.JiT, 2);
            parameterCount.Add(OpCode.JiF, 2);
            parameterCount.Add((OpCode.Les), 3);
            parameterCount.Add(OpCode.Eq, 3);
            parameterCount.Add(OpCode.End, 0);
            data = GetSafeIntArray(_program);
            isInitialized = true;
        }
        private int[] GetSafeIntArray(string input)
        {
            string[] strArr = input.Split(',');
            int[] intArr = new int[strArr.Length];
            for (int i = 0; i < strArr.Length; i++)
            {
                intArr[i] = ToSafeInt(strArr[i]);
            }
            return intArr;
        }
        private static int ToSafeInt(string val, int error = -1)
        {
            int test;
            bool isint = int.TryParse(val, out test);
            if (isint)
            {
                return test;
            }
            return error;
        }
        public static ParamMode[] getParameterModes(string modes)
        {
            ParamMode[] pModes = new ParamMode[modes.Length];
            for (int i = 0; i < modes.Length; i++)
            {
                pModes[modes.Length - i - 1] = (ParamMode)ToSafeInt(modes.Substring(i, 1));
            }
            return pModes;
        }
        public int? Compute()
        {
            if (!isInitialized)
            {
                throw new Exception("Computer is not initialized!");
            }
            int? lastOutPut = null;
            int posCount = data.Length;
            bool noExit = true;
            //string lastOutPut = String.Empty;
            int outputstep = 0;
            _outputs.Clear();
            while (currentPosition < posCount && noExit)
            {
                string posCode = data[currentPosition].ToString("D5");
                OpCode opCode = (OpCode)ToSafeInt(posCode.Substring(3, 2));
                ParamMode[] parameterMode = getParameterModes(posCode.Substring(0, 3));
                int paramCount = parameterCount[opCode];
                if (opCode==OpCode.End)
                {
                    endedCorrectly = true;
                    noExit = false;
                    return lastOutPut;
                }
                int[] parameters=new int[paramCount];
                int[] values = new int[paramCount];
                for (int i = 0; i < paramCount; i++)
                {
                    parameters[i] = data[currentPosition + 1 + i];
                    if (parameterMode[i]==ParamMode.Ref)
                    {
                        values[i] = data[parameters[i]];
                    }
                    else
                    {
                        values[i] = parameters[i];
                    }
                }
                switch (opCode)
                {
                    case OpCode.Add:
                        data[parameters[2]] = values[0] + values[1];
                        currentPosition = currentPosition + 1 + paramCount;
                        break;
                    case OpCode.Mul:
                        data[parameters[2]] = values[0] * values[1];
                        currentPosition = currentPosition + 1 + paramCount;
                        break;
                    case OpCode.In:
                        data[parameters[0]] = _inputs[inputstep];
                        inputstep++;
                        currentPosition = currentPosition + 1 + paramCount;
                        break;
                    case OpCode.Out:
                        _outputs.Add(outputstep, data[parameters[0]]);
                        outputstep++;
                        currentPosition = currentPosition + 1 + paramCount;
                        return values[0];
                    case OpCode.JiT:
                        if (values[0]!=0)
                        {
                            currentPosition = values[1];
                        }
                        else
                        {
                            currentPosition = currentPosition + 1 + paramCount;
                        }
                        break;
                    case OpCode.JiF:
                        if (values[0] == 0)
                        {
                            currentPosition = values[1];
                        }
                        else
                        {
                            currentPosition = currentPosition + 1 + paramCount;
                        }
                        break;
                    case OpCode.Les:
                        if (values[0]<values[1])
                        {
                            data[parameters[2]] = 1;
                        }
                        else
                        {
                            data[parameters[2]] = 0;
                        }
                        currentPosition = currentPosition + 1 + paramCount;
                        break;
                    case OpCode.Eq:
                        if (values[0] == values[1])
                        {
                            data[parameters[2]] = 1;
                        }
                        else
                        {
                            data[parameters[2]] = 0;
                        }
                        currentPosition = currentPosition + 1 + paramCount;
                        break;
                    case OpCode.End:
                        currentPosition = currentPosition + 1;
                        endedCorrectly = true;
                        noExit = false;
                        break;
                    default:
                        break;
                }
                if (!nextIsValid(data[currentPosition]))
                {
                    throw new Exception("Hur kom vi hit?");
                }
            }
            if (endedCorrectly)
            {
                return lastOutPut;
            }
            else
            {
                return null;
            }
        }
        private bool nextIsValid(int nextInstruction)
        {
            string posCode = data[currentPosition].ToString("D5");
            OpCode opCode = (OpCode)ToSafeInt(posCode.Substring(3, 2));
            return parameterCount.ContainsKey(opCode);
        }

    }

package main

import (
	"fmt"
)

type Memory []int

const NUM_AMPLIFIERS = 5

const (
	Add = iota + 1
	Mul
	In
	Out
	JmpIfTrue
	JmpIfFalse
	LessThan
	Equal
	Halt = 99
)

func run(mem Memory, input <-chan int, output chan<- int) {
	defer close(output)
	ip := 0
	ld_imm := func(addr int) int {
		return mem[addr]
	}
	for {
		opcode := mem[ip]
		is_imm := []bool{opcode/100%10 != 0, opcode/1000%10 != 0}
		ld := func(offset int) int {
			v := ld_imm(offset + ip)
			if !is_imm[offset-1] {
				v = mem[v]
			}
			return v
		}
		st := func(offset, val int) {
			mem[ld_imm(offset+ip)] = val
		}
		switch opcode % 100 {
		case Add:
			st(3, ld(1)+ld(2))
			ip += 4
		case Mul:
			st(3, ld(1)*ld(2))
			ip += 4
		case In:
			st(1, <-input)
			ip += 2
		case Out:
			output <- ld(1)
			ip += 2
		case JmpIfFalse:
			if ld(1) == 0 {
				ip = ld(2)
			} else {
				ip += 3
			}
		case JmpIfTrue:
			if ld(1) != 0 {
				ip = ld(2)
			} else {
				ip += 3
			}
		case LessThan:
			if ld(1) < ld(2) {
				st(3, 1)
			} else {
				st(3, 0)
			}
			ip += 4
		case Equal:
			if ld(1) == ld(2) {
				st(3, 1)
			} else {
				st(3, 0)
			}
			ip += 4
		case Halt:
			return
		default:
			panic("Invalid instruction")
		}
	}
}

func amplifiers(program Memory, phases []int) (chan<- int, <-chan int) {
	var chs [NUM_AMPLIFIERS + 1]chan int
	for i := 0; i <= NUM_AMPLIFIERS; i++ {
		chs[i] = make(chan int, 1)
	}
	for i := 0; i < NUM_AMPLIFIERS; i++ {
		mem := make(Memory, len(program))
		copy(mem, program)
		go run(mem, chs[i], chs[i+1])
		chs[i] <- phases[i]
	}
	return chs[0], chs[NUM_AMPLIFIERS]
}

func thrustWithPhases(prog Memory, phases []int) int {
	tx, rx := amplifiers(prog, phases)
	tx <- 0
	final_result := 0
	// Loop while the amplifiers has not halted
	for result := range rx {
		tx <- result
		final_result = result
	}
	return final_result
}

func maxThrust(prog Memory, phases []int) (max int) {
	ch := make(chan int)
	go func() {
		defer close(ch)
		Perm(phases, func(phasesPerm []int) {
			ch <- thrustWithPhases(prog, phasesPerm)
		})
	}()
	max = <-ch
	for thrust := range ch {
		if max < thrust {
			max = thrust
		}
	}
	return
}

func main() {
	prog := loadProgram("input.txt")
	fmt.Println(maxThrust(prog, []int{0, 1, 2, 3, 4}))
	fmt.Println(maxThrust(prog, []int{5, 6, 7, 8, 9}))
}