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

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

Към профила на Дария Лазарова

Код

// Structures:

pub struct FibIter {

prev: u32,

curr: u32,

n: u32,

}

impl FibIter {

pub fn new() -> FibIter {

FibIter {

prev: 0,

curr: 1,

n: 0,

}

}

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

if self.n == 0 {

self.n += 1;

return self.curr;

} else {

let next = self.prev + self.curr;

self.prev = self.curr;

self.curr = next;

self.n += 1;

return self.curr;

}

}

}

impl FibIter {

pub fn rev(self) -> RevFibIter {

RevFibIter {

curr: self.prev,

next: self.curr,

n: self.n as i32 - 1,

}

}

}

pub struct RevFibIter {

curr: u32,

next: u32,

n: i32,

}

impl RevFibIter {

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

if self.n < 0 {

return None;

}

let result = self.next;

let new_next = self.next - self.curr;

self.next = self.curr;

self.curr = new_next;

self.n = self.n - 1;

Some(result)

}

}

// Functions:

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

let mut result = Vec::new();

let mut iter = FibIter::new();

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

let mut current_index = 0;

while current_index < text_chars.len() {

let next = iter.next() as usize;

let to_take = to_take(&text_chars, current_index, next, false);

let text: String = text_chars[current_index..current_index + to_take].iter().collect();

result.push(text);

current_index += to_take;

}

result

}

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

let (result, text, _) = split_n(text, n);

(result, text)

}

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

let (mut result, rem, iter) = split_n(text, n);

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

let mut current_index = 0;

let mut rev_iter = iter.rev();

while let Some(next) = rev_iter.next() {

let to_take = to_take(&text_chars, current_index, next as usize, true);

let text: String = text_chars[current_index..current_index + to_take].iter().collect();

result.push(text);

current_index += to_take;

}

(result, text_chars[current_index..].iter().collect())

}

// Helper functions:

pub fn to_take(text_chars: &Vec<char>, current_index: usize, next: usize, error: bool) -> usize {

let to_take = if current_index + next <= text_chars.len() {

next

} else {

text_chars.len() - current_index

};

if error && to_take <= 0 {

panic!("Too short text for n");

}

to_take

}

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

let mut result = Vec::new();

let mut iter = FibIter::new();

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

let mut current_index = 0;

while iter.n < n {

let next = iter.next() as usize;

let to_take = to_take(&text_chars, current_index, next, true);

let text: String = text_chars[current_index..current_index + to_take].iter().collect();

result.push(text);

current_index += to_take;

}

let text: String = text_chars[current_index..].iter().collect();

(result, text, iter)

}

#[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-x8lqya/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.94s
     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 ... ok
test solution_test::fib_split_n_symmetric_ascii_exact ... ok
test solution_test::fib_split_n_symmetric_cyrillic ... 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_panic ... ok
test solution_test::fib_split_n_zero ... ok
test solution_test::fib_split_n_symmetric_zero ... ok
test solution_test::rev_fib_iter ... ok
test solution_test::rev_fib_iter_empty ... ok

failures:

---- solution_test::fib_split_n_ascii_panic stdout ----
thread 'solution_test::fib_split_n_ascii_panic' panicked at 'Too short text for n', src/lib.rs:113:9
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


failures:
    solution_test::fib_split_n_ascii_panic
    solution_test::fib_split_n_cyrillic_panic

test result: FAILED. 18 passed; 2 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--test solution_test`

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