Xjyuk

I am solving the problems for Advent of Code 2016 to learn Rust programming. The prompt for the first problem can be summarized:

I start at position 0,0 on a regular grid. I am given a set of directions to get to a location. I can only travel in "steps" on this grid, and I am only given directions in the form (e.g.):

R5, L2, L1, R1, R3, R3, L3, R3, R4, L2, R4, L4, R4

Where the first character is the direction to turn right or left and the following number is the number of steps to take. I need to compute the Manhattan distance between my starting point and the ending point.

The instructions are saved in a text file called "2016-1.txt".

use std::fs;

struct Pos 
 facing: char,
 x: i32,
 y: i32,


fn split_dir(dir_str: &str) -> Vec<&str> 
 dir_str.split(", ").collect()


fn update_facing(rel_dir: &char, face_char: &char) -> char 
 if *rel_dir == 'L' 
 match face_char 
 'N' => 'W',
 'S' => 'E',
 'E' => 'N',
 'W' => 'S',
 _ => 'I', // Is there a better way to handle the catch-all?
 
 else 
 match face_char 
 'N' => 'E',
 'S' => 'W',
 'E' => 'S',
 'W' => 'N',
 _ => 'I',
 
 


fn update_x(pos_x: i32, face_char: char, move_num: i32) -> i32 
 match face_char 
 'E' => pos_x + move_num,
 'W' => pos_x - move_num,
 _ => pos_x
 


fn update_y(pos_y: i32, face_char: char, move_num: &i32) -> i32 
 match face_char 
 'N' => pos_y + move_num,
 'S' => pos_y - move_num,
 _ => pos_y
 


fn get_manhattan_dist(pos_x: i32, pos_y: i32, origin_x: i32, origin_y: i32) -> i32 
 (pos_x - origin_x).abs() + (pos_y - origin_y).abs()


fn main() 
 let s = fs::read_to_string("2016-1.txt")
 .expect("Failed to read file.");

 let split: Vec<&str> = split_dir(&s);

 let mut pos: Pos = Pos x: 0, y: 0, facing: 'N';

 for inst in split 
 // Update direction
 let rel_dir = inst.chars().nth(0).unwrap(); // Get first character of the instruction
 pos.facing = update_facing(&rel_dir, &pos.facing);

 // Update position
 let move_num = &inst[1..].parse::<i32>().unwrap();
 pos.x = update_x(pos.x, pos.facing, *move_num);
 pos.y = update_y(pos.y, pos.facing, &move_num);
 

 let dist = get_manhattan_dist(pos.x, pos.y, 0, 0);
 println!("", dist);

I am particularly interested in error handling. Particularly in the update_facing function. This is my first Rust program, so all advice is warranted as well.

Your code looks more complicated than necessary for this task.

The first thing I noticed was the directions N, E, S, W. There is no need to explicitly name them. It is simpler to just define a direction as a 2-dimensional tuple:

struct Direction 
 dx: i32,
 dy: i32

That's the essence of a direction. As the next step, I remembered that rotating such a direction by 90 degrees is quite simple. It just involves swapping the coordinates and reversing one of them. To get these right, I manually checked all the combinations after writing this code:

impl Direction 
 fn left(&self) -> Direction Direction dx: self.dy, dy: -self.dx 
 fn right(&self) -> Direction Direction dx: -self.dy, dy: self.dx 

By these simple definitions, I avoided dealing with N, E, S, W at all.

When I tested the program using the example you provided, my IDE added a trailing newline to the file, as is usual for text files. Then the program crashed because it could not parse an empty string. Therefore I changed split_dir(&s) into split_dir(s.trim()), and it worked.

To understand the main program, I separated it into the part that deals with input and output, and the processing part in between. To do this, I defined this function:

fn manhattan_distance(s: &str) -> i32 
 ...

I inlined the split_dir, update_x, update_y and get_manhattan_dist functions, and in the end my code became:

use std::fs;

struct Pos 
 x: i32,
 y: i32,
 dir: Direction,


struct Direction 
 dx: i32,
 dy: i32,


impl Direction 
 fn left(&self) -> Direction 
 Direction 
 dx: self.dy,
 dy: -self.dx,
 
 

 fn right(&self) -> Direction 
 Direction 
 dx: -self.dy,
 dy: self.dx,
 
 


fn manhattan_distance(s: &str) -> i32 
 let steps = s.trim().split(", ");

 let mut pos = Pos 
 x: 0,
 y: 0,
 dir: Direction dx: 0, dy: -1 ,
 ;

 for step in steps 
 let (turn, dist) = step.split_at(1);

 // Update direction
 pos.dir = match turn 
 "L" => pos.dir.left(),
 "R" => pos.dir.right(),
 _ => panic!("invalid turn in step ", turn, step),
 ;

 // Update position
 let dist = dist.parse::<i32>().unwrap();
 pos.x += pos.dir.dx * dist;
 pos.y += pos.dir.dy * dist;
 

 pos.x.abs() + pos.y.abs()


fn main() 
 let s = fs::read_to_string("2016-1.txt").expect("Failed to read file.");

 println!("", manhattan_distance(&s));

What's left now are some automatic tests. The function manhattan_distance is well-prepared for that since it has no side-effects, does not need any input or output, gets its parameter as a simple string and just returns its result.

And here are some example tests. You should add some more to explore other interesting cases, like crossing the x or y axis. The current tests might also pass if you omit the calls to abs.

#[cfg(test)]
mod tests 
 use crate::manhattan_distance;

 #[test]
 fn manhattan_distance_example() 
 assert_eq!(11, manhattan_distance("R5, L2, L1, R1, R3, R3, L3, R3, R4, L2, R4, L4, R4"))
 

 #[test]
 fn manhattan_distance_empty() 
 assert_eq!(0, manhattan_distance(" tn"))
 

 #[test]
 fn manhattan_distance_simple() 
 assert_eq!(13, manhattan_distance("R8, L5"))
 

 #[test]
 fn manhattan_distance_rectangle() 
 assert_eq!(0, manhattan_distance("R8, L5, L8, L5"))
 

Your code is a good working base, it was just longer than necessary. I also changed most of the variable names to be a little more precise and easier to grasp for a casual reader of the code. For example, since the task talks about "steps", it's only natural to name the corresponding variables in the code also "steps" and "step".

Since this is my first real program in Rust as well, I don't know what the really idiomatic Rust code looks like, I hope I could improve the code nevertheless.

To check whether I made any typical beginner's mistakes, I ran cargo-clippy, and I didn't get any complaints.