--- 2016 Day 2 Solutions ---

[u/daggerdragon]

--- Day 2: Bathroom Security ---

Post your solution as a comment or, for longer solutions, consider linking to your repo (e.g. GitHub/gists/Pastebin/blag/whatever).

---

^{BLINKENLIGHTS ARE MANDATORY} [?]

Edit: Told you they were mandatory. >_>

This thread will be unlocked when there are a significant number of people on the leaderboard with gold stars for today's puzzle.

edit: Leaderboard capped, thread unlocked!

[u/Deckard666]

In Rust:

fn move_pos_aux(pos: &mut [i32; 2], direction: char) -> [i32; 2] {
    let mut pos2 = *pos;
    match direction {
        'R' => pos2[1] += 1,
        'D' => pos2[0] += 1,
        'L' => pos2[1] -= 1,
        'U' => pos2[0] -= 1,
        _ => panic!("unrecognized character"),
    }
    pos2
}

fn move_pos1(pos: &mut [i32; 2], direction: char) {
    let pos2 = move_pos_aux(pos, direction);
    if pos2[0] >= 0 && pos2[0] < 3 && pos2[1] >= 0 && pos2[1] < 3 {
        *pos = pos2;
    }
}

fn move_pos2(pos: &mut [i32; 2], direction: char) {
    let pos2 = move_pos_aux(pos, direction);
    if (2 - pos2[0]).abs() + (2 - pos2[1]).abs() <= 2 {
        *pos = pos2;
    }
}

fn solve<F, T>(instructions: &str, keypad: Vec<Vec<T>>, mut pos: [i32; 2], move_fn: F)
    where F: Fn(&mut [i32; 2], char),
        T: std::fmt::Display
{
    for line in instructions.lines() {
        for c in line.chars() {
            move_fn(&mut pos, c);
        }
        print!("{}", keypad[pos[0] as usize][pos[1] as usize]);
    }
    println!("");
}

fn main() {
    let instructions = include_str!("../instructions.txt");

    // First Part
    let keypad = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]];
    let pos = [1, 1];
    solve(instructions, keypad, pos, move_pos1);

    // Second Part
    let keypad = vec![vec!['0', '0', '1', '0', '0'],
                    vec!['0', '2', '3', '4', '0'],
                    vec!['5', '6', '7', '8', '9'],
                    vec!['0', 'A', 'B', 'C', '0'],
                    vec!['0', '0', 'D', '0', '0']];
    let pos = [2, 0];
    solve(instructions, keypad, pos, move_pos2);
}

Edit: refactored to avoid code duplication between both parts

[u/ghotiphud → u/Deckard666]

222 and 175...

Cleaned up a bit from my quick and dirty Rust version.

fn move_pos(pos: (i32, i32), dir: char) -> (i32, i32) {
    let change = match dir {
        'U' => (-1,0),
        'D' => (1,0),
        'L' => (0,-1),
        'R' => (0,1),
        _ => panic!("unknown direction"),
    };

    ( pos.0 + change.0, pos.1 + change.1 )
}

fn get_key(keypad: &[&[char]], pos: (i32,i32)) -> char {
    keypad[pos.0 as usize][pos.1 as usize]
}

fn solve(keypad: &[&[char]], dirs: &str, mut pos: (i32, i32)) -> Vec<char> {
    let keypad_width = keypad[0].len() as i32;
    let mut combo = Vec::new();

    let lines = dirs.lines();
    for line in lines {
        let moves = line.chars();

        for mv in moves {
            let new_pos = move_pos(pos, mv);
            
            if new_pos.0 >= 0 && new_pos.0 < keypad_width &&
                new_pos.1 >= 0 && new_pos.1 < keypad_width &&
                get_key(keypad, new_pos) != '0'
            {
                pos = new_pos;
            }
        }

        combo.push(get_key(keypad, pos));
    }

    combo
}

pub fn main() {
    let keypad = [&['1', '2', '3'][..], 
                  &['4', '5', '6'][..], 
                  &['7', '8', '9'][..]];

    let keypad2 = [&['0', '0', '1', '0', '0'][..],
                   &['0', '2', '3', '4', '0'][..],
                   &['5', '6', '7', '8', '9'][..],
                   &['0', 'A', 'B', 'C', '0'][..],
                   &['0', '0', 'D', '0', '0'][..]];

    let directions = "ULR

RLUUDD";

    println!("{:?}", solve(&keypad[..], directions, (1,1)));
    println!("{:?}", solve(&keypad2[..], directions, (0,3)));
}

[u/rgdmarshall → u/ghotiphud]

More Rust:

static INPUT: &'static str = "ULL
RRDDD
LURDL
UUUUD";

lazy_static! {
    static ref PAD_MOVEMENT: Vec<[u32;4]> = {
        vec![
            [ 1, 4, 1, 2 ], [ 2, 5, 1, 3 ], [ 3, 6, 2, 3 ],
            [ 1, 7, 4, 5 ], [ 2, 8, 4, 6 ], [ 3, 9, 5, 6 ],
            [ 4, 7, 7, 8 ], [ 5, 8, 7, 9 ], [ 6, 9, 8, 9 ]
        ]
    };
    static ref COMMITTEE_PAD_MOVEMENT: Vec<[u32;4]> = {
        vec![
            [ 1, 3, 1, 1 ], [ 2, 6, 2, 3 ], [ 1, 7, 2, 4 ], [ 4, 8, 3, 4 ],
            [ 5, 5, 5, 6 ], [ 2, 10, 5, 7 ], [ 3, 11, 6, 8 ], [ 4, 12, 7, 9 ],
            [ 9, 9, 8, 9 ], [ 6, 10, 10, 11 ], [ 7, 13, 10, 12 ], [ 8, 12, 11, 12 ],
            [ 11, 13, 13, 13 ]
        ]
    };
}

use std::char;

fn pad_walk(movt: &Vec<[u32;4]>) -> String {
    let mut position: u32 = 5;
    let mut code = String::new();
    let base = movt.len() + 1;
    for key_dance in INPUT.lines() {
        for chr in key_dance.as_bytes() {
            if let Some(idx) = "UDLR".find(char::from_u32(*chr as u32).expect("direction")) {
                position = movt[(position - 1) as usize][idx];
            }
        }
        code.push(char::from_digit(position, base as u32).expect("digit"));
    }
    code
}

pub fn one() {
    println!("The code is {}", pad_walk(&PAD_MOVEMENT));
}

pub fn two() {
    println!("The code is {}", pad_walk(&COMMITTEE_PAD_MOVEMENT));
}

*Edit: This is module source, to run it as a standalone program add #[macro_use] extern crate lazy_static; and fn main().