2018 day 12 done
This commit is contained in:
@@ -7,136 +7,177 @@ import (
|
||||
"strings"
|
||||
)
|
||||
|
||||
var row map[int]bool
|
||||
var transitions []*Transition
|
||||
const (
|
||||
MaxInt = int(^uint(0) >> 1)
|
||||
MinInt = -MaxInt - 1
|
||||
)
|
||||
|
||||
var lastState string
|
||||
var garden *Garden
|
||||
|
||||
func main() {
|
||||
inp := StdinToStringSlice()
|
||||
BuildRow(inp[0])
|
||||
garden = NewGarden(strings.Trim(inp[0], "intalsae: "), 0)
|
||||
for _, v := range inp[2:] {
|
||||
transitions = append(transitions, NewTransition(v))
|
||||
garden.transitions = append(garden.transitions, NewTransition(v))
|
||||
}
|
||||
fmt.Print("St: ")
|
||||
PrintState()
|
||||
for i := 0; i < 20; i++ {
|
||||
Tick()
|
||||
fmt.Printf("%2d: ", i)
|
||||
PrintState()
|
||||
generations := 50000000000
|
||||
var i int
|
||||
for i = 0; i < generations; i++ {
|
||||
lastState = garden.string()
|
||||
garden = garden.tick()
|
||||
if garden.string() == lastState {
|
||||
i++
|
||||
break
|
||||
}
|
||||
}
|
||||
fmt.Println("Total:", GetSum())
|
||||
garden.shiftPots(generations - i)
|
||||
fmt.Println(garden.sum())
|
||||
}
|
||||
|
||||
func Tick() {
|
||||
m := make(map[int]bool)
|
||||
lowest, highest := 0, 0
|
||||
for i := range row {
|
||||
if i < lowest {
|
||||
lowest = i
|
||||
}
|
||||
if i > highest {
|
||||
highest = i
|
||||
/**
|
||||
* A Garden
|
||||
*/
|
||||
type Garden struct {
|
||||
pots []*Pot
|
||||
transitions []*Transition
|
||||
}
|
||||
|
||||
func NewGarden(inp string, start int) *Garden {
|
||||
g := &Garden{}
|
||||
for k, v := range inp {
|
||||
p := &Pot{
|
||||
id: k + start,
|
||||
value: rb(v),
|
||||
}
|
||||
g.pots = append(g.pots, p)
|
||||
}
|
||||
for i := lowest - 2; i <= highest+2; i++ {
|
||||
m[i] = GetNextValue(i)
|
||||
}
|
||||
lowest, highest = 0, 0
|
||||
for k := range m {
|
||||
if k < lowest && m[k] {
|
||||
lowest = k
|
||||
}
|
||||
if k > highest && m[k] {
|
||||
highest = k
|
||||
}
|
||||
}
|
||||
row = make(map[int]bool)
|
||||
for i := lowest; i <= highest; i++ {
|
||||
row[i] = m[i]
|
||||
return g
|
||||
}
|
||||
|
||||
func (g *Garden) shiftPots(val int) {
|
||||
for i := range g.pots {
|
||||
g.pots[i].id = g.pots[i].id + val
|
||||
}
|
||||
}
|
||||
|
||||
func GetSum() int {
|
||||
var ret int
|
||||
lowest, highest := 0, 0
|
||||
for i := range row {
|
||||
if i < lowest {
|
||||
lowest = i
|
||||
}
|
||||
if i > highest {
|
||||
highest = i
|
||||
}
|
||||
}
|
||||
for i := lowest; i <= highest; i++ {
|
||||
if row[i] {
|
||||
ret += i
|
||||
func (g *Garden) sum() int64 {
|
||||
var ret int64
|
||||
st, ed := g.getStartIndex(), g.getEndIndex()
|
||||
for i := st; i <= ed; i++ {
|
||||
if g.getPot(i).value {
|
||||
ret += int64(i)
|
||||
}
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func BuildRow(inp string) {
|
||||
inp = strings.Split(inp, ": ")[1]
|
||||
row = make(map[int]bool)
|
||||
for i, v := range inp {
|
||||
row[i] = rb(v)
|
||||
func (g *Garden) tick() *Garden {
|
||||
earliest, latest := g.getStartIndex(), g.getEndIndex()
|
||||
st := earliest - 2
|
||||
ed := latest + 2
|
||||
ret := &Garden{
|
||||
transitions: g.transitions,
|
||||
}
|
||||
for i := st; i <= ed; i++ {
|
||||
next := g.getNextStateForPot(i)
|
||||
if next {
|
||||
ret.pots = append(ret.pots, &Pot{
|
||||
id: i,
|
||||
value: next,
|
||||
})
|
||||
}
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func GetIdxValue(idx int) byte {
|
||||
func (g *Garden) getNextStateForPot(id int) bool {
|
||||
var ret byte
|
||||
for i := idx + 2; i >= idx-2; i-- {
|
||||
for i := id - 2; i <= id+2; i++ {
|
||||
ret = ret << 1
|
||||
if row[i] {
|
||||
if g.getPot(i).value {
|
||||
ret = ret | 1
|
||||
}
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func GetNextValue(idx int) bool {
|
||||
idxVal := GetIdxValue(idx)
|
||||
for _, v := range transitions {
|
||||
if v.GetValue() == idxVal {
|
||||
for _, v := range g.transitions {
|
||||
if v.GetValue() == ret {
|
||||
return v.next
|
||||
}
|
||||
}
|
||||
return false
|
||||
return false //g.getPot(id).value
|
||||
}
|
||||
|
||||
func GetValueString(b byte) string {
|
||||
func (g *Garden) substring(st, ed int) string {
|
||||
var ret string
|
||||
for i := 0; i < 5; i++ {
|
||||
if (b & 1) == 1 {
|
||||
ret = ret + "#"
|
||||
} else {
|
||||
ret = ret + "."
|
||||
}
|
||||
b = b >> 1
|
||||
for i := st; i <= ed; i++ {
|
||||
ret += g.getPot(i).string()
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func PrintState() {
|
||||
lowest, highest := -2, 30
|
||||
for i := range row {
|
||||
if i < lowest {
|
||||
lowest = i
|
||||
}
|
||||
if i > highest {
|
||||
highest = i
|
||||
}
|
||||
func (g *Garden) string() string {
|
||||
var ret string
|
||||
for i := g.getStartIndex(); i <= g.getEndIndex(); i++ {
|
||||
ret += g.getPot(i).string()
|
||||
}
|
||||
fmt.Print("(", lowest, ") ")
|
||||
for i := lowest; i <= highest; i++ {
|
||||
if row[i] {
|
||||
fmt.Print("#")
|
||||
} else {
|
||||
fmt.Print(".")
|
||||
}
|
||||
}
|
||||
fmt.Println(" (", highest, ") ")
|
||||
return ret
|
||||
}
|
||||
|
||||
func (g *Garden) transitionStrings() string {
|
||||
var ret string
|
||||
for _, v := range g.transitions {
|
||||
ret = ret + v.string() + "\n"
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func (g *Garden) getStartIndex() int {
|
||||
min := MaxInt
|
||||
for _, v := range g.pots {
|
||||
if v.id < min {
|
||||
min = v.id
|
||||
}
|
||||
}
|
||||
return min
|
||||
}
|
||||
|
||||
func (g *Garden) getEndIndex() int {
|
||||
max := MinInt
|
||||
for _, v := range g.pots {
|
||||
if v.id > max {
|
||||
max = v.id
|
||||
}
|
||||
}
|
||||
return max
|
||||
}
|
||||
|
||||
func (g *Garden) getPot(idx int) *Pot {
|
||||
for _, v := range g.pots {
|
||||
if v.id == idx {
|
||||
return v
|
||||
}
|
||||
}
|
||||
return &Pot{
|
||||
id: idx,
|
||||
value: false,
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* A Pot
|
||||
*/
|
||||
type Pot struct {
|
||||
id int
|
||||
value bool
|
||||
}
|
||||
|
||||
func (p *Pot) string() string {
|
||||
return bs(p.value)
|
||||
}
|
||||
|
||||
/**
|
||||
* Transitions
|
||||
*/
|
||||
type Transition struct {
|
||||
state []bool
|
||||
next bool
|
||||
@@ -146,9 +187,12 @@ func NewTransition(inp string) *Transition {
|
||||
var state []bool
|
||||
var next bool
|
||||
pts := strings.Split(inp, " => ")
|
||||
for i := len(pts[0]) - 1; i >= 0; i-- {
|
||||
for i := range pts[0] {
|
||||
state = append(state, bb(pts[0][i]))
|
||||
}
|
||||
//for i := len(pts[0]) - 1; i >= 0; i-- {
|
||||
// state = append(state, bb(pts[0][i]))
|
||||
//}
|
||||
next = bb(pts[1][0])
|
||||
t := &Transition{
|
||||
state: state,
|
||||
@@ -157,6 +201,14 @@ func NewTransition(inp string) *Transition {
|
||||
return t
|
||||
}
|
||||
|
||||
func (t *Transition) string() string {
|
||||
var ret string
|
||||
for _, v := range t.state {
|
||||
ret += bs(v)
|
||||
}
|
||||
return ret + " => " + bs(t.next)
|
||||
}
|
||||
|
||||
func (t *Transition) GetValue() byte {
|
||||
var ret byte
|
||||
for _, v := range t.state {
|
||||
@@ -168,6 +220,43 @@ func (t *Transition) GetValue() byte {
|
||||
return ret
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper Functions
|
||||
*/
|
||||
|
||||
// Take a byte and return a string representation of the bits
|
||||
func byteToString(b byte) string {
|
||||
var ret string
|
||||
for i := 0; i < 8; i++ {
|
||||
if b&1 == 1 {
|
||||
ret += "#"
|
||||
} else {
|
||||
ret += "."
|
||||
}
|
||||
b = b >> 1
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
// Take a string representation of a bits and return the byte
|
||||
func stringToByte(n string) byte {
|
||||
var b byte
|
||||
for i := range n {
|
||||
if n[i] == '#' {
|
||||
b = b | 1
|
||||
}
|
||||
b = b << 1
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
func bs(b bool) string {
|
||||
if b {
|
||||
return "#"
|
||||
}
|
||||
return "."
|
||||
}
|
||||
|
||||
func rb(r rune) bool {
|
||||
return bb(byte(r))
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user