🌟 Advent of Code (AoC) 2020 🌟

        public static string Run1()
        {
            int _Day = 2;
            string[] inputData = InputData.GetInputArrString(_Day);
            bool foundSolution = true;
            int validCount = 0;
            foreach (string item in inputData)
            {
                string[] parts = item.Split(":");
                string[] rule = parts[0].Split(" ");
                string[] counts = rule[0].Split("-");
                int from = Helper.toInt(counts[0].Trim());
                int to = Helper.toInt(counts[1].Trim());
                string character = rule[1].Trim();
                string pwd = parts[1].Trim();
                int count = pwd.Length - pwd.Replace(character, "").Length;
                if (count>=from && count<=to)
                {
                    validCount++;
                }
            }
            if (foundSolution)
            {
                return validCount.ToString();
            }
            return "FAIL";
        }
        public static string Run2()
        {
            int _Day = 2;
            string[] inputData = InputData.GetInputArrString(_Day);
            bool foundSolution = true;
            int validCount = 0;
            int invalidCount = 0;
            foreach (string item in inputData)
            {
                string[] parts = item.Split(":");
                string[] rule = parts[0].Split(" ");
                string[] counts = rule[0].Split("-");
                int pos1 = Helper.toInt(counts[0].Trim());
                int pos2 = Helper.toInt(counts[1].Trim());
                string character = rule[1].Trim();
                string pwd = parts[1].Trim();
                bool pos1v = pwd.Substring(pos1 - 1, 1) == character;
                bool pos2v = pwd.Substring(pos2 - 1, 1) == character;

                if (pos1v ^ pos2v)
                {
                    validCount++;
                }
                else
                {
                    invalidCount++;
                }
            }
            if (foundSolution)
            {
                return validCount.ToString();
            }
            return "FAIL";
        }

from collections import Counter
from numpy import sum
from re import match

      # 5) Sum up all the pairs
          # 4) Build a list with a pair of true/false for both conditions
print(sum([(lo <= c and c <= hi, (s[lo] == l) + (s[hi] == l) == 1)
           # Compute lo and hi limit, the letter, occureances of the letter, and padded string
           for lo,hi,l,c,s in [(int(m[1]), int(m[2]), m[3], Counter(m[4])[m[3]], ' ' + m[4])
                         # Extract different parts of the line
                         for m in [re.match(r'(\d+)-(\d+) (\w): (\w+)', l)
                                   # 1) For all lines in input
                                   for l in open("input")]]], axis=0))

static async Task Main(string[] args)
{
  var lines = await File.ReadAllLinesAsync("input.txt");
  Part1(lines);
  Part2(lines);
}
static void Part1(string[] lines)
{
  Console.WriteLine("--- Part #1 ---");
  var valid = 0;
  foreach (var line in lines)
  {
    var parts = line.Split(' ');
    var minmax = parts[0].Split('-').Select(int.Parse).ToArray();
    var character = parts[1].Trim(':').Single();
    var password = parts[2];
    var matches = password.Count(x => x == character);
    if (matches >= minmax[0] && matches <= minmax[1])
    {
      valid++;
    }
  }
  Console.WriteLine(valid);
}
static void Part2(string[] lines)
{
  Console.WriteLine("--- Part #2 ---");
  var valid = 0;
  foreach (var line in lines)
  {
    var parts = line.Split(' ');
    var positions = parts[0].Split('-').Select(int.Parse).ToArray();
    var character = parts[1].Trim(':').Single();
    var password = parts[2];
    if (password[positions[0] - 1] == character && password[positions[1] - 1] != character ||
        password[positions[0] - 1] != character && password[positions[1] - 1] == character)
    {
      valid++;
    }
  }
  Console.WriteLine(valid);
}

open System.IO

let day1_1 list target =
                    let listSet = Set.ofList list 
                    let factor = list |> List.where(fun i -> listSet.Contains(target-i)) |> List.head
                    (factor * (target-factor))
 
let rec combine n list = //Copied from https://stackoverflow.com/a/1231711
    match n, list with
    | 0, _ -> [[]]
    | _, [] -> []
    | k, (x::xs) -> List.map ((@) [x]) (combine (k-1) xs) @ combine k xs

let day1_2 input target =
                        let factors = combine 3 input |> List.where (fun x -> x|> List.sum = target) |> List.head
                        factors |> List.fold (fun x y-> x * y) 1

[<EntryPoint>]
let main argv =
    let input = File.ReadAllLines "input.txt" |> List.ofArray |> List.map (fun x-> x |> int)
    printfn "%i %i" (day1_1 input 2020) (day1_2 input 2020)
    0 // return an integer exit code

open System.IO

type PasswordRule = { Letter:char; minOccurs:int; maxOccurs:int }
type PasswordRow = PasswordRule * string

let parseRow (row:string):PasswordRow =
                   let parseRule (rule:string)  =
                       let parts = rule.Split ' '
                       let char = parts.[1].[0]
                       let occurs = (parts.[0]).Split '-'
                       let min = occurs.[0] |> int
                       let max = occurs.[1] |> int
                       {Letter=char; minOccurs=min; maxOccurs=max}
                   let parts = row.Split ':'
                   let rule = parseRule parts.[0]
                   let password = (parts.[1])
                   (rule,password)

let verifyRow ((rule,password):PasswordRow):bool =
     let {minOccurs = min; maxOccurs = max; Letter=char;} = rule;
     let chars = password.ToCharArray() |> List.ofSeq |> List.filter (fun c -> c = char) |> List.length
     chars >= min && chars <= max

let verifyRow_2 ((rule,password):PasswordRow):bool =
     let {minOccurs = min; maxOccurs = max; Letter=char;} = rule;
     (password.[min] = char || password.[max] = char) && (password.[min] <> password.[max])
     
[<EntryPoint>]
let main argv =
    let input = File.ReadLines "input.txt"
    let calculateValidPasswords verifier =  (input |> List.ofSeq |> List.map (fun l -> l |> parseRow |> verifier) |> List.filter id |> List.length)
    printfn "Part 1: %i" (calculateValidPasswords verifyRow)
    printfn "Part 2: %i" (calculateValidPasswords verifyRow_2)
    0 // return an integer exit code

$exps = Get-Content 'input.txt';
$size = $exps.Count;

for ($i = 0; $i -lt $size; $i++) {
    for ($j = $i; $j -lt $size; $j++) {
        if ([int]$exps[$i] + [int]$exps[$j] -eq 2020) {
            $ans = [int]$exps[$i] * [int]$exps[$j];
        }
    }
}

Write-Host "Day1-1: $ans";
$ans = 0;

for ($i = 0; $i -lt $size; $i++) {
    if ($ans -ne 0) {break;}
    for ($j = $i; $j -lt $size; $j++) {
        for ($k = $j; $k -lt $size; $k++) {
            if ([int]$exps[$i] + [int]$exps[$j] + [int]$exps[$k] -eq 2020) {
                $ans = [int]$exps[$i] * [int]$exps[$j] * [int]$exps[$k];
                break;
            }
        }
    }
}

Write-Host "Day1-2: $ans";

$pswds = Get-Content 'input.txt';
$valid = 0;

foreach ($pswd in $pswds) {
    $parts = $pswd.Split(" ");
    $limits = $parts[0].Split("-");

    $group = $parts[2].ToCharArray() | Group-Object -AsHashTable -AsString

    $charCount = $group[$parts[1].TrimEnd(":")].Count;

    if ($charCount -ge $limits[0] -and $charCount -le $limits[1] ) {
       $valid++;
    }
}

Write-Host "Day2-1 valid passwords: $valid";
$valid = 0;

foreach ($pswd in $pswds) {
    $parts = $pswd.Split(" ");
    $positions = $parts[0].Split("-");
    $pos1 = $positions[0];
    $pos2 = $positions[1];
    $key = $parts[1].TrimEnd(":");
    $password = $parts[2].ToCharArray()

    if ($password[$pos1 - 1] -eq $key -XOR $password[$pos2 - 1] -eq $key) {
        $valid++;
    }
}

Write-Host "Day2-2 valid passwords: $valid";

        static void Main()
        {
            StreamReader reader = new StreamReader("C:\\Users\\willh\\AoC2020Input\\2.txt");

            List<string> input = new List<string>();

            string line;
            while ((line = reader.ReadLine()) != null)
            {
                input.Add(line);
            }

            Console.WriteLine("First solution");
            SolutionOne(input);
            Console.WriteLine("Second solution");
            SolutionTwo(input);

            Console.ReadKey();
        }

        static void SolutionOne(List<string> input)
        {
            int count = 0;

            foreach (string item in input)
            {
                string[] candidate = item.Split(' ');

                int min = Int32.Parse(candidate[0].Split('-')[0]);
                int max = Int32.Parse(candidate[0].Split('-')[1]);
                char letter = char.Parse(candidate[1].Substring(0, 1));
                int amount = candidate[2].Split(letter).Length - 1;

                if (amount >= min && amount <= max)
                {
                    count += 1;
                }
            }

            Console.WriteLine(count);
        }

        static void SolutionTwo(List<string> input)
        {
            int count = 0;

            foreach (string item in input)
            {
                string[] candidate = item.Split(' ');

                int first = Int32.Parse(candidate[0].Split('-')[0]) - 1;
                int second = Int32.Parse(candidate[0].Split('-')[1]) - 1;
                char letter = char.Parse(candidate[1].Substring(0, 1));
                char letterInPosOne;
                char letterInPosTwo;

                try
                {
                    letterInPosOne = char.Parse(candidate[2].Substring(first, 1));
                }
                catch (Exception)
                {

                    letterInPosOne = '-';
                }

                try
                {
                    letterInPosTwo = char.Parse(candidate[2].Substring(second, 1));
                }
                catch (Exception)
                {

                    letterInPosTwo = '-';
                }


                if (letterInPosOne == letter ^ letterInPosTwo == letter)
                {
                    count += 1;
                }
            }

            Console.WriteLine(count);
        }

package main

import (
	"bufio"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"strconv"
	"strings"
)

func check(e error) {
	if e != nil {
		panic(e)
	}
}

func main() {
	dat, err := ioutil.ReadFile("filename")
	check(err)
	fmt.Print(string(dat))

	counter, err := readLines("filename")
	if err != nil {
		log.Fatalf("readlines: %s", err)
	}

	fmt.Printf("This is fulfilled %d number of times", counter)

}

func readLines(path string) (int, error) {
	file, err := os.Open(path)
	if err != nil {
		return 0, err
	}
	defer file.Close()

	var counter int
	var booleancounter bool
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		lineStr := scanner.Text()
		booleancounter = intoParts(lineStr)
		if booleancounter {
			counter++
			booleancounter = false
		}

	}

	return counter, scanner.Err()
}

func intoParts(password string) bool {
	var limits []int
	possiblevalues := strings.Split(password, ": ")
	firststring := strings.Split(possiblevalues[0], " ")
	pass := possiblevalues[1]
	letter := firststring[1]
	stringlimits := strings.Split(firststring[0], "-")
	tempstuff, _ := strconv.Atoi(stringlimits[0])
	tempstuff2, _ := strconv.Atoi(stringlimits[1])
	limits = append(limits, tempstuff)
	limits = append(limits, tempstuff2)

	return passwordVerificationPart2(limits, pass, letter) // change to Part1 for part1
}

func passwordVerificationPart1(limits []int, password string, letter string) bool {
	res := strings.Count(password, letter)
	fulfillsRequirement := false
	if res >= limits[0] {
		if res <= limits[1] {
			fulfillsRequirement = true
		}
	}
	return fulfillsRequirement
}

func passwordVerificationPart2(position []int, password string, letter string) bool {
	fulfillsRequirement := false
	pos1 := position[0] - 1
	pos2 := position[1] - 1
	count := 0
	if string(password[pos1]) == letter {
		count++
	}
	if string(password[pos2]) == letter {
		count++
	}
	if count == 1 {
		fulfillsRequirement = true
	}
	return fulfillsRequirement
}

func main() { // day 2
		f, err := os.Open("files\\day2")

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

		defer f.Close()

		scanner := bufio.NewScanner(f)

		var a []string

		for scanner.Scan() {
			a = append(a, scanner.Text())
		}

		if err := scanner.Err(); err != nil {
			log.Fatal(err)
		}
		
		var pattern = `^(\d+)-(\d+)\s(\w)$`
		var compiledRegex = regexp.MustCompile(pattern)
		var matchedCount = 0
		var indexOccuredCount = 0

		for _, v := range a {
			var split = strings.Split(v, ":")
			var submatches = compiledRegex.FindAllStringSubmatch(split[0], -1)
			var min, _ = strconv.Atoi(submatches[0][1])
			var max, _ = strconv.Atoi(submatches[0][2])
			var charMatch = submatches[0][3]
			var rightsideRegexp = regexp.MustCompile(charMatch)

			amount := rightsideRegexp.FindAllStringSubmatch(split[1], -1)

			var indexOccurence = rightsideRegexp.FindAllStringSubmatchIndex(split[1], -1)

			minHit := false
			maxHit := false

			for _, v := range indexOccurence {
				if v[0] == min {
					minHit = true
				} else if v[0] == max {
					maxHit = true
				}
			}

			if minHit && !maxHit {
				indexOccuredCount++
			}

			if !minHit && maxHit {
				indexOccuredCount++
			}

			matched := len(amount) >= min && max >= len(amount)
			if matched {
				matchedCount++
			}

			fmt.Println("Leftside:", split[0], "Rightside:", split[1], "Min:", min, "Max:", max, "character To Match:", charMatch, "matched:", matched, "indexOccur:", indexOccurence)
		}

		fmt.Println("Matched Total: ", matchedCount, "Did not match: ", 1000 - matchedCount, "Index occurence Count: ", indexOccuredCount)
}

public class Main
    {
        public static string Run1()
        {
            int _Day = 3;
            int x = 0;
            int y = 0;
            int treecount = 0;
            string[] inputData = InputData.GetInputArrString(_Day);
            while (y<inputData.Length)
            {
                if (inputData[y].Substring(x,1)=="#")
                {
                    treecount++;
                }
                x = (x + 3) % (inputData[y].Length);
                y = y + 1;
            }
            return treecount.ToString();
        }
        public static string Run2()
        {
            int _Day = 3;
            string[] inputData = InputData.GetInputArrString(_Day);
            CoordSteps[] steps = new CoordSteps[] { new CoordSteps(1, 1), new CoordSteps(3, 1), new CoordSteps(5, 1), new CoordSteps(7, 1), new CoordSteps(1, 2) };
            int[] treeCounts = new int[] { 0, 0, 0, 0, 0 };
            int factor = 1;
            for (int i = 0; i < steps.Length; i++)
            {
                int x = 0;
                int y = 0;
                int treecount = 0;
                while (y < inputData.Length)
                {
                    if (inputData[y].Substring(x, 1) == "#")
                    {
                        treecount++;
                    }
                    x = (x + steps[i].x) % (inputData[y].Length);
                    y = y + steps[i].y;
                }
                factor = factor * treecount;
                treeCounts[i] = treecount;
            }
            return factor.ToString();
        }
    }

    public class CoordSteps
    {
        public int x;
        public int y;
        public CoordSteps(int _x, int _y)
        {
            x = _x;
            y = _y;
        }

from numpy import prod
slope = ["".join([line.strip()]*75) for line in open("input")]
print([prod([sum([slope[y][x * xs]  == '#' for x,y in enumerate(range(0, len(slope), ys))])
             for ys, xl in enumerate(l)
             for xs in xl])
       for l in [[[], [3]], [[], [1,3,5,7], [1]]]])