Решение на Думи на Фибоначи от Ивона Стоянова

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

Към профила на Ивона Стоянова

Код

use std::str::Chars;

pub struct FibIter {

f1: u32,

f2: u32,

}

impl FibIter {

pub fn new() -> FibIter {

FibIter { f1: 0, f2: 0 }

}

pub fn next(&mut self) -> u32 {

let result: u32;

if self.f2 == 0 {

result = 1

} else {

result = self.f1 + self.f2;

}

self.f1 = self.f2;

self.f2 = result;

result

}

pub fn rev(self) -> RevFibIter {

RevFibIter::new(self.f1, self.f2)

}

}

impl RevFibIter {

pub fn new(f1: u32, f2: u32) -> RevFibIter {

RevFibIter { f1, f2 }

}

pub fn next(&mut self) -> Option<u32> {

let higher_term = self.f2;

let lower_term = self.f1;

let mut placeholder: u32;

let mut result: Option<u32>;

if higher_term >= 0 {

result = Some(self.f2);

placeholder = higher_term - lower_term;

self.f2 = lower_term;

self.f1 = placeholder;

} else {

result = None;

}

result

}

}

pub struct RevFibIter {

f1: u32,

f2: u32,

}

pub fn fib_split(text: &str) -> Vec<String> {

let mut iter_fib = FibIter::new();

let mut iter_char = text.chars();

let mut vector: Vec<String> = Vec::new();

while let Some(ch) = iter_char.next() {

let mut word: String = String::new();

word.push(ch);

let num = iter_fib.next();

for _ in 1..num {

match iter_char.next() {

Some(ch) => word.push(ch),

None => break,

}

}

vector.push(word);

}

vector

}

pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String) {

// panic when text.len(smaller than n)

// струва ли си да го проверявам колко е дълъг или просто да паниквам, ако стигна до място

let mut iter_fib = FibIter::new();

let mut iter_char = text.chars();

let mut result: Vec<String> = match forward_iter_till_n(n, &mut iter_fib, &mut iter_char) {

Some(r) => r,

None => panic!("Out of characters"),

};

(result, iter_char.collect::<String>())

}

fn forward_iter_till_n(n: u32, iter_fib: &mut FibIter, iter_char: &mut Chars) -> Option<Vec<String>> {

let mut result: Vec<String> = Vec::new();

for _ in 0..n {

let mut word: String = String::new();

let num = iter_fib.next();

for _ in 0..num {

match iter_char.next() {

Some(ch) => word.push(ch),

None => return None,

}

}

result.push(word);

}

Some(result)

}

pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, &str) {

let mut iter_fib = FibIter::new();

let mut iter_char = text.chars();

let mut result_first_part: Vec<String> = match forward_iter_till_n(n, &mut iter_fib, &mut iter_char) {

Some(r) => r,

None => panic!("Out of characters, reduce n"),

};

let mut iter_backward = RevFibIter::new(iter_fib.f1, iter_fib.f2);

let mut result_second_half: Vec<String> = Vec::new();

let num_iterations = if iter_backward.f2 == 1 { 2} else {iter_backward.f2};

for _ in 0..num_iterations {

let mut word: String = String::new();

let num =

match iter_backward.next() {

Some(n) => {

for _ in 0..n {

match iter_char.next() {

Some(ch) => word.push(ch),

None => panic!("Oh no, not enough characters to iterate backwards"),

}

}

result_second_half.push(word)

}

None => unreachable!()

};

}

result_first_part.append(&mut result_second_half);

(result_first_part, iter_char.as_str())

}

#[cfg(test)]

mod tests {

use super::*;

#[test]

fn test_fib_split() {

assert_eq!(fib_split("Fibonacci words!"), ["F", "i", "bo", "nac", "ci wo", "rds!"]);

assert_eq!(fib_split("Числа на фибоначи"), ["Ч", "и", "сл", "а н", "а фиб", "оначи"]);

assert_eq!(fib_split("Числа на фибоначи..!0"), ["Ч", "и", "сл", "а н", "а фиб", "оначи..!", "0"]);

assert_eq!(fib_split(" "), [" ", " ", " "]);

}

#[test]

fn test_fib_split_n() {

assert_eq!(fib_split_n("Lorem ipsum dolor sit amet.", 6), (vec![String::from("L"), String::from("o"), String::from("re"), String::from("m i"), String::from("psum "), String::from("dolor si")], String::from("t amet.")));

assert_eq!(fib_split_n("Lorem ipsum dolor si", 6), (vec![String::from("L"), String::from("o"), String::from("re"), String::from("m i"), String::from("psum "), String::from("dolor si")], String::from("")));

assert_eq!(fib_split_n("Лорем ипсум долор си", 6), (vec![String::from("Л"), String::from("о"), String::from("ре"), String::from("м и"), String::from("псум "), String::from("долор си")], String::from("")));

}

#[test]

fn test_fib_split_n_symmetric(){

assert_eq!(fib_split_n_symmetric("Lorem ipsum dolor sit amet.", 5), (vec![String::from("L"), String::from("o"), String::from("re"), String::from("m i"),String::from( "psum "), String::from("dolor"), String::from(" si"), String::from("t "), String::from("a"), String::from("m")], "et."));

assert_eq!(fib_split_n_symmetric("Lorem ipsum dolor sit amet.", 2), (vec![String::from("L"), String::from("o"), String::from("r"), String::from("e")], "m ipsum dolor sit amet."));

assert_eq!(fib_split_n_symmetric("Лорем ипсум долор сиt амет.", 5), (vec![String::from("Л"), String::from("о"), String::from("ре"), String::from("м и"),String::from( "псум "), String::from("долор"), String::from(" си"), String::from("t "), String::from("а"), String::from("м")], "ет."));

}

#[test]

fn test_basic() {

let mut fib_iter = FibIter::new();

fib_iter.next();

let mut rev_fib_iter: RevFibIter = fib_iter.rev();

rev_fib_iter.next();

let words: Vec<String> = fib_split("Fibonacci words!");

assert_eq!(words, &["F", "i", "bo", "nac", "ci wo", "rds!"]);

let (words, rest) = fib_split_n("Lorem ipsum dolor sit amet.", 6);

assert_eq!(words, &["L", "o", "re", "m i", "psum ", "dolor si"]);

assert_eq!(rest, "t amet.");

let (words, rest) = fib_split_n_symmetric("Lorem ipsum dolor sit amet.", 5);

assert_eq!(words, &["L", "o", "re", "m i", "psum ", "dolor", " si", "t ", "a", "m"]);

assert_eq!(rest, "et.");

}

}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-51dt6b/solution)
warning: unused variable: `num`
   --> src/lib.rs:137:13
    |
137 |         let num =
    |             ^^^ help: if this is intentional, prefix it with an underscore: `_num`
    |
    = note: `#[warn(unused_variables)]` on by default

warning: variable does not need to be mutable
  --> src/lib.rs:41:13
   |
41 |         let mut placeholder: u32;
   |             ----^^^^^^^^^^^
   |             |
   |             help: remove this `mut`
   |
   = note: `#[warn(unused_mut)]` on by default

warning: variable does not need to be mutable
  --> src/lib.rs:43:13
   |
43 |         let mut result: Option<u32>;
   |             ----^^^^^^
   |             |
   |             help: remove this `mut`

warning: variable does not need to be mutable
  --> src/lib.rs:93:9
   |
93 |     let mut result: Vec<String> = match forward_iter_till_n(n, &mut iter_fib, &mut iter_char) {
   |         ----^^^^^^
   |         |
   |         help: remove this `mut`

warning: comparison is useless due to type limits
  --> src/lib.rs:44:12
   |
44 |         if higher_term >= 0 {
   |            ^^^^^^^^^^^^^^^^
   |
   = note: `#[warn(unused_comparisons)]` on by default

warning: `solution` (lib) generated 5 warnings
    Finished test [unoptimized + debuginfo] target(s) in 1.02s
     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 ... FAILED
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 ... FAILED
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_symmetric_ascii stdout ----
thread 'solution_test::fib_split_n_symmetric_ascii' panicked at 'attempt to subtract with overflow', src/lib.rs:46:27

---- 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 stdout ----
thread 'solution_test::fib_split_n_symmetric_cyrillic' panicked at 'attempt to subtract with overflow', src/lib.rs:46:27

---- 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 'attempt to subtract with overflow', src/lib.rs:46:27

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


failures:
    solution_test::fib_split_n_symmetric_ascii
    solution_test::fib_split_n_symmetric_ascii_exact
    solution_test::fib_split_n_symmetric_cyrillic
    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`

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