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

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

Решение на Думи на Фибоначи от Хари Христов

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

Към профила на Хари Христов

Резултати

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

Код

use std::str::Chars;
pub struct FibIter {
next: u32,
number: u32,
}
impl FibIter {
pub fn new() -> FibIter {
FibIter { next: 1, number: 0, }
}
pub fn next(&mut self) -> u32 {
let old_next: u32 = self.next;
self.next += self.number;
self.number = old_next;
self.number
}
}
pub fn fib_split(text: &str) -> Vec<String> {
let mut result: Vec<String> = Vec::new();
let size: u32 = text.chars().count().try_into().unwrap_or(0);
let mut char_iter: Chars = text.chars();
let mut iter: FibIter = FibIter::new();
let mut index: u32 = 0;
while index < size {
let current_fib: u32 = iter.next();
result.push(char_iter.by_ref().take(current_fib as usize).collect());
index += current_fib;
}
result
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String) {
let mut result: Vec<String> = Vec::new();
let size: u32 = text.chars().count().try_into().unwrap_or(0);
let mut iter: FibIter = FibIter::new();
let mut index: u32 = 0;
let mut char_iter: Chars = text.chars();
let mut number_of_words: u32 = 0;
while index < size {
let current_fib: u32 = iter.next();
result.push(char_iter.by_ref().take(current_fib as usize).collect());
number_of_words += 1;
index += current_fib;
if number_of_words == n {
break;
}
}
if number_of_words < n {
panic!("Not enough letters to generate the first {:?} words!", n);
}
(result, char_iter.take(size as usize).collect())
}
impl FibIter {
pub fn rev(self) -> RevFibIter {
RevFibIter { number: self.next, previous: self.number, }
}
}
pub struct RevFibIter {
number: u32,
previous: u32,
}
impl RevFibIter {
pub fn next(&mut self) -> Option<u32> {
if self.number == 1 && self.previous == 0 {
return None;
}
let old_number: u32 = self.number;
self.number = self.previous;
self.previous = old_number.saturating_sub(self.previous);
Some(self.number)
}
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String) {
let (mut result, leftover_text) = fib_split_n(text, n);
let size: u32 = leftover_text.chars().count().try_into().unwrap_or(0);
let mut iter: FibIter = FibIter::new();
for _i in 0..n {
iter.next();
}
let mut rev_iter: RevFibIter = iter.rev();
let mut char_iter: Chars = leftover_text.chars();
let mut index:u32 = 0;
let mut number_of_words: u32 = 0;
while index < size {
let current_fib: Option<u32> = rev_iter.next();
if current_fib == None {
break;
}
result.push(char_iter.by_ref().take(current_fib.unwrap() as usize).collect());
number_of_words += 1;
index += current_fib.unwrap();
if number_of_words == n {
break;
}
}
if number_of_words < n {
panic!("Not enough letters to generate the last {:?} words!", n);
}
(result, char_iter.take(size as usize).collect())
}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-c0dc0m/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.18s
     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 ... ok
test solution_test::fib_split_n_ascii_panic ... FAILED
test solution_test::fib_split_n_cyrillic ... ok
test solution_test::fib_split_n_cyrillic_exact ... ok
test solution_test::fib_split_n_cyrillic_panic ... FAILED
test solution_test::fib_split_n_symmetric_ascii ... ok
test solution_test::fib_split_n_symmetric_ascii_exact ... ok
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 ... ok
test solution_test::fib_split_n_symmetric_cyrillic_panic ... ok
test solution_test::fib_split_n_symmetric_zero ... FAILED
test solution_test::fib_split_n_zero ... FAILED
test solution_test::rev_fib_iter ... ok
test solution_test::rev_fib_iter_empty ... ok

failures:

---- solution_test::fib_split_n_ascii_panic stdout ----
thread 'solution_test::fib_split_n_ascii_panic' panicked at 'Not enough letters to generate the first 1 words!', src/lib.rs:63:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
thread 'solution_test::fib_split_n_ascii_panic' panicked at 'assertion failed: catch_unwind(|| fib_split_n(\"abcd_123\", 5)).is_err()', tests/solution_test.rs:96:5

---- solution_test::fib_split_n_cyrillic_panic stdout ----
thread 'solution_test::fib_split_n_cyrillic_panic' panicked at 'assertion failed: catch_unwind(|| fib_split_n(\"манджа_with_грозде\", 6)).is_err()', tests/solution_test.rs:119:5

---- solution_test::fib_split_n_symmetric_zero stdout ----
thread 'solution_test::fib_split_n_symmetric_zero' panicked at 'assertion failed: `(left == right)`
  left: `["a", "b", "cd", "гро", "зде"]`,
 right: `[]`', tests/solution_test.rs:129:5

---- solution_test::fib_split_n_zero stdout ----
thread 'solution_test::fib_split_n_zero' panicked at 'assertion failed: `(left == right)`
  left: `["a", "b", "cd", "гро", "зде"]`,
 right: `[]`', tests/solution_test.rs:71:5


failures:
    solution_test::fib_split_n_ascii_panic
    solution_test::fib_split_n_cyrillic_panic
    solution_test::fib_split_n_symmetric_zero
    solution_test::fib_split_n_zero

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

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

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

Хари качи първо решение на 27.10.2024 19:28 (преди 11 месеца)

Хари качи решение на 29.10.2024 19:28 (преди 11 месеца)

+use std::str::Chars;
+
pub struct FibIter {
next: u32,
number: u32,
}
impl FibIter {
pub fn new() -> FibIter {
FibIter { next: 1, number: 0, }
}
pub fn next(&mut self) -> u32 {
let old_next: u32 = self.next;
self.next += self.number;
self.number = old_next;
self.number
}
}
pub fn fib_split(text: &str) -> Vec<String> {
let mut result: Vec<String> = Vec::new();
- let size: u32 = text.len().try_into().unwrap_or(0);
+ let size: u32 = text.chars().count().try_into().unwrap_or(0);
+ let mut char_iter: Chars = text.chars();
let mut iter: FibIter = FibIter::new();
let mut index: u32 = 0;
- let mut current: u32 = index + iter.next();
-
- while current < size {
- result.push(text[index as usize..current as usize].to_string());
- index = current;
- current += iter.next();
+ while index < size {
+ let current_fib: u32 = iter.next();
+ result.push(char_iter.by_ref().take(current_fib as usize).collect());
+ index += current_fib;
}
- if current >= size {
- result.push(text[index as usize..size as usize].to_string());
- }
-
result
}
-pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, &str) {
+
+pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String) {
let mut result: Vec<String> = Vec::new();
- let size: u32 = text.len().try_into().unwrap_or(0);
+ let size: u32 = text.chars().count().try_into().unwrap_or(0);
let mut iter: FibIter = FibIter::new();
let mut index: u32 = 0;
- let mut current: u32 = index + iter.next();
+ let mut char_iter: Chars = text.chars();
let mut number_of_words: u32 = 0;
- while current < size {
- result.push(text[index as usize..current as usize].to_string());
+ while index < size {
+ let current_fib: u32 = iter.next();
+ result.push(char_iter.by_ref().take(current_fib as usize).collect());
number_of_words += 1;
- index = current;
- current += iter.next();
+ index += current_fib;
if number_of_words == n {
break;
}
}
if number_of_words < n {
panic!("Not enough letters to generate the first {:?} words!", n);
}
- (result, text.get(index as usize..).unwrap_or(""))
+ (result, char_iter.take(size as usize).collect())
}
impl FibIter {
pub fn rev(self) -> RevFibIter {
RevFibIter { number: self.next, previous: self.number, }
}
}
pub struct RevFibIter {
number: u32,
previous: u32,
}
impl RevFibIter {
pub fn next(&mut self) -> Option<u32> {
if self.number == 1 && self.previous == 0 {
return None;
}
let old_number: u32 = self.number;
self.number = self.previous;
self.previous = old_number.saturating_sub(self.previous);
Some(self.number)
}
}
-pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, &str) {
+pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String) {
let (mut result, leftover_text) = fib_split_n(text, n);
- let size: u32 = leftover_text.len().try_into().unwrap_or(0);
+ let size: u32 = leftover_text.chars().count().try_into().unwrap_or(0);
let mut iter: FibIter = FibIter::new();
for _i in 0..n {
iter.next();
}
let mut rev_iter: RevFibIter = iter.rev();
+ let mut char_iter: Chars = leftover_text.chars();
let mut index:u32 = 0;
- let mut current : u32 = index + rev_iter.next().unwrap_or(0);
let mut number_of_words: u32 = 0;
- while current < size {
- result.push(leftover_text[index as usize..current as usize].to_string());
- number_of_words += 1;
- index = current;
-
- let next_number: Option<u32> = rev_iter.next();
- if next_number == None {
+ while index < size {
+ let current_fib: Option<u32> = rev_iter.next();
+ if current_fib == None {
break;
}
- current += next_number.unwrap();
+ result.push(char_iter.by_ref().take(current_fib.unwrap() as usize).collect());
+ number_of_words += 1;
+ index += current_fib.unwrap();
if number_of_words == n {
break;
}
}
if number_of_words < n {
panic!("Not enough letters to generate the last {:?} words!", n);
}
- (result, &leftover_text[index as usize..size as usize])
+ (result, char_iter.take(size as usize).collect())
}