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

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

Решение на Думи на Фибоначи от Пламен Дарджиков

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

Към профила на Пламен Дарджиков

Резултати

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

Код

pub struct FibIter {
curr_value: u32,
prev_value: u32,
}
pub struct RevFibIter {
curr_value: u32,
prev_value: u32,
}
impl RevFibIter {
pub fn next(&mut self) -> Option<u32> {
if self.curr_value < 1 {
return None;
}
let temp = self.prev_value - self.curr_value;
self.prev_value = self.curr_value;
self.curr_value = temp;
Some(self.prev_value)
}
}
impl FibIter {
pub fn new() -> FibIter {
FibIter {
curr_value: 1,
prev_value: 0,
}
}
pub fn rev(self) -> RevFibIter {
RevFibIter {
prev_value: self.curr_value,
curr_value: self.prev_value,
}
}
pub fn next(&mut self) -> u32 {
let temp = self.curr_value + self.prev_value;
self.prev_value = self.curr_value;
self.curr_value = temp;
self.prev_value
}
}
fn get_word_cutoff(added_chars_count: &mut usize, word_len: usize, chars: &Vec<char>) -> String {
let word_end = *added_chars_count + word_len;
let word: String = if word_end < chars.len() {
chars[*added_chars_count..word_end].into_iter().collect()
} else {
chars[*added_chars_count..].into_iter().collect()
};
*added_chars_count += word_len;
word
}
fn get_word_safely(
added_chars_count: &mut usize,
added_bites_size: &mut usize,
word_len: usize,
chars: &Vec<char>,
) -> String {
let word_end = *added_chars_count + word_len;
if word_end > chars.len() {
panic!("Низът е твърде кратък!");
}
let word: String = chars[*added_chars_count..word_end].into_iter().collect();
*added_chars_count += word_len;
*added_bites_size += word.len();
word
}
pub fn fib_split(text: &str) -> Vec<String> {
let mut fib_iter = FibIter::new();
let mut words = Vec::<String>::new();
let chars: Vec<char> = text.chars().collect();
let mut added_chars_count = 0;
while added_chars_count < chars.len() {
let word_len = fib_iter.next() as usize;
let word = get_word_cutoff(&mut added_chars_count, word_len, &chars);
words.push(word);
}
words
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, &str) {
let mut fib_iter = FibIter::new();
let mut words = Vec::<String>::new();
let chars: Vec<char> = text.chars().collect();
let mut added_chars_count = 0;
let mut added_bites_size = 0;
for _ in 0..n {
let word_len = fib_iter.next() as usize;
let word = get_word_safely(&mut added_chars_count, &mut added_bites_size, word_len, &chars);
words.push(word);
}
(words, &text[added_bites_size..])
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, &str) {
let mut fib_iter = FibIter::new();
let mut words = Vec::<String>::new();
let chars: Vec<char> = text.chars().collect();
let mut added_chars_count = 0;
let mut added_bites_size = 0;
for _ in 0..n {
let word_len = fib_iter.next() as usize;
let word = get_word_safely(&mut added_chars_count, &mut added_bites_size, word_len, &chars);
words.push(word);
}
let mut rev_fib_iter = fib_iter.rev();
while let Some(word_len) = rev_fib_iter.next() {
let word = get_word_safely(&mut added_chars_count, &mut added_bites_size, word_len as usize, &chars);
words.push(word);
}
(words, &text[added_bites_size..])
}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-122us39/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.11s
     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_cyrillic ... ok
test solution_test::fib_split_n_ascii_panic ... ok
test solution_test::fib_split_n_cyrillic_exact ... ok
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 ... 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 ... ok
test solution_test::fib_split_n_zero ... ok
test solution_test::rev_fib_iter ... ok
test solution_test::rev_fib_iter_empty ... ok

test result: ok. 20 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

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

Пламен качи първо решение на 28.10.2024 16:02 (преди 11 месеца)

Извинявай, някакси съм пропуснал да ти пиша по-рано. Решението ти не се компилира с пълния тест.

Функциите fib_split, fib_split_n и fib_split_n_symmetric трябва да са свободни функции. Само new, next и rev трябва да са методи на FibIter.

Здрасти, преди малко си говорехме относно решението ми. Не се комплираше, защото функции бяха в impl блока на FibIter. Долу е правилното решение, като единствената разликата е че съм извадил функциите от този impl блок.

pub struct FibIter { curr_value: u32, prev_value: u32, }

pub struct RevFibIter { curr_value: u32, prev_value: u32, }

impl RevFibIter { pub fn next(&mut self) -> Option { if self.curr_value < 1 { return None; }

    let temp = self.prev_value - self.curr_value;
    self.prev_value = self.curr_value;
    self.curr_value = temp;

    Some(self.prev_value)
}

}

impl FibIter { pub fn new() -> FibIter { FibIter {curr_value: 1, prev_value: 0} }

pub fn rev(self) -> RevFibIter {
    RevFibIter {prev_value: self.curr_value, curr_value: self.prev_value}
}

pub fn next(&mut self) -> u32 {
    let temp = self.curr_value + self.prev_value;
    self.prev_value = self.curr_value;
    self.curr_value = temp;

    self.prev_value
}

} fn get_word_cutoff(added_chars_count: &mut usize, word_len: usize, chars: &Vec::) -> String { let word_end = *added_chars_count + word_len;

    let word: String = if word_end < chars.len() {
        chars[*added_chars_count..word_end].into_iter().collect()
    } else {
        chars[*added_chars_count..].into_iter().collect()
    };

    *added_chars_count += word_len;

    word
}

fn get_word_safely(added_chars_count: &mut usize, added_bites_size: &mut usize, word_len: usize, chars: &Vec::<char>) -> String {
    let word_end = *added_chars_count + word_len;

    if word_end > chars.len() {
        panic!("Низът е твърде кратък!");
    }

    let word: String = chars[*added_chars_count..word_end].into_iter().collect();

    *added_chars_count += word_len;
    *added_bites_size += word.len();

    word
}

pub fn fib_split(text: &str) -> Vec<String> {
    let mut fib_iter = FibIter::new();
    let mut words = Vec::<String>::new();

    let chars: Vec<char> = text.chars().collect();
    let mut added_chars_count= 0;
    while added_chars_count < chars.len() {
        let word_len = fib_iter.next() as usize;
        let word = get_word_cutoff(&mut added_chars_count, word_len, &chars);

        words.push(word);
    }

    words
}

pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, &str) {
    let mut fib_iter = FibIter::new();
    let mut words = Vec::<String>::new();

    let chars: Vec<char> = text.chars().collect();

    let mut added_chars_count = 0;
    let mut added_bites_size = 0;
    for _ in 0..n {
        let word_len = fib_iter.next() as usize;
        let word = get_word_safely(&mut added_chars_count, &mut added_bites_size, word_len, &chars);

        words.push(word);
    }

    (words, &text[added_bites_size..])
}

pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, &str) {
    let mut fib_iter = FibIter::new();
    let mut words = Vec::<String>::new();
    let chars: Vec<char> = text.chars().collect();

    let mut added_chars_count = 0;
    let mut added_bites_size = 0;
    for _ in 0..n {
        let word_len = fib_iter.next() as usize;
        let word = get_word_safely(&mut added_chars_count, &mut added_bites_size, word_len, &chars);

        words.push(word);
    }

    let mut rev_fib_iter = fib_iter.rev();

    while let Some(word_len) = rev_fib_iter.next() {
        let word = get_word_safely(&mut added_chars_count, &mut added_bites_size, word_len as usize, &chars);
        words.push(word);
    }

    (words, &text[added_bites_size..])
}

Пламен качи решение на 04.11.2024 21:21 (преди 10 месеца)

pub struct FibIter {
curr_value: u32,
prev_value: u32,
}
pub struct RevFibIter {
curr_value: u32,
prev_value: u32,
}
impl RevFibIter {
pub fn next(&mut self) -> Option<u32> {
if self.curr_value < 1 {
return None;
}
let temp = self.prev_value - self.curr_value;
self.prev_value = self.curr_value;
self.curr_value = temp;
Some(self.prev_value)
}
}
impl FibIter {
pub fn new() -> FibIter {
- FibIter {curr_value: 1, prev_value: 0}
+ FibIter {
+ curr_value: 1,
+ prev_value: 0,
+ }
}
+ pub fn rev(self) -> RevFibIter {
+ RevFibIter {
+ prev_value: self.curr_value,
+ curr_value: self.prev_value,
+ }
+ }
+
pub fn next(&mut self) -> u32 {
let temp = self.curr_value + self.prev_value;
self.prev_value = self.curr_value;
self.curr_value = temp;
-
+
self.prev_value
}
+}
- fn get_word_cutoff(added_chars_count: &mut usize, word_len: usize, chars: &Vec::<char>) -> String {
- let word_end = *added_chars_count + word_len;
-
- let word: String = if word_end < chars.len() {
- chars[*added_chars_count..word_end].into_iter().collect()
- } else {
- chars[*added_chars_count..].into_iter().collect()
- };
+fn get_word_cutoff(added_chars_count: &mut usize, word_len: usize, chars: &Vec<char>) -> String {
+ let word_end = *added_chars_count + word_len;
- *added_chars_count += word_len;
+ let word: String = if word_end < chars.len() {
+ chars[*added_chars_count..word_end].into_iter().collect()
+ } else {
+ chars[*added_chars_count..].into_iter().collect()
+ };
- word
- }
+ *added_chars_count += word_len;
- fn get_word_safely(added_chars_count: &mut usize, added_bites_size: &mut usize, word_len: usize, chars: &Vec::<char>) -> String {
- let word_end = *added_chars_count + word_len;
+ word
+}
- if word_end > chars.len() {
- panic!("Низът е твърде кратък!");
- }
-
- let word: String = chars[*added_chars_count..word_end].into_iter().collect();
-
- *added_chars_count += word_len;
- *added_bites_size += word.len();
+fn get_word_safely(
+ added_chars_count: &mut usize,
+ added_bites_size: &mut usize,
+ word_len: usize,
+ chars: &Vec<char>,
+) -> String {
+ let word_end = *added_chars_count + word_len;
- word
+ if word_end > chars.len() {
+ panic!("Низът е твърде кратък!");
}
- pub fn fib_split(text: &str) -> Vec<String> {
- let mut fib_iter = FibIter::new();
- let mut words = Vec::<String>::new();
-
- let chars: Vec<char> = text.chars().collect();
- let mut added_chars_count= 0;
- while added_chars_count < chars.len() {
- let word_len = fib_iter.next() as usize;
- let word = FibIter::get_word_cutoff(&mut added_chars_count, word_len, &chars);
+ let word: String = chars[*added_chars_count..word_end].into_iter().collect();
- words.push(word);
- }
+ *added_chars_count += word_len;
+ *added_bites_size += word.len();
- words
+ word
+}
+
+pub fn fib_split(text: &str) -> Vec<String> {
+ let mut fib_iter = FibIter::new();
+ let mut words = Vec::<String>::new();
+
+ let chars: Vec<char> = text.chars().collect();
+ let mut added_chars_count = 0;
+ while added_chars_count < chars.len() {
+ let word_len = fib_iter.next() as usize;
+ let word = get_word_cutoff(&mut added_chars_count, word_len, &chars);
+
+ words.push(word);
}
- pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, &str) {
- let mut fib_iter = FibIter::new();
- let mut words = Vec::<String>::new();
+ words
+}
- let chars: Vec<char> = text.chars().collect();
+pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, &str) {
+ let mut fib_iter = FibIter::new();
+ let mut words = Vec::<String>::new();
- let mut added_chars_count = 0;
- let mut added_bites_size = 0;
- for _ in 0..n {
- let word_len = fib_iter.next() as usize;
- let word = FibIter::get_word_safely(&mut added_chars_count, &mut added_bites_size, word_len, &chars);
+ let chars: Vec<char> = text.chars().collect();
- words.push(word);
- }
+ let mut added_chars_count = 0;
+ let mut added_bites_size = 0;
+ for _ in 0..n {
+ let word_len = fib_iter.next() as usize;
+ let word = get_word_safely(&mut added_chars_count, &mut added_bites_size, word_len, &chars);
- (words, &text[added_bites_size..])
+ words.push(word);
}
- pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, &str) {
- let mut fib_iter = FibIter::new();
- let mut words = Vec::<String>::new();
- let chars: Vec<char> = text.chars().collect();
+ (words, &text[added_bites_size..])
+}
- let mut added_chars_count = 0;
- let mut added_bites_size = 0;
- for _ in 0..n {
- let word_len = fib_iter.next() as usize;
- let word = FibIter::get_word_safely(&mut added_chars_count, &mut added_bites_size, word_len, &chars);
+pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, &str) {
+ let mut fib_iter = FibIter::new();
+ let mut words = Vec::<String>::new();
+ let chars: Vec<char> = text.chars().collect();
- words.push(word);
- }
+ let mut added_chars_count = 0;
+ let mut added_bites_size = 0;
+ for _ in 0..n {
+ let word_len = fib_iter.next() as usize;
+ let word = get_word_safely(&mut added_chars_count, &mut added_bites_size, word_len, &chars);
- let mut rev_fib_iter = fib_iter.rev();
+ words.push(word);
+ }
- while let Some(word_len) = rev_fib_iter.next() {
- let word = FibIter::get_word_safely(&mut added_chars_count, &mut added_bites_size, word_len as usize, &chars);
- words.push(word);
- }
+ let mut rev_fib_iter = fib_iter.rev();
- (words, &text[added_bites_size..])
+ while let Some(word_len) = rev_fib_iter.next() {
+ let word = get_word_safely(&mut added_chars_count, &mut added_bites_size, word_len as usize, &chars);
+ words.push(word);
}
- pub fn rev(self) -> RevFibIter {
- RevFibIter {prev_value: self.curr_value, curr_value: self.prev_value}
+ (words, &text[added_bites_size..])
- }
+}
-}