Надежда качи първо решение на 17.11.2021 17:08 (преди почти 4 години)
Първи, доста грозен вариант на домашното
Решение на Matrix 4 от Надежда Панделиева
Към профила на Надежда Панделиева
Резултати
- 20 точки от тестове
- 0 бонус точки
- 20 точки общо
- 15 успешни тест(а)
- 0 неуспешни тест(а)
Код
Лог от изпълнението
Compiling solution v0.1.0 (/tmp/d20220112-2706256-kwfzoa/solution)
Finished test [unoptimized + debuginfo] target(s) in 7.56s
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
История (4 версии и 7 коментара)
Надежда качи решение на 17.11.2021 18:43 (преди почти 4 години)
#[derive(Debug)]
pub struct Matrix<T: Clone> {
matrix: Vec<Cell<T>>
}
#[derive(Debug, Clone, PartialEq)]
pub struct Cell<T>(pub T);
impl<T: Clone> Matrix<T> {
pub fn new(data: &[T; 4]) -> Matrix<T> {
let copied_data = data.clone();
let mut new_created_matrix: Vec<Cell<T>> = Vec::new();
for item in copied_data{
new_created_matrix.push(Cell(item));
}
Matrix{
matrix:new_created_matrix
}
}
pub fn by_row(&self) -> Vec<Cell<T>> {
- // let copied_matrix = self.matrix.clone();
- // let mut matrix_by_row: Vec<Cell<T>> = Vec::new();
-
- // for var in copied_matrix{
- // matrix_by_row.push(var);
- // }
+
let matrix_by_row: Vec<Cell<T>> = self.matrix.clone();
return matrix_by_row;
}
pub fn by_col(&self) -> Vec<Cell<T>> {
let copied_matrix = self.matrix.clone();
let mut matrix_by_col: Vec<Cell<T>> = Vec::new();
matrix_by_col.push(copied_matrix[0].clone());
matrix_by_col.push(copied_matrix[2].clone());
matrix_by_col.push(copied_matrix[1].clone());
matrix_by_col.push(copied_matrix[3].clone());
return matrix_by_col;
}
}
use std::ops::Add;
use std::ops::Mul;
pub trait ToString {
fn to_string(&self) -> String;
}
impl Add<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn add(self, other: Cell<String>) -> Self::Output {
let first_var: i32 = self.0;
let mut second_var: String = other.0;
if first_var >= 0 {
return Cell(first_var.to_string() +" "+ &second_var.to_string())
} else {
let first_var = first_var.abs();
second_var = second_var.chars().rev().collect();
return Cell(second_var +" "+ &first_var.to_string());
}
}
}
impl Add<Matrix<String>> for Matrix<i32> {
type Output = Matrix<String>;
fn add(self, other: Matrix<String>) -> Self::Output {
let first_var = self.matrix;
let second_var = other.matrix;
let mut new_created_matrix: Vec<Cell<String>> = Vec::new();
for index in 0..4{
new_created_matrix.push(first_var[index].clone() + second_var[index].clone());
}
Matrix{
matrix:new_created_matrix,
}
}
}
impl Mul<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn mul(self, other: Cell<String>) -> Self::Output {
let first_var: i32 = self.0;
let mut second_var: String = other.0;
if first_var >= 0 {
//let val = second.repeat(first.try_into().unwrap());
return Cell(second_var.repeat(first_var.try_into().unwrap()));
} else {
let first_var = first_var.abs();
second_var = second_var.chars().rev().collect();
// let val = second.repeat(first.try_into().unwrap());
return Cell(second_var.repeat(first_var.try_into().unwrap()));
}
}
}
impl Mul<Matrix<String>> for Matrix<i32>{
type Output = String;
-
fn mul(self, other: Matrix<String>) -> Self::Output {
- let first_var = self.matrix;
- let second_var = other.matrix;
+ let first = self.matrix;
+ let second = Matrix::by_col(&other);
+
let mut new_matrix: String = String::new();
for index in 0..4{
- let var = format!("{} ",(first_var[index].clone() * second_var[index].clone()).0) ;
- new_matrix.push_str(&var);
+ match index{
+ 3 => new_matrix.push_str(&format!("{}",(first[index].clone() * second[index].clone()).0)),
+ _ => new_matrix.push_str(&format!("{} ",(first[index].clone() * second[index].clone()).0)),
+ }
}
- return new_matrix;
+ return new_matrix;
}
}
-
-
-
-
-
тук се сетих че съм забравила да умножавам ред по колона
Надежда качи решение на 17.11.2021 21:10 (преди почти 4 години)
+use std::ops::Add;
+use std::ops::Mul;
+
#[derive(Debug)]
pub struct Matrix<T: Clone> {
matrix: Vec<Cell<T>>
}
-
+
#[derive(Debug, Clone, PartialEq)]
pub struct Cell<T>(pub T);
-
+
impl<T: Clone> Matrix<T> {
-
+
pub fn new(data: &[T; 4]) -> Matrix<T> {
-
- let copied_data = data.clone();
- let mut new_created_matrix: Vec<Cell<T>> = Vec::new();
- for item in copied_data{
- new_created_matrix.push(Cell(item));
+
+ let mut new_created_matrix: Vec<Cell<T>> = Vec::with_capacity(4);
+
+ for item in data {
+ new_created_matrix.push(Cell(item.clone()));
}
- Matrix{
- matrix:new_created_matrix
- }
+
+ return Matrix {
+ matrix: new_created_matrix
+ };
}
-
+
pub fn by_row(&self) -> Vec<Cell<T>> {
-
- let matrix_by_row: Vec<Cell<T>> = self.matrix.clone();
- return matrix_by_row;
+
+ return self.matrix.clone();
}
-
+
pub fn by_col(&self) -> Vec<Cell<T>> {
-
- let copied_matrix = self.matrix.clone();
+
let mut matrix_by_col: Vec<Cell<T>> = Vec::new();
-
- matrix_by_col.push(copied_matrix[0].clone());
- matrix_by_col.push(copied_matrix[2].clone());
- matrix_by_col.push(copied_matrix[1].clone());
- matrix_by_col.push(copied_matrix[3].clone());
-
+
+ matrix_by_col.push(self.matrix[0].clone());
+ matrix_by_col.push(self.matrix[2].clone());
+ matrix_by_col.push(self.matrix[1].clone());
+ matrix_by_col.push(self.matrix[3].clone());
+
return matrix_by_col;
}
}
-use std::ops::Add;
-use std::ops::Mul;
-
-pub trait ToString {
- fn to_string(&self) -> String;
-}
-
+
impl Add<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
+
fn add(self, other: Cell<String>) -> Self::Output {
- let first_var: i32 = self.0;
- let mut second_var: String = other.0;
+ let first_var: i32 = self.0;
+ let mut second_var: String = other.0;
+
if first_var >= 0 {
- return Cell(first_var.to_string() +" "+ &second_var.to_string())
- } else {
- let first_var = first_var.abs();
+ return Cell(first_var.to_string() + " " + &second_var.to_string())
+ }
+ else {
+ let first_var: i32 = first_var.abs();
second_var = second_var.chars().rev().collect();
- return Cell(second_var +" "+ &first_var.to_string());
+ return Cell(second_var + " " + &first_var.to_string());
}
}
}
-
+
impl Add<Matrix<String>> for Matrix<i32> {
type Output = Matrix<String>;
-
+
fn add(self, other: Matrix<String>) -> Self::Output {
- let first_var = self.matrix;
- let second_var = other.matrix;
+ let first_var: Vec<Cell<i32>> = self.matrix;
+ let second_var: Vec<Cell<String>> = other.matrix;
let mut new_created_matrix: Vec<Cell<String>> = Vec::new();
-
- for index in 0..4{
+
+ for index in 0..4 {
new_created_matrix.push(first_var[index].clone() + second_var[index].clone());
}
-
- Matrix{
+
+ return Matrix {
matrix:new_created_matrix,
- }
+ };
}
}
-
-
+
+
impl Mul<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
-
+
fn mul(self, other: Cell<String>) -> Self::Output {
- let first_var: i32 = self.0;
- let mut second_var: String = other.0;
-
+ let first_var: i32 = self.0;
+ let mut second_var: String = other.0;
+
if first_var >= 0 {
- //let val = second.repeat(first.try_into().unwrap());
return Cell(second_var.repeat(first_var.try_into().unwrap()));
- } else {
- let first_var = first_var.abs();
+ }
+ else {
+ let first_var: i32 = first_var.abs();
second_var = second_var.chars().rev().collect();
- // let val = second.repeat(first.try_into().unwrap());
return Cell(second_var.repeat(first_var.try_into().unwrap()));
}
}
}
-
+
impl Mul<Matrix<String>> for Matrix<i32>{
type Output = String;
+
fn mul(self, other: Matrix<String>) -> Self::Output {
- let first = self.matrix;
- let second = Matrix::by_col(&other);
-
+ let first_var: Vec<Cell<i32>> = self.matrix;
+ let second_var: Vec<Cell<String>> = Matrix::by_col(&other);
let mut new_matrix: String = String::new();
- for index in 0..4{
- match index{
- 3 => new_matrix.push_str(&format!("{}",(first[index].clone() * second[index].clone()).0)),
- _ => new_matrix.push_str(&format!("{} ",(first[index].clone() * second[index].clone()).0)),
- }
- }
- return new_matrix;
+
+ new_matrix.push_str(&format!("{} ", (first_var[0].clone() * second_var[0].clone()).0));
+ new_matrix.push_str(&format!("{} ", (first_var[1].clone() * second_var[1].clone()).0));
+ new_matrix.push_str(&format!("{} ", (first_var[2].clone() * second_var[2].clone()).0));
+ new_matrix.push_str(&format!("{}" , (first_var[3].clone() * second_var[3].clone()).0));
+
+ return new_matrix;
}
-}
+}
Така вече е по-добре(извинявам се за тъпите имена на променливите, не ме бива в това). Време е да започнем да мислим за по-интересни тестове
Надежда качи решение на 18.11.2021 08:35 (преди почти 4 години)
use std::ops::Add;
use std::ops::Mul;
#[derive(Debug)]
pub struct Matrix<T: Clone> {
matrix: Vec<Cell<T>>
}
#[derive(Debug, Clone, PartialEq)]
pub struct Cell<T>(pub T);
impl<T: Clone> Matrix<T> {
pub fn new(data: &[T; 4]) -> Matrix<T> {
let mut new_created_matrix: Vec<Cell<T>> = Vec::with_capacity(4);
for item in data {
new_created_matrix.push(Cell(item.clone()));
}
return Matrix {
matrix: new_created_matrix
};
}
Ако "Matrix" е името на типа, може би вътрешната стойност не е добре също да е "matrix" -- две различни неща са. Може би "cells" щеше да е по-удачно, и например new_created_matrix можеше да е new_matrix_cells. Също и по-надолу, cells_by_col etc. Basically, името на стойността има смисъл да е консистентно с типа ѝ.
pub fn by_row(&self) -> Vec<Cell<T>> {
return self.matrix.clone();
}
pub fn by_col(&self) -> Vec<Cell<T>> {
let mut matrix_by_col: Vec<Cell<T>> = Vec::new();
matrix_by_col.push(self.matrix[0].clone());
matrix_by_col.push(self.matrix[2].clone());
matrix_by_col.push(self.matrix[1].clone());
matrix_by_col.push(self.matrix[3].clone());
return matrix_by_col;
}
}
impl Add<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn add(self, other: Cell<String>) -> Self::Output {
let first_var: i32 = self.0;
let mut second_var: String = other.0;
if first_var >= 0 {
return Cell(first_var.to_string() + " " + &second_var.to_string())
}
else {
let first_var: i32 = first_var.abs();
second_var = second_var.chars().rev().collect();
return Cell(second_var + " " + &first_var.to_string());
}
}
"First var" и "Second var" са малко мета имена :). Името е добре да описва не какво е това в контекста на текущия блок код, а каква е тази стойност. Може би first_value вместо first_var щеше да е по-удачно. Допълнително, в случая първото и второто нещо са и различни типове неща, така че може би number и string щяха да са ок като имена. И като видиш string.to_string() и можеш да си кажеш "хм, защо изобщо го to-string-вам, като вече е string" :D. (В случая, може би move semantics, но тогава .clone() ще изясни по-добре какво правиш)
}
impl Add<Matrix<String>> for Matrix<i32> {
type Output = Matrix<String>;
fn add(self, other: Matrix<String>) -> Self::Output {
let first_var: Vec<Cell<i32>> = self.matrix;
let second_var: Vec<Cell<String>> = other.matrix;
let mut new_created_matrix: Vec<Cell<String>> = Vec::new();
for index in 0..4 {
new_created_matrix.push(first_var[index].clone() + second_var[index].clone());
}
return Matrix {
matrix:new_created_matrix,
};
}
}
impl Mul<Cell<String>> for Cell<i32> {
type Output = Cell<String>;
fn mul(self, other: Cell<String>) -> Self::Output {
let first_var: i32 = self.0;
let mut second_var: String = other.0;
if first_var >= 0 {
return Cell(second_var.repeat(first_var.try_into().unwrap()));
}
else {
let first_var: i32 = first_var.abs();
second_var = second_var.chars().rev().collect();
return Cell(second_var.repeat(first_var.try_into().unwrap()));
}
}
}
impl Mul<Matrix<String>> for Matrix<i32>{
type Output = String;
fn mul(self, other: Matrix<String>) -> Self::Output {
let first_var: Vec<Cell<i32>> = self.matrix;
let second_var: Vec<Cell<String>> = Matrix::by_col(&other);
let mut new_matrix: String = String::new();
new_matrix.push_str(&format!("{} ", (first_var[0].clone() * second_var[0].clone()).0));
new_matrix.push_str(&format!("{} ", (first_var[1].clone() * second_var[1].clone()).0));
new_matrix.push_str(&format!("{} ", (first_var[2].clone() * second_var[2].clone()).0));
new_matrix.push_str(&format!("{}" , (first_var[3].clone() * second_var[3].clone()).0));
return new_matrix;
}
+}
+
+#[cfg(test)]
+
+mod tests{
+ use super::*;
+
+ fn string_cell_vec(s1: &str, s2: &str, s3: &str, s4: &str) -> Vec<Cell<String>> {
+ [s1, s2, s3, s4].into_iter().map(String::from).map(Cell).collect::<Vec<Cell<String>>>()
+ }
+
+ #[test]
+ fn test_for_cell_addition() {
+ assert_eq!((Cell(4) + Cell(String::from("badger"))).0, String::from("4 badger"));
+ assert_eq!((Cell(-4) + Cell(String::from("gmo"))).0, String::from("omg 4"));
+ assert_eq!((Cell(0) + Cell(String::from("hello"))).0, String::from("0 hello"));
+ }
+
+ #[test]
+ fn test_for_cell_multiplication() {
+ assert_eq!((Cell(4) * Cell(String::from("badger"))).0, String::from("badgerbadgerbadgerbadger"));
+ assert_eq!((Cell(-4) * Cell(String::from("gmo"))).0, String::from("omgomgomgomg"));
+ assert_eq!((Cell(-10) * Cell(String::from(" deiputs yrev"))).0, String::from("very stupied very stupied very stupied very stupied very stupied very stupied very stupied very stupied very stupied very stupied "));
+ assert_eq!((Cell(0) * Cell(String::from("hello"))).0, String::from(""));
+ }
+
+ #[test]
+ fn test_for_matrix_addition() {
+ let matrix1 = Matrix::new(&[-1, -2, -3, -4]);
+ let matrix2 = Matrix::new(&[
+ String::from("olleH"),String::from("sdneirf"),
+ String::from("morf"), String::from("tsuR"),
+ ]);
+ assert_eq!((matrix1 + matrix2).by_row(),string_cell_vec("Hello 1","friends 2","from 3","Rust 4") );
+
+ let matrix1 = Matrix::new(&[-1, 2, -3, 4]);
+ let matrix2 = Matrix::new(&[
+ String::from("olleH"),String::from("friends"),
+ String::from("morf"), String::from("Rust"),
+ ]);
+ assert_eq!((matrix1 + matrix2).by_row(),string_cell_vec("Hello 1","2 friends","from 3","4 Rust") );
+
+ let matrix1 = Matrix::new(&[11, 11, 11, -11]);
+ let matrix2 = Matrix::new(&[
+ String::from("Hello"),String::from("friends"),
+ String::from("from"), String::from("tsuR"),
+ ]);
+ assert_eq!((matrix1 + matrix2).by_col(),string_cell_vec("11 Hello","11 from", "11 friends","Rust 11") );
+ }
+
+ #[test]
+ fn test_for_matrix_multiplication() {
+ let matrix1 = Matrix::new(&[-1, -2, -3, -4]);
+ let matrix2 = Matrix::new(&[
+ String::from("olleH"),String::from("sdneirf"),
+ String::from("morf"), String::from("tsuR"),
+ ]);
+ assert_eq!((matrix1 * matrix2),String::from("Hello fromfrom friendsfriendsfriends RustRustRustRust"));
+
+ let matrix1 = Matrix::new(&[-1, -2, 3, 4]);
+ let matrix2 = Matrix::new(&[
+ String::from("olleH"),String::from("friends"),
+ String::from("morf"), String::from("Rust"),
+ ]);
+ assert_eq!((matrix1 * matrix2),String::from("Hello fromfrom friendsfriendsfriends RustRustRustRust"));
+
+ let matrix1 = Matrix::new(&[5, 6, 6, -5]);
+ let matrix2 = Matrix::new(&[
+ String::from("Hello"),String::from("friends"),
+ String::from("from"), String::from("Rust"),
+ ]);
+ assert_eq!((matrix1 * matrix2),String::from("HelloHelloHelloHelloHello fromfromfromfromfromfrom friendsfriendsfriendsfriendsfriendsfriends tsuRtsuRtsuRtsuRtsuR"));
+ }
+
}
ами нищо интересно не съм направила от към тестове
Хубава сутрин! https://www.youtube.com/watch?v=iX-QaNzd-0Y&list=PLJm8WaghjTeFfIKjEXyMHPhUFD7Kc0V1g&index=6
Тестовете не са лоши, и е добре, че си ги пробвала 👍. Липсват ти тестове на кирилица (или някакъв друг unicode), добре щеше да е да пробваш и умножение по 0, може би още някои и друг тест с интервали.
Оставих и бележки по именуването, защото го спомена :).
Ако "Matrix" е името на типа, може би вътрешната стойност не е добре също да е "matrix" -- две различни неща са. Може би "cells" щеше да е по-удачно, и например
new_created_matrixможеше да еnew_matrix_cells. Също и по-надолу,cells_by_coletc. Basically, името на стойността има смисъл да е консистентно с типа ѝ."First var" и "Second var" са малко мета имена :). Името е добре да описва не какво е това в контекста на текущия блок код, а каква е тази стойност. Може би
first_valueвместоfirst_varщеше да е по-удачно. Допълнително, в случая първото и второто нещо са и различни типове неща, така че може биnumberиstringщяха да са ок като имена. И като видишstring.to_string()и можеш да си кажеш "хм, защо изобщо го to-string-вам, като вече е string" :D. (В случая, може би move semantics, но тогава.clone()ще изясни по-добре какво правиш)