Решение на Думи на Фибоначи от Теодор Каракашев

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

Към профила на Теодор Каракашев

Код

#[derive(Debug)]

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 = self.current;

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

self.previous = current;

current

}

pub fn rev(mut self) -> RevFibIter {

let mut sequence = Vec::new();

while self.previous != 0 {

sequence.push(self.previous);

let current = self.current;

self.current = self.previous;

self.previous = current - self.previous;

}

RevFibIter { sequence, index: 0 }

}

}

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

let mut fib_iter = FibIter::new();

let mut result = Vec::new();

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

let mut start = 0;

while start < chars.len() {

let fib_length = fib_iter.next() as usize;

let end = start + fib_length;

let end = if end > chars.len() {

chars.len()

} else {

end

};

let word: String = chars[start..end].iter().collect();

result.push(word);

start = end;

}

result

}

#[derive(Debug)]

pub struct RevFibIter {

sequence: Vec<u32>,

index: usize,

}

impl RevFibIter {

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

if self.index < self.sequence.len() {

let value = self.sequence[self.index];

self.index += 1;

Some(value)

} else {

None

}

}

}

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

let mut fib_iter = FibIter::new();

let mut result = Vec::new();

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

let mut start = 0;

for _ in 0..n {

let fib_length = fib_iter.next() as usize;

let end = start + fib_length;

if end > chars.len() {

panic!("Text is too short");

} else {

end

};

let word: String = chars[start..end].iter().collect();

result.push(word);

start = end;

}

let remaining: String = chars[start..].iter().collect();

(result, remaining)

}

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

let (mut result, remaining_text) = fib_split_n(text, n);

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

let mut start = 0;

let mut fib_iter = FibIter::new();

for _ in 0..n {

fib_iter.next();

}

let mut rev_fib_iter = fib_iter.rev();

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

let end = start + length as usize;

if end > chars.len() {

panic!("Text is too short");

} else {

end

};

let word: String = chars[start..end].iter().collect();

result.push(word);

start = end;

}

let remaining: String = chars[start..].iter().collect();

(result, remaining)

}

#[cfg(test)]

mod tests {

use super::*;

#[test]

fn test_fib_iter() {

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 test_fib_split() {

let text = "Fibonacci words!";

let result = fib_split(text);

let expected = vec!["F", "i", "bo", "nac", "ci wo", "rds!"];

assert_eq!(result, expected);

}

#[test]

fn test_fib_split_bg() {

let text = "Фибоначи думи!";

let result = fib_split(text);

let expected = vec!["Ф", "и", "бо", "нач", "и дум", "и!"];

assert_eq!(result, expected);

}

#[test]

fn test_fib_split_short_text() {

let text = "Rust!";

let result = fib_split(text);

let expected = vec!["R", "u", "st", "!"];

assert_eq!(result, expected);

}

#[test]

fn test_fib_split_empty_text() {

let text = "";

let result = fib_split(text);

let expected: Vec<String> = vec![];

assert_eq!(result, expected);

}

#[test]

fn test_fib_split_exact_fib_lengths() {

let text = "abcdefghi";

let result = fib_split(text);

let expected = vec!["a", "b", "cd", "efg", "hi"];

assert_eq!(result, expected);

}

#[test]

fn test_fib_split_n() {

let text = "Lorem ipsum dolor sit amet.";

let (result, remaining) = fib_split_n(text, 6);

let expected = vec!["L", "o", "re", "m i", "psum ", "dolor si"];

assert_eq!(result, expected);

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

}

#[test]

fn test_fib_split_n_bg() {

let text = "Ръстче!!";

let (result, remaining) = fib_split_n(text, 4);

let expected = vec!["Р", "ъ", "ст", "че!"];

assert_eq!(result, expected);

assert_eq!(remaining, "!");

}

#[test]

fn test_fib_split_n_short_text() {

let text = "Rust!";

let (result, remaining) = fib_split_n(text, 3);

let expected = vec!["R", "u", "st"];

assert_eq!(result, expected);

assert_eq!(remaining, "!");

}

#[test]

#[should_panic]

fn test_fib_split_n_short_text_panic() {

let text = "Rust!";

fib_split_n(text, 4);

}

#[test]

fn test_fib_split_n_empty_text() {

let text = "";

let (result, remaining) = fib_split_n(text, 0);

let expected: Vec<String> = vec![];

assert_eq!(result, expected);

assert_eq!(remaining, "");

}

#[test]

fn test_fib_split_n_exact_fib_lengths() {

let text = "abcdefghigkl";

let (result, remaining) = fib_split_n(text, 5);

let expected = vec!["a", "b", "cd", "efg", "higkl"];

assert_eq!(result, expected);

assert_eq!(remaining, "");

}

#[test]

fn test_fib_split_n_symmetric() {

let text = "Lorem ipsum dolor sit amet.";

let (result, remaining) = fib_split_n_symmetric(text, 5);

let expected = vec!["L", "o", "re", "m i", "psum ", "dolor", " si", "t ", "a", "m"];

assert_eq!(result, expected);

assert_eq!(remaining, "et.");

}

#[test]

fn test_fib_split_n_symmetric_exact_length() {

let text = "Lorem ipsum dolor sit am";

let (result, remaining) = fib_split_n_symmetric(text, 5);

let expected = vec!["L", "o", "re", "m i", "psum ", "dolor", " si", "t ", "a", "m"];

assert_eq!(result, expected);

assert_eq!(remaining, "");

}

#[test]

fn test_fib_split_n_symmetric_bg() {

let text = "Ръстче!!";

let (result, remaining) = fib_split_n_symmetric(text, 3);

let expected = vec![

"Р", "ъ", "ст", "че", "!", "!",

];

assert_eq!(result, expected);

assert_eq!(remaining, "");

}

#[test]

#[should_panic]

fn test_fib_split_n_symmetric_panic() {

let text = "Lorem ipsum";

fib_split_n_symmetric(text, 5);

}

#[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-7hga6m/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.95s
     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 коментара)