brian/adventofcode
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

I've gotta stop for now.

Browse Source
This commit is contained in:
Brian Buller
2017-12-22 12:45:49 -06:00
parent 3d7ac83d3f
commit d16cc22158
7 changed files with 931 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

213
2017/day22/day22.go Normal file
View File

@@ -0,0 +1,213 @@
package main
import (
"bufio"
"fmt"
"log"
"os"
"strconv"
"strings"
)
const (
N = iota
E
S
W
)
const (
ST_CLEAN = iota
ST_WEAK
ST_INFECTED
ST_FLAGGED
ST_ERROR
)
var nodes map[string]int
var cX, cY, cD int
var minX, minY, maxX, maxY int
var tickCount, infectCount int
func main() {
inp := StdinToStrings()
nodes = make(map[string]int)
cX, cY, cD = len(inp)/2, len(inp[0])/2, N
for y := 0; y < len(inp); y++ {
for x := 0; x < len(inp[y]); x++ {
nodes[cs(x, y)] = ST_CLEAN
if inp[y][x] == '#' {
nodes[cs(x, y)] = ST_INFECTED
}
updateMinMax(x, y)
}
}
for i := 0; i < 10000000; i++ {
//ClearScreen()
if part1 {
p1Tick()
} else {
p2Tick()
}
//PrettyPrint()
//PrintStatus()
//time.Sleep(time.Second / 5)
}
}
func p1Tick() {
tickCount++
switch nodes[cs(cX, cY)] {
case ST_INFECTED:
TurnRight()
nodes[cs(cX, cY)] = ST_CLEAN
infectCount++
default:
TurnLeft()
nodes[cs(cX, cY)] = ST_INFECTED
infectCount++
}
cX, cY = getXYInDir()
updateMinMax(cX, cY)
}
func p2Tick() {
tickCount++
switch nodes[cs(cX, cY)] {
case ST_CLEAN:
TurnLeft()
nodes[cs(cX, cY)] = ST_WEAK
case ST_WEAK:
nodes[cs(cX, cY)] = ST_INFECTED
infectCount++
case ST_INFECTED:
TurnRight()
nodes[cs(cX, cY)] = ST_FLAGGED
case ST_FLAGGED:
TurnRight()
TurnRight()
nodes[cs(cX, cY)] = ST_CLEAN
}
cX, cY = getXYInDir()
updateMinMax(cX, cY)
}
func updateMinMax(x, y int) {
if x < minX {
minX = x
}
if x > maxX {
maxX = x
}
if y < minY {
minY = y
}
if y > maxY {
maxY = y
}
}
func PrettyPrint() {
for kY := minY; kY <= maxY; kY++ {
for kX := minX; kX <= maxX; kX++ {
if kX == cX && kY == cY {
fmt.Print("[")
} else {
fmt.Print(" ")
}
switch nodes[cs(kX, kY)] {
case ST_CLEAN:
fmt.Print(".")
case ST_WEAK:
fmt.Print("W")
case ST_INFECTED:
fmt.Print("#")
case ST_FLAGGED:
fmt.Print("F")
}
if kX == cX && kY == cY {
fmt.Print("]")
} else {
fmt.Print(" ")
}
}
fmt.Println()
}
}
func PrintStatus() {
fmt.Println("Ticks:", tickCount)
fmt.Println("Infections:", infectCount)
}
func TurnRight() {
switch cD {
case N:
cD = E
case E:
cD = S
case S:
cD = W
case W:
cD = N
}
}
func TurnLeft() {
switch cD {
case N:
cD = W
case E:
cD = N
case S:
cD = E
case W:
cD = S
}
}
func getXYInDir() (int, int) {
switch cD {
case N:
return cX, cY - 1
case E:
return cX + 1, cY
case S:
return cX, cY + 1
case W:
return cX - 1, cY
}
return cX, cY
}
func cs(x, y int) string {
return fmt.Sprintf("%d;%d", x, y)
}
func sc(key string) (int, int) {
pts := strings.Split(key, ";")
return Atoi(pts[0]), Atoi(pts[1])
}
func Atoi(i string) int {
var ret int
var err error
if ret, err = strconv.Atoi(i); err != nil {
log.Fatal("Invalid Atoi")
}
return ret
}
func ClearScreen() {
fmt.Println("\033[H\033[2J")
}
func StdinToStrings() []string {
var input []string
scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() {
input = append(input, scanner.Text())
}
return input
}

25
2017/day22/input Normal file
View File

@@ -0,0 +1,25 @@
###.#######...#####.#..##
.####...###.##...#..#....
.#.#...####.###..##..##.#
########.#.#...##.#.##.#.
..#.#...##..#.#.##..####.
..#.#.....#....#####..#..
#.#..##...#....#.##...###
.#.##########...#......#.
.#...#..##...#...###.#...
......#.###.#..#...#.####
.#.###.##...###.###.###.#
.##..##...#.#.#####.#...#
#...#..###....#.##.......
####.....######.#.##..#..
..#...#..##.####.#####.##
#...#.#.#.#.#...##..##.#.
#####.#...#.#.#.#.##.####
....###...#.##.#.##.####.
.#....###.#####...#.....#
#.....#....#####.#..#....
.#####.#....#..##.#.#.###
####.#..#..##..#.#..#.###
.##.##.#.#.#.#.#..####.#.
#####..##.#.#..#..#...#..
#.#..#.###...##....###.##

263
2017/day22/problem Normal file
View File

@@ -0,0 +1,263 @@
Advent of Code
--- Day 22: Sporifica Virus ---
Diagnostics indicate that the local grid computing cluster has been
contaminated with the Sporifica Virus. The grid computing cluster is a
seemingly-infinite two-dimensional grid of compute nodes. Each node is either
clean or infected by the virus.
To prevent overloading the nodes (which would render them useless to the
virus) or detection by system administrators, exactly one virus carrier moves
through the network, infecting or cleaning nodes as it moves. The virus
carrier is always located on a single node in the network (the current node)
and keeps track of the direction it is facing.
To avoid detection, the virus carrier works in bursts; in each burst, it
wakes up, does some work, and goes back to sleep. The following steps are all
executed in order one time each burst:
* If the current node is infected, it turns to its right. Otherwise, it
turns to its left. (Turning is done in-place; the current node does not
change.)
* If the current node is clean, it becomes infected. Otherwise, it becomes
cleaned. (This is done after the node is considered for the purposes of
changing direction.)
* The virus carrier moves forward one node in the direction it is facing.
Diagnostics have also provided a map of the node infection status (your
puzzle input). Clean nodes are shown as .; infected nodes are shown as #.
This map only shows the center of the grid; there are many more nodes beyond
those shown, but none of them are currently infected.
The virus carrier begins in the middle of the map facing up.
For example, suppose you are given a map like this:
..#
#..
...
Then, the middle of the infinite grid looks like this, with the virus
carrier's position marked with [ ]:
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . # . . .
. . . #[.]. . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
The virus carrier is on a clean node, so it turns left, infects the node, and
moves left:
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . # . . .
. . .[#]# . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
The virus carrier is on an infected node, so it turns right, cleans the node,
and moves up:
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . .[.]. # . . .
. . . . # . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
Four times in a row, the virus carrier finds a clean, infects it, turns left,
and moves forward, ending in the same place and still facing up:
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . #[#]. # . . .
. . # # # . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
Now on the same node as before, it sees an infection, which causes it to turn
right, clean the node, and move forward:
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . # .[.]# . . .
. . # # # . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
After the above actions, a total of 7 bursts of activity had taken place. Of
them, 5 bursts of activity caused an infection.
After a total of 70, the grid looks like this, with the virus carrier facing
up:
. . . . . # # . .
. . . . # . . # .
. . . # . . . . #
. . # . #[.]. . #
. . # . # . . # .
. . . . . # # . .
. . . . . . . . .
. . . . . . . . .
By this time, 41 bursts of activity caused an infection (though most of those
nodes have since been cleaned).
After a total of 10000 bursts of activity, 5587 bursts will have caused an
infection.
Given your actual map, after 10000 bursts of activity, how many bursts cause
a node to become infected? (Do not count nodes that begin infected.)
Your puzzle answer was _______.
The first half of this puzzle is complete! It provides one gold star: *
--- Part Two ---
As you go to remove the virus from the infected nodes, it evolves to resist
your attempt.
Now, before it infects a clean node, it will weaken it to disable your
defenses. If it encounters an infected node, it will instead flag the node to
be cleaned in the future. So:
* Clean nodes become weakened.
* Weakened nodes become infected.
* Infected nodes become flagged.
* Flagged nodes become clean.
Every node is always in exactly one of the above states.
The virus carrier still functions in a similar way, but now uses the
following logic during its bursts of action:
* Decide which way to turn based on the current node:
* If it is clean, it turns left.
* If it is weakened, it does not turn, and will continue moving in the
same direction.
* If it is infected, it turns right.
* If it is flagged, it reverses direction, and will go back the way it
came.
* Modify the state of the current node, as described above.
* The virus carrier moves forward one node in the direction it is facing.
Start with the same map (still using . for clean and # for infected) and
still with the virus carrier starting in the middle and facing up.
Using the same initial state as the previous example, and drawing weakened as
W and flagged as F, the middle of the infinite grid looks like this, with the
virus carrier's position again marked with [ ]:
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . # . . .
. . . #[.]. . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
This is the same as before, since no initial nodes are weakened or flagged.
The virus carrier is on a clean node, so it still turns left, instead weakens
the node, and moves left:
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . # . . .
. . .[#]W . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
The virus carrier is on an infected node, so it still turns right, instead
flags the node, and moves up:
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . .[.]. # . . .
. . . F W . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
This process repeats three more times, ending on the previously-flagged node
and facing right:
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . W W . # . . .
. . W[F]W . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
Finding a flagged node, it reverses direction and cleans the node:
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . W W . # . . .
. .[W]. W . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
The weakened node becomes infected, and it continues in the same direction:
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . W W . # . . .
.[.]# . W . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
Of the first 100 bursts, 26 will result in infection. Unfortunately, another
feature of this evolved virus is speed; of the first 10000000 bursts, 2511944
will result in infection.
Given your actual map, after 10000000 bursts of activity, how many bursts
cause a node to become infected? (Do not count nodes that begin infected.)
Although it hasn't changed, you can still get your puzzle input.
Answer: _____________________ [ [Submit] ]
References
Visible links
. http://adventofcode.com/
. http://adventofcode.com/2017/about
. http://adventofcode.com/2017/support
. http://adventofcode.com/2017/events
. http://adventofcode.com/2017/settings
. http://adventofcode.com/2017/auth/logout
. http://adventofcode.com/2017
. http://adventofcode.com/2017
. http://adventofcode.com/2017/leaderboard
. http://adventofcode.com/2017/stats
. http://adventofcode.com/2017/sponsors
. http://adventofcode.com/2017/sponsors
. https://en.wikipedia.org/wiki/Morris_worm#The_mistake
. https://www.youtube.com/watch?v=2vj37yeQQHg
. http://adventofcode.com/2017/day/22/input

3
2017/day22/testinput Normal file
View File

@@ -0,0 +1,3 @@
..#
#..
...