🌟 Advent of Code (AoC) 2020 🌟

from functools import partial

instructions = [l.split() for l in open('input', 'r')]

def acc(pc, accumulator, offset): return pc + 1,      accumulator + offset
def jmp(pc, accumulator, offset): return pc + offset, accumulator
def nop(pc, accumulator, offset): return pc + 1,      accumulator

def swap(instructions, i):
    s = instructions[i][0]
    swaps = { 'jmp':'nop', 'nop':'jmp'}
    if s in swaps:
        instructions[i][0] = swaps[s]
        pc, accumulator = run(instructions, set([len(instructions)]))
        instructions[i][0] = s
        if pc == len(instructions):
            return accumulator
    return 0

def run(instructions, executed = set()):
    pc, accumulator = 0, 0
    while pc not in executed:
        executed.add(pc)
        i = instructions[pc]
        pc, accumulator = eval(i[0])(pc, accumulator, int(i[1]))
    return pc, accumulator

print(run(instructions)[1],
      sum(map(partial(swap, instructions), range(len(instructions)))))

$InputData = Get-Content "input.txt" -Raw
$Fields = @('byr','iyr','eyr','hgt','hcl','ecl','pid')
function Test-Passports {
    param (
        [string]$Data,
        [Array]$RequiredFields
    )

    $Result = @()

    $Passports = $Data -Split "`n`n"

    # Validate passwords
    for ($i = 0; $i -lt $Passports.Count; $i++) {
        $Entries = $Passports[$i].Split("`n").Split(" ")
        $PassportResults = @();

        $HasFields = -not (($RequiredFields | % {$Entries.Split(":") -contains $_}) -contains $false)

        if ($HasFields) {
            foreach ($Entry in $Entries) {
                $PassportResults += Test-PassportField $Entry.Trim()
            } 
        } Else {
            $PassportResults += $false
        }

        $Result += -not ($PassportResults -contains $false)
    }

    return $Result
}

function Test-PassportField {
    param (
        [string]$PassportField
    )
    
    $Field, $Data = $PassportField.Split(":")

    switch ($Field) {
        # byr (Birth Year) - four digits; at least 1920 and at most 2002.
        "byr" { $Data -match "^(19[2-9][0-9]|200[0-2])$" }
        # iyr (Issue Year) - four digits; at least 2010 and at most 2020.
        "iyr" { $Data -match "^20(1[0-9]|20)$" }
        # eyr (Expiration Year) - four digits; at least 2020 and at most 2030.
        "eyr" { $Data -match "^20(2[0-9]|30)$" }
        # hgt (Height) - a number followed by either cm or in:
        # If cm, the number must be at least 150 and at most 193.
        # If in, the number must be at least 59 and at most 76.
        "hgt" { 
            
            $hgt = $Data.Substring(0,$Data.Length-2)
            $unit = $Data.Substring($Data.Length-2,2)
            switch ($unit) {
                "cm" { $hgt -ge 150 -AND $hgt -le 193 }
                "in" { $hgt -ge 59 -AND $hgt -le 76 }
                Default {$false}
            }
        }
        # hcl (Hair Color) - a # followed by exactly six characters 0-9 or a-f.
        "hcl" { $Data -match "^#[0-9a-f]{6}$" }
        # ecl (Eye Color) - exactly one of: amb blu brn gry grn hzl oth.
        "ecl" { $Data -match "^(amb|blu|brn|gry|grn|hzl|oth)$" }
        # pid (Passport ID) - a nine-digit number, including leading zeroes.
        "pid" { $Data -match "^\d{9}$" }
        # cid (Country ID) - ignored, missing or not.
        "cid" { $true }
        Default {$false}
    }
}

$ValidatedPassports = Test-Passports -Data $InputData -RequiredFields $Fields
($ValidatedPassports -eq $true).Count

$InputData = Get-Content "input.txt"

function Get-SeatID {
    param (
        [String]$Seat
    )

    $Row = [convert]::ToInt32($Seat.Substring(0,7).Replace("F",0).Replace("B",1),2)
    $Colum = [convert]::ToInt32($Seat.Substring(7,3).Replace("L",0).Replace("R",1),2)

    return $Row * 8 + $Colum;
}

$Seats = $InputData | % {Get-SeatID $_}
$Max = ($Seats | Measure-Object -Maximum).Maximum

$AllSeats = $Seats[0]..$Max

$MySeat = $AllSeats | ? {-not ($Seats -contains $_)}

Write-Host "Highest Seat ID: $Max"
Write-Host "My Seat ID: $MySeat"

$InputData = Get-Content "$PSScriptRoot\input.txt" -Delimiter "`r`n`r`n"

function Measure-Answares {
    param (
        [array]$Answares,
        [switch]$PartTwo=$false
    )

    if (-not $PartTwo) {
        ($Answares | % {$_.Replace("`r`n", "").ToCharArray() | Sort-Object | Get-Unique}).Count  
    } Else {
        foreach ($Set in $Answares) {
            $Rows = ($Set | Measure-Object -Word).Words
            $SetAns = $Set | % {$_.Replace("`r`n", "").ToCharArray() | Group-Object}

            $AllYes += (($SetAns | % {$_.Count -eq $Rows}) -eq $true).Count
        }

        $AllYes
    }
}   

Write-Host "Part #1: " -NoNewline
Measure-Answares -Answares $InputData
Write-Host "Part #2: " -NoNewline
Measure-Answares -Answares $InputData -PartTwo

Imports System.IO

Module Program
    Sub Main(args As String())

        Dim instructionSet = File.ReadAllLines("input.txt")
        Dim partOne As Integer = 0
        Dim partTwo As Integer = 0

        IsInfiniteLoop(instructionSet, partOne)

        Dim correctFound As Boolean = False
        Dim index As Integer = 0
        While Not correctFound And index < instructionSet.Length
            Dim instructionSetToTest(instructionSet.Length - 1) As String
            For i = 0 To instructionSet.Length - 1
                instructionSetToTest(i) = instructionSet(i).Clone()
            Next
            Dim instruction = instructionSetToTest(index).Split(" "c)
            If instruction(0) = "jmp" Then
                instructionSetToTest(index) = "nop " & instruction(1)
            ElseIf instruction(0) = "nop" Then
                instructionSetToTest(index) = "jmp " & instruction(1)
            End If
            If Not IsInfiniteLoop(instructionSetToTest, partTwo) Then correctFound = True
            index += 1
        End While

        Console.WriteLine("Part 1: " & partOne)
        Console.WriteLine("Part 2: " & partTwo)
    End Sub

    Function IsInfiniteLoop(instructionSet As String(), ByRef acc As Integer) As Boolean
        Dim hasBeenRun(instructionSet.Length - 1) As Boolean
        Dim infiniteLoopFound As Boolean = False
        Dim internalAcc As Integer = 0
        Dim index As Integer = 0

        While Not infiniteLoopFound And index < instructionSet.Length
            hasBeenRun(index) = True

            Dim instruction = instructionSet(index).Split(" "c)
            Dim code = instruction(0)
            Dim increment = instruction(1)

            If code = "acc" Then
                If increment(0) = "+"c Then internalAcc += Integer.Parse(increment.Substring(1))
                If increment(0) = "-"c Then internalAcc -= Integer.Parse(increment.Substring(1))
                index += 1
            End If
            If code = "jmp" Then
                If increment(0) = "+"c Then index += Integer.Parse(increment.Substring(1))
                If increment(0) = "-"c Then index -= Integer.Parse(increment.Substring(1))
            End If
            If code = "nop" Then
                index += 1
            End If

            If index < instructionSet.Length AndAlso hasBeenRun(index) Then infiniteLoopFound = True
        End While

        acc = internalAcc
        Return infiniteLoopFound
    End Function

End Module

#include <chrono>
#include <cstdint>
#include <fstream>
#include <functional>
#include <iostream>
#include <string>
#include <vector>

#define OP_ACC 0
#define OP_JMP 1
#define OP_NOP 2

typedef struct {
    uint32_t bits[256];
} executed_t;

__device__  bool mark_executed(executed_t *exec, unsigned pc) {
    unsigned a = pc >> 5;
    unsigned b = 1 << (pc & 31);
    bool c = !!(exec->bits[a] & b);
    exec->bits[a] |= b;
    return c;
}

__global__  void day8_kernel(executed_t *execs, int *res, uint8_t *ops, int *args, int prog_len) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    executed_t *exec = execs + idx;
    uint8_t new_op = ops[idx] ^ (OP_JMP + OP_NOP);
    int pc = 0;
    int acc = 0;

    if (idx < prog_len) {
        while (!mark_executed(exec, pc)) {
            uint8_t op = (idx == pc) ? new_op : ops[pc];
            switch (op) {
            case OP_JMP:
                pc += args[pc];
                break;
            case OP_NOP:
                pc += 1;
                break;
            default:
                acc += args[pc];
                pc += 1;
            }
            if (pc == prog_len) {
                res[idx] = acc;
                break;
            }
        }
    }
}

static void * gpu_buf(void *host_ptr, size_t buf_len) {
    void *gpu_ptr;
    cudaMallocManaged(&gpu_ptr, buf_len);
    if (host_ptr == nullptr) {
        memset(gpu_ptr, 0, buf_len);
    } else {
        memcpy(gpu_ptr, host_ptr, buf_len);
    }
    return gpu_ptr;
}

static void day6(const std::vector<uint8_t> &ops, const std::vector<int> &args) {
    uint8_t    *gpu_ops = (uint8_t *)gpu_buf((void *)ops.data(), ops.size() * sizeof(uint8_t));
    int        *gpu_args = (int *)gpu_buf((void *)args.data(), args.size() * sizeof(int));
    executed_t *gpu_exec = (executed_t *)gpu_buf(nullptr, ops.size() * sizeof(executed_t));
    int        *gpu_res = (int*)gpu_buf(nullptr, ops.size() * sizeof(int));
    int         prog_len = ops.size();

    day8_kernel<<<prog_len, 1>>>(gpu_exec, gpu_res, gpu_ops, gpu_args, prog_len);
    cudaDeviceSynchronize();
    for (int i = 0; i < prog_len; i++) {
        if (gpu_res[i]) {
            std::cout << "Part 2 : " << gpu_res[i] << '\n';
        }
    }

    cudaFree(gpu_ops);
    cudaFree(gpu_args);
    cudaFree(gpu_exec);
    cudaFree(gpu_res);
}

static int measure(std::function<void()> fn) {
    auto start = std::chrono::high_resolution_clock::now();
    fn();
    auto finish = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(finish - start);
    auto sec = duration.count();
    return sec;
}

int main(int argc, char *argv[]) {
    std::ifstream fin("input.txt");
    std::string line;
    std::vector<uint8_t> ops;
    std::vector<int> args;
    while (std::getline(fin, line)) {
        if (line.rfind("acc") == 0) {
            ops.push_back(OP_ACC);
        } else if (line.rfind("jmp") == 0) {
            ops.push_back(OP_JMP);
        } else {
            ops.push_back(OP_NOP);
        }
        args.push_back(std::atoi(line.c_str() + 4));
    }

    std::cout << "Took "
              << measure([&]() { day6(ops, args); })
              << "ms\n";
    }

// Local Variables:
// mode: c++
// compile-command: "cd build; make"
// End:

void Main()
{
	var file = File.ReadAllLines("day-08.txt");

	var parsed = Parse(file, out var parse_ms);
	var part1 = Part1(parsed, out var part1_ms);
	var part2 = Part2(parsed, out var part2_ms);

	new { part1, part2, }.Dump();
	new { Parsed = $"{parse_ms:0.000}ms", Part1 = $"{part1_ms:0.000}ms", Part2 = $"{part2_ms:0.000}ms", }.Dump();
}

enum Command { Accumulator, Jump, NoOperation };

Dictionary<int, (Command, int)> Parse(string[] lines, out double ms)
{
	var stopwatch = Stopwatch.StartNew();
	var parsed = new Dictionary<int, (Command, int)>();

	for (int i = 0; i < lines.Length; i++)
	{
		var line = lines[i];
		var split = line.Split(' ');
		var command = split[0];
		var argument = int.Parse(split[1]);
		var command_parsed =
		  command == "acc" ? Command.Accumulator :
		  command == "jmp" ? Command.Jump :
		  command == "nop" ? Command.NoOperation :
		  throw new NotImplementedException($"Invalid Command: '{command}'");
		parsed.Add(i, (command_parsed, argument));
	}

	ms = stopwatch.Elapsed.TotalMilliseconds;
	return parsed;
}

int Part1(Dictionary<int, (Command Command, int Argument)> instructions, out double ms)
{
	var stopwatch = Stopwatch.StartNew();
	var index = 0;
	var accumulator = 0;
	var executed_instructions = new HashSet<int>();

	while (executed_instructions.Add(index))
	{
		var instruction = instructions[index];

		if (instruction.Command == Command.Accumulator)
		{
			accumulator += instruction.Argument;
			index++;
		}
		else if (instruction.Command == Command.Jump)
		{
			index += instruction.Argument;
		}
		else if (instruction.Command == Command.NoOperation)
		{
			index++;
		}
	}

	ms = stopwatch.Elapsed.TotalMilliseconds;
	return accumulator;
}

int Part2(Dictionary<int, (Command Command, int Argument)> instructions, out double ms)
{
	var stopwatch = Stopwatch.StartNew();
	var index = 0;
	var accumulator = 0;
	var swapped_instruction = false;
	var executed_instructions = new HashSet<int>();
	var attempted_nops = new HashSet<int>();
	var attempted_jmps = new HashSet<int>();

	while (true)
	{
		var instruction = instructions[index];

		if (!swapped_instruction &&
		  instruction.Command == Command.NoOperation &&
		  attempted_nops.Add(index))
		{
			swapped_instruction = true;
			instruction.Command = Command.Jump;
		}
		else if (!swapped_instruction &&
		  instruction.Command == Command.Jump &&
		  attempted_jmps.Add(index))
		{
			swapped_instruction = true;
			instruction.Command = Command.NoOperation;
		}

		if (instruction.Command == Command.Accumulator)
		{
			accumulator += instruction.Argument;
			index++;
		}
		else if (instruction.Command == Command.Jump)
		{
			index += instruction.Argument;
		}
		else if (instruction.Command == Command.NoOperation)
		{
			index++;
		}

		if (index == instructions.Count) // last instruction => exit
		{
			break;
		}
		else if (!executed_instructions.Add(index)) // infinite loop => retry
		{
			index = 0;
			accumulator = 0;
			swapped_instruction = false;
			executed_instructions.Clear();
		}
	}

	ms = stopwatch.Elapsed.TotalMilliseconds;
	return accumulator;
}

    private static final int nrSize = 25;
    private static ArrayList<Integer> nrList = new ArrayList<Integer>(nrSize);
    private static HashSet<Integer> validNumbers = new HashSet<Integer>();

    public static int uppgiftA(ArrayList<String> a1) {
        for (String row : a1) {
            int number = Integer.parseInt(row);
            if (nrList.size() != nrSize) {
                nrList.add(number);
                continue;
            }
            validNumbers.clear();
            for (int i = 0; i < nrList.size() - 1; i++) {
                for (int j = 1; j < nrList.size(); j++) {
                    validNumbers.add(nrList.get(i) + nrList.get(j));
                }
            }
            if (validNumbers.contains(number)) {
                nrList.remove(0);
                nrList.add(number);
            } else {
                return (number);
                // break;
            }
        }
        System.err.println("! No badNo found (Uppgift A)");
        return 0;
    }

    public static void uppgiftB(ArrayList<String> a1, int i0) {
        int c = 0;
        long badNo = i0;
        for (String row : a1) {
            long number = Long.parseLong(row);
            
            int c2 = c + 1;
            long total = number;
            long smallest = number;
            long largest = number;
            while (total <= badNo) {
                if (c2 > a1.size()) {
                    break;
                } 
                long i1 = Long.parseLong(a1.get(c2));
                if (smallest > i1) {
                    smallest = i1;
                } else if (largest < i1) {
                    largest = i1;
                }
                total += i1;
                if (total == badNo) {
                    System.out.println("Contigiuos numbers found! " + smallest + " + " + largest + " = " + (smallest+largest));
                    break;
                }
                c2++;
            }
            c++;
        }
    }

    public static void main(String[] args) throws Exception {
        String inputFile = "... /AdventOfCode2020/src/day9/input.txt";
        ArrayList<String> a1 = new ArrayList<String>(MyFileReader.read(inputFile));
        // uppgiftA(a1);
        // nrList.clear(); validNumbers.clear();
        uppgiftB(a1, uppgiftA(a1));
    }

part1$ <in awk '{ n[NR] = $1; for (i = NR - 25; i < NR; i++) { x = n[NR] + n[i]; a[x] = NR; b[x] = i } }
NR > 25 && !($1 in a); $1 in a && NR - a[$1] > 25 && NR - b[$1] > 25'
part2$ <in awk -v bad=1639024365 '{ n[NR] = $1 }
END {
	for (o = 0; o <= NR; o++) {
		for (i = 1; i + o  <= NR; i++) {
			v[i, o] = v[i, (o - 1)] + n[i + o]
			if (v[i, o] == bad && o > 0) {
				for (k = i; k <= i + o; k++) { print n[k] }
				exit
			}
		}
	}
}' | sort -n | awk '{ n[NR] = $1 } END { print n[1] + n[NR] }'

function calculatePartOne(list, preambleLength) {
    for (let i = preambleLength; i < list.length; i++) {
        let match = false;
        for (let j = i - preambleLength; j < i; j++) {
            for (let k = i - preambleLength; k < i; k++) {
                if (j != k) {
                    let res = (list[j] + list[k]);
                    if (res === list[i]) {
                        match = true;
                    }
                }
            }
        }
        if (match == false) {
            console.log("Part 1: " + list[i]);
            return list[i];
        }
    }
}

function calculatePartTwo(list, invalidNumber) {
    for (let i = 0; i < list.length; i++) {
        let res = 0;
        let j = i;
        match = false;
        let addedNumbers = [];
        while (res < invalidNumber) {
            res =+ list[j];
            addedNumbers.push(list[j])
            j++;
            if (res == invalidNumber) {
                match = true;
                break;
            }
        }
        if (match == true) {
            console.log("Part 2: " + (Math.min(...addedNumbers) + Math.max(...addedNumbers)));
            return;
        }
    }
    if (match == false) {
        console.log("No match");
    }
}

async function fetchInput() {
    var response = await fetch('input.txt');
    var text = await response.text();
    var list = text.split("\n").map(function (x) { return parseInt(x, 10); });

    let answerFromPartOne = calculatePartOne(list, 25);
    calculatePartTwo(list, answerFromPartOne);
}

fetchInput();

from itertools import combinations

input = [int(line) for line in open("input", "r")]

def valid(input, i):
    return input[i] in map(sum, combinations(input[i-25:i], 2))

invalid = [input[i] for i in range(26, len(input))
           if not valid(input, i)][0]

print(invalid, *[min(l) + max(l) for l in [input[i:j]
                                           for i in range(len(input))
                                           for j in range(i + 2, len(input))]
                 if sum(l) == invalid])

void Main() {
  var lines = File.ReadAllLines("day-09.txt");
  var parse = Parse(lines);
  var part1 = Part1(parse);
  var part2 = Part2(parse, part1);
}

long[] Parse(string[] lines) {
  var parsed = new long[lines.Length];
  for (int i = 0; i < lines.Length; i++) { parsed[i] = long.Parse(lines[i]); }
  return parsed;
}

const int preamble = 25;

long Part1(long[] numbers) {
  for (int i = preamble; i < numbers.Length; i++) {
    var number = numbers[i];
    var contains = false;
    for (int j = i - preamble; j < i; j++) {
      if (contains) { break; }
      for (int k = i - preamble; k < i; k++) {
        if (numbers[j] + numbers[k] == number) { contains = true; break; }
      }
    }
    if (!contains) { return number; }
  }
  return -1L;
}

long Part2(long[] numbers, long part1) {
  for (int i = numbers.Length - 1; 0 <= i; i--) {
    var number1 = numbers[i];
    var sum = number1;
    if (sum > part1) { continue; }
    var range = new List<long> { number1 };
    for (int j = i - 1; 0 <= j; j--) {
      var number2 = numbers[j];
      sum += number2;
      if (sum > part1) { break; }
      range.Add(number2);
      if (sum == part1) { return range.Min() + range.Max(); }
    }
  }
  return -1L;
}