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

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

Към профила на Мариан Марчев

Код

pub struct FibIter {

curr : u32,

next : u32

}

impl FibIter {

pub fn new() -> FibIter {

FibIter {

curr: 1,

next: 1

}

}

pub fn print(&self) {

println!("curr: {} next: {}", self.curr, self.next);

}

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

let result :u32 = self.curr;

self.curr = self.next;

self.next = result+self.next;

result

}

pub fn rev(self) -> RevFibIter {

RevFibIter {

curr: self.next,

prev: self.curr

}

}

}

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

let mut fib_iterator :FibIter = FibIter::new();

let mut curr_index :usize = 0;

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

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

while curr_index < chars.len() {

let length :usize = fib_iterator.next() as usize;

let end :usize = (curr_index + length).min(chars.len());

result.push(chars[curr_index..end].iter().collect());

curr_index = end;

}

result

}

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

let mut fib_iterator :FibIter = FibIter::new();

let mut curr_index :usize = 0;

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

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

for _ in 0..n {

let length :usize = fib_iterator.next() as usize;

let end :usize = (curr_index + length).min(chars.len());

if curr_index >= chars.len() {

panic!("The text is too short");

}

result.push(chars[curr_index..end].iter().collect());

curr_index = end;

}

let remaining_text: String = chars[curr_index..].iter().collect();

(result, remaining_text)

}

pub struct RevFibIter {

curr: u32,

prev : u32

}

impl RevFibIter {

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

if self.curr == 0 {

None

} else {

let result :u32 = self.curr;

self.curr = self.prev;

self.prev = result - self.prev;

Some(result)

}

}

}

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

let mut fib_iterator :FibIter = FibIter::new();

let mut curr_index :usize = 0;

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

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

let mut amount_of_chars :u32 = 0;

for _ in 0..n {

amount_of_chars += fib_iterator.next();

}

fib_iterator = FibIter::new();

if chars.len() < amount_of_chars as usize {

panic!("The text is too short");

}

for _ in 0..n {

let length :usize = fib_iterator.next() as usize;

let end :usize = curr_index + length;

result.push(chars[curr_index..end].iter().collect());

curr_index = end;

}

let mut rev_fib_iterator :RevFibIter = fib_iterator.rev();

rev_fib_iterator.next();

rev_fib_iterator.next();

while let Some(length) = rev_fib_iterator.next() {

let end :usize = (curr_index + length as usize).min(chars.len());

result.push(chars[curr_index..end].iter().collect());

curr_index = end;

}

let remaining_text: String = chars[curr_index..].iter().collect();

(result, remaining_text)

}

#[test]

fn test_case() {

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("Тествам първата функция на български");

assert_eq!(words, &["Т", "е", "ст", "вам", " първ", "ата функ", "ция на българ", "ски"]);

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("Тествам втората функция на български.", 6);

assert_eq!(words, &["Т", "е", "ст", "вам", " втор", "ата функ"]);

assert_eq!(rest, "ция на български.");

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.");

let (words, rest) = fib_split_n_symmetric("Тествам третата функция на български.", 5);

assert_eq!(words, &["Т", "е", "ст", "вам", " трет", "ата ф", "унк", "ци", "я", " "]);

assert_eq!(rest, "на български.");

println!("Finished test");

}

fn main() {

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

for i in vec {

println!("{} ", i);

}

println!();

let res2 : (Vec<String>, String) = fib_split_n("Lorem ipsum dolor sit amet.", 6);

println!("{:?}", res2);

let res3 : (Vec<String>, String) = fib_split_n_symmetric("Lorem ipsum dolor sit amet.", 5);

println!("{:?}", res3);

let vec : Vec<String> = fib_split("Тествам първата функция на български");

for i in vec {

print!("{} ", i);

}

println!();

let res2 : (Vec<String>, String) = fib_split_n("Тествам втората функция на български.", 6);

println!("{:?}", res2);

let res3 : (Vec<String>, String) = fib_split_n_symmetric("Тествам третата функция на български.", 5);

println!("{:?}", res3);

}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-1ysolzy/solution)
warning: function `main` is never used
   --> src/lib.rs:159:4
    |
159 | fn main() {
    |    ^^^^
    |
    = note: `#[warn(dead_code)]` on by default

warning: `solution` (lib) generated 1 warning
    Finished test [unoptimized + debuginfo] target(s) in 0.98s
     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 ... FAILED
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_exact ... ok
test solution_test::fib_split_n_symmetric_ascii ... ok
test solution_test::fib_split_n_symmetric_ascii_panic ... FAILED
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 ... FAILED
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_panic stdout ----
thread 'solution_test::fib_split_n_ascii_panic' panicked at 'The text is too short', src/lib.rs:58:13
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_ascii_panic stdout ----
thread 'solution_test::fib_split_n_symmetric_ascii_panic' panicked at 'The text is too short', src/lib.rs:100:9
thread 'solution_test::fib_split_n_symmetric_ascii_panic' panicked at 'assertion failed: catch_unwind(|| fib_split_n_symmetric(\"abcd_1234\", 4)).is_err()', tests/solution_test.rs:154:5

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

---- solution_test::rev_fib_iter stdout ----
thread 'solution_test::rev_fib_iter' panicked at 'assertion failed: `(left == right)`
  left: `Some(34)`,
 right: `Some(13)`', tests/solution_test.rs:28: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_panic
    solution_test::fib_split_n_cyrillic_panic
    solution_test::fib_split_n_symmetric_ascii_panic
    solution_test::fib_split_n_symmetric_cyrillic_panic
    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 коментара)