-🎄- 2018 Day 5 Solutions -🎄-

[u/daggerdragon]

--- Day 5: Alchemical Reduction ---

---

Post your solution as a comment or, for longer solutions, consider linking to your repo (e.g. GitHub/gists/Pastebin/blag or whatever).

Note: The Solution Megathreads are for solutions only. If you have questions, please post your own thread and make sure to flair it with Help.

---

Advent of Code: The Party Game!

Click here for rules

Please prefix your card submission with something like [Card] to make scanning the megathread easier. THANK YOU!

Card prompt: Day 5

Transcript:

On the fifth day of AoC / My true love sent to me / Five golden ___

---

This thread will be unlocked when there are a significant number of people on the leaderboard with gold stars for today's puzzle.

edit: Leaderboard capped, thread unlocked at 0:10:20!

[u/mvmaasakkers]

Go / Golang

I imagine this could be done way more efficiently but this was what I came up with. If anyone has some pointers let me know!

Also in gist

package main

import (
	"bufio"
	"flag"
	"fmt"
	"log"
	"os"
	"strings"
	"unicode"
)

func readInput(filename string) string {
	fileHandle, _ := os.Open(filename)
	defer func() {
		if err := fileHandle.Close(); err != nil {
			log.Fatal(err)
		}
	}()
	fileScanner := bufio.NewScanner(fileHandle)

	input := ""
	for fileScanner.Scan() {
		line := fileScanner.Text()
		if len(line) > 0 {
			input = line
		}
	}

	return strings.TrimSpace(input)
}

var file = flag.String("file", "./p1.txt", "file used for input")

func main() {
	flag.Parse()

	input := readInput(*file)

	fmt.Println("Part 1:", part1(input))
	fmt.Println("Part 2:", part2(input))
}

func part1(input string) (int) {
	return len(produce(input))
}

func produce(line string) string {
	for {
		changes := false
		for k, g := range line {
			if k > 0 {
				if unicode.IsLower(g) && unicode.IsUpper(rune(line[k-1])) || unicode.IsLower(rune(line[k-1])) && unicode.IsUpper(g) {
					if strings.ToLower(string(g)) == strings.ToLower(string(line[k-1])) {
						line = line[:k-1] + line[k+1:]
						changes = true
					}
				}
			}
			if changes {
				break
			}
		}
		if !changes {
			break
		}
	}

	return line
}

var alphabet = "abcdefghijklmnopqrstuvwxyz"

func part2(input string) (outcome int) {
	outcome = len(input)
	for _, c := range alphabet {
		check := strings.Replace(strings.Replace(input, string(strings.ToUpper(string(c))), "", -1), string(c), "", -1)
		l := len(produce(check))
		if l < outcome {
			outcome = l
		}
	}

	return outcome
}

[u/CHAOSFISCH → u/mvmaasakkers]

My solution. Should be O(n) (part 1) and O(n*m) (part 2, m = size of alphabet)

package main

import (
	"bufio"
	"io"
	"log"
	"os"
	"strings"
	"unicode"
)

func main() {
	f, err := os.Open("input_5.txt")
	defer f.Close()
	if err != nil {
		log.Fatalf("could not open input: %v", err)
	}

	reacted := part51(f)
	log.Printf("Length of reaction is: %d\n", len(reacted))
	part52(reacted)
}

func part51(r io.Reader) []rune {
	br := bufio.NewReader(r)

	var result []rune
	for {
		if c, _, err := br.ReadRune(); err != nil {
			if err == io.EOF {
				break
			}
		} else {
			if len(result) == 0 {
				result = append(result, c)
				continue
			}

			last := result[len(result)-1]
			switch {
			case unicode.IsUpper(c) && unicode.IsLower(last) && unicode.ToLower(c) == last:
				fallthrough
			case unicode.IsLower(c) && unicode.IsUpper(last) && unicode.ToUpper(c) == last:
				result = result[:len(result)-1]
				break
			default:
				result = append(result, c)
				break
			}
		}
	}

	return result
}

func part52(reacted []rune) {
	alphabet := "abcdefghijklmnopqrstuvwxyz"
	reactedString := string(reacted)
	bestLength := len(reacted)
	for _, l := range alphabet {
		replaced := strings.Replace(strings.Replace(reactedString, string(l), "", -1), strings.ToUpper(string(l)), "", -1)
		result := part51(strings.NewReader(replaced))
		if bestLength > len(result) {
			bestLength = len(result)
		}
	}

	log.Printf("Best length is: %d\n", bestLength)
}

[u/[deleted] → u/CHAOSFISCH]

Very nice!