-
Notifications
You must be signed in to change notification settings - Fork 0
/
day05.go
97 lines (83 loc) · 2.47 KB
/
day05.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package day05 solves AoC 2022 day 5.
package day05
import (
"fmt"
"slices"
"github.com/fis/aoc/glue"
"github.com/fis/aoc/util"
"github.com/fis/aoc/util/fn"
)
func init() {
glue.RegisterSolver(2022, 5, glue.LineSolver(solve))
}
func solve(lines []string) ([]string, error) {
stacks, moves := parseInput(lines)
stacks1 := applyMoves(stacks, moves, move.apply9000)
stacks2 := applyMoves(stacks, moves, move.apply9001)
p1 := tops(stacks1)
p2 := tops(stacks2)
return []string{p1, p2}, nil
}
func applyMoves(stacks [][]byte, moves []move, f func(move, [][]byte)) [][]byte {
stacks = fn.Map(stacks, slices.Clone[[]byte])
for _, m := range moves {
f(m, stacks)
}
return stacks
}
func tops(stacks [][]byte) string {
return string(fn.Map(stacks, func(s []byte) byte { return s[len(s)-1] }))
}
type move struct {
count, from, to int
}
func (m move) apply9000(stacks [][]byte) {
from, to := stacks[m.from], stacks[m.to]
for i := 0; i < m.count; i++ {
t := from[len(from)-1]
from = from[:len(from)-1]
to = append(to, t)
}
stacks[m.from], stacks[m.to] = from, to
}
func (m move) apply9001(stacks [][]byte) {
from, to := stacks[m.from], stacks[m.to]
fromTop, toTop := len(from), len(to)
to = append(to, make([]byte, m.count)...)
copy(to[toTop:], from[fromTop-m.count:])
from = from[:fromTop-m.count]
stacks[m.from], stacks[m.to] = from, to
}
func parseInput(lines []string) (stacks [][]byte, moves []move) {
split := slices.Index(lines, "")
stacks = make([][]byte, len(util.Words(lines[split-1])))
for i := split - 2; i >= 0; i-- {
line := lines[i]
for j, k := 1, 0; j < len(line); j, k = j+4, k+1 {
b := line[j]
if b != ' ' {
stacks[k] = append(stacks[k], line[j])
}
}
}
for _, line := range lines[split+1:] {
var m move
fmt.Sscanf(line, "move %d from %d to %d", &m.count, &m.from, &m.to)
m.from, m.to = m.from-1, m.to-1
moves = append(moves, m)
}
return stacks, moves
}