Merge pull request #6 from romellem/day-6

Day 6

Author: romellem

6/README.md

@@ -0,0 +1,99 @@
+# Answers
+
+| Part 1 | Part 2 |
+|--------|--------|
+|   4233 |  45290 |
+
+## --- Day 6: Chronal Coordinates ---
+
+The device on your wrist beeps several times, and once again you feel like you're falling.
+
+"Situation critical," the device announces. "Destination indeterminate. Chronal interference detected. Please specify new target coordinates."
+
+The device then produces a list of coordinates (your puzzle input). Are they places it thinks are safe or dangerous? It recommends you check manual page 729. The Elves did not give you a manual.
+
+_If they're dangerous,_ maybe you can minimize the danger by finding the coordinate that gives the largest distance from the other points.
+
+Using only the [Manhattan distance](https://en.wikipedia.org/wiki/Taxicab_geometry), determine the _area_ around each coordinate by counting the number of [integer](https://en.wikipedia.org/wiki/Integer) X,Y locations that are _closest_ to that coordinate (and aren't _tied in distance_ to any other coordinate).
+
+Your goal is to find the size of the _largest area_ that isn't infinite. For example, consider the following list of coordinates:
+
+    1, 1
+    1, 6
+    8, 3
+    3, 4
+    5, 5
+    8, 9
+    
+
+If we name these coordinates `A` through `F`, we can draw them on a grid, putting `0,0` at the top left:
+
+    ..........
+    .A........
+    ..........
+    ........C.
+    ...D......
+    .....E....
+    .B........
+    ..........
+    ..........
+    ........F.
+    
+
+This view is partial - the actual grid extends infinitely in all directions. Using the Manhattan distance, each location's closest coordinate can be determined, shown here in lowercase:
+
+    aaaaa.cccc
+    aAaaa.cccc
+    aaaddecccc
+    aadddeccCc
+    ..dDdeeccc
+    bb.deEeecc
+    bBb.eeee..
+    bbb.eeefff
+    bbb.eeffff
+    bbb.ffffFf
+    
+
+Locations shown as `.` are equally far from two or more coordinates, and so they don't count as being closest to any.
+
+In this example, the areas of coordinates A, B, C, and F are infinite - while not shown here, their areas extend forever outside the visible grid. However, the areas of coordinates D and E are finite: D is closest to 9 locations, and E is closest to 17 (both including the coordinate's location itself). Therefore, in this example, the size of the largest area is _17_.
+
+_What is the size of the largest area_ that isn't infinite?
+
+-----------------
+
+## --- Part Two ---
+
+On the other hand, _if the coordinates are safe_, maybe the best you can do is try to find a _region_ near as many coordinates as possible.
+
+For example, suppose you want the sum of the [Manhattan distance](https://en.wikipedia.org/wiki/Taxicab_geometry) to all of the coordinates to be _less than 32_. For each location, add up the distances to all of the given coordinates; if the total of those distances is less than 32, that location is within the desired region. Using the same coordinates as above, the resulting region looks like this:
+
+    ..........
+    .A........
+    ..........
+    ...###..C.
+    ..#D###...
+    ..###E#...
+    .B.###....
+    ..........
+    ..........
+    ........F.
+    
+
+In particular, consider the highlighted location `4,3` located at the top middle of the region. Its calculation is as follows, where `abs()` is the [absolute value](https://en.wikipedia.org/wiki/Absolute_value) function:
+
+*   Distance to coordinate A: `abs(4-1) + abs(3-1) =  5`
+*   Distance to coordinate B: `abs(4-1) + abs(3-6) =  6`
+*   Distance to coordinate C: `abs(4-8) + abs(3-3) =  4`
+*   Distance to coordinate D: `abs(4-3) + abs(3-4) =  2`
+*   Distance to coordinate E: `abs(4-5) + abs(3-5) =  3`
+*   Distance to coordinate F: `abs(4-8) + abs(3-9) = 10`
+*   Total distance: `5 + 6 + 4 + 2 + 3 + 10 = 30`
+
+Because the total distance to all coordinates (`30`) is less than 32, the location is _within_ the region.
+
+This region, which also includes coordinates D and E, has a total size of _16_.
+
+Your actual region will need to be much larger than this example, though, instead including all locations with a total distance of less than _10000_.
+
+_What is the size of the region containing all locations which have a total distance to all given coordinates of less than 10000?_

6/input.txt

@@ -0,0 +1,50 @@
+181, 47
+337, 53
+331, 40
+137, 57
+200, 96
+351, 180
+157, 332
+113, 101
+285, 55
+189, 188
+174, 254
+339, 81
+143, 61
+131, 155
+239, 334
+357, 291
+290, 89
+164, 149
+248, 73
+311, 190
+54, 217
+285, 268
+354, 113
+318, 191
+182, 230
+156, 252
+114, 232
+159, 299
+324, 280
+152, 155
+295, 293
+194, 214
+252, 345
+233, 172
+272, 311
+230, 82
+62, 160
+275, 96
+335, 215
+185, 347
+134, 272
+58, 113
+112, 155
+220, 83
+153, 244
+279, 149
+302, 167
+185, 158
+72, 91
+264, 67

6/part-one.js

@@ -0,0 +1,119 @@
+const fs = require('fs');
+const path = require('path');
+const distance = require('manhattan');
+const flat = require('array.prototype.flat');
+
+let raw_input = fs.readFileSync(path.resolve(__dirname, './input.txt'), 'utf8');
+
+// Last filter is to remove any empty lines
+let input = raw_input.split('\n').filter(n => n);
+
+let coordinates = input.map(p => p.split(',').map(n => +n));
+
+let flattened = flat(coordinates);
+let largest = Math.max.apply(null, flattened);
+
+let grid = Array(largest + 2)
+    .fill()
+    .map(n => {
+        return Array(largest + 2).fill(-1);
+    });
+
+// Loop through grid and mark spots that are coordinates
+coordinates.forEach((coord, index) => {
+    let [i, j] = coord;
+    grid[i][j] = 'C' + index;
+});
+
+// Iterate each coord in grid, and measure its distance from each point in our list.
+// Keep track of the smallest one. If tie, mark as null
+for (let i = 0; i < grid.length; i++) {
+    let row = grid[i];
+    for (let j = 0; j < grid.length; j++) {
+        let cell = row[j];
+        if (typeof cell !== 'string') {
+            // Not a coord, measure it
+            let lengths = coordinates.map((coord, index) => {
+                let d = distance(coord, [i, j]);
+                return {
+                    index: index,
+                    dist: d,
+                };
+            });
+
+            lengths.sort((a, b) => {
+                if (a.dist < b.dist) return -1;
+                else if (a.dist > b.dist) return 1;
+                else return 0;
+            });
+
+            let first = lengths[0];
+            let second = lengths[1];
+
+            if (first.dist === second.dist) {
+                // tied distance, mark as null
+                grid[i][j] = null;
+            } else {
+                grid[i][j] = first.index;
+            }
+        }
+    }
+}
+
+// Now, get all edges
+let edges = [];
+for (let i = 0; i < grid.length; i++) {
+    for (let dir = 0; dir < 4; dir++) {
+        if (dir === 0) {
+            // top row
+            edges.push(grid[0][i]);
+        } else if (dir === 1) {
+            // right col
+            edges.push(grid[i][grid.length - 1]);
+        } else if (dir === 2) {
+            // bottom row col
+            edges.push(grid[grid.length - 1][i]);
+        } else {
+            // left col
+            edges.push(grid[i][0]);
+        }
+    }
+}
+
+let unique_edges_list = [...new Set(edges)];
+unique_edges_list = unique_edges_list.filter(n => typeof n === 'number');
+let unique_edges = {};
+unique_edges_list.forEach(e => (unique_edges[e] = true));
+
+let total_area = {};
+
+// Loop through grid and remove all edge nodes (they are infinite area)
+for (let i = 0; i < grid.length; i++) {
+    for (let j = 0; j < grid.length; j++) {
+        let cell = grid[i][j];
+        if (typeof cell === 'number') {
+            if (unique_edges[cell]) {
+                // Remove any index with infinite area
+                grid[i][j] = null;
+            } else {
+                if (!total_area[cell]) {
+                    total_area[cell] = 0;
+                }
+
+                total_area[cell] += 1;
+            }
+        }
+    }
+}
+
+let areas = Object.entries(total_area);
+areas.sort((a, b) => {
+    if (a[1] < b[1]) return -1;
+    else if (a[1] > b[1]) return 1;
+    else return 0;
+});
+
+let max = areas.pop();
+
+// Plus 1 because we need to count the original coordinate!!
+console.log(max[1] + 1);

6/part-two.js

@@ -0,0 +1,65 @@
+const fs = require('fs');
+const path = require('path');
+const distance = require('manhattan');
+const flat = require('array.prototype.flat');
+
+let raw_input = fs.readFileSync(path.resolve(__dirname, './input.txt'), 'utf8');
+
+// Last filter is to remove any empty lines
+let input = raw_input.split('\n').filter(n => n);
+
+let coordinates = input.map(p => p.split(',').map(n => +n));
+
+let flattened = flat(coordinates);
+let largest = Math.max.apply(null, flattened);
+
+let grid = Array(largest + 2)
+    .fill()
+    .map(n => {
+        return Array(largest + 2).fill(-1);
+    });
+
+// Loop through grid and mark spots that are coordinates
+coordinates.forEach((coord, index) => {
+    let [i, j] = coord;
+    grid[i][j] = 'C' + index;
+});
+
+const MIN_DIST = 10000;
+
+let min_dist_count = 0;
+for (let i = 0; i < grid.length; i++) {
+    let row = grid[i];
+    for (let j = 0; j < grid.length; j++) {
+        let cell = row[j];
+        if (typeof cell !== 'string') {
+            // Not a coord, measure it
+            let lengths = coordinates.map((coord, index) => {
+                return distance(coord, [i, j]);
+            });
+
+            let sum = lengths.reduce((a, b) => a + b);
+            if (sum < MIN_DIST) {
+                grid[i][j] = 'close';
+                min_dist_count++;
+            }
+        }
+    }
+}
+
+// Loop through coords, and find ones that are surrounded by "found" areas
+coordinates.forEach(coord => {
+    let [i, j] = coord;
+    let t = grid[i - 1][j];
+    let r = grid[i][j + 1];
+    let b = grid[i + 1][j];
+    let l = grid[i][j - 1];
+
+    const C = 'close';
+
+    if (t === C && r === C && b === C && l === C) {
+        min_dist_count++;
+    }
+});
+
+console.log(min_dist_count);

package.json

@@ -12,5 +12,9 @@
   },
   "keywords": [],
   "author": "",
-  "license": "MIT"
+  "license": "MIT",
+  "dependencies": {
+    "array.prototype.flat": "^1.2.1",
+    "manhattan": "^1.0.0"
+  }
 }