day5.go

package day5

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strconv"
	"strings"
)

type Rearangement struct {
	n    int
	from int
	to   int
}

var State []Stack

// Cannot be arsed t parse this from the input today
const Stacks = 9

var InitialState [Stacks][]byte = [9][]byte{
	{'D', 'L', 'V', 'T', 'M', 'H', 'F'},
	{'H', 'Q', 'G', 'J', 'C', 'T', 'N', 'P'},
	{'R', 'S', 'D', 'M', 'P', 'H'},
	{'L', 'B', 'V', 'F'},
	{'N', 'H', 'G', 'L', 'O'},
	{'W', 'B', 'D', 'G', 'R', 'M', 'P'},
	{'G', 'M', 'N', 'R', 'C', 'H', 'L', 'Q'},
	{'C', 'L', 'W'},
	{'R', 'D', 'L', 'Q', 'J', 'Z', 'M', 'T'},
}

func Run() {
	initialState := getInitialState()

	procedures := getRearangementProceduresFromInput("./day5/5.txt")
	normal := executeRearrangements(procedures, initialState, false)
	reverse := executeRearrangements(procedures, initialState, true)

	fmt.Println("Top crates CrateMover 9000: ", string(getTopCratesFromState(normal)))
	fmt.Println("Top crates CrateMover 9001: ", string(getTopCratesFromState(reverse)))
}

func getInitialState() [Stacks]Stack {
	var state [Stacks]Stack
	for i, stack := range InitialState {
		var crateStack Stack
		for _, crate := range stack {
			crateStack.Push(crate)
		}
		state[i] = crateStack
	}
	return state
}

func getRearangementProceduresFromInput(path string) []Rearangement {
	content, err := os.Open(path)
	if err != nil {
		log.Fatal("Cannot read input: ", err)
	}
	scanner := bufio.NewScanner(content)
	scanner.Split(bufio.ScanLines)

	var rearangements []Rearangement
	for scanner.Scan() {
		line := scanner.Text()

		// Simply split by spaces. Format will be:
		//
		// 0 "move"
		// 1 n
		// 2 "from"
		// 3 from
		// 4 "to"
		// 5 to
		parts := strings.Split(line, " ")
		n, _ := strconv.Atoi(parts[1])
		from, _ := strconv.Atoi(parts[3])
		to, _ := strconv.Atoi(parts[5])

		rearangements = append(rearangements, Rearangement{
			n:    n,
			from: from,
			to:   to,
		})
	}

	return rearangements
}

func executeRearrangements(rearrangements []Rearangement, state [Stacks]Stack, reverse bool) [Stacks]Stack {
	for _, r := range rearrangements {
		state = executeRearrangement(&r, state, reverse)
	}
	return state
}

func executeRearrangement(r *Rearangement, state [Stacks]Stack, reverse bool) [Stacks]Stack {
	var cratesToMove []byte
	for i := 0; i < r.n; i++ {
		crate := state[r.from-1].Pop()
		cratesToMove = append(cratesToMove, crate)
		// State[r.to-1].Push(crate)
	}

	if reverse {
		for i, j := 0, len(cratesToMove)-1; i < j; i, j = i+1, j-1 {
			cratesToMove[i], cratesToMove[j] = cratesToMove[j], cratesToMove[i]
		}
	}

	for i := 0; i < len(cratesToMove); i++ {
		state[r.to-1].Push(cratesToMove[i])
	}

	return state
}

func getTopCratesFromState(state [Stacks]Stack) []byte {
	var crates []byte
	for _, stack := range state {
		crates = append(crates, stack.Pop())
	}
	return crates
}