🌟 Advent of Code (AoC) 2020 🌟

        public static string Run1(bool test = false)
        {
            int _Day = 5;
            string[] inputData = InputData.GetInputArrString(_Day, test);
            List<UInt16> AllSeats = new List<UInt16>();
            for (UInt16 row = 0; row < 128; row++)
            {
                for (UInt16 col = 0; col < 8; col++)
                {
                    UInt16 _seatId = (UInt16)((row * (UInt16)8) + col);
                    AllSeats.Add(_seatId);
                }
            }
            UInt16 highestSeatId = 0;
            for (int i = 0; i < inputData.Length; i++)
            {
                string bp = inputData[i];
                bp = bp.Replace("B", "1");
                bp = bp.Replace("F", "0");
                bp = bp.Replace("R", "1");
                bp = bp.Replace("L", "0");
                UInt16 SeatId = Convert.ToUInt16(bp, 2);
                if (SeatId>highestSeatId)
                {
                    highestSeatId = SeatId;
                }
                AllSeats.Remove(SeatId);
            }
            UInt16 foundId = 0;
            foreach (UInt16 item in AllSeats)
            {
                if (!AllSeats.Contains((UInt16)(item+(UInt16)1)) && !AllSeats.Contains((UInt16)(item - (UInt16)1)))
                {
                    foundId = item;
                }
            }

            return highestSeatId.ToString() + " : " +foundId.ToString();
        }

Imports System.IO

Module Program
    Sub Main(args As String())

        Dim expenseReport As New List(Of Integer)
        For Each entry In File.ReadLines("input.txt")
            expenseReport.Add(Integer.Parse(entry))
        Next

        Console.WriteLine("Part 1: " & CalculatePart1(expenseReport).ToString())
        Console.WriteLine("Part 2: " & CalculatePart2(expenseReport).ToString())

    End Sub

    Function CalculatePart1(expenseReport As List(Of Integer)) As Integer

        For Each entry In expenseReport
            For Each entry2 In expenseReport
                If entry + entry2 = 2020 Then
                    Return entry * entry2
                End If
            Next
        Next

        Return 0

    End Function

    Function CalculatePart2(expenseReport As List(Of Integer)) As Integer

        For Each entry In expenseReport
            For Each entry2 In expenseReport
                For Each entry3 In expenseReport
                    If entry + entry2 + entry3 = 2020 Then
                        Return entry * entry2 * entry3
                    End If
                Next
            Next
        Next
        Return 0

    End Function
End Module

Imports System.IO

Module Program
    Sub Main(args As String())

        Dim PartOneCount As Integer
        Dim PartTwoCount As Integer

        For Each entry In File.ReadLines("input.txt")
            Dim parts = entry.Split({"-"c, " "c, ":"c}, StringSplitOptions.RemoveEmptyEntries)
            Dim min = Integer.Parse(parts(0))
            Dim max = Integer.Parse(parts(1))
            Dim character = parts(2)
            Dim password = parts(3)

            Dim charCount = password.Count(Function(c) c = character)
            If charCount >= min And charCount <= max Then
                PartOneCount += 1
            End If

            If password(min - 1) = character Xor password(max - 1) = character Then
                PartTwoCount += 1
            End If

        Next
        Console.WriteLine("Part 1: " & PartOneCount.ToString())
        Console.WriteLine("Part 2: " & PartTwoCount.ToString())
    End Sub
End Module

Imports System.IO

Module Program
    Sub Main(args As String())
        Dim map As List(Of String) = File.ReadLines("input.txt").ToList()
        Dim part1 = CalculateSlope(map, 3, 1)
        Dim part2 = CalculateSlope(map, 1, 1) * CalculateSlope(map, 3, 1) * CalculateSlope(map, 5, 1) * CalculateSlope(map, 7, 1) * CalculateSlope(map, 1, 2)
        Console.WriteLine("Part 1: " & part1.ToString())
        Console.WriteLine("Part 2: " & part2.ToString())
    End Sub

    Function CalculateSlope(map As List(Of String), stepRight As Integer, stepDown As Integer) As Long
        Dim treeCount As Long = 0
        Dim x As Integer = 0
        Dim y As Integer = 0

        While y < map.Count
            If map(y)(x) = "#"c Then
                treeCount += 1
            End If

            x = (x + stepRight) Mod map(0).Length
            y += stepDown
        End While

        Return treeCount
    End Function
End Module

Imports System.IO
Imports System.Text.RegularExpressions

Module Program
    Sub Main(args As String())

        Dim validCount1 As Integer = 0
        Dim validCount2 As Integer = 0

        Using reader As New StreamReader("input.txt")
            While Not reader.EndOfStream

                Dim passPortData As String = ""
                Dim line = reader.ReadLine()
                While Not String.IsNullOrWhiteSpace(line)
                    passPortData += line & Environment.NewLine
                    line = reader.ReadLine()
                End While

                If Not String.IsNullOrWhiteSpace(passPortData) Then
                    Dim passPort As New Dictionary(Of String, String)
                    Dim fields = passPortData.Split(New String() {" ", Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries)
                    For Each field In fields
                        Dim key = field.Split(":"c).First
                        Dim value = field.Split(":"c).Last
                        passPort.Add(key, value)
                    Next

                    If IsPassPortValidPartOne(passPort) Then
                        validCount1 += 1
                    End If
                    If IsPassPortValidPartTwo(passPort) Then
                        validCount2 += 1
                    End If
                End If
            End While
        End Using

        Console.WriteLine("Part 1: " & validCount1.ToString())
        Console.WriteLine("Part 2: " & validCount2.ToString())
    End Sub

    Function IsPassPortValidPartOne(passPort As Dictionary(Of String, String)) As Boolean

        If Not (passPort.ContainsKey("byr") AndAlso Not String.IsNullOrWhiteSpace(passPort("byr"))) Then Return False
        If Not (passPort.ContainsKey("iyr") AndAlso Not String.IsNullOrWhiteSpace(passPort("iyr"))) Then Return False
        If Not (passPort.ContainsKey("eyr") AndAlso Not String.IsNullOrWhiteSpace(passPort("eyr"))) Then Return False
        If Not (passPort.ContainsKey("hgt") AndAlso Not String.IsNullOrWhiteSpace(passPort("hgt"))) Then Return False
        If Not (passPort.ContainsKey("hcl") AndAlso Not String.IsNullOrWhiteSpace(passPort("hcl"))) Then Return False
        If Not (passPort.ContainsKey("ecl") AndAlso Not String.IsNullOrWhiteSpace(passPort("ecl"))) Then Return False
        If Not (passPort.ContainsKey("pid") AndAlso Not String.IsNullOrWhiteSpace(passPort("pid"))) Then Return False

        Return True

    End Function

    Function IsPassPortValidPartTwo(passPort As Dictionary(Of String, String)) As Boolean

        If Not IsPassPortValidPartOne(passPort) Then Return False
        If Not (Integer.Parse(passPort("byr")) >= 1920 And Integer.Parse(passPort("byr")) <= 2002) Then Return False
        If Not (Integer.Parse(passPort("iyr")) >= 2010 And Integer.Parse(passPort("iyr")) <= 2020) Then Return False
        If Not (Integer.Parse(passPort("eyr")) >= 2020 And Integer.Parse(passPort("eyr")) <= 2030) Then Return False

        Dim format = Strings.Right(passPort("hgt"), 2)
        If Not (format = "in" Or format = "cm") Then Return False
        Dim height = Integer.Parse(Strings.Left(passPort("hgt"), passPort("hgt").Length - 2))
        If Not ((format = "in" And height >= 59 And height <= 76) Or (format = "cm" And height >= 150 And height <= 193)) Then Return False

        If Not Regex.IsMatch(passPort("hcl"), "#[0-9a-f]{6}") Then Return False
        If Not Regex.IsMatch(passPort("ecl"), "amb|blu|brn|gry|grn|hzl|oth") Then Return False
        If Not (IsNumeric(passPort("pid")) And passPort("pid").Length = 9) Then Return False

        Return True

    End Function
End Module

Imports System.IO

Module Program
    Sub Main(args As String())

        Dim seats As New List(Of Integer)

        For Each boardingPass In File.ReadLines("input.txt")
            seats.Add(CalculateSeatId(boardingPass))
        Next
        seats.Sort()

        Console.WriteLine("Part 1: " & seats.Last.ToString())
        Console.WriteLine("Part 2: " & FindMissingSeat(seats).ToString())
    End Sub

    Function CalculateSeatId(boardingPass As String)

        Dim front As Integer = 0
        Dim back As Integer = 127
        Dim left As Integer = 0
        Dim right As Integer = 7

        For i = 0 To 9
            If boardingPass(i) = "F"c Then back = Math.Floor((back + front) / 2)
            If boardingPass(i) = "B"c Then front = Math.Ceiling((back + front) / 2)
            If boardingPass(i) = "L"c Then right = Math.Floor((left + right) / 2)
            If boardingPass(i) = "R"c Then left = Math.Ceiling((left + right) / 2)
        Next

        Return front * 8 + left
    End Function

    Function FindMissingSeat(seats As List(Of Integer)) As Integer

        Dim seatToCheck = seats.First
        For i = 0 To seats.Count
            If seatToCheck <> seats(i) Then Return seatToCheck
            seatToCheck += 1
        Next

        Return 0
    End Function
End Module

#include <algorithm>
#include <cstdio>
#include <fstream>
#include <string>
#include <vector>

unsigned seat_id(const std::string &desc) {
    unsigned id = 0;
    for (auto c: desc) {
        id = (id << 1) + (c == 'B' || c == 'R');
    }
    return id;
}

unsigned my_seat_id(const std::vector<unsigned> &boarding_passes) {
    for (auto i = 0; i < boarding_passes.size() - 1; i++) {
        if (boarding_passes[i] + 2 == boarding_passes[i+1]) {
            return boarding_passes[i] + 1;
        }
    }
    return ~0;
}

std::vector<unsigned> boarding_passes_get() {
    std::string line;
    std::ifstream fin("input.txt");
    std::vector<unsigned> boarding_passes;
    while (std::getline(fin, line)) {
        boarding_passes.push_back(seat_id(line));
    }
    std::sort(boarding_passes.begin(), boarding_passes.end());
    return boarding_passes;
}

int main() {
    auto boarding_passes = boarding_passes_get();
    std::printf("Part 1 : %u\n", boarding_passes.back());
    std::printf("Part 2 : %u\n", my_seat_id(boarding_passes));
}

kjonsson@bean:~/AoC/advent-of-code-2020/day5$ sudo perf stat ./day5
Part 1 : 904
Part 2 : 669

 Performance counter stats for './day5':

          0,686254      task-clock (msec)         #    0,815 CPUs utilized          
                 0      context-switches          #    0,000 K/sec                  
                 0      cpu-migrations            #    0,000 K/sec                  
               115      page-faults               #    0,168 M/sec                  
         2 801 283      cycles                    #    4,082 GHz                    
         3 154 994      instructions              #    1,13  insn per cycle         
           542 754      branches                  #  790,894 M/sec                  
            18 454      branch-misses             #    3,40% of all branches        

       0,000841584 seconds time elapsed

kjonsson@bean:~/AoC/advent-of-code-2020/day5$ sudo perf stat ./day5 
Part 1 : 904
Part 2 : 669

 Performance counter stats for './day5':

          0,765458      task-clock (msec)         #    0,837 CPUs utilized          
                 0      context-switches          #    0,000 K/sec                  
                 0      cpu-migrations            #    0,000 K/sec                  
               118      page-faults               #    0,154 M/sec                  
         3 123 889      cycles                    #    4,081 GHz                    
         3 459 350      instructions              #    1,11  insn per cycle         
           599 518      branches                  #  783,215 M/sec                  
            19 851      branch-misses             #    3,31% of all branches        

       0,000914872 seconds time elapsed

func main() {
	passes := myIo()

	highest := 0
	var seatIds []int
	for _, v := range passes {
		result := calcSeat(v)

		seatIds = append(seatIds, result)

		if result > highest {
			highest = result
		}
	}

	fmt.Println("Highest seat ID: ", highest)
	sort.Ints(seatIds)

	previous := seatIds[0] - 1
	for _, v := range seatIds {
		fmt.Print(" ID: ", v)
		if v != previous+1 {
			fmt.Println("Found missing seat at: ", previous+1)
		}
		previous = v
	}
}

func calcSeat(pass string) int {
	rowPart := pass[0:7]

	rowMax := 127
	rowMin := 0

	for _, v := range rowPart {
		if string(v) == "F" {
			rowMax = (rowMin + rowMax) / 2
		} else if string(v) == "B" {
			rowMin = (rowMin + rowMax + 1) / 2
		}
	}

	colMax := 7
	colMin := 0

	colPart := pass[7:10]
	for _, v := range colPart {
		if string(v) == "L" {
			colMax = (colMin + colMax) / 2
		} else if string(v) == "R" {
			colMin = (colMin + colMax + 1) / 2
		}
	}

	return ((rowMax+rowMin)/2)*8 + ((colMax + colMin) / 2)
}

func day4() {
	f, err := os.Open("files\\day4")

	if err != nil {
		log.Fatal(err)
	}

	defer f.Close()

	scanner := bufio.NewScanner(f)

	var passports []string
	var temp string

	for scanner.Scan() {
		temp += scanner.Text()
		temp += " "
		if len(scanner.Text()) <= 0 {
			passports = append(passports, temp)
			temp = ""
		}
	}

	if err := scanner.Err(); err != nil {
		log.Fatal(err)
	}

	required := []string{"byr", "iyr", "eyr", "hgt", "hcl", "ecl", "pid"}

	var validPassports []passport.Passport

	count := 0
	for _, v := range passports {
		valid := true
		for _, vv := range required {
			if !strings.Contains(v, vv) {
				valid = false
			}
		}
		if valid {
			count++

			split := strings.Split(v, " ")

			newPassport := passport.Passport{
				Byr: getWhereName(split, "byr"),
				Iyr: getWhereName(split, "iyr"),
				Eyr: getWhereName(split, "eyr"),
				Hgt: getWhereName(split, "hgt"),
				Hcl: getWhereName(split, "hcl"),
				Ecl: getWhereName(split, "ecl"),
				Pid: getWhereName(split, "pid"),
			}
			validPassports = append(validPassports, newPassport)
		}
	}
	validCount := 0
	for _, v := range validPassports {
		if v.Valid() {
			fmt.Println(v.ToString())
			validCount++
		}
	}

	fmt.Println("Amount of passports:", len(passports), "Amount of first part valid passports:", count)
	fmt.Println("Second part validated passports amount:", validCount)
}

func getWhereName(p []string, which string) string {
	for _, v := range p {
		if which == getLeftside(v) {
			return getRightside(v)
		}
	}
	return ""
}

func getLeftside(val string) string {
	return strings.Split(val, ":")[0]
}

func getRightside(val string) string {
	return strings.Split(val, ":")[1]
}

type Passport struct {
	Byr string
	Iyr string
	Eyr string
	Hgt string
	Hcl string
	Ecl string
	Pid string
}

func (p Passport) ToString() string {
	return "Byr: " + p.Byr + " Iyr: " + p.Iyr + " Eyr: " + p.Eyr + " Hgt: " + p.Hgt + " Hcl: " + p.Hcl + " Ecl: " + p.Ecl + " Pid: " + p.Pid
}

func (p Passport) Valid() bool {
	return validateBirthyear(p.Byr) && validateIssueyear(p.Iyr) &&
		validateExpyear(p.Eyr) && validateHeight(p.Hgt) && validateHaircolor(p.Hcl) &&
		validateEyecolor(p.Ecl) && validatePassportId(p.Pid)
}

func validateBirthyear(val string) bool {
	convert, _ := strconv.Atoi(val)
	return convert >= 1920 && convert <= 2002
}

func validateIssueyear(val string) bool {
	convert, _ := strconv.Atoi(val)
	return convert >= 2010 && convert <= 2020
}

func validateExpyear(val string) bool {
	convert, _ := strconv.Atoi(val)
	return convert >= 2020 && convert <= 2030
}

func validateHeight(val string) bool {
	pattern := `^(\d+)(cm|in)$`
	compiledRegex := regexp.MustCompile(pattern)
	submatches := compiledRegex.FindAllStringSubmatch(val, -1)
	if submatches == nil {
		return false
	}
	convert, _ := strconv.Atoi(submatches[0][1])
	if submatches[0][2] == "cm" {
		return convert >= 150 && convert <= 193
	} else if submatches[0][2] == "in" {
		return convert >= 59 && convert <= 76
	} else {
		return false
	}
}

func validateHaircolor(val string) bool {
	pattern := `^[#a-f0-9]{7}$`
	compiledRegex := regexp.MustCompile(pattern)
	if compiledRegex.FindString(val) == "" {
		return false
	} else {
		return true
	}
}

func validateEyecolor(val string) bool {
	valid := []string{"amb", "blu", "brn", "gry", "grn", "hzl", "oth"}
	for _, v := range valid {
		if strings.Contains(val, v) {
			return true
		}
	}
	return false
}

func validatePassportId(val string) bool {
	pattern := `^[0-9]{9}$`
	compiledRegex := regexp.MustCompile(pattern)
	if compiledRegex.FindString(val) == "" {
		return false
	} else {
		return true
	}
}

Imports System.IO

Module Program
    Sub Main(args As String())

        Dim partOneCount As Integer = 0
        Dim partTwoCount As Integer = 0

        Using reader As New StreamReader("input.txt")
            While Not reader.EndOfStream
                Dim groupAnswers As String = ""
                Dim groupMemberCount As Integer = 0

                Dim line = reader.ReadLine()
                While Not String.IsNullOrWhiteSpace(line)
                    groupMemberCount += 1
                    groupAnswers += line
                    line = reader.ReadLine()
                End While

                Dim anyoneYes As New HashSet(Of Char)
                For i = 0 To groupAnswers.Length - 1
                    anyoneYes.Add(groupAnswers(i))
                Next
                partOneCount += anyoneYes.Count

                For Each question In anyoneYes
                    If groupMemberCount = groupAnswers.Count(Function(q) q = question) Then
                        partTwoCount += 1
                    End If
                Next
            End While
        End Using

        Console.WriteLine("Part 1: " & partOneCount.ToString())
        Console.WriteLine("Part 2: " & partTwoCount.ToString())
    End Sub
End Module

var input = File
  .ReadAllText("day-06.txt")
  .Split(new[] { "\n\n" }, StringSplitOptions.RemoveEmptyEntries)
  .Select(x => x.Split('\n'))
  .ToArray();
var part1 = input.Sum(x => x.SelectMany(y => y).Distinct().Count());
var part2 = input.Sum(x => x.First().Count(y => x.All(z => z.Contains(y))));

# The one-liner
print(*[sum([len(a) for a in [operation(*sets)
                              for sets in [[set([letter for letter in line])
                                            for line in group]
                                           for group in [group.split('\n')
                                                         for group in open("input", "r").read().split('\n\n')]]]])
        for operation in [set.union, set.intersection]])

# The slightly less convoluted solution :)

# Read the whole file, split into one string per group
groups = [group.split('\n') for group in open("input", "r").read().split('\n\n')]

# Build a list, per group, with sets of letters per line in the group
letters_per_group = [[set([letter for letter in line])
                      for line in group]
                     for group in groups ]

# Use the set union operation to find the letters that are in *any* of the lines
any = [set.union(*sets) for sets in letters_per_group]

# Use the set intersection operation to find the letters that are in *all* of the lines
all = [set.intersection(*sets) for sets in letters_per_group]

# Add the number of members in the all/any sets
print(sum([len(a) for a in any]), sum([len(a) for a in all]))

        public static string Run1(string inputData,bool test = false)
        {
            inputData = inputData.Replace("\r", "");
            string[] groups = inputData.Split("\n\n", StringSplitOptions.RemoveEmptyEntries);
            int[] answers = new int[26];
            int sumgroupanswers = 0;
            foreach (string group in groups)
            {
                int groupanswers = 0;
                for (int i = 0; i < answers.Length; i++)
                {
                    answers[i] = 0;
                }
                string[] persons = group.Split("\n", StringSplitOptions.RemoveEmptyEntries);
                foreach (string person in persons)
                {
                    byte[] asciiBytes = Encoding.ASCII.GetBytes(person);
                    foreach (byte bytechar in asciiBytes)
                    {
                        int index = (int)bytechar - 97;
                        answers[index] = 1;
                    }
                }
                for (int i = 0; i < answers.Length; i++)
                {
                    groupanswers=groupanswers + answers[i];
                }
                sumgroupanswers = sumgroupanswers + groupanswers;
            }
            return sumgroupanswers.ToString();
        }
        public static string Run2(string inputData, bool test = false)
        {
            inputData = inputData.Replace("\r", "");
            string[] groups = inputData.Split("\n\n", StringSplitOptions.RemoveEmptyEntries);
            int[] answers = new int[26];
            int sumgroupanswers = 0;
            foreach (string group in groups)
            {
                int groupanswers = 0;
                for (int i = 0; i < answers.Length; i++)
                {
                    answers[i] = 0;
                }
                string[] persons = group.Split("\n", StringSplitOptions.RemoveEmptyEntries);
                foreach (string person in persons)
                {
                    byte[] asciiBytes = Encoding.ASCII.GetBytes(person);
                    foreach (byte bytechar in asciiBytes)
                    {
                        int index = (int)bytechar - 97;
                        answers[index] = answers[index]+1;
                    }   
                }
                for (int i = 0; i < answers.Length; i++)
                {
                    if (answers[i]==persons.Length)
                    {
                        groupanswers = groupanswers + 1;
                    }
                }
                sumgroupanswers = sumgroupanswers + groupanswers;
            }
            return sumgroupanswers.ToString();
        }

const dataSet = `
abc

a
b
c

ab
ac

a
a
a
a

b`
const alts = ["a", "b", "c", "x", "y", "z"]

let result = 0
dataSet.split(/\n\n/).forEach((group) => alts.forEach((alt) => group.indexOf(alt) !== -1 && result++))

console.log(result)

part1$ <in sed 's/^$/@/' | tr '\n' ' ' | tr '@' '\n' | tr -d ' ' | awk '{ split("", c); split($0, a, ""); for (i in a) { c[a[i]] } r += length(c) } END { print r }'
part2$ <in sed 's/^$/@/' | tr '\n' ' ' | tr '@' '\n' | awk '{ split("", q); for (i = 1; i <= NF; i++) { split($i, a, ""); for (j in a) { if (++q[a[j]] == NF) { print } } } }' | wc -l