diff --git a/2018/day05/day05.go b/2018/day05/day05.go
new file mode 100644
index 0000000..2e4b90d
--- /dev/null
+++ b/2018/day05/day05.go
@@ -0,0 +1,96 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"log"
+	"math"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func main() {
+	inp := StdinToString()
+	fmt.Println("= Part 1 =")
+	fmt.Println(part1(inp))
+	fmt.Println("\n= Part 2 =")
+	fmt.Println(part2(inp))
+}
+
+func part1(inp string) int {
+	last := inp
+	curr := react(last)
+	for last != curr {
+		last = curr
+		curr = react(last)
+	}
+	return len(curr)
+}
+
+// useShortest will skip runs where there are fewer letters in the input than the current shortest...
+// It reduced _my_ runtime by about 3 minutes, but may fail depending on your input
+var useShortest bool
+
+func part2(inp string) int {
+	// If yours fails, try setting this to false
+	useShortest = true
+	shortest := len(inp)
+	var shortestCount int
+	var count int
+	for i := 65; i <= 90; i++ {
+		var try string
+		if useShortest {
+			count = strings.Count(inp, string(i))
+			if count < shortestCount {
+				continue
+			}
+		}
+		for j := range inp {
+			if int(inp[j]) == i || int(inp[j]) == i+32 {
+				continue
+			}
+			try += string(inp[j])
+		}
+		v := part1(try)
+		if v < shortest {
+			shortest = v
+			shortestCount = count
+		}
+	}
+	return shortest
+}
+
+func react(v string) string {
+	var ret string
+	for i := 0; i < len(v); i++ {
+		if i < len(v)-1 && Abs(v[i], v[i+1]) == 32 {
+			i++
+			continue
+		}
+		ret += string(v[i])
+	}
+	return ret
+}
+
+func StdinToString() string {
+	var input string
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		input += scanner.Text()
+	}
+	return input
+}
+
+func Atoi(i string) int {
+	var ret int
+	var err error
+	if ret, err = strconv.Atoi(i); err != nil {
+		log.Fatal("Invalid Atoi")
+	}
+	return ret
+}
+
+func Abs(val1, val2 byte) int {
+	return int(math.Abs(float64(val1) - float64(val2)))
+}
diff --git a/2018/day05/go.mod b/2018/day05/go.mod
new file mode 100644
index 0000000..c2a6032
--- /dev/null
+++ b/2018/day05/go.mod
@@ -0,0 +1 @@
+module day05
diff --git a/2018/day05/input b/2018/day05/input
new file mode 100644
index 0000000..c14b02e
--- /dev/null
+++ b/2018/day05/input
@@ -0,0 +1 @@
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
diff --git a/2018/day05/testinput b/2018/day05/testinput
new file mode 100644
index 0000000..8637b35
--- /dev/null
+++ b/2018/day05/testinput
@@ -0,0 +1 @@
+dabAcCaCBAcCcaDA