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

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

Решение на Matrix 4 от Ивайло Димитров

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

Към профила на Ивайло Димитров

Резултати

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

Код

#[derive(Debug, Clone, PartialEq)]
pub struct Cell<T>(pub T);
impl std::ops::Add<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn add(self, rhs: Cell<String>) -> Cell<String> {
let nr = self.0;
if nr >= 0 {
Cell(nr.to_string() + " " + &rhs.0)
}
else {
Cell(rhs.0.chars().rev().collect::<String>() + " " + &(-nr).to_string())
}
}
}
impl std::ops::Mul<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn mul(self, rhs: Cell<String>) -> Cell<String> {
let nr = self.0;
if nr >= 0 {
Cell(rhs.0.repeat(nr as usize))
}
else {
Cell(rhs.0.chars().rev().collect::<String>().repeat((-nr) as usize))
}
}
}
#[derive(Debug)]
pub struct Matrix<T: Clone> {
// size е размера на матрицата
size: usize,
elements: Vec<Cell<T>>,
}
impl<T: Clone> Matrix<T> {
pub fn new(data: &[T; 4]) -> Matrix<T> {
let mut elements: Vec<Cell<T>> = Vec::new();
let size = (data.len() as f64).sqrt() as usize;
for var in data {
elements.push(Cell(var.clone()));
}
Matrix {size, elements}
}
pub fn by_row(&self) -> Vec<Cell<T>> {
self.elements.clone()
}
pub fn by_col(&self) -> Vec<Cell<T>> {
let mut elements_by_column: Vec<Cell<T>> = Vec::new();
for i in 0..self.size {
for j in 0..self.size {
elements_by_column.push(self.elements[j * self.size + i].clone());
}
}
elements_by_column
}
}
impl std::ops::Add<Matrix<String>> for Matrix<i32> {
type Output = Matrix<String>;
fn add(self, rhs: Matrix<String>) -> Matrix<String> {
if self.size != rhs.size {
panic!("Matrices should be of same size")
}
let mut result: Vec<Cell<String>> = Vec::new();
for iterator_pair in self.elements.iter().zip(rhs.elements.iter()) {
let (first_elem, second_elem) = iterator_pair;
result.push(first_elem.clone() + second_elem.clone());
}
Matrix{size: self.size, elements: result}
}
}
impl std::ops::Mul<Matrix<String>> for Matrix<i32> {
type Output = String;
fn mul(self, rhs: Matrix<String>) -> String {
if self.size != rhs.size {
panic!("Matrices should be of same size")
}
let mut result = String::from("");
// iterate second matrix by columns
for iterator_pair in self.elements.iter().zip(rhs.by_col().iter()) {
let (first_elem, second_elem) = iterator_pair;
result += " ";
result += &(first_elem.clone() * second_elem.clone()).0;
}
result.trim().to_string()
}
}

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

Compiling solution v0.1.0 (/tmp/d20220112-2706256-1n9g7nm/solution)
    Finished test [unoptimized + debuginfo] target(s) in 8.00s
     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 коментара)

Ивайло качи първо решение на 18.11.2021 15:15 (преди почти 4 години)

Ивайло качи решение на 18.11.2021 16:55 (преди почти 4 години)

-use std::mem::ManuallyDrop;
-
#[derive(Debug, Clone, PartialEq)]
pub struct Cell<T>(pub T);
impl std::ops::Add<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn add(self, rhs: Cell<String>) -> Cell<String> {
let nr = self.0;
if nr >= 0 {
Cell(nr.to_string() + " " + &rhs.0)
}
else {
Cell(rhs.0.chars().rev().collect::<String>() + " " + &(-nr).to_string())
}
}
}
impl std::ops::Mul<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn mul(self, rhs: Cell<String>) -> Cell<String> {
let nr = self.0;
if nr >= 0 {
Cell(rhs.0.repeat(nr as usize))
}
else {
Cell(rhs.0.chars().rev().collect::<String>().repeat((-nr) as usize))
}
}
}
#[derive(Debug)]
pub struct Matrix<T: Clone> {
- // Каквито данни ви вършат работа
+ // size е размера на матрицата
size: usize,
elements: Vec<Cell<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 elements: Vec<Cell<T>> = Vec::new();
let size = (data.len() as f64).sqrt() as usize;
for var in data {
elements.push(Cell(var.clone()));
}
Matrix {size, elements}
}
- /// Връща вектор, който съдържа в себе си всички 4 елемента на матрицата, наредени по редове,
- /// от ляво надясно и от горе надолу, обвити в `Cell`. Тоест, ако матрицата изглежда така:
- ///
- /// | 1 2 |
- /// | 3 4 |
- ///
- /// Очакваме `.by_row` да върне елементите в ред: 1, 2, 3, 4
- ///
pub fn by_row(&self) -> Vec<Cell<T>> {
self.elements.clone()
}
- /// Връща вектор, който съдържа в себе си всички 4 елемента на матрицата, наредени по колони,
- /// от горе надолу и от ляво надясно, Обвити в `Cell`. Тоест, ако матрицата изглежда така:
- ///
- /// | 1 2 |
- /// | 3 4 |
- ///
- /// Очакваме `.by_col` да върне елементите в ред: 1, 3, 2, 4
- ///
pub fn by_col(&self) -> Vec<Cell<T>> {
- let mut elementsByColumn: Vec<Cell<T>> = Vec::new();
+ let mut elements_by_column: Vec<Cell<T>> = Vec::new();
for i in 0..self.size {
for j in 0..self.size {
- elementsByColumn.push(self.elements[j * self.size + i].clone());
+ elements_by_column.push(self.elements[j * self.size + i].clone());
}
}
- elementsByColumn
+ elements_by_column
}
}
impl std::ops::Add<Matrix<String>> for Matrix<i32> {
type Output = Matrix<String>;
fn add(self, rhs: Matrix<String>) -> Matrix<String> {
if self.size != rhs.size {
panic!("Matrices should be of same size")
}
let mut result: Vec<Cell<String>> = Vec::new();
for iterator_pair in self.elements.iter().zip(rhs.elements.iter()) {
let (first_elem, second_elem) = iterator_pair;
result.push(first_elem.clone() + second_elem.clone());
}
Matrix{size: self.size, elements: result}
}
}
impl std::ops::Mul<Matrix<String>> for Matrix<i32> {
type Output = String;
fn mul(self, rhs: Matrix<String>) -> String {
if self.size != rhs.size {
panic!("Matrices should be of same size")
}
let mut result = String::from("");
// iterate second matrix by columns
for iterator_pair in self.elements.iter().zip(rhs.by_col().iter()) {
let (first_elem, second_elem) = iterator_pair;
result += " ";
result += &(first_elem.clone() * second_elem.clone()).0;
}
result.trim().to_string()
}
}