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

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

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

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

Към профила на Николай Петков

Резултати

  • 16 точки от тестове
  • 0 бонус точки
  • 16 точки общо
  • 12 успешни тест(а)
  • 3 неуспешни тест(а)

Код

use std::ops::{Add, Mul, Neg};
#[derive(Debug)]
pub struct Matrix<T: Clone> {
contents: Vec<Cell<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> {
Matrix { contents: data.to_owned().into_iter().map(|c| Cell(c)).collect() }
}
/// Връща вектор, който съдържа в себе си всички 4 елемента на матрицата, наредени по редове,
/// от ляво надясно и от горе надолу, обвити в `Cell`. Тоест, ако матрицата изглежда така:
///
/// | 1 2 |
/// | 3 4 |
///
/// Очакваме `.by_row` да върне елементите в ред: 1, 2, 3, 4
///
pub fn by_row(&self) -> Vec<Cell<T>> {
self.contents.clone()
}
/// Връща вектор, който съдържа в себе си всички 4 елемента на матрицата, наредени по колони,
/// от горе надолу и от ляво надясно, Обвити в `Cell`. Тоест, ако матрицата изглежда така:
///
/// | 1 2 |
/// | 3 4 |
///
/// Очакваме `.by_col` да върне елементите в ред: 1, 3, 2, 4
///
pub fn by_col(&self) -> Vec<Cell<T>> {
let mut col1: Vec<Cell<T>> = self.contents
.iter()
.step_by(2)
.map(|c| c.clone())
.collect();
let mut col2: Vec<Cell<T>> = self.contents
.iter()
.skip(1)
.step_by(2)
.map(|c| c.clone())
.collect();
col1.append(&mut col2);
col1
}
}
impl Add<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn add(self, rhs: Cell<String>) -> Self::Output {
if self.0 > -1 {
let result = format!("{} {}", self.0, rhs.0);
Cell(result)
} else {
let result = format!("{} {}", self.0.neg(), rhs.0.chars().rev().collect::<String>());
Cell(result)
}
}
}
impl Mul<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn mul(self, rhs: Cell<String>) -> Self::Output {
if self.0 > -1 {
Cell(rhs.0.repeat(self.0 as usize))
} else {
Cell(rhs.0.chars().rev().collect::<String>().repeat(self.0.neg() as usize))
}
}
}
impl Add<Matrix<String>> for Matrix<i32> {
type Output = Matrix<String>;
fn add(self, rhs: Matrix<String>) -> Self::Output {
let result: [String; 4] = self.contents
.into_iter()
.zip(rhs.contents.into_iter())
.map(|(a, b)| (a + b).0)
.collect::<Vec<String>>()
.try_into()
.unwrap();
Matrix::new(&result)
}
}
impl Mul<Matrix<String>> for Matrix<i32> {
type Output = String;
fn mul(self, rhs: Matrix<String>) -> Self::Output {
self.by_row()
.into_iter()
.zip(rhs.by_col().into_iter())
.map(|(a, b)| (a * b).0)
.collect::<Vec<String>>().join(" ")
}
}

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

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

running 15 tests
test solution_test::test_adding_int_and_string_negative ... FAILED
test solution_test::test_adding_int_and_string_positive ... ok
test solution_test::test_adding_int_and_string_unicode ... FAILED
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 ... FAILED
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

failures:

---- solution_test::test_adding_int_and_string_negative stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `"2 regdab"`,
 right: `"regdab 2"`', tests/solution_test.rs:55:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

---- solution_test::test_adding_int_and_string_unicode stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `"3 апо"`,
 right: `"апо 3"`', tests/solution_test.rs:64:5

---- solution_test::test_adding_matrices_2 stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `[Cell("1 едно"), Cell("0 две"), Cell("3  "), Cell("37  иритеч")]`,
 right: `[Cell("1 едно"), Cell("0 две"), Cell("  3"), Cell(" иритеч 37")]`', tests/solution_test.rs:125:5


failures:
    solution_test::test_adding_int_and_string_negative
    solution_test::test_adding_int_and_string_unicode
    solution_test::test_adding_matrices_2

test result: FAILED. 12 passed; 3 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass '--test solution_test'

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

Николай качи първо решение на 16.11.2021 22:17 (преди почти 4 години)

Николай качи решение на 16.11.2021 22:29 (преди почти 4 години)

use std::ops::{Add, Mul};
#[derive(Debug)]
pub struct Matrix<T: Clone> {
contents: Vec<Cell<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> {
Matrix{contents: data.to_owned().into_iter().map(|c| Cell(c)).collect()}
}
/// Връща вектор, който съдържа в себе си всички 4 елемента на матрицата, наредени по редове,
/// от ляво надясно и от горе надолу, обвити в `Cell`. Тоест, ако матрицата изглежда така:
///
/// | 1 2 |
/// | 3 4 |
///
/// Очакваме `.by_row` да върне елементите в ред: 1, 2, 3, 4
///
pub fn by_row(&self) -> Vec<Cell<T>> {
self.contents.clone()
}
/// Връща вектор, който съдържа в себе си всички 4 елемента на матрицата, наредени по колони,
/// от горе надолу и от ляво надясно, Обвити в `Cell`. Тоест, ако матрицата изглежда така:
///
/// | 1 2 |
/// | 3 4 |
///
/// Очакваме `.by_col` да върне елементите в ред: 1, 3, 2, 4
///
pub fn by_col(&self) -> Vec<Cell<T>> {
let mut a: Vec<Cell<T>> = self.contents.clone().into_iter().step_by(2).collect();
let mut b: Vec<Cell<T>> = self.contents.clone().into_iter().skip(1).step_by(2).collect();
a.append(&mut b);
a
}
}
impl Add<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn add(self, rhs: Cell<String>) -> Self::Output {
if self.0 > -1 {
let result = format!("{} {}", self.0, rhs.0);
Cell(result)
} else {
let result = format!("{} {}", self.0 * -1, rhs.0.chars().rev().collect::<String>());
Cell(result)
}
}
}
impl Mul<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn mul(self, rhs: Cell<String>) -> Self::Output {
if self.0 > -1 {
Cell(rhs.0.repeat(self.0 as usize))
} else {
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>) -> Self::Output {
let result: [String; 4] = self.contents.into_iter().zip(rhs.contents.into_iter())
.map(|(a, b)| (a + b).0)
.collect::<Vec<String>>()
.try_into()
.unwrap();
Matrix::new(&result)
}
}
+// Това съм го объркал, утре по някое време ще го оправя :)
impl Mul<Matrix<String>> for Matrix<i32> {
type Output = Matrix<String>;
fn mul(self, rhs: Matrix<String>) -> Self::Output {
let result: [String; 4] = self.contents.into_iter().zip(rhs.contents.into_iter())
.map(|(a, b)| (a * b).0)
.collect::<Vec<String>>()
.try_into()
.unwrap();
Matrix::new(&result)
}
}

Николай качи решение на 17.11.2021 18:02 (преди почти 4 години)

use std::ops::{Add, Mul};
#[derive(Debug)]
pub struct Matrix<T: Clone> {
contents: Vec<Cell<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> {
Matrix{contents: data.to_owned().into_iter().map(|c| Cell(c)).collect()}
}
/// Връща вектор, който съдържа в себе си всички 4 елемента на матрицата, наредени по редове,
/// от ляво надясно и от горе надолу, обвити в `Cell`. Тоест, ако матрицата изглежда така:
///
/// | 1 2 |
/// | 3 4 |
///
/// Очакваме `.by_row` да върне елементите в ред: 1, 2, 3, 4
///
pub fn by_row(&self) -> Vec<Cell<T>> {
self.contents.clone()
}
/// Връща вектор, който съдържа в себе си всички 4 елемента на матрицата, наредени по колони,
/// от горе надолу и от ляво надясно, Обвити в `Cell`. Тоест, ако матрицата изглежда така:
///
/// | 1 2 |
/// | 3 4 |
///
/// Очакваме `.by_col` да върне елементите в ред: 1, 3, 2, 4
///
pub fn by_col(&self) -> Vec<Cell<T>> {
let mut a: Vec<Cell<T>> = self.contents.clone().into_iter().step_by(2).collect();
let mut b: Vec<Cell<T>> = self.contents.clone().into_iter().skip(1).step_by(2).collect();
a.append(&mut b);
a
}
}
impl Add<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn add(self, rhs: Cell<String>) -> Self::Output {
if self.0 > -1 {
let result = format!("{} {}", self.0, rhs.0);
Cell(result)
} else {
let result = format!("{} {}", self.0 * -1, rhs.0.chars().rev().collect::<String>());
Cell(result)
}
}
}
impl Mul<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn mul(self, rhs: Cell<String>) -> Self::Output {
if self.0 > -1 {
Cell(rhs.0.repeat(self.0 as usize))
} else {
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>) -> Self::Output {
let result: [String; 4] = self.contents.into_iter().zip(rhs.contents.into_iter())
.map(|(a, b)| (a + b).0)
.collect::<Vec<String>>()
.try_into()
.unwrap();
Matrix::new(&result)
}
}
-// Това съм го объркал, утре по някое време ще го оправя :)
impl Mul<Matrix<String>> for Matrix<i32> {
- type Output = Matrix<String>;
+ type Output = String;
fn mul(self, rhs: Matrix<String>) -> Self::Output {
- let result: [String; 4] = self.contents.into_iter().zip(rhs.contents.into_iter())
+ self.by_row().into_iter().zip(rhs.by_col().into_iter())
.map(|(a, b)| (a * b).0)
- .collect::<Vec<String>>()
- .try_into()
- .unwrap();
-
- Matrix::new(&result)
+ .collect::<Vec<String>>().join(" ")
}
}

Николай качи решение на 17.11.2021 18:22 (преди почти 4 години)

-use std::ops::{Add, Mul};
+use std::ops::{Add, Mul, Neg};
#[derive(Debug)]
pub struct Matrix<T: Clone> {
- contents: Vec<Cell<T>>
+ contents: Vec<Cell<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> {
- Matrix{contents: data.to_owned().into_iter().map(|c| Cell(c)).collect()}
+ Matrix { contents: data.to_owned().into_iter().map(|c| Cell(c)).collect() }
}
/// Връща вектор, който съдържа в себе си всички 4 елемента на матрицата, наредени по редове,
/// от ляво надясно и от горе надолу, обвити в `Cell`. Тоест, ако матрицата изглежда така:
///
/// | 1 2 |
/// | 3 4 |
///
/// Очакваме `.by_row` да върне елементите в ред: 1, 2, 3, 4
///
pub fn by_row(&self) -> Vec<Cell<T>> {
self.contents.clone()
}
/// Връща вектор, който съдържа в себе си всички 4 елемента на матрицата, наредени по колони,
/// от горе надолу и от ляво надясно, Обвити в `Cell`. Тоест, ако матрицата изглежда така:
///
/// | 1 2 |
/// | 3 4 |
///
/// Очакваме `.by_col` да върне елементите в ред: 1, 3, 2, 4
///
pub fn by_col(&self) -> Vec<Cell<T>> {
- let mut a: Vec<Cell<T>> = self.contents.clone().into_iter().step_by(2).collect();
- let mut b: Vec<Cell<T>> = self.contents.clone().into_iter().skip(1).step_by(2).collect();
+ let mut col1: Vec<Cell<T>> = self.contents
+ .iter()
+ .step_by(2)
+ .map(|c| c.clone())
+ .collect();
+ let mut col2: Vec<Cell<T>> = self.contents
+ .iter()
+ .skip(1)
+ .step_by(2)
+ .map(|c| c.clone())
+ .collect();
- a.append(&mut b);
- a
+ col1.append(&mut col2);
+ col1
}
}
impl Add<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn add(self, rhs: Cell<String>) -> Self::Output {
if self.0 > -1 {
let result = format!("{} {}", self.0, rhs.0);
Cell(result)
} else {
- let result = format!("{} {}", self.0 * -1, rhs.0.chars().rev().collect::<String>());
+ let result = format!("{} {}", self.0.neg(), rhs.0.chars().rev().collect::<String>());
Cell(result)
}
}
}
impl Mul<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn mul(self, rhs: Cell<String>) -> Self::Output {
if self.0 > -1 {
Cell(rhs.0.repeat(self.0 as usize))
} else {
- Cell(rhs.0.chars().rev().collect::<String>().repeat((self.0 * -1) as usize ))
+ Cell(rhs.0.chars().rev().collect::<String>().repeat(self.0.neg() as usize))
}
}
}
impl Add<Matrix<String>> for Matrix<i32> {
type Output = Matrix<String>;
fn add(self, rhs: Matrix<String>) -> Self::Output {
- let result: [String; 4] = self.contents.into_iter().zip(rhs.contents.into_iter())
+ let result: [String; 4] = self.contents
+ .into_iter()
+ .zip(rhs.contents.into_iter())
.map(|(a, b)| (a + b).0)
.collect::<Vec<String>>()
.try_into()
.unwrap();
Matrix::new(&result)
}
}
impl Mul<Matrix<String>> for Matrix<i32> {
type Output = String;
fn mul(self, rhs: Matrix<String>) -> Self::Output {
- self.by_row().into_iter().zip(rhs.by_col().into_iter())
+ self.by_row()
+ .into_iter()
+ .zip(rhs.by_col().into_iter())
.map(|(a, b)| (a * b).0)
.collect::<Vec<String>>().join(" ")
}
}