Решение на Matrix 4 от Никола Николов

Обратно към всички решения

Към профила на Никола Николов

Код

#[derive(Debug)]

pub struct Matrix<T: Clone> {

pub cells: [Cell<T>; 4],

}

#[derive(Debug, Clone, PartialEq)]

pub struct Cell<T>(pub T);

impl<T: Clone> Matrix<T> {

pub fn new(data: &[T; 4]) -> Matrix<T> {

let cells = [

Cell(data[0].clone()),

Cell(data[1].clone()),

Cell(data[2].clone()),

Cell(data[3].clone()),

];

Matrix { cells }

}

pub fn by_row(&self) -> Vec<Cell<T>> {

let mut result = Vec::new();

for cell in self.cells.clone() {

result.push(Cell(cell.0));

}

result

}

pub fn by_col(&self) -> Vec<Cell<T>> {

let mut result = Vec::new();

result.push(Cell(self.cells[0].0.clone()));

result.push(Cell(self.cells[2].0.clone()));

result.push(Cell(self.cells[1].0.clone()));

result.push(Cell(self.cells[3].0.clone()));

result

}

}

impl std::ops::Add<Cell<String>> for Cell<i32> {

type Output = Cell<String>;

fn add(self, rhs: Cell<String>) -> Self::Output {

if self.0 >= 0 {

Cell(self.0.to_string() + " " + &rhs.0)

} else {

Cell(rhs.0.chars().rev().collect::<String>() + " " + &self.0.abs().to_string())

}

}

}

impl std::ops::Mul<Cell<String>> for Cell<i32> {

type Output = Cell<String>;

fn mul(self, rhs: Cell<String>) -> Self::Output {

let mut result_str = String::new();

let string_to_multiply;

let multiplier;

if self.0 >= 0 {

string_to_multiply = rhs.0;

multiplier = self.0;

} else {

string_to_multiply = rhs.0.chars().rev().collect::<String>();

multiplier = self.0.abs();

}

for _ in 0..multiplier {

result_str += &string_to_multiply

}

Cell(result_str)

}

}

impl std::ops::Add<Matrix<String>> for Matrix<i32> {

type Output = Matrix<String>;

fn add(self, rhs: Matrix<String>) -> Self::Output {

let left_cells = self.by_row();

let right_cells = rhs.by_row();

Matrix::new(&[

(left_cells[0].clone() + right_cells[0].clone()).0,

(left_cells[1].clone() + right_cells[1].clone()).0,

(left_cells[2].clone() + right_cells[2].clone()).0,

(left_cells[3].clone() + right_cells[3].clone()).0,

])

}

}

impl std::ops::Mul<Matrix<String>> for Matrix<i32> {

type Output = String;

fn mul(self, rhs: Matrix<String>) -> Self::Output {

let left_cells = self.by_row();

let right_cells = rhs.by_col();

vec![

(left_cells[0].clone() * right_cells[0].clone()).0,

(left_cells[1].clone() * right_cells[1].clone()).0,

(left_cells[2].clone() * right_cells[2].clone()).0,

(left_cells[3].clone() * right_cells[3].clone()).0,

].join(" ")

}

}

#[cfg(test)]

mod tests {

#[test]

fn it_creates_matrix_from_data() {

let i32_data = [1, 2, 3, 4];

let i32_matrix = super::Matrix::new(&i32_data);

assert_eq!(i32_matrix.cells.map(|c| c.0), i32_data);

let string_data = [

String::from("foo"),

String::from("bar"),

String::from("baz"),

String::from("surprise"),

];

let string_matrix = super::Matrix::new(&string_data);

assert_eq!(string_matrix.cells.map(|c| c.0), string_data);

}

#[test]

fn it_returns_matrix_cells_by_row() {

let i32_matrix = super::Matrix::new(&[1, 2, 3, 4]);

assert_eq!(

i32_matrix.by_row(),

vec![

super::Cell(1),

super::Cell(2),

super::Cell(3),

super::Cell(4),

]

);

let string_matrix = super::Matrix::new(&[

String::from("foo"),

String::from("waa"),

String::from("boo"),

String::from("baz"),

]);

assert_eq!(

string_matrix.by_row(),

vec![

super::Cell(String::from("foo")),

super::Cell(String::from("waa")),

super::Cell(String::from("boo")),

super::Cell(String::from("baz"))

]

)

}

#[test]

fn it_returns_matrix_cells_by_col() {

let i32_matrix = super::Matrix::new(&[1, 2, 3, 4]);

assert_eq!(

i32_matrix.by_col(),

vec![

super::Cell(1),

super::Cell(3),

super::Cell(2),

super::Cell(4),

]

);

let string_matrix = super::Matrix::new(&[

String::from("foo"),

String::from("waa"),

String::from("boo"),

String::from("baz"),

]);

assert_eq!(

string_matrix.by_col(),

vec![

super::Cell(String::from("foo")),

super::Cell(String::from("boo")),

super::Cell(String::from("waa")),

super::Cell(String::from("baz"))

]

)

}

#[test]

fn it_adds_string_cell_to_positive_i32_cell() {

assert_eq!(

super::Cell(22) + super::Cell(String::from("years ago")),

super::Cell(String::from("22 years ago"))

);

assert_eq!(

super::Cell(0) + super::Cell(String::from("expectation")),

super::Cell(String::from("0 expectation"))

)

}

#[test]

fn it_adds_string_cell_to_negative_i32_cell() {

assert_eq!(

super::Cell(-4) + super::Cell(String::from("xirtam")),

super::Cell(String::from("matrix 4"))

);

assert_eq!(

super::Cell(-5) + super::Cell(String::from("Нещо на кирилица")),

super::Cell(String::from("ацилирик ан ощеН 5"))

);

assert_eq!(

super::Cell(-3) + super::Cell(String::from("Vær så snill")),

super::Cell(String::from("llins ås ræV 3"))

);

assert_eq!(

super::Cell(-1) + super::Cell(String::from("🥶😔😟😕☹😭😤")),

super::Cell(String::from("😤😭☹😕😟😔🥶 1"))

);

}

#[test]

fn it_multiplies_string_cell_by_positive_i32_cell() {

assert_eq!(

super::Cell(3) * super::Cell(String::from("woah!")),

super::Cell(String::from("woah!woah!woah!"))

);

assert_eq!(

super::Cell(0) * super::Cell(String::from("woah?")),

super::Cell(String::from(""))

)

}

#[test]

fn it_multiplies_string_cell_by_negative_i32_cell() {

assert_eq!(

super::Cell(-3) * super::Cell(String::from(",regdab")),

super::Cell(String::from("badger,badger,badger,"))

);

assert_eq!(

super::Cell(-2) * super::Cell(String::from("как сме")),

super::Cell(String::from("емс какемс как"))

);

assert_eq!(

super::Cell(-3) * super::Cell(String::from("😟😔🥶")),

super::Cell(String::from("🥶😔😟🥶😔😟🥶😔😟"))

);

}

#[test]

fn it_adds_string_matrix_to_i32_matrix() {

let m1 = super::Matrix::new(&[1, 2, 3, 4]);

let m2 = super::Matrix::new(&[

String::from("waa"),

String::from("bar"),

String::from("gaz"),

String::from("bazybar"),

]);

assert_eq!(

(m1 + m2).cells.map(|c| c.0),

[

String::from("1 waa"),

String::from("2 bar"),

String::from("3 gaz"),

String::from("4 bazybar"),

]

);

let m3 = super::Matrix::new(&[-1, -5, -3, 6]);

let m4 = super::Matrix::new(&[

String::from("как сме"),

String::from("😟😔🥶"),

String::from("Vær så snill"),

String::from("woo"),

]);

assert_eq!(

(m3 + m4).cells.map(|c| c.0),

[

String::from("емс как 1"),

String::from("🥶😔😟 5"),

String::from("llins ås ræV 3"),

String::from("6 woo"),

]

)

}

#[test]

fn it_multiplies_string_matrix_by_i32_matrix() {

let m1 = super::Matrix::new(&[1, 2, 3, 1]);

let m2 = super::Matrix::new(&[

String::from("one"),

String::from("two"),

String::from("three"),

String::from("you get it"),

]);

assert_eq!(

m1 * m2,

String::from("one threethree twotwotwo you get it")

);

let m3 = super::Matrix::new(&[-1, -2, -3, 1]);

let m4 = super::Matrix::new(&[

String::from("как сме"),

String::from("😟😔🥶"),

String::from("Vær så snill"),

String::from("woo"),

]);

assert_eq!(

m3 * m4,

String::from("емс как llins ås ræVllins ås ræV 🥶😔😟🥶😔😟🥶😔😟 woo")

)

}

}

Лог от изпълнението

Compiling solution v0.1.0 (/tmp/d20220112-2706256-6f8ins/solution)
    Finished test [unoptimized + debuginfo] target(s) in 7.94s
     Running tests/solution_test.rs (target/debug/deps/solution_test-4c880d3f0adaac34)

running 15 tests
test solution_test::test_adding_int_and_string_negative ... ok
test solution_test::test_adding_int_and_string_positive ... ok
test solution_test::test_adding_int_and_string_unicode ... ok
test solution_test::test_adding_int_and_string_zero ... ok
test solution_test::test_adding_matrices_1 ... ok
test solution_test::test_adding_matrices_2 ... ok
test solution_test::test_blank_strings ... ok
test solution_test::test_iterating_i32s ... ok
test solution_test::test_iterating_strings ... ok
test solution_test::test_multiplying_int_and_string_negative ... ok
test solution_test::test_multiplying_int_and_string_positive ... ok
test solution_test::test_multiplying_int_and_string_unicode ... ok
test solution_test::test_multiplying_int_and_string_zero ... ok
test solution_test::test_multiplying_matrices_1 ... ok
test solution_test::test_multiplying_matrices_2 ... ok

test result: ok. 15 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

История (1 версия и 1 коментар)