Решение на Думи на Фибоначи от Александър Глушков

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

Към профила на Александър Глушков

Код

use core::panic;

pub struct FibIter {

prev: u32,

curr: u32

}

impl FibIter {

pub fn new() -> FibIter {

FibIter {prev: 0, curr: 1}

}

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

let cpy = self.curr;

let next_num = self.curr + self.prev;

self.prev = self.curr;

self.curr = next_num;

cpy

}

pub fn rev(self) -> RevFibIter {

RevFibIter {curr: self.prev, next: self.curr}

}

}

pub struct RevFibIter {

curr: u32,

next: u32,

}

impl RevFibIter {

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

if self.curr == 0 {

None

}

else {

let cpy = self.curr;

let temp = self.next - self.curr;

self.next = self.curr;

self.curr = temp;

Some(cpy) // we start from curr, but need to return it first

}

}

}

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

let mut fib_iter = FibIter::new();

let mut result = Vec::new();

let mut end = 0;

let mut start_ind = 0_usize;

let mut end_ind;

let char_count = text.chars().count();

println!("Char count: {char_count}");

loop {

end += fib_iter.next() as usize;

if end >= char_count {

result.push(String::from(&text[start_ind..text.len()]));

break;

}

// find the char index by the its number

end_ind = text.char_indices().nth(end).unwrap().0;

// need char subsequence from start_ind to end_ind

// start and end represent the actual characters, _ind represent the byte indices

result.push(String::from(&text[start_ind..end_ind]));

start_ind = end_ind;

}

result

}

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

let mut fib_iter = FibIter::new();

let mut result = Vec::new();

let mut end = 0;

let mut start_ind = 0_usize;

let mut end_ind;

let char_count = text.chars().count();

for _ in 0..n {

end += fib_iter.next() as usize;

if end >= char_count {

panic!("Text doesn't have enough letters!");

}

end_ind = text.char_indices().nth(end).unwrap().0;

result.push(String::from(&text[start_ind..end_ind]));

start_ind = end_ind;

}

(result, &text[start_ind..])

}

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

let mut fib_iter = FibIter::new();

let mut result = Vec::new();

let mut end = 0;

let mut start_ind = 0_usize;

let mut end_ind;

let char_count = text.chars().count();

for _ in 0..n {

end += fib_iter.next() as usize;

if end >= char_count {

panic!("Text doesn't have enough letters!");

}

end_ind = text.char_indices().nth(end).unwrap().0;

result.push(String::from(&text[start_ind..end_ind]));

start_ind = end_ind;

}

let mut rev_iter = fib_iter.rev();

for _ in 0..n {

if let Some(val) = rev_iter.next() {

end += val as usize;

}

else {

panic!("Not enough characters for the reverse part");

}

if end >= char_count {

panic!("Text doesn't have enough letters!");

}

end_ind = text.char_indices().nth(end).unwrap().0;

result.push(String::from(&text[start_ind..end_ind]));

start_ind = end_ind;

}

(result, &text[start_ind..])

}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-11gb2hv/solution)
    Finished test [unoptimized + debuginfo] target(s) in 5.02s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 20 tests
test solution_test::fib_split_ascii ... ok
test solution_test::fib_split_cyrillic ... ok
test solution_test::fib_iter ... ok
test solution_test::fib_split_n_ascii ... ok
test solution_test::fib_split_empty ... 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 ... FAILED
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 ... FAILED
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 ... FAILED
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_ascii_exact ... FAILED
test solution_test::fib_split_n_zero ... ok
test solution_test::rev_fib_iter ... ok
test solution_test::rev_fib_iter_empty ... ok

failures:

---- solution_test::fib_split_n_cyrillic_exact stdout ----
thread 'solution_test::fib_split_n_cyrillic_exact' panicked at 'Text doesn't have enough letters!', src/lib.rs:93:13

---- solution_test::fib_split_n_symmetric_ascii_exact stdout ----
thread 'solution_test::fib_split_n_symmetric_ascii_exact' panicked at 'Text doesn't have enough letters!', src/lib.rs:142:13

---- solution_test::fib_split_n_symmetric_cyrillic_exact stdout ----
thread 'solution_test::fib_split_n_symmetric_cyrillic_exact' panicked at 'Text doesn't have enough letters!', src/lib.rs:142:13

---- solution_test::fib_split_n_ascii_exact stdout ----
thread 'solution_test::fib_split_n_ascii_exact' panicked at 'Text doesn't have enough letters!', src/lib.rs:93:13
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    solution_test::fib_split_n_ascii_exact
    solution_test::fib_split_n_cyrillic_exact
    solution_test::fib_split_n_symmetric_ascii_exact
    solution_test::fib_split_n_symmetric_cyrillic_exact

test result: FAILED. 16 passed; 4 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s

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

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