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

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

Решение на Думи на Фибоначи от Георги Илиев

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

Към профила на Георги Илиев

Резултати

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

Код

pub struct FibIter {
a: u32,
b: u32
}
impl FibIter {
pub fn new() -> FibIter {
FibIter { a: 0, b: 1 }
}
pub fn next(&mut self) -> u32 {
let c = self.a + self.b;
self.a = self.b;
self.b = c;
self.a
}
pub fn rev(&self) -> RevFibIter {
RevFibIter { a: self.a, b: self.b }
}
}
pub struct RevFibIter {
a: u32,
b: u32
}
impl RevFibIter {
pub fn next(&mut self) -> Option<u32> {
if self.a == 0 && self.b == 0 {
return None;
}
if self.a == 0 {
self.b = 0;
return Some(1);
}
let c = self.b - self.a;
self.b = self.a;
self.a = c;
Some(self.b)
}
}
pub fn fib_split(text: &str) -> Vec<String> {
let mut fib = FibIter::new();
let mut result: Vec<String> = Vec::new();
let mut word_len: u32 = fib.next();
let mut counter: u32 = 0;
let mut word = String::new();
for char in text.chars() {
if counter == word_len {
result.push(word);
word = String::new();
word_len = fib.next();
counter = 0;
}
word.push(char);
counter += 1;
}
if !word.is_empty() {
result.push(word);
}
result
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String) {
let mut fib = FibIter::new();
let mut result: Vec<String> = Vec::new();
let mut word_len: u32 = fib.next();
let mut counter: u32 = 0;
let mut word = String::new();
for char in text.chars() {
if counter == word_len && result.len() < n as usize {
result.push(word);
word = String::new();
word_len = fib.next();
counter = 0;
}
word.push(char);
counter += 1;
}
if counter < word_len && result.len() != n as usize {
panic!("Not enough words to split");
}
(result, word)
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String) {
let mut fib = FibIter::new();
let mut fib_rev = FibIter::new().rev();
let mut result: Vec<String> = Vec::new();
let mut word_len: u32 = fib.next();
let mut counter: u32 = 0;
let mut word = String::new();
for char in text.chars() {
if result.len() < n as usize && counter == word_len {
result.push(word);
word = String::new();
if result.len() == n as usize {
fib_rev = fib.rev();
let fib_rev_res: Option<u32> = fib_rev.next();
if !fib_rev_res.is_none() {
word_len = fib_rev_res.unwrap();
}
} else {
word_len = fib.next();
}
counter = 0;
} else if result.len() < (n * 2) as usize && counter == word_len {
result.push(word);
word = String::new();
let fib_rev_res: Option<u32> = fib_rev.next();
if !fib_rev_res.is_none() {
word_len = fib_rev_res.unwrap();
}
counter = 0;
}
word.push(char);
counter += 1;
}
if counter < word_len && result.len() != (n * 2) as usize {
panic!("Not enough words to split");
}
(result, word)
}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-1yt534c/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.89s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 20 tests
test solution_test::fib_iter ... ok
test solution_test::fib_split_ascii ... ok
test solution_test::fib_split_cyrillic ... ok
test solution_test::fib_split_empty ... ok
test solution_test::fib_split_n_ascii ... ok
test solution_test::fib_split_n_ascii_exact ... FAILED
test solution_test::fib_split_n_ascii_panic ... ok
test solution_test::fib_split_n_cyrillic ... ok
test solution_test::fib_split_n_cyrillic_exact ... FAILED
test solution_test::fib_split_n_cyrillic_panic ... ok
test solution_test::fib_split_n_symmetric_ascii ... ok
test solution_test::fib_split_n_symmetric_ascii_exact ... FAILED
test solution_test::fib_split_n_symmetric_ascii_panic ... ok
test solution_test::fib_split_n_symmetric_cyrillic ... ok
test solution_test::fib_split_n_symmetric_cyrillic_exact ... FAILED
test solution_test::fib_split_n_symmetric_cyrillic_panic ... ok
test solution_test::fib_split_n_symmetric_zero ... ok
test solution_test::fib_split_n_zero ... ok
test solution_test::rev_fib_iter ... FAILED
test solution_test::rev_fib_iter_empty ... FAILED

failures:

---- solution_test::fib_split_n_ascii_exact stdout ----
thread 'solution_test::fib_split_n_ascii_exact' panicked at 'assertion failed: `(left == right)`
  left: `["a", "b", "cd", "_12"]`,
 right: `["a", "b", "cd", "_12", "_3456"]`', tests/solution_test.rs:89:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

---- solution_test::fib_split_n_cyrillic_exact stdout ----
thread 'solution_test::fib_split_n_cyrillic_exact' panicked at 'assertion failed: `(left == right)`
  left: `["м", "а", "нд", "жа_"]`,
 right: `["м", "а", "нд", "жа_", "with_"]`', tests/solution_test.rs:113:5

---- solution_test::fib_split_n_symmetric_ascii_exact stdout ----
thread 'solution_test::fib_split_n_symmetric_ascii_exact' panicked at 'assertion failed: `(left == right)`
  left: `["a", "b", "cd", "12", "3"]`,
 right: `["a", "b", "cd", "12", "3", "4"]`', tests/solution_test.rs:147:5

---- solution_test::fib_split_n_symmetric_cyrillic_exact stdout ----
thread 'solution_test::fib_split_n_symmetric_cyrillic_exact' panicked at 'assertion failed: `(left == right)`
  left: `["м", "а", "нд", "жа_", "wit", "h_", "г"]`,
 right: `["м", "а", "нд", "жа_", "wit", "h_", "г", "р"]`', tests/solution_test.rs:171:5

---- solution_test::rev_fib_iter stdout ----
thread 'solution_test::rev_fib_iter' panicked at 'assertion failed: `(left == right)`
  left: `Some(1)`,
 right: `None`', tests/solution_test.rs:35:5

---- solution_test::rev_fib_iter_empty stdout ----
thread 'solution_test::rev_fib_iter_empty' panicked at 'assertion failed: `(left == right)`
  left: `Some(1)`,
 right: `None`', tests/solution_test.rs:43:5


failures:
    solution_test::fib_split_n_ascii_exact
    solution_test::fib_split_n_cyrillic_exact
    solution_test::fib_split_n_symmetric_ascii_exact
    solution_test::fib_split_n_symmetric_cyrillic_exact
    solution_test::rev_fib_iter
    solution_test::rev_fib_iter_empty

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

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

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

Георги качи първо решение на 30.10.2024 11:38 (преди 11 месеца)

Решението ти не се компилира с пълния тест. Махни модула solution. Трябва да предадеш само съдържанието на модула.

Може би си се объркал от use solution::* в базовия тест. Ние създаваме проект, който се казва "solution" и добавяме предадения код в src/lib.rs. Така че "solution" е името на библиотеката, а не на някой модул.

Теста се добавя в tests/test_basic.rs (не в src/tests/test_basic.rs). Теста не е част от библиотеката, третира се като отделна програма, която използва библиотеката "solution" като външно dependency.

Георги качи решение на 31.10.2024 09:50 (преди 11 месеца)

-pub mod solution {
- pub struct FibIter {
- a: u32,
- b: u32
+pub struct FibIter {
+ a: u32,
+ b: u32
+}
+
+impl FibIter {
+ pub fn new() -> FibIter {
+ FibIter { a: 0, b: 1 }
}
- impl FibIter {
- pub fn new() -> FibIter {
- FibIter { a: 0, b: 1 }
- }
-
- pub fn next(&mut self) -> u32 {
- let c = self.a + self.b;
- self.a = self.b;
- self.b = c;
- self.a
- }
-
- pub fn rev(&self) -> RevFibIter {
- RevFibIter { a: self.a, b: self.b }
- }
+ pub fn next(&mut self) -> u32 {
+ let c = self.a + self.b;
+ self.a = self.b;
+ self.b = c;
+ self.a
}
- pub struct RevFibIter {
- a: u32,
- b: u32
+ pub fn rev(&self) -> RevFibIter {
+ RevFibIter { a: self.a, b: self.b }
}
+}
- impl RevFibIter {
- pub fn next(&mut self) -> Option<u32> {
- if self.a == 0 && self.b == 0 {
- return None;
- }
- if self.a == 0 {
- self.b = 0;
- return Some(1);
- }
+pub struct RevFibIter {
+ a: u32,
+ b: u32
+}
- let c = self.b - self.a;
- self.b = self.a;
- self.a = c;
-
- Some(self.b)
+impl RevFibIter {
+ pub fn next(&mut self) -> Option<u32> {
+ if self.a == 0 && self.b == 0 {
+ return None;
}
- }
+ if self.a == 0 {
+ self.b = 0;
+ return Some(1);
+ }
- pub fn fib_split(text: &str) -> Vec<String> {
- let mut fib = FibIter::new();
- let mut result: Vec<String> = Vec::new();
+ let c = self.b - self.a;
+ self.b = self.a;
+ self.a = c;
- let mut word_len: u32 = fib.next();
- let mut counter: u32 = 0;
- let mut word = String::new();
+ Some(self.b)
+ }
+}
- for char in text.chars() {
- if counter == word_len {
- result.push(word);
- word = String::new();
- word_len = fib.next();
- counter = 0;
- }
- word.push(char);
- counter += 1;
- }
+pub fn fib_split(text: &str) -> Vec<String> {
+ let mut fib = FibIter::new();
+ let mut result: Vec<String> = Vec::new();
- if !word.is_empty() {
+ let mut word_len: u32 = fib.next();
+ let mut counter: u32 = 0;
+ let mut word = String::new();
+
+ for char in text.chars() {
+ if counter == word_len {
result.push(word);
+ word = String::new();
+ word_len = fib.next();
+ counter = 0;
}
+ word.push(char);
+ counter += 1;
+ }
- result
+ if !word.is_empty() {
+ result.push(word);
}
- pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String) {
- let mut fib = FibIter::new();
- let mut result: Vec<String> = Vec::new();
+ result
+}
- let mut word_len: u32 = fib.next();
- let mut counter: u32 = 0;
- let mut word = String::new();
+pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String) {
+ let mut fib = FibIter::new();
+ let mut result: Vec<String> = Vec::new();
- for char in text.chars() {
- if counter == word_len && result.len() < n as usize {
- result.push(word);
- word = String::new();
- word_len = fib.next();
- counter = 0;
- }
- word.push(char);
- counter += 1;
- }
+ let mut word_len: u32 = fib.next();
+ let mut counter: u32 = 0;
+ let mut word = String::new();
- if counter < word_len && result.len() != n as usize {
- panic!("Not enough words to split");
+ for char in text.chars() {
+ if counter == word_len && result.len() < n as usize {
+ result.push(word);
+ word = String::new();
+ word_len = fib.next();
+ counter = 0;
}
+ word.push(char);
+ counter += 1;
+ }
- (result, word)
+ if counter < word_len && result.len() != n as usize {
+ panic!("Not enough words to split");
}
- pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String) {
- let mut fib = FibIter::new();
- let mut fib_rev = FibIter::new().rev();
- let mut result: Vec<String> = Vec::new();
+ (result, word)
+}
- let mut word_len: u32 = fib.next();
- let mut counter: u32 = 0;
- let mut word = String::new();
+pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String) {
+ let mut fib = FibIter::new();
+ let mut fib_rev = FibIter::new().rev();
+ let mut result: Vec<String> = Vec::new();
- for char in text.chars() {
- if result.len() < n as usize && counter == word_len {
- result.push(word);
- word = String::new();
- if result.len() == n as usize {
- fib_rev = fib.rev();
- let fib_rev_res: Option<u32> = fib_rev.next();
- if !fib_rev_res.is_none() {
- word_len = fib_rev_res.unwrap();
- }
- } else {
- word_len = fib.next();
- }
- counter = 0;
- } else if result.len() < (n * 2) as usize && counter == word_len {
- result.push(word);
- word = String::new();
+ let mut word_len: u32 = fib.next();
+ let mut counter: u32 = 0;
+ let mut word = String::new();
+
+ for char in text.chars() {
+ if result.len() < n as usize && counter == word_len {
+ result.push(word);
+ word = String::new();
+ if result.len() == n as usize {
+ fib_rev = fib.rev();
let fib_rev_res: Option<u32> = fib_rev.next();
if !fib_rev_res.is_none() {
word_len = fib_rev_res.unwrap();
}
- counter = 0;
+ } else {
+ word_len = fib.next();
}
- word.push(char);
-
- counter += 1;
+ counter = 0;
+ } else if result.len() < (n * 2) as usize && counter == word_len {
+ result.push(word);
+ word = String::new();
+ let fib_rev_res: Option<u32> = fib_rev.next();
+ if !fib_rev_res.is_none() {
+ word_len = fib_rev_res.unwrap();
+ }
+ counter = 0;
}
+ word.push(char);
- if counter < word_len && result.len() != (n * 2) as usize {
- panic!("Not enough words to split");
- }
+ counter += 1;
+ }
- (result, word)
+ if counter < word_len && result.len() != (n * 2) as usize {
+ panic!("Not enough words to split");
}
+
+ (result, word)
}