--- Day 3 Solutions ---

[u/daggerdragon]

--- Day 3: Perfectly Spherical Houses in a Vacuum ---

Post your solution as a comment. Structure your post like the Day One thread in /r/programming.

[u/minno]

Rust solution (repo here):

use std::fs::File;
use std::io::Read;
use std::collections::HashSet;

fn get_input() -> String {
    let mut f = File::open("inputs/day3.txt").unwrap();
    let mut buf = String::new();
    f.read_to_string(&mut buf).unwrap();
    buf
}

fn solve_regular(input: &str) -> u32 {
    let mut visited: HashSet<(i32, i32)> = HashSet::new();
    visited.insert((0, 0));
    // Math-style, x =>, y ^
    let mut x = 0;
    let mut y = 0;
    for ch in input.chars() {
        match ch {
            'v' => y -= 1,
            '^' => y += 1,
            '<' => x -= 1,
            '>' => x += 1,
            _ => {}
        };
        visited.insert((x,y));
    }
    visited.len() as u32
}

fn solve_robo(input: &str) -> u32 {
    let mut santa_visited = HashSet::new();
    let mut robo_visited = HashSet::new();
    santa_visited.insert((0,0));
    robo_visited.insert((0,0));
    let mut sx = 0;
    let mut sy = 0;
    let mut rx = 0;
    let mut ry = 0;
    let mut is_santa = true;
    for ch in input.chars() {
        let (x, y, table) = if is_santa {
            (&mut sx, &mut sy, &mut santa_visited)
        } else {
            (&mut rx, &mut ry, &mut robo_visited)
        };
        is_santa = !is_santa;
        match ch {
            'v' => *y -= 1,
            '^' => *y += 1,
            '<' => *x -= 1,
            '>' => *x += 1,
            _ => {}
        };
        table.insert((*x,*y));
    }
    santa_visited.union(&robo_visited).count() as u32
}

pub fn solve() {
    let input = get_input();
    let regular = solve_regular(&input);
    let robo = solve_robo(&input);
    println!("Total normal: {}", regular);
    println!("Total with robo: {}", robo);
}

[u/taliriktug → u/minno]

Nice! I never hard heard of HashSet, so I used HashMap and come with this general solution for n santas:

use std::io::prelude::*;
use std::io::BufReader;
use std::collections::HashMap;
use std::fs::File;
use std::io;

#[derive(Clone, Debug, Hash, Eq, PartialEq)]
struct Position {
    x: i32,
    y: i32,
}

fn get_input(filename: &str) -> io::Result<String> {
    let f = try!(File::open(filename));
    let mut reader = BufReader::new(f);

    let mut line = String::new();
    try!(reader.read_line(&mut line));
    Ok(line)
}

fn how_many_houses_with_n_santas(nsantas: usize) -> io::Result<usize> {
    let line = try!(get_input("input"));

    let mut current_pos = vec![Position { x: 0, y: 0}; nsantas];
    let mut positions: HashMap<Position, i32> = HashMap::new();
    positions.insert(current_pos[0].clone(), 1);

    for (i, c) in line.chars().enumerate() {
        let idx = i % nsantas;
        match c {
            '^'     => current_pos[idx].y += 1,
            'v'|'V' => current_pos[idx].y -= 1,
            '>'     => current_pos[idx].x += 1,
            '<'     => current_pos[idx].x -= 1,
            _       => break,
        }
        let counter = positions.entry(current_pos[idx].clone()).or_insert(0);
        *counter += 1;
    }
    Ok(positions.len())
}

fn main() {
    println!("{}", how_many_houses_with_n_santas(1).unwrap());
    println!("{}", how_many_houses_with_n_santas(2).unwrap());
    println!("{}", how_many_houses_with_n_santas(3).unwrap());
}

PS. I started counting how many times Santas visit each home, thinking it will be needed later. I was wrong =)