97 lines
2.2 KiB
Go
97 lines
2.2 KiB
Go
package main
|
|
|
|
import (
|
|
"os"
|
|
"io/ioutil"
|
|
"strings"
|
|
"strconv"
|
|
"math"
|
|
"fmt"
|
|
"sort"
|
|
)
|
|
type movedCar struct {
|
|
id byte
|
|
steps int
|
|
direction int
|
|
}
|
|
|
|
var querAutos []byte
|
|
|
|
func main() {
|
|
for _, filepath := range os.Args[1:] {
|
|
fmt.Printf("%s: \n", filepath)
|
|
rawFile, err := ioutil.ReadFile(filepath)
|
|
throw(err)
|
|
input := string(rawFile)
|
|
firstChar := input[0]
|
|
querAutos = make([]byte, input[2] - firstChar + 1)
|
|
for _, line := range strings.Split(input, "\n")[2:] {
|
|
if len(line) == 0 {
|
|
continue
|
|
}
|
|
i, err := strconv.Atoi(line[2:])
|
|
throw(err)
|
|
querAutos[i], querAutos[i + 1] = line[0], line[0]
|
|
}
|
|
for i := range querAutos {
|
|
var currentMoves []movedCar
|
|
var carLeastSteps uint32 = math.MaxUint32
|
|
for _, direction := range []int{-1, 1} {
|
|
movedCars, steps, success := move(i, direction, []movedCar{}, 0, 0)
|
|
if success && (currentMoves == nil || len(movedCars) < len(currentMoves) || len(movedCars) == len(currentMoves) && steps < carLeastSteps) {
|
|
currentMoves = movedCars
|
|
carLeastSteps = steps
|
|
}
|
|
}
|
|
sort.Slice(currentMoves, func(i, j int) bool {
|
|
return currentMoves[i].id < currentMoves[j].id
|
|
})
|
|
fmt.Printf("%s: ", string(firstChar + byte(i)))
|
|
for j, car := range currentMoves {
|
|
if(j != 0) {
|
|
fmt.Print(", ")
|
|
}
|
|
fmt.Printf("%s %d ", string(car.id), car.steps)
|
|
if car.direction == 1 {
|
|
fmt.Print("rechts")
|
|
} else {
|
|
fmt.Print("links")
|
|
}
|
|
}
|
|
fmt.Println()
|
|
}
|
|
}
|
|
}
|
|
|
|
func throw(err error) {
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
func move(i, direction int, movedCars []movedCar, lastMoved byte, totalSteps uint32) ([]movedCar, uint32, bool) {
|
|
querAuto := querAutos[i]
|
|
if querAuto == 0 || querAuto == lastMoved {
|
|
return movedCars, totalSteps, true
|
|
}
|
|
if outOfBounds(querAutos, i + direction) {
|
|
return movedCars, totalSteps, false
|
|
}
|
|
var steps int
|
|
if querAutos[i + direction] == querAuto {
|
|
steps = 1
|
|
} else {
|
|
steps = 2
|
|
}
|
|
endCar := i + direction * 2
|
|
if outOfBounds(querAutos, endCar) {
|
|
return movedCars, totalSteps, false
|
|
}
|
|
movedCars = append(movedCars, movedCar{querAuto, steps, direction})
|
|
return move(endCar, direction, movedCars, querAuto, totalSteps + uint32(steps))
|
|
}
|
|
|
|
func outOfBounds(slice []byte, i int) bool {
|
|
return i < 0 || i >= len(slice)
|
|
}
|