Helpers for Advent of Code

This crate contains some helper methods that I regularly use in my Advent of Code solutions.

Processing of command line arguments

args::get_args

Reads the command line arguments and checks whether the correct number of arguments are present.

Example

```rust use rdclaochelpers::args::get_args;

fn example1() { let args = get_args(&["", ""], 1); println!("{:?}", args); }

fn example2() { let args = getargsrepeating(&["", " ... "], 1); println!("{:?}", args); } ```

Error handling

error::WithOrExit

This trait adds a or_exit_with method. The purpose of this method, is to allow you to easily let your program terminate with a specific exit code. It has been implemented for [Result] and [Option]. The implementation for [Result] requires that the associated error type implements [fmt::Debug].

Example

```rust use rdclaochelpers::error::WithOrExit;

fn main() { someoperationthatreturnsaresult() .orexit_with(25); } ```

error::ParseError

A generic error containing just a message. It implements [fmt::Display] and [fmt::Debug], and it can be converted from [io::Error] and [num::ParseIntError].

Example

```rust use rdclaochelpers::error::ParseError;

fn examplewithparams(param: u8) -> Result<(), ParseError> { if process(param) { Ok(()) } else { Err(ParseError(format!("Failed to process param: {}", param))) } }

fn examplewithoutparams() -> Result<(), ParseError> { if process() { Ok(()) } else { Err(ParseError.of("Failed to process")) } } ```

I/O operations

input::MultilineFromStr

This trait is inspired by the [str::FromStr] trait, and allows you to parse input where data might span several lines.

Example

```rust use rdclaochelpers::error::ParseError; use rdclaochelpers::input::MultilineFromStr;

pub struct Record { items: Vec, }

impl MultilineFromStr for Record { type Err = ParseError;

fn new() -> Self {
    Record {
        items: Vec::new(),
    }
}

fn indicates_new_record(&self, line: &str) -> bool {
    line.is_empty()
}

fn parse(&mut self, line: &str) -> Result<(), Self::Err> {
    if !line.is_empty() {
        self.items.push(line.parse::<u8>()?);
    }

    Ok(())
}

} ```

input::WithReadLines

This trait adds a read_lines method. The purpose of this method is to read the lines from some source (e.g. a file), and then convert each line to a specific type. As an argument, this method takes an exit code that should be used if processing the source fails, and it returns an iterator. This trait has been implemented for [fs::File].

Example

```rust use rdclaochelpers::input::WithReadLines;

fn main() { for item in File::open("./my-file.txt").read_lines::(1) { println!("Item: {}", item); } } ```

input::WithReadMultiLines

This trait adds a read_multi_lines method. It's the equivalent of input::WithReadLines, but rather than depending on [str::FromStr], it depends on input::MultilineFromStr.

Example

```rust use rdclaochelpers::input::WithReadMultiLines;

fn main() { for record in File::open("./my-file.txt").readmultilines::(1) { println!("Item: {:?}", record); } }

[derive(Debug)]

struct Record { /* ... / } impl MultilineFromStr for Record { / ... */ } ```

input::WithAsRecords & input::WithAsMultilineRecords

These traits allow you to easily convert an object to a vec of items of the required type.

Example

```rust

[cfg(test)]

mod tests { use rdclaochelpers::input::WithAsRecords; use rdclaochelpers::input::WithAsMultilineRecords;

use super::*;

#[test]
fn test_simple() {
    let input = vec!["1", "2", "3", "4", "5"]
        .as_records::<u8>()
        .unwrap();

    assert_eq!(input, vec![1, 2, 3, 4, 5]);
}

#[test]
fn test_multiline() {
    let input = vec!["1", "2", "", "3", "4", "", "5"]
        .as_multiline_records::<Record>()
        .unwrap();

    assert_eq!(
        input,
        vec![
            Record { items: vec![1, 2] },
            Record { items: vec![3, 4] },
            Record { items: vec![5] },
        ]
    );
}

} ```

Math

math::gcd

Computes the greatest common divisor of two numbers.

Example

```rust use rdclaochelpers::math::gcd;

fn main() { let a = 35; let b = 49; println!("gcd({}, {}) = {}", a, b, gcd(a, b)); } ```

math::lcm

Computes the least common multiple of two numbers.

Example

```rust use rdclaochelpers::math::lcm;

fn main() { let a = 35; let b = 49; println!("lcm({}, {}) = {}", a, b, lcm(a, b)); } ```

math::solve_crt

Solve the chinese remainder theorem for (n1, a1) and (n2, a2). We assume that: * n1 and n2 are coprime * n1 and n2 are no more than 63 bits (as they are converted to i64)

Example

```rust use rdclaochelpers::math::solve_crt;

fn main() { println!("solvecrt((3, 1), (5, 4)) = {}", solvecrt((3, 1), (5, 4))); } ```

math::bezout_coefficients

Find t and s, such that ta + sb = gcd(p, q).

Example

```rust use rdclaochelpers::math::bezout_coefficients;

fn main() { println!("bezoutcoefficients(3, 4) = {}", bezoutcoefficients(3, 4)); } ```

Parts

part::Part

This enum is useful if you need to explicitly refer to a part. It implemts [str::FromStr] and [fmt::Display], so you can easily convert to and from a string.

Example

```rust use rdclaochelpers::part::Part;

fn main() { let part = "part 1".parse::().unwrap(); println!("[{}] ...", part); // outputs "[part 1] ..."

let part = Part::Two;
println!("[{}] ...", part); // outputs "[part 2] ..."

} ```

Search

search::Navigable

Implement this trait to be able to use [A*] to find the shortest path between two points.