Решение на Думи на Фибоначи от Венцислав Монев

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

Към профила на Венцислав Монев

Код

const FIRST_FIB_VALUE:u32 = 1;

pub struct FibIter {

first: u32,

second: u32,

count: i32,

}

impl FibIter {

pub fn new() -> FibIter {

FibIter {

first: FIRST_FIB_VALUE,

second: FIRST_FIB_VALUE,

count: 0,

}

}

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

if self.count == 1 || self.count == 0 {

self.count += 1;

FIRST_FIB_VALUE

} else {

let result = self.first + self.second;

self.first = self.second;

self.second = result;

self.count += 1;

result

}

}

pub fn rev(self) -> RevFibIter {

RevFibIter {

first: self.first,

second: self.second,

count: self.count-1,

}

}

}

//Reverse FibIter

pub struct RevFibIter {

first: u32,

second: u32,

count: i32,

}

impl RevFibIter {

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

if self.count < 0 {

None

} else if self.count == 0 || self.count == 1 {

self.count -= 1;

Some(FIRST_FIB_VALUE)

} else {

let result = self.second;

self.second = self.first;

self.first = result - self.first;

self.count -= 1;

Some(result)

}

}

}

//fib_split

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

let mut fib_gen = FibIter::new();

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

let mut charachters = text.chars();

'outerCycle: loop {

let curr_fib_numb = fib_gen.next();

let mut separate_word = String::new();

for _i in 0..curr_fib_numb {

if let Some(c) = charachters.next() {

separate_word.push(c);

} else {

if !separate_word.is_empty() {

result.push(separate_word);

}

break 'outerCycle;

}

}

result.push(separate_word);

}

result

}

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

let mut fib_gen = FibIter::new();

let mut charachters = text.chars();

let mut result: (Vec<String>, &str) = (vec![], "");

collect_fib_words(n, &mut fib_gen, &mut charachters, &mut result);

result.1 = charachters.as_str();

result

}

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

let mut fib_gen = FibIter::new();

let mut result: (Vec<String>, &str) = (vec![], "");

let mut charachters = text.chars();

collect_fib_words(n, &mut fib_gen, &mut charachters, &mut result);

let mut rev_fib_gen = fib_gen.rev();

for _i in 0..n {

let prev_fib_numb = match rev_fib_gen.next() {

Some(value) => value,

None => panic!("Text is too short!"),

};

build_fib_word(prev_fib_numb, &mut charachters, &mut result.0);

}

result.1 = charachters.as_str();

result

}

fn build_fib_word<I>(curr_fib_numb: u32, charachters: &mut I, result: &mut Vec<String>)

where

I: Iterator<Item = char>,

{

let mut separate_word = String::new();

for _i in 0..curr_fib_numb {

if let Some(c) = charachters.next() {

separate_word.push(c);

} else {

panic!("Text is too short")

}

}

result.push(separate_word);

}

fn collect_fib_words<I>(

n: u32,

fib_gen: &mut FibIter,

charachters: &mut I,

result: &mut (Vec<String>, &str),

) where

I: Iterator<Item = char>,

{

for _i in 0..n {

let curr_fib_numb = fib_gen.next();

build_fib_word(curr_fib_numb, charachters, &mut result.0);

}

}

//Additional tests

#[test]

fn fib_new() {

let mut fib_iter = FibIter::new();

assert_eq!(fib_iter.next(), 1);

}

#[test]

fn fib_next() {

let mut fib_iter = FibIter::new();

assert_eq!(fib_iter.next(), 1);

assert_eq!(fib_iter.next(), 1);

assert_eq!(fib_iter.next(), 2);

assert_eq!(fib_iter.next(), 3);

assert_eq!(fib_iter.next(), 5);

assert_eq!(fib_iter.next(), 8);

}

#[test]

fn fib_rev() {

let mut fib_iter = FibIter::new();

assert_eq!(fib_iter.next(), 1);

assert_eq!(fib_iter.next(), 1);

assert_eq!(fib_iter.next(), 2);

assert_eq!(fib_iter.next(), 3);

assert_eq!(fib_iter.next(), 5);

let mut rev_fib_iter = fib_iter.rev();

assert_eq!(rev_fib_iter.next(), Some(5));

}

#[test]

fn rev_fib_iter_next() {

let mut fib_iter = FibIter::new();

assert_eq!(fib_iter.next(), 1);

assert_eq!(fib_iter.next(), 1);

assert_eq!(fib_iter.next(), 2);

assert_eq!(fib_iter.next(), 3);

assert_eq!(fib_iter.next(), 5);

let mut rev_fib_iter = fib_iter.rev();

assert_eq!(rev_fib_iter.next(), Some(5));

assert_eq!(rev_fib_iter.next(), Some(3));

assert_eq!(rev_fib_iter.next(), Some(2));

assert_eq!(rev_fib_iter.next(), Some(1));

assert_eq!(rev_fib_iter.next(), Some(1));

assert_eq!(rev_fib_iter.next(), None);

assert_eq!(rev_fib_iter.next(), None);

assert_eq!(rev_fib_iter.next(), None);

}

#[test]

fn fib_split_additional() {

//with an empty string

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

assert_eq!(words, Vec::<String>::new());

//with a single letter

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

assert_eq!(words, vec!["a"]);

//with other symbols and if the text doesnt fit the last number

let words: Vec<String> = fib_split("this ис а тест. Нека сега проверим");

assert_eq!(

words,

vec![

"t",

"h",

"is",

" ис",

" а те",

"ст. Нека",

" сега провери",

"м"

]

);

//if the length is exact

let words: Vec<String> = fib_split("asdfghjkl;'.");

assert_eq!(words, vec!["a", "s", "df", "ghj", "kl;'."]);

}

#[test]

fn fib_split_n_additional() {

//with an empty string

let words = fib_split_n("", 0);

assert_eq!(words.0, Vec::<String>::new());

assert_eq!(words.1, "");

//if the text fits perfectly

let words = fib_split_n("asdfghjkl;'.", 5);

assert_eq!(words.0, vec!["a", "s", "df", "ghj", "kl;'."]);

assert_eq!(words.1, "");

//if the text doesnt fit perfectly

let words = fib_split_n("Police and thieves in the streets", 6);

assert_eq!(words.0, vec!["P", "o", "li", "ce ", "and t", "hieves i"]);

assert_eq!(words.1, "n the streets");

//Text with different some symbols

let words = fib_split_n("Now let`s see with: кирилица", 6);

assert_eq!(words.0, vec!["N", "o", "w ", "let", "`s se", "e with: "]);

assert_eq!(words.1, "кирилица");

}

#[test]

fn fib_split_n_symetric_additional() {

//with an empty string

let words = fib_split_n_symmetric("", 0);

assert_eq!(words.0, Vec::<String>::new());

assert_eq!(words.1, "");

//if the text fits perfectly

let words = fib_split_n_symmetric("asdfghjkl;'..';lkjhgfdsa", 5);

assert_eq!(

words.0,

vec!["a", "s", "df", "ghj", "kl;'.", ".';lk", "jhg", "fd", "s", "a"],

);

assert_eq!(words.1, "");

//if the text doesnt fit perfectly

let words = fib_split_n_symmetric("asdfghjkl;'..';lkjhgfdsa whitespace", 5);

assert_eq!(

words.0,

vec!["a", "s", "df", "ghj", "kl;'.", ".';lk", "jhg", "fd", "s", "a"],

);

assert_eq!(words.1, " whitespace");

//Text with different symbols

let words = fib_split_n_symmetric("asdfghjkl;'.Нека видим с кирилица.';lkjhgfdsa", 6);

assert_eq!(

words.0,

vec![

"a",

"s",

"df",

"ghj",

"kl;'.",

"Нека вид",

"им с кир",

"илица",

".';",

"lk",

"j",

"h"

]

);

assert_eq!(words.1, "gfdsa");

}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-7kt09l/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.91s
     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_exact ... ok
test solution_test::fib_split_n_symmetric_cyrillic ... 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 коментара)