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

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

Към профила на Иван Панайотов

Код

pub struct FibIter {

previous: u32,

current: u32,

}

impl FibIter {

pub fn new() -> FibIter {

FibIter {

previous: 0,

current: 1,

}

}

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

let current_fib = self.current;

// Тук може да стане overflow за 64-тото число на Фибоначи.

self.current = self.previous + self.current;

self.previous = current_fib;

current_fib

}

pub fn rev(self) -> RevFibIter {

RevFibIter {

previous: self.previous,

current: self.current,

}

}

}

pub struct RevFibIter {

previous: u32,

current: u32,

}

impl RevFibIter {

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

let current_rev_fib = self.current;

let previous_rev_fib = self.previous;

if current_rev_fib >= previous_rev_fib && previous_rev_fib != 0 {

let diff_rev_fib = current_rev_fib - previous_rev_fib;

self.previous = diff_rev_fib;

self.current = previous_rev_fib;

Some(self.current)

} else {

None

}

}

}

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

let mut fib_iter = FibIter::new();

let mut fib_words = Vec::new();

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

let mut buffer: Vec<char> = Vec::new();

let mut current_fib_capacity = fib_iter.next();

while current_fib_capacity <= characters.len() as u32 {

for _ in 0..current_fib_capacity {

buffer.push(characters.remove(0));

}

fib_words.push(buffer.iter().collect());

buffer.clear();

current_fib_capacity = fib_iter.next();

}

if !characters.is_empty() {

fib_words.push(characters.into_iter().collect());

}

fib_words

}

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

let mut fib_iter = FibIter::new();

let mut fib_words = Vec::new();

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

let mut buffer: Vec<char> = Vec::new();

for _ in 0..n {

let fib_current_length = fib_iter.next();

if fib_current_length > characters.len() as u32 {

panic!("The number of requested words is greater than the number of Fibonacci words.");

}

for _ in 0..fib_current_length {

buffer.push(characters.remove(0));

}

fib_words.push(buffer.iter().collect());

buffer.clear();

}

(fib_words, characters.into_iter().collect())

}

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

let mut fib_iter = FibIter::new();

let mut fib_words = Vec::new();

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

let mut buffer: Vec<char> = Vec::new();

for _ in 0..n {

let fib_current_length = fib_iter.next();

if fib_current_length > characters.len() as u32 {

panic!("The number of requested words is greater than the number of Fibonacci words.");

}

for _ in 0..fib_current_length {

buffer.push(characters.remove(0));

}

fib_words.push(buffer.iter().collect());

buffer.clear();

}

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

for _ in 0..n {

let fib_current_length = rev_fib_iter.next();

let unwrapped_fib_length = fib_current_length.unwrap_or(0);

if unwrapped_fib_length > characters.len() as u32 {

panic!("The number of requested words is greater than the number of Fibonacci words.");

}

for _ in 0..unwrapped_fib_length {

buffer.push(characters.remove(0));

}

fib_words.push(buffer.iter().collect());

buffer.clear();

}

(fib_words, characters.into_iter().collect())

}

#[cfg(test)]

mod tests {

use super::*;

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

}

#[test]

fn test_custom() {

let mut fib_iter = FibIter::new();

fib_iter.next();

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

// println!("rev_fib_iter: {:?}", rev_fib_iter.next().unwrap());

// println!("rev_fib_iter: {:?}", rev_fib_iter.next().unwrap());

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

println!("words: {:?}", _words);

let _words: Vec<String> = fib_split("Йоаоао аяо яао яо");

println!("words: {:?}", _words);

let _words: Vec<String> = fib_split("");

println!("words: {:?}", _words);

let (_words, _rest): (Vec<String>, String) = fib_split_n(

"Lorem ipsum dolor sit amet, consectetur adipiscing elit.",

6,

);

println!("words: {:?}", (_words, _rest));

let (_words, _rest): (Vec<String>, String) = fib_split_n(

"ffa", 1,

// 10, - time to panic

);

println!("words: {:?}", (_words, _rest));

let (_words, _rest): (Vec<String>, String) = fib_split_n(

"Да бъда, или да не бъда. Да си ти, или да не си ти.",

6,

// 10, - time to panic

);

println!("words: {:?}", (_words, _rest));

let (_words, _rest): (Vec<String>, String) = fib_split_n_symmetric(

"Lorem ipsum dolor sit amet, consectetur adipiscing elit.",

1,

);

println!("words: {:?}", (_words, _rest));

let (_words, _rest): (Vec<String>, String) =

fib_split_n_symmetric("Lorem ipsum dolor sit amet.", 5);

println!("words: {:?}", (_words, _rest));

let (_words, _rest): (Vec<String>, String) = fib_split_n_symmetric(

"Да бъда, или да не бъда. Да си ти, или да не си ти.",

6,

// 10, - time to panic

);

println!("words: {:?}", (_words, _rest));

let (_words, _rest): (Vec<String>, String) = fib_split_n(

"ff", 2,

// 10, - time to panic

);

println!("words: {:?}", (_words, _rest));

}

}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-1nndraj/solution)
    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_ascii_panic ... ok
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 ... 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

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