Project Euler: #196

Cargo.toml

[package]
name = "problem-one-hundred-and-ninety-six"
version = "0.1.0"
authors = ["Jens Hausdorf <[email protected]>"]
edition = "2018"

[dependencies]
yansi = "0.5.0"

main.rs

extern crate yansi;

use std::fmt;
use yansi::Paint;

#[derive(Debug)]
struct Integer {
    value: u32,
    is_prime: bool,
}

impl Integer {
    fn from_raw(value: u32) -> Integer {
        let is_prime = is_prime(value);
        Integer { value, is_prime }
    }
}

#[derive(Debug)]
struct IntegerRow {
    numbers: Vec<Integer>,
}

struct IntegerTriangle {
    rows: Vec<IntegerRow>,
}

impl fmt::Display for IntegerTriangle {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        for numbers in self.rows.iter() {
            fmt.write_str(&format!("{}\n", numbers))?;
        }

        Ok(())
    }
}

impl fmt::Display for IntegerRow {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        for numbers in self.numbers.iter() {
            fmt.write_str(&format!("{}", numbers))?;
        }

        Ok(())
    }
}

impl fmt::Display for Integer {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        let raw_output = format!("{:04}", self.value);

        fmt.write_str(&format!(
            "{} ",
            if self.is_prime {
                Paint::red(raw_output)
            } else {
                Paint::green(raw_output)
            }
        ))?;

        Ok(())
    }
}

fn is_prime(candidate: u32) -> bool {
    if (candidate & 1) == 0 {
        if candidate == 2 {
            return true;
        } else {
            return false;
        }
    } else if candidate == 1 {
        return false;
    }

    let mut i: u32 = 3;

    while i * i <= candidate {
        if (candidate % i) == 0 {
            return false;
        }

        i += 2;
    }

    return true;
}

fn main() {
    println!("Test output:\n{}", build_triangle(50));
}

fn build_triangle(number_of_rows: u32) -> IntegerTriangle {
    assert!(number_of_rows > 0);

    let mut rows: Vec<IntegerRow> = Vec::with_capacity(number_of_rows as usize);

    let mut current_index: u32 = 1;

    for row_number in 0..=number_of_rows {
        // we insert that many numbers like what row number this is.
        let mut integers_in_row: Vec<Integer> = Vec::with_capacity(row_number as usize);

        for i in current_index..=(current_index + row_number) {
            integers_in_row.push(Integer::from_raw(i));
        }

        // we need to add one here, because we start with 0 in the outer loop
        current_index += row_number + 1;

        rows.push(IntegerRow {
            numbers: integers_in_row,
        });
    }

    IntegerTriangle { rows }
}