Day 5: Hydrothermal Venture

I used a nested default dict like @spit-evil-olive-tips recommended the other day. It worked great for handling my grid and making it so I could expand it. And I build a regular expression the grabbed the x and y coordinates and walked through them incrementing the values of each coordinate it passes. Then just count up anything with more than vent at a given location

from collections import defaultdict
import re

#data = test_data
data = real_data
data = data.split('\n')

grid = defaultdict(lambda: defaultdict(int))

pattern = re.compile(r'(\d+),(\d+) -> (\d+),(\d+)')

for vent in data:
    results = re.search(pattern, vent)
    cords = results[0]
    x1, y1, x2, y2 = int(results[1]), int(results[2]), int(results[3]), int(results[4])
    if x1 == x2:
        for i in range(min([y1, y2],), max([y1,y2])+1):
            grid[x1][i] = grid[x1][i] + 1
    elif y1 == y2:
        for i in range(min([x1, x2],), max([x1,x2])+1):
            grid[i][y1] = grid[i][y1] + 1
count = 0
for x in grid.keys():
    for y in grid[x].keys():
        if grid[x][y] > 1:
            count = count + 1
            
print(count)

My original method worked well enough that I just had to add walking through diagonals. It was pretty simple conceptually, but a bit tedious to get all the x1 vs x2 and y1 vs y2 and +/- and what not in the right order.

from collections import defaultdict
import re

#data = test_data
data = real_data
data = data.split('\n')

grid = defaultdict(lambda: defaultdict(int))

pattern = re.compile(r'(\d+),(\d+) -> (\d+),(\d+)')

for vent in data:
    #print(vent)
    results = re.search(pattern, vent)
    cords = results[0]
    x1, y1, x2, y2 = int(results[1]), int(results[2]), int(results[3]), int(results[4])
    if x1 == x2:
        for i in range(min([y1, y2],), max([y1,y2])+1):
            #print(x1, i)
            grid[x1][i] = grid[x1][i] + 1
    elif y1 == y2:
        for i in range(min([x1, x2],), max([x1,x2])+1):
            #print(i, y1)
            grid[i][y1] = grid[i][y1] + 1
    else:
        if x2 > x1:
            if y2 > y1:
                for index, x in enumerate(range(x1, x2+1)):
                    #print(x, y1 + index)
                    grid[x][y1+index] = grid[x][y1+index] + 1 
            else:
                for index, x in enumerate(range(x1, x2+1)):
                    #print(x, y1 - index)
                    grid[x][y1-index] = grid[x][y1-index] + 1
        else:
            if y2 > y1:
                for index, x in enumerate(range(x2, x1+1)):
                    #print(x, y2 - index)
                    grid[x][y2-index] = grid[x][y2-index] + 1
            else:
                for index, x in enumerate(range(x2, x1+1)):
                    grid[x][y2+index] = grid[x][y2+index] + 1
                    #print(x, y2 + index)
count = 0
for x in grid.keys():
    for y in grid[x].keys():
        if grid[x][y] > 1:
            count = count + 1
            
print(count)

• The text parsing required here is a bit more sophisticate than what we've been using. If you're not already familiar with them, regular expressions (AKA Regex) are a very handy approach to this

• Pay special attention in part B. If you run into problems it may help to walk through the path one step at a time and make sure it's travelling at the correct angle

L=[[[int(y)for y in x.split(',')]for x in l.strip().split('->')]for l in open(0)]
M=max(sum(sum(L,[]),[]))+1
D=[[0]*M for _ in range(M)]
R=lambda a,A:range(min(a,A),max(a,A)+1)
for l in L:
 s,e=l;x,y=s;X,Y=e
 if x==X:
  for j in R(y,Y):D[j][x]+=1
 elif y==Y:
  for i in R(x,X):D[y][i]+=1
print(len([c for r in D for c in r if c>1]))

L=[[[int(y)for y in x.split(',')]for x in l.strip().split('->')]for l in open(0)]
M=max(sum(sum(L,[]),[]))+1
D=[[0]*M for _ in range(M)]
R=lambda a,A:range(min(a,A),max(a,A)+1)
for l in L:
 s,e=l;x,y=s;X,Y=e
 if x==X:
  for j in R(y,Y):D[j][x]+=1
 elif y==Y:
  for i in R(x,X):D[y][i]+=1
 else:
  p=int(X>x)or-1;q=int(Y>y)or-1
  for x,y in zip(range(x,X+p,p),range(y,Y+q,q)):D[y][x]+=1
print(len([c for r in D for c in r if c>1]))

import re, itertools

vents = list()

with open("input.txt") as file:
    for line in file:
        x1, y1, x2, y2 = map(int, re.findall(r"\d+", line))
        xo = 1 if x1 <= x2 else -1
        yo = 1 if y1 <= y2 else -1

        # For Part One
        # if x1 == x2 or y1 == y2:

        for x, y in itertools.zip_longest(
            range(x1, x2 + xo, xo),
            range(y1, y2 + yo, yo),
            fillvalue=x1 if x1 == x2 else y1 if y1 == y2 else None,
        ):
            vents.append((x, y))

overlaps = {}

for e in vents:
    overlaps[e] = overlaps.get(e, 0) + 1

points = 0

for _, o in overlaps.items():
    if o > 1:
        points += 1

print("Answer:", points)  # 7436, 21104

#!/usr/bin/awk -f
{
	split($0, line, " -> ")
	split(line[1], start, ",")
	split(line[2], end, ",")

	x = start[1]
	y = start[2]

	if (start[1] != end[1] && start[2] != end[2])
		next

	if (start[1] != end[1])
		diff = start[1] - end[1]
	else
		diff = start[2] - end[2]

	if (diff < 0)
		diff = diff * -1

	for (i = 0; i <= diff; ++i) {
		grid[x, y] += 1

		if (start[1] < end[1])
			x += 1
		else if (start[1] > end[1])
			x -= 1
		else if (start[2] < end[2])
			y += 1
		else if (start[2] > end[2])
			y -= 1
	}
}

END {
	for (i in grid)
		if (grid[i] >= 2)
			total += 1

	print total
}

#!/usr/bin/awk -f
{
	split($0, line, " -> ")
	split(line[1], start, ",")
	split(line[2], end, ",")

	x = start[1]
	y = start[2]

	if (start[1] != end[1])
		diff = start[1] - end[1]
	else
		diff = start[2] - end[2]

	if (diff < 0)
		diff = diff * -1

	for (i = 0; i <= diff; ++i) {
		grid[x, y] += 1

		if (start[1] < end[1])
			x += 1
		if (start[1] > end[1])
			x -= 1
		if (start[2] < end[2])
			y += 1
		if (start[2] > end[2])
			y -= 1
	}
}

END {
	for (i in grid)
		if (grid[i] >= 2)
			total += 1

	print total
}

#!/usr/bin/awk -f
{
	split($0, line, " -> ")
	split(line[1], start, ",")
	split(line[2], end, ",")

	x = start[1]
	y = start[2]

	if (start[1] < end[1]) {
		for (x = start[1]; x <= end[1]; ++x) {
			grid[x, y] += 1

			if (start[2] < end[2]) { 
				y += 1
			} else if (start[2] > end[2]) {
				y -= 1
			}
		}

	} else if (start[1] > end[1]) {
		for (x = start[1]; x >= end[1]; --x) {
			grid[x, y] += 1

			if (start[2] < end[2]) { 
				y += 1
			} else if (start[2] > end[2]) {
				y -= 1
			}
		}
	} else if (start[2] < end[2]) {
		for (y = start[2]; y <= end[2]; ++y) {
			grid[x, y] += 1

			if (start[1] < end[1]) {
				x ++ 1
			} else if (start[1] > end[1]) {
				x -= 1
			}
		}
	} else if (start[2] > end[2]) {
		for (y = start[2]; y >= end[2]; --y) {
			grid[x, y] += 1

			if (start[1] < end[1]) {
				x ++ 1
			} else if (start[1] > end[1]) {
				x -= 1
			}
		}
	}
}

END {
	for (i in grid) {
		if (grid[i] >= 2) {
			total += 1
		}
	}

	print total

	# debug visual
	if (FILENAME == "sample") {
		for (y = 0; y <= 9; ++y) {
			for (x = 0; x <= 9; ++x) {
				if (grid[x, y] == "") {
					printf("%s", ".")
				} else {
					printf("%s", grid[x, y])
				}
			}

			print ""
		}
	}
}

#![feature(drain_filter)]

use std::collections::HashMap;

use nom::{
    bytes::complete::tag, character::complete::multispace1, character::complete::space0, IResult,
};

#[derive(Debug, Eq, PartialEq, Hash, Copy, Clone)]
struct Coordinate {
    x: i16,
    y: i16,
}

#[derive(Debug)]
struct Line {
    start: Coordinate,
    end: Coordinate,
}

fn parse_position(input: &str) -> IResult<&str, Coordinate> {
    let (input, x) = nom::character::complete::i16(input)?;
    let (input, _) = tag(",")(input)?;
    let (input, y) = nom::character::complete::i16(input)?;

    Ok((input, Coordinate { x, y }))
}

fn parse_arrow(input: &str) -> IResult<&str, ()> {
    let (input, _) = space0(input)?;
    let (input, _) = tag("->")(input)?;
    let (input, _) = space0(input)?;

    Ok((input, ()))
}

fn parse_line(input: &str) -> IResult<&str, Line> {
    let (input, start) = parse_position(input)?;
    let (input, _) = parse_arrow(input)?;
    let (input, end) = parse_position(input)?;
    let (input, _) = multispace1(input)?;

    Ok((input, Line { start, end }))
}

fn parse_input(input: &str) -> Vec<Line> {
    let (_, lines) = nom::multi::many1(parse_line)(input).unwrap();
    return lines;
}

Writing a parser here is probably overkill, but I wanted to further familiarize myself with nom.

fn line_coordinates(l: &Line) -> Vec<Coordinate> {
    let dx = (l.end.x - l.start.x).clamp(-1, 1);
    let dy = (l.end.y - l.start.y).clamp(-1, 1);

    let mut cur = Coordinate {
        x: l.start.x,
        y: l.start.y,
    };

    let mut result = Vec::new();

    loop {
        result.push(cur);

        if cur.x == l.end.x && cur.y == l.end.y {
            break;
        };

        cur = Coordinate {
            x: cur.x + dx,
            y: cur.y + dy,
        };
    }

    result
}

This returns a vector of all coordinates in a line. I like the use of clamp(-1, 1) here. It's a bit unfortunate that this returns a vector; I should try to convert it into an iterator if I find more time to work on this.

Edit: Here is what I came up with to return an iterator. I don't quite understand why the trailing + '_ is necessary here. Ah, the mysteries of the borrow checker...

fn line_coordinates(l: &Line) -> impl std::iter::Iterator<Item = Coordinate> + '_ {
    let dx = (l.end.x - l.start.x).clamp(-1, 1);
    let dy = (l.end.y - l.start.y).clamp(-1, 1);

    let mut cur = Coordinate {
        x: l.start.x,
        y: l.start.y,
    };

    std::iter::once(cur).chain(std::iter::from_fn(move || {
        if cur.x == l.end.x && cur.y == l.end.y {
            return None;
        };

        cur = Coordinate {
            x: cur.x + dx,
            y: cur.y + dy,
        };

        Some(cur)
    }))
}

This filters out all diagonal lines using drain_filterand then counts the number of times each coordinate appears in the remaining lines using a HashMap.

fn solve(input: &str) -> u16 {
    let mut lines = parse_input(input);
    lines.drain_filter(|line| line.start.x != line.end.x && line.start.y != line.end.y);

    let mut vent_map = HashMap::new();

    for line in lines {
        for coord in line_coordinates(&line) {
            let e = vent_map.entry(coord).or_insert(0);
            *e += 1;
        }
    }

    let mut overlap_sum = 0;
    for (_, &v) in vent_map.iter() {
        if v > 1 {
            overlap_sum += 1;
        }
    }

    overlap_sum
}

fn main() {
    println!("{}", solve(include_str!("../../input-05.txt")));
}

fn solve(input: &str) -> i16 {
    let lines = parse_input(input);

    let mut vent_map = HashMap::new();

    for line in lines {
        for coord in line_coordinates(&line) {
            let e = vent_map.entry(coord).or_insert(0);
            *e += 1;
        }
    }

    let mut overlap_sum = 0;

    for (_, &v) in vent_map.iter() {
        if v > 1 {
            overlap_sum += 1;
        }
    }

    overlap_sum
}

fn main() {
    println!("{}", solve(include_str!("../../input-05.txt")));
}

import sugar, std/[strformat, sequtils, strutils, tables, hashes]

type Point = object of RootObj
  x: int
  y: int

func initPoint(x: int, y: int): Point =
  result.x = x
  result.y = y

func hash(x: Point): Hash =
  return !$(hash(x.x) !& hash(x.y))

func generateLine(point1: Point, point2: Point): seq[Point] =
  var line: seq[Point]
  if point1.x == point2.x:
    if point1.y < point2.y:
      for ydx in point1.y .. point2.y:
        line.add(initPoint(point1.x, ydx))
    else:
      for ydx in point2.y .. point1.y:
        line.add(initPoint(point1.x, ydx))

  elif point1.y == point2.y:
    if point1.x < point2.x:
      for xdx in point1.x .. point2.x:
        line.add(initPoint(xdx, point1.y))
    else:
      for xdx in point2.x .. point1.x:
        line.add(initPoint(xdx, point1.y))

  return line

proc parseInput(inputFile: string): seq[(Point, Point)] =
  var input: seq[string] = collect(newSeq):
    for line in inputFile.lines: line

  var points: seq[(Point, Point)]
  for line in input:
    var splitLine: seq[string] = split(line, " -> ")
    var leftSplit: seq[int] = map(split(splitLine[0], ","),
                                  (x: string) => parseInt(x))
    var rightSplit: seq[int] = map(split(splitLine[1], ","),
                                  (x: string) => parseInt(x))

    points.add((initPoint(leftSplit[0], leftSplit[1]),
                initPoint(rightSplit[0], rightSplit[1])))

  return points

proc main(inputFile: string) =
  var lines: seq[(Point, Point)] = parseInput(inputFile)
  var points: seq[Point]

  for line in lines:
    points = concat(points, generateLine(line[0], line[1]))

  var countPoints = toCountTable(points)
  sort(countPoints)

  var numDangers: int
  for point, count in pairs(countPoints):
    if count > 1:
      inc numDangers

  echo &"The number of dangerous points is {numDangers}"

when is_main_module:
  main("test.txt")
  main("input.txt")

@@ -11,7 +11,9 @@ func initPoint(x: int, y: int): Point =
 func hash(x: Point): Hash =
   return !$(hash(x.x) !& hash(x.y))
 
-func generateLine(point1: Point, point2: Point): seq[Point] =
+func generateLine(point1: Point,
+                  point2: Point,
+                  diag: bool): seq[Point] =
   var line: seq[Point]
   if point1.x == point2.x:
     if point1.y < point2.y:
@@ -29,6 +31,29 @@ func generateLine(point1: Point, point2: Point): seq[Point] =
       for xdx in point2.x .. point1.x:
         line.add(initPoint(xdx, point1.y))
 
+  elif diag:
+    # bottom left to top right
+    if point1.x < point2.x and point1.y < point2.y:
+      for (xdx, ydx) in zip(toSeq(countup(point1.x, point2.x, 1)),
+                            toSeq(countup(point1.y, point2.y, 1))):
+        line.add(initPoint(xdx, ydx))
+    # bottom right to top left
+    elif point1.x > point2.x and point1.y < point2.y:
+      for (xdx, ydx) in zip(toSeq(countdown(point1.x, point2.x, 1)),
+                            toSeq(countup(point1.y, point2.y, 1))):
+        line.add(initPoint(xdx, ydx))
+    # top left to bottom right
+    elif point1.x < point2.x and point1.y > point2.y:
+      for (xdx, ydx) in zip(toSeq(countup(point1.x, point2.x, 1)),
+                            toSeq(countdown(point1.y, point2.y, 1))):
+        line.add(initPoint(xdx, ydx))
+    # top right to bottom left
+    elif point1.x > point2.x and point1.y > point2.y:
+      for (xdx, ydx) in zip(toSeq(countdown(point1.x, point2.x, 1)),
+                            toSeq(countdown(point1.y, point2.y, 1))):
+        line.add(initPoint(xdx, ydx))
+
+
   return line
 
 proc parseInput(inputFile: string): seq[(Point, Point)] =
@@ -53,7 +78,7 @@ proc main(inputFile: string) =
   var points: seq[Point]
 
   for line in lines:
-    points = concat(points, generateLine(line[0], line[1]))
+    points = concat(points, generateLine(line[0], line[1], false))
 
   var countPoints = toCountTable(points)
   sort(countPoints)
@@ -65,6 +90,21 @@ proc main(inputFile: string) =
 
   echo &"The number of dangerous points is {numDangers}"
 
+  points = @[]
+  numDangers = 0
+
+  for line in lines:
+    points = concat(points, generateLine(line[0], line[1], true))
+
+  countPoints = toCountTable(points)
+  sort(countPoints)
+
+  for point, count in pairs(countPoints):
+    if count > 1:
+      inc numDangers
+
+  echo &"The number of diagonally dangerous points is {numDangers}"
+
 when is_main_module:
   main("test.txt")
   main("input.txt")

I guess most of us have a few procedures bundled up into a small library that are useful for AoC problems and take the pain out of having to do really common tasks.

Mine are:

• read-input - convert the input into a list of strings.
• map-input - same but run a procedure against each line.
• words - split a string on white-space.
• numbers - extract only numbers from a string into a list.

I find it fun to parse complex input, but not today.

(map-input numbers "day05.input")

vents is a hash-table from co-ordinate (list x y) to count.^*

Part 1 ignores diagonal lines, so I decided to write 2 plot procedures for orthogonal and diagonal lines. To support those I wrote the in-plot sequence which goes either forward or reverse though the range taking care to include the end point.

(define (orthogonal? line)
  (match-define (list x1 y1 x2 y2) line)
  (xor (= x1 x2) (= y1 y2)))

(define (in-plot start end)
  (if (> start end)
      (in-range start (sub1 end) -1)
      (in-range start (add1 end)  1)))

It feels wrong but since one of the axes won't change for the orthogonal plot - it turns out tidier writing nested iterators (using for*) one of which only iterates once. This meant I didn't have to write any fussy logic to check which axis changes.

(define (plot-orthogonal line vents)
  (match-define (list x1 y1 x2 y2) line)
  (for*/fold ([vents vents])
             ([y (in-plot y1 y2)]
              [x (in-plot x1 x2)])
    (hash-update vents (list x y) add1 0)))

hash-update is nice - you give it a procedure to update an existing key's hash value (add1 here) and either a default value (0 in this case) or another procedure that generates the default value which gets inserted into the table if the key is missing.

Update:
* - I was a bit disappointed at the time of each part of my answer. The obvious choice was to change the hash table to a 2d array (using vectors). This wastes a lot of space but is faster. I need to find the maximum co-ordinate from the input to generate the array. At the end I scan the whole array to find the dangerous vents.

hash table - averaging out over 50 runs:
Part 1: cpu time: 102.4 real time: 102.4 gc time: 25.4
Part 2: cpu time: 232.4 real time: 233 gc time: 62.6

2d array - averaging out over 50 runs:
Part 1: cpu time: 16.58 real time: 16.58 gc time: 1.74
Part 2: cpu time: 22.22 real time: 22.3 gc time: 1.72

lol: more time spent garbage collecting with the hash table than the runtime of the array.

(define (part-01 input)
  (define vents
    (for/fold ([vents (hash)])
               ([line input]
               #:when (orthogonal? line))
      (plot-orthogonal line vents)))
  (dangerous vents))

(define (dangerous vents)
  (count (curry < 1) (hash-values vents)))

The interesting thing about plot-diagonal is that it iterates through both axes in parallel (using for) as opposed to nested (using for*)

(define (part-02 input)
  (define vents
    (for*/fold ([vents (hash)])
               ([line input])
      (if (orthogonal? line)
          (plot-orthogonal line vents)
          (plot-diagonal line vents))))
  (dangerous vents))

(define (plot-diagonal line vents)
  (match-define (list x1 y1 x2 y2) line)
  (for/fold ([vents vents])
            ([y (in-plot y1 y2)]
             [x (in-plot x1 x2)])
    (hash-update vents (list x y) add1 0)))

Anything involving a 2d grid usually has y increasing down the screen.
For some reason my gut instinct is to iterate x values first. For AoC I generally iterate through increasing y values in the outer loop and then nest the x values. That way any debug output gets output in the same direction as the displayed examples.

use std::env;
use std::io::{self, prelude::*, BufReader};
use std::fs::File;
use std::collections::HashMap;

extern crate regex;
use regex::Regex;

#[derive(Clone,Hash,PartialEq,Eq)]
struct Point {
    x: isize,
    y: isize,
}

#[derive(Clone)]
struct Line {
    start: Point,
    end: Point,
}
impl From<&String> for Line {
    fn from(s: &String) -> Self {
        let re = Regex::new(r"(\d+),(\d+) -> (\d+),(\d+)").unwrap();
        let matches = re.captures(s).unwrap();
        Self {
            start: Point { x: matches[1].parse().unwrap(), y: matches[2].parse().unwrap() },
            end:   Point { x: matches[3].parse().unwrap(), y: matches[4].parse().unwrap() },
         }
    }
}
impl Line {
    pub fn points(&self, diagonals: bool) -> Vec<Point> {
        let mut points = Vec::new();
        let dx = self.end.x-self.start.x;
        let dy = self.end.y-self.start.y;
        let delta = if dx != 0 { dx } else { dy };
        if !diagonals && dx != 0 && dy != 0 { return points; } // part1: only vertical or horizontal lines
        let dx = dx.signum();
        let dy = dy.signum();
        for i in 0..delta.abs() + 1 {
            points.push(Point { x: self.start.x + i * dx, y: self.start.y + i * dy });
        }
        points
    }
}

fn day05(input: &str) -> io::Result<()> {
    let file = File::open(input).expect("Input file not found.");
    let reader = BufReader::new(file);

    // Input
    let input: Vec<String> = match reader.lines().collect() {
        Err(err) => panic!("Unknown error reading input: {}", err),
        Ok(result) => result,
    };
    let lines: Vec<_> = input.iter().map(Line::from).collect();

    // Part 1 (using nested Vecs)
    let mut vent_map = vec![vec![0; 1000]; 1000];
    for line in lines.clone() {
        for pt in line.points(false) {
            vent_map[pt.x as usize][pt.y as usize] += 1;
        }
    }
    let part1 = vent_map.iter().flat_map(|x| x.iter().filter(|&x| *x >= 2)).count();    
    println!("Part 1: {}", part1); // 6461

    // Part 2 (using HashMap)
    let mut vent_map: HashMap<Point,usize> = HashMap::new();
    for line in lines.clone() {
        for pt in line.points(true) {
            *vent_map.entry(pt).or_insert(0) += 1;
        }
    }
    let part2 = vent_map.iter().filter(|(_,&num)| num >= 2).count();
    println!("Part 2: {}", part2); // 18065

    Ok(())
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let filename = &args[1];
    day05(&filename).unwrap();
}

const fs = require('fs');
const readline = require('readline');

let inputArr = [];

async function openFileForReading(file) {
	const fileStream = fs.createReadStream(file);

	const rl = readline.createInterface({
		input: fileStream,
		crlfDelay: Infinity
	});

	for await (const line of rl) {
		try {
			inputArr.push(line);
		} catch(e) {
			console.error(e);
		}
	}
}

function findMaxDimensions(vectorArray) {
	let maxX = 0;
	let maxY = 0;
	for (const vectorPair of vectorArray) {
		if (vectorPair.x1 > maxX) {
			maxX = vectorPair.x1;
		}
		if (vectorPair.y1 > maxY) {
			maxY = vectorPair.y1;
		}
		if (vectorPair.x2 > maxX) {
			maxX = vectorPair.x2;
		}
		if (vectorPair.y2 > maxY) {
			maxY = vectorPair.y2;
		}
	}
	return { maxX: maxX, maxY: maxY };
}

function initGrid(x, y) {
	let grid = [];
	for (let i=0; i<=y; i++) {
		let currentRow = [];
		for (let j=0; j<=x; j++) {
			currentRow.push('.');
		}
		grid.push(currentRow);
	}
	return grid;
}

function addLine(grid, vector) {
	let startX = vector.x1;
	let startY = vector.y1;
	let endX = vector.x2;
	let endY = vector.y2;
	let cursorX = startX;
	let cursorY = startY;
	console.log("DEBUG: startX = " + startX + ", startY = " + startY);
	console.log("DEBUG: endX = " + endX + ", endY = " + endY);
	console.log("DEBUG: cursorX != endX is " + (cursorX != endX));
	console.log("DEBUG: cursorY != endY is " + (cursorY != endY));
	while (true) {
		console.log("DEBUG: cursorX = " + cursorX + ", cursorY = " + cursorY);
		let row = grid[cursorY];
		let currentValue = row[cursorX];
		if (currentValue === '.') {
			grid[cursorY][cursorX] = 1;
		} else {
			grid[cursorY][cursorX]++;
		}
		if (cursorX === endX && cursorY === endY) {
			break;
		}
		console.log("DEBUG: cursorX != endX is " + (cursorX != endX));
		if (cursorX != endX && cursorX > endX) {
			cursorX--;
		} else if (cursorX != endX && cursorX < endX) {
			cursorX++;
		}
		console.log("DEBUG: cursorY != endY is " + (cursorY != endY));
		if (cursorY != endY && cursorY > endY) {
			cursorY--;
		} else if (cursorY != endY && cursorY < endY) {
			cursorY++;
		}
	}
}

function getPoints(grid) {
	let points = 0;
	for (const row of grid) {
		for (const value of row) {
			if (value > 1) {
				points++;
			}
		}
	}
	return points;
}

function isDiagonal(vector) {
	return ((vector.x1 != vector.x2) && (vector.y1 != vector.y2));
}

(async function mainExecution() {
	await openFileForReading('input.txt');
	let vectorArray = inputArr.map(e => {
		let regex = /(\d+),(\d+) -> (\d+),(\d+)/;
		let found = e.match(regex);
		return { x1: parseInt(found[1]), y1: parseInt(found[2]),
			x2: parseInt(found[3]), y2: parseInt(found[4])
		};
	});
	gridDimensions = findMaxDimensions(vectorArray);
	let grid = initGrid(gridDimensions.maxX, gridDimensions.maxY);
	console.log(grid.map(e => e.join('')).join('\n'));
	for (const vector of vectorArray) {
		if (!isDiagonal(vector)) {
			console.log("DEBUG: Operating on vector " + vector.x1 + ","
				+ vector.y1 + " -> " + vector.x2 + "," + vector.y2);
			addLine(grid, vector);
			console.log(grid.map(e => e.join('')).join('\n'));
		}
	}
	console.log("Answer found! " + getPoints(grid));
})();

const fs = require('fs');
const readline = require('readline');

let inputArr = [];

async function openFileForReading(file) {
	const fileStream = fs.createReadStream(file);

	const rl = readline.createInterface({
		input: fileStream,
		crlfDelay: Infinity
	});

	for await (const line of rl) {
		try {
			inputArr.push(line);
		} catch(e) {
			console.error(e);
		}
	}
}

function findMaxDimensions(vectorArray) {
	let maxX = 0;
	let maxY = 0;
	for (const vectorPair of vectorArray) {
		if (vectorPair.x1 > maxX) {
			maxX = vectorPair.x1;
		}
		if (vectorPair.y1 > maxY) {
			maxY = vectorPair.y1;
		}
		if (vectorPair.x2 > maxX) {
			maxX = vectorPair.x2;
		}
		if (vectorPair.y2 > maxY) {
			maxY = vectorPair.y2;
		}
	}
	return { maxX: maxX, maxY: maxY };
}

function initGrid(x, y) {
	let grid = [];
	for (let i=0; i<=y; i++) {
		let currentRow = [];
		for (let j=0; j<=x; j++) {
			currentRow.push('.');
		}
		grid.push(currentRow);
	}
	return grid;
}

function addLine(grid, vector) {
	let startX = vector.x1;
	let startY = vector.y1;
	let endX = vector.x2;
	let endY = vector.y2;
	let cursorX = startX;
	let cursorY = startY;
	console.log("DEBUG: startX = " + startX + ", startY = " + startY);
	console.log("DEBUG: endX = " + endX + ", endY = " + endY);
	console.log("DEBUG: cursorX != endX is " + (cursorX != endX));
	console.log("DEBUG: cursorY != endY is " + (cursorY != endY));
	while (true) {
		console.log("DEBUG: cursorX = " + cursorX + ", cursorY = " + cursorY);
		let row = grid[cursorY];
		let currentValue = row[cursorX];
		if (currentValue === '.') {
			grid[cursorY][cursorX] = 1;
		} else {
			grid[cursorY][cursorX]++;
		}
		if (cursorX === endX && cursorY === endY) {
			break;
		}
		console.log("DEBUG: cursorX != endX is " + (cursorX != endX));
		if (cursorX != endX && cursorX > endX) {
			cursorX--;
		} else if (cursorX != endX && cursorX < endX) {
			cursorX++;
		}
		console.log("DEBUG: cursorY != endY is " + (cursorY != endY));
		if (cursorY != endY && cursorY > endY) {
			cursorY--;
		} else if (cursorY != endY && cursorY < endY) {
			cursorY++;
		}
	}
}

function getPoints(grid) {
	let points = 0;
	for (const row of grid) {
		for (const value of row) {
			if (value > 1) {
				points++;
			}
		}
	}
	return points;
}

function isDiagonal(vector) {
	return ((vector.x1 != vector.x2) && (vector.y1 != vector.y2));
}

(async function mainExecution() {
	await openFileForReading('input.txt');
	let vectorArray = inputArr.map(e => {
		let regex = /(\d+),(\d+) -> (\d+),(\d+)/;
		let found = e.match(regex);
		return { x1: parseInt(found[1]), y1: parseInt(found[2]),
			x2: parseInt(found[3]), y2: parseInt(found[4])
		};
	});
	gridDimensions = findMaxDimensions(vectorArray);
	let grid = initGrid(gridDimensions.maxX, gridDimensions.maxY);
	console.log(grid.map(e => e.join('')).join('\n'));
	for (const vector of vectorArray) {
		console.log("DEBUG: Operating on vector " + vector.x1 + ","
			+ vector.y1 + " -> " + vector.x2 + "," + vector.y2);
		addLine(grid, vector);
		console.log(grid.map(e => e.join('')).join('\n'));
	}
	console.log("Answer found! " + getPoints(grid));
})();

use std::fs;

type Point = (i32, i32);

type Segment = Vec<Point>;

fn new_segment(start: Point, end: Point) -> Segment {
    let first_x = start.0.min(end.0);
    let second_x = start.0.max(end.0);
    let first_y = start.1.min(end.1);
    let second_y = start.1.max(end.1);

    if start.0 == end.0 {
        // is vertical
        (first_y..=second_y).map(|y| (first_x, y)).collect()
    } else if start.1 == end.1 {
        // is horizontal
        (first_x..=second_x).map(|x| (x, first_y)).collect()
    } else {
        // is diagonal @ 45 degrees
        // replace with Vec::new() for part 1 sln
        let step_x = if end.0 > start.0 { 1 } else { -1 };
        let step_y = if end.1 > start.1 { 1 } else { -1 };

        let mut points: Segment = Vec::new();
        let mut cur = start;
        loop {
            points.push(cur);
            if cur == end {
                break;
            }
            cur = (cur.0 + step_x, cur.1 + step_y);
        }

        points
    }
}

fn main() {
    let contents = fs::read_to_string("src/input.txt").unwrap();
    let lines = contents.lines();
    let parsed: Vec<Vec<Vec<i32>>> = lines
        .map(|l| {
            l.split(" -> ")
                .map(|coords| coords.split(',').map(|x| x.parse().unwrap()).collect())
                .collect()
        })
        .collect();

    let mut all_points: Vec<Point> = Vec::new();
    for seg in parsed {
        all_points.extend(new_segment((seg[0][0], seg[0][1]), (seg[1][0], seg[1][1])))
    }

    all_points.sort();

    let mut dupe_points: Vec<Point> = Vec::new();
    let mut last: Point = (-1, -1);
    for point in all_points {
        if point == last {
            dupe_points.push(point);
        }
        last = point;
    }

    dupe_points.dedup();
    println!("Answer is: {:?}", dupe_points.len());
}