Програмиране с Rust

Курс във Факултета по Математика и Информатика към СУ

Решение на Matrix 4 от Мариян Момчилов

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

Към профила на Мариян Момчилов

Резултати

  • 20 точки от тестове
  • 0 бонус точки
  • 20 точки общо
  • 15 успешни тест(а)
  • 0 неуспешни тест(а)

Код

use std::ops::Add;
use std::ops::Mul;
#[derive(Debug)]
pub struct Matrix<T: Clone> {
buff: Vec<T>
}
#[derive(Debug, Clone, PartialEq)]
pub struct Cell<T>(pub T);
impl<T: Clone> Matrix<T> {
/// Данните се очаква да бъдат подадени със статичен масив -- вижте по-долу за примери за
/// конструиране. Какви може да са елементите? Ще тестваме само с два типа: String и i32.
///
/// Очаква се да бъдат подадени по редове, от ляво надясно. Тоест, ако подадем като вход списък
/// с елементи: 1, 2, 3, 4, се очаква конструираната матрица:
///
/// | 1 2 |
/// | 3 4 |
///
/// Забележете, че подаваме като вход някакъв slice -- reference тип. Не очакваме матрицата да
/// държи reference, клонирайте си данните, за да имате ownership.
///
pub fn new(data: &[T; 4]) -> Matrix<T> {
let mut buff = Vec::<T>::new();
for el in data.iter() {
buff.push(el.clone());
}
Matrix{buff}
}
/// Връща вектор, който съдържа в себе си всички 4 елемента на матрицата, наредени по редове,
/// от ляво надясно и от горе надолу, обвити в `Cell`. Тоест, ако матрицата изглежда така:
///
/// | 1 2 |
/// | 3 4 |
///
/// Очакваме `.by_row` да върне елементите в ред: 1, 2, 3, 4
///
pub fn by_row(&self) -> Vec<Cell<T>> {
let mut buff = Vec::<Cell<T>>::new();
for el in self.buff.iter() {
buff.push(Cell(el.clone()));
}
buff
}
/// Връща вектор, който съдържа в себе си всички 4 елемента на матрицата, наредени по колони,
/// от горе надолу и от ляво надясно, Обвити в `Cell`. Тоест, ако матрицата изглежда така:
///
/// | 1 2 |
/// | 3 4 |
///
/// Очакваме `.by_col` да върне елементите в ред: 1, 3, 2, 4
///
pub fn by_col(&self) -> Vec<Cell<T>> {
let mut buff = Vec::<Cell<T>>::new();
for j in 0..2 {
for i in 0..2 {
buff.push(Cell(self.buff[j + i * 2].clone()));
}
}
buff
}
}
impl Add<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn add(self, rhs: Cell<String>) -> Cell<String> {
if self.0 < 0 {
return Cell(rhs.0.chars().rev().collect::<String>() + " " + &(self.0 * -1).to_string());
}
Cell(self.0.to_string() + " " + &rhs.0)
}
}
impl Mul<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn mul(self, rhs: Cell<String>) -> Cell<String> {
if self.0 >= 0 {
return Cell(rhs.0.repeat(self.0 as usize));
}
Cell(rhs.0.chars().rev().collect::<String>().repeat((self.0 * -1) as usize))
}
}
impl Add<Matrix<String>> for Matrix<i32> {
type Output = Matrix<String>;
fn add(self, rhs: Matrix<String>) -> Matrix<String> {
let lhs = self.by_row();
let rhs = rhs.by_row();
let mut arr: [String; 4] = [String::new(), String::new(), String::new(), String::new()];
for i in 0..4 {
let number_cell = lhs[i].clone();
let string_cell = rhs[i].clone();
arr[i] = (number_cell + string_cell).0;
}
Matrix::new(&arr)
}
}
impl Mul<Matrix<String>> for Matrix<i32> {
type Output = String;
fn mul(self, rhs: Matrix<String>) -> String {
let lhs_row = self.by_row();
let rhs_col = rhs.by_col();
let mut result = String::new();
for i in 0..4 {
let number_cell = lhs_row[i].clone();
let string_cell = rhs_col[i].clone();
result = result + (number_cell * string_cell).0.as_str();
if i < 3 {
result.push(' ');
}
}
result
}
}

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

Compiling solution v0.1.0 (/tmp/d20220112-2706256-946x3x/solution)
    Finished test [unoptimized + debuginfo] target(s) in 7.53s
     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

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

Мариян качи първо решение на 17.11.2021 22:57 (преди почти 4 години)

Мариян качи решение на 17.11.2021 22:59 (преди почти 4 години)

use std::ops::Add;
use std::ops::Mul;
#[derive(Debug)]
pub struct Matrix<T: Clone> {
buff: Vec<T>
}
#[derive(Debug, Clone, PartialEq)]
pub struct Cell<T>(pub T);
impl<T: Clone> Matrix<T> {
/// Данните се очаква да бъдат подадени със статичен масив -- вижте по-долу за примери за
/// конструиране. Какви може да са елементите? Ще тестваме само с два типа: String и i32.
///
/// Очаква се да бъдат подадени по редове, от ляво надясно. Тоест, ако подадем като вход списък
/// с елементи: 1, 2, 3, 4, се очаква конструираната матрица:
///
/// | 1 2 |
/// | 3 4 |
///
/// Забележете, че подаваме като вход някакъв slice -- reference тип. Не очакваме матрицата да
/// държи reference, клонирайте си данните, за да имате ownership.
///
pub fn new(data: &[T; 4]) -> Matrix<T> {
let mut buff = Vec::<T>::new();
for el in data.iter() {
buff.push(el.clone());
}
Matrix{buff}
}
/// Връща вектор, който съдържа в себе си всички 4 елемента на матрицата, наредени по редове,
/// от ляво надясно и от горе надолу, обвити в `Cell`. Тоест, ако матрицата изглежда така:
///
/// | 1 2 |
/// | 3 4 |
///
/// Очакваме `.by_row` да върне елементите в ред: 1, 2, 3, 4
///
pub fn by_row(&self) -> Vec<Cell<T>> {
let mut buff = Vec::<Cell<T>>::new();
for el in self.buff.iter() {
buff.push(Cell(el.clone()));
}
buff
}
/// Връща вектор, който съдържа в себе си всички 4 елемента на матрицата, наредени по колони,
/// от горе надолу и от ляво надясно, Обвити в `Cell`. Тоест, ако матрицата изглежда така:
///
/// | 1 2 |
/// | 3 4 |
///
/// Очакваме `.by_col` да върне елементите в ред: 1, 3, 2, 4
///
pub fn by_col(&self) -> Vec<Cell<T>> {
let mut buff = Vec::<Cell<T>>::new();
for j in 0..2 {
for i in 0..2 {
buff.push(Cell(self.buff[j + i * 2].clone()));
}
}
buff
}
}
impl Add<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn add(self, rhs: Cell<String>) -> Cell<String> {
if self.0 < 0 {
return Cell(rhs.0.chars().rev().collect::<String>() + " " + &(self.0 * -1).to_string());
}
Cell(self.0.to_string() + " " + &rhs.0)
}
}
impl Mul<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn mul(self, rhs: Cell<String>) -> Cell<String> {
if self.0 >= 0 {
return Cell(rhs.0.repeat(self.0 as usize));
}
Cell(rhs.0.chars().rev().collect::<String>().repeat((self.0 * -1) as usize))
}
}
impl Add<Matrix<String>> for Matrix<i32> {
type Output = Matrix<String>;
fn add(self, rhs: Matrix<String>) -> Matrix<String> {
let lhs = self.by_row();
let rhs = rhs.by_row();
let mut arr: [String; 4] = [String::new(), String::new(), String::new(), String::new()];
for i in 0..4 {
let number_cell = lhs[i].clone();
let string_cell = rhs[i].clone();
arr[i] = (number_cell + string_cell).0;
}
Matrix::new(&arr)
}
}
impl Mul<Matrix<String>> for Matrix<i32> {
type Output = String;
fn mul(self, rhs: Matrix<String>) -> String {
let lhs_row = self.by_row();
let rhs_col = rhs.by_col();
- println!("{:?}", rhs_col);
let mut result = String::new();
for i in 0..4 {
let number_cell = lhs_row[i].clone();
let string_cell = rhs_col[i].clone();
result = result + (number_cell * string_cell).0.as_str();
if i < 3 {
result.push(' ');
}
}
result
}
-}
+}