Решение на Думи на Фибоначи от Владимир Стоянов

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

Към профила на Владимир Стоянов

Код

use core::panic;

use std::{char, cmp::min};

pub struct FibIter {

prev_num: u32,

current_num: u32,

}

impl FibIter {

pub fn new() -> FibIter {

FibIter {

current_num: 1,

prev_num: 0,

}

}

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

let temp = self.current_num;

self.current_num = self.prev_num + self.current_num;

self.prev_num = temp;

self.prev_num

}

pub fn rev(self) -> RevFibIter {

RevFibIter::new(self.current_num, self.prev_num)

}

}

pub struct RevFibIter {

prev_num: u32,

current_num: u32,

}

impl RevFibIter {

pub fn new(prev_num: u32, current_num: u32) -> RevFibIter {

RevFibIter {

prev_num,

current_num,

}

}

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

if self.current_num > self.prev_num || self.current_num == 0 {

return None;

}

let res = self.current_num;

self.current_num = self.prev_num - self.current_num;

self.prev_num = res;

// Positive result

Some(res)

}

}

pub fn to_string(char_vec: &[char]) -> String {

let mut res = String::new();

for ch in char_vec {

res.push(ch.clone());

}

res

}

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

let mut iter = FibIter::new();

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

let mut begin: usize = 0;

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

let size: usize = chars.len();

loop {

let next_iter = iter.next() as usize;

let end = min(size, begin + next_iter);

res.push(to_string(&chars[begin..end]));

begin = end;

if end == size {

break;

}

}

res

}

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

let mut iter = FibIter::new();

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

let mut chars = text.chars();

if text.is_empty() { // word is not long enough - so the last one contains less than needed - 0

return vec![String::from("")];

}

loop {

let chunk_size= iter.next() as usize;

let to_push: String = chars.by_ref().take(chunk_size).collect();

if to_push.is_empty(){

break;

}

res.push(to_push);

}

res

}

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

let mut iter = FibIter::new();

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

let mut text_iter = text.chars();

for _ in 0..n {

let chunk_size = iter.next() as usize;

let word: String = text_iter.by_ref().take(chunk_size).collect();

if word.chars().count() < chunk_size {

panic!("Низът е твърде къс.")

}

res.push(word);

}

let rest = text_iter.collect();

(res, rest)

}

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

let mut fw_iter = FibIter::new();

for _ in 0..n{

fw_iter.next();

}

let mut iter = fw_iter.rev();

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

let mut text_iter = text.chars();

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

let chunk_size = chunk_size_int as usize;

let word: String = text_iter.by_ref().take(chunk_size).collect();

if word.chars().count() < chunk_size {

panic!("Низът е твърде къс.")

}

res.push(word);

}

let rest = text_iter.collect();

(res, rest)

}

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

let mut iter = FibIter::new();

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

let mut text_iter = text.chars();

for _ in 0..n{

let chunk_size = iter.next() as usize;

let word: String = text_iter.by_ref().take(chunk_size).collect();

if word.chars().count() < chunk_size {

panic!("Низът е твърде къс.")

}

res.push(word);

}

let mut rev_iter = iter.rev();

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

let chunk_size = chunk_size_int as usize;

let word: String = text_iter.by_ref().take(chunk_size).collect();

if word.chars().count() < chunk_size {

panic!("Низът е твърде къс.")

}

res.push(word);

}

let rest = text_iter.collect();

(res, rest)

}

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

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

let (mut res2, real_rest) = fib_split_n_reverse(rest.as_str(), n);

result.append(&mut res2);

(result, real_rest)

}

fn main(){}

#[cfg(test)]

mod tests {

use super::*;

#[test]

fn test_fib_split_latin() {

let result = fib_split("Fibonacci words!");

assert_eq!(result, vec!["F", "i", "bo", "nac", "ci wo", "rds!"]);

let result = fib_split("F");

assert_eq!(result, vec!["F"]);

let result = fib_split("");

assert_eq!(result, vec![""]);

}

#[test]

fn test_fib_split_cyrillic() {

let result = fib_split("Фибоначи думи!");

assert_eq!(result, vec!["Ф", "и", "бо", "нач", "и дум", "и!"]);

}

#[test]

fn test_fib_split_n_latin() {

let (result, rest) = fib_split_n("Lorem ipsum dolor sit amet.", 6);

assert_eq!(result, vec!["L", "o", "re", "m i", "psum ", "dolor si"]);

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

}

#[test]

#[should_panic]

fn test_fib_split_n_insufficient_text() {

fib_split_n("Short text", 10);

}

#[test]

#[should_panic]

fn test_fib_split_n_insufficient_text_2() {

fib_split_n("", 6);

}

#[test]

fn test_fib_split_n_cyrillic() {

let (result, rest) = fib_split_n("Това е тестов текст.", 5);

assert_eq!(result, vec!["Т", "о", "ва", " е ", "тесто"]);

assert_eq!(rest, "в текст.");

}

#[test]

fn test_fib_split_n_symmetric_latin() {

let (result, rest) = fib_split_n_symmetric("Lorem ipsum dolor sit amet.", 5);

assert_eq!(result, vec!["L", "o", "re", "m i", "psum ", "dolor", " si", "t ", "a", "m"]);

assert_eq!(rest, "et.");

}

#[test]

#[should_panic]

fn test_fib_split_n_symmetric_insufficient_text() {

fib_split_n_symmetric("Short text", 8);

}

#[test]

fn test_fib_split_n_symmetric_cyrillic() {

let (result, rest) = fib_split_n_symmetric("Лорем ипсум долор сит амет.", 5);

assert_eq!(result, vec!["Л", "о", "ре", "м и", "псум ", "долор", " си", "т ", "а", "м"]);

assert_eq!(rest, "ет.");

}

#[test]

fn test_fib_split_n_symmetric_cyrillic_alt() {

let (result, rest) = fib_split_n_symmetric_alt("Лорем ипсум долор сит амет.", 5);

assert_eq!(result, vec!["Л", "о", "ре", "м и", "псум ", "долор", " си", "т ", "а", "м"]);

assert_eq!(rest, "ет.");

}

#[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-1wz3p11/solution)
warning: function `main` is never used
   --> src/lib.rs:173:4
    |
173 | fn main(){}
    |    ^^^^
    |
    = note: `#[warn(dead_code)]` on by default

warning: `solution` (lib) generated 1 warning
    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_exact ... ok
test solution_test::fib_split_n_cyrillic ... 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 коментара)