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

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

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

Код

use std::mem::swap;

pub struct FibIter {

first: u32,

second: u32

}

impl FibIter {

pub fn new() -> FibIter {

FibIter {

first: 0,

second: 1

}

}

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

let result = self.second;

swap(&mut self.second, &mut self.first);

self.second += self.first;

result

}

pub fn rev(self) -> RevFibIter {

RevFibIter::new(self)

}

}

pub struct RevFibIter {

first: u32,

second: u32

}

impl RevFibIter {

pub fn new(fib_iter: FibIter) -> RevFibIter {

RevFibIter {

first: fib_iter.first,

second: fib_iter.second,

}

}

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

if self.second == 0 {

return None;

}

swap(&mut self.second, &mut self.first);

self.first -= self.second;

Some(self.second)

}

}

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

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

let mut fib_iter = FibIter::new();

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

let mut i = 0;

while i < chars.len() {

let fib: usize = fib_iter.next().try_into().unwrap();

if chars.len() - i < fib {

result.append(&mut vec![chars[i..chars.len()].iter().collect::<String>()]);

break;

} else {

result.append(&mut vec![chars[i..i + fib].iter().collect::<String>()]);

}

i += fib;

}

result

}

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

let mut fib_iter = FibIter::new();

let mut wordlen: usize = 0;

for _ in 0..n {

let fib: usize = fib_iter.next().try_into().unwrap();

wordlen += fib;

}

if wordlen > text.len() {

panic!();

}

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

let mut byte_len = 0;

let mut iter = chars[0..wordlen].iter();

while let Some(ch) = iter.next() {

byte_len += ch.len_utf8();

}

(

fib_split(chars[0..wordlen].iter().collect::<String>().as_str()),

&text[byte_len..text.len()],

)

}

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

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

let mut fib_iter = FibIter::new();

let mut wordlen: usize = 0;

for _ in 0..n {

let fib: usize = fib_iter.next().try_into().unwrap();

wordlen += fib;

}

if wordlen * 2 > text.len() {

panic!();

}

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

fib_iter = FibIter::new();

let mut i = 0;

while i < wordlen {

let fib: usize = fib_iter.next().try_into().unwrap();

result.append(&mut vec![chars[i..i + fib].iter().collect::<String>()]);

i += fib;

}

let mut rev_fib_iter = fib_iter.rev();

while i < wordlen * 2 {

let fib: usize = rev_fib_iter.next().unwrap().try_into().unwrap();

result.append(&mut vec![chars[i..i + fib].iter().collect::<String>()]);

i += fib;

}

let mut byte_len = 0;

let mut iter = chars[0..wordlen * 2].iter();

while let Some(ch) = iter.next() {

byte_len += ch.len_utf8();

}

(result, &text[byte_len..text.len()])

}

#[cfg(test)]

mod tests {

use std::str::FromStr;

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!");

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

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

1,

);

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

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

1,

);

}

#[test]

fn test_split_n() {

let tupl: (Vec<String>, &str) = fib_split_n("Lorem ipsum dolor sit amet.", 6);

assert_eq!(

tupl,

(

["L", "o", "re", "m i", "psum ", "dolor si"]

.iter()

.map(|v| String::from_str(v).unwrap())

.collect(),

"t amet."

)

);

}

#[test]

fn test_split_n_cyr() {

let tupl: (Vec<String>, &str) = fib_split_n("Лорем ипсум долор сит амет,", 6);

assert_eq!(

tupl,

(

["Л", "о", "ре", "м и", "псум ", "долор си"]

.iter()

.map(|v| String::from_str(v).unwrap())

.collect(),

"т амет,"

)

);

}

#[test]

fn test_split_n_sym() {

let tupl: (Vec<String>, &str) = fib_split_n_symmetric("Lorem ipsum dolor sit amet.", 5);

assert_eq!(

tupl,

(

["L", "o", "re", "m i", "psum ", "dolor", " si", "t ", "a", "m"]

.iter()

.map(|v| String::from_str(v).unwrap())

.collect(),

"et."

)

);

}

#[test]

fn test_split_n_sym_cyr() {

let tupl: (Vec<String>, &str) = fib_split_n_symmetric("Лорем ипсум долор сит амет,", 5);

assert_eq!(

tupl,

(

[

"Л",

"о",

"ре",

"м и",

"псум ",

"долор",

" си",

"т ",

"а",

"м"

]

.iter()

.map(|v| String::from_str(v).unwrap())

.collect(),

"ет,"

)

);

}

}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-1a3znhe/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.00s
     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 ... 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_zero ... ok
test solution_test::fib_split_n_symmetric_cyrillic_panic ... ok
test solution_test::fib_split_n_zero ... ok
test solution_test::rev_fib_iter ... FAILED
test solution_test::rev_fib_iter_empty ... FAILED

failures:

---- solution_test::rev_fib_iter stdout ----
thread 'solution_test::rev_fib_iter' panicked at 'assertion failed: `(left == right)`
  left: `Some(0)`,
 right: `None`', tests/solution_test.rs:35:5

---- solution_test::rev_fib_iter_empty stdout ----
thread 'solution_test::rev_fib_iter_empty' panicked at 'assertion failed: `(left == right)`
  left: `Some(0)`,
 right: `None`', tests/solution_test.rs:43:5


failures:
    solution_test::rev_fib_iter
    solution_test::rev_fib_iter_empty

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 коментара)