Решение на Думи на Фибоначи от Калоян Петков

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

Към профила на Калоян Петков

Код

// FibIter

pub struct FibIter {

a: u32,

b: u32,

}

impl FibIter {

pub fn new() -> FibIter {

FibIter { a: 0, b: 1 }

}

pub fn rev(self) -> RevFibIter {

RevFibIter { a: (self.a + self.b) as i32, b: self.b as i32 }

}

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

let c = self.a + self.b;

self.a = self.b;

self.b = c;

c

}

}

// RevFibIter

pub struct RevFibIter {

a: i32,

b: i32,

}

impl RevFibIter {

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

let c = self.a - self.b;

self.a = self.b;

self.b = c;

if self.a <= 0 {

return None;

}

Some(self.a as u32)

}

}

// Solution

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

let mut iter = FibIter::new();

let mut words = Vec::new();

let mut start: u32 = 0;

let mut end: u32 = 1;

if text.is_empty() {

return words;

}

loop {

if end as usize > text.len() {

if end as usize != text.len() && (start as usize) < text.len() {

words.push(text[start as usize..].to_string());

}

break;

}

words.push(text[start as usize..end as usize].to_string()); // TODO tva trqbva li da e unicode safe?

start = end;

end = start + iter.next();

}

words

}

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

let mut iter = FibIter::new();

let mut words = Vec::new();

let mut start: u32 = 0;

let mut end: u32 = 1;

let mut remaining: &str = "";

if text.is_empty() && n == 0 {

return (words, text);

}

loop {

if n == words.len() as u32 {

remaining = &text[start as usize..];

break;

}

if end as usize > text.len() {

if end as usize != text.len() && (start as usize) < text.len() {

words.push(text[start as usize..].to_string());

}

break;

}

words.push(text[start as usize..end as usize].to_string()); // TODO tva trqbva li da e unicode safe?

start = end;

end = start + iter.next();

}

if n > words.len() as u32 {

panic!("n is greater than the number of words in text");

}

(words, remaining)

}

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

let mut iter = FibIter::new();

let mut rev_iter: RevFibIter;

let mut words = Vec::new();

let mut start: i32 = 0;

let mut end: i32 = 1;

let mut remaining: &str = "";

if text.is_empty() && n == 0 {

return (words, text);

}

loop {

words.push(text[start as usize..end as usize].to_string()); // TODO tva trqbva li da e unicode safe?

if n == words.len() as u32 {

rev_iter = iter.rev();

break;

}

start = end;

end = start + iter.next() as i32;

}

loop {

let val = rev_iter.next();

if val.is_none() {

break;

}

start = end;

end = start + val.unwrap() as i32;

words.push(text[start as usize..end as usize].to_string()); // TODO tva trqbva li da e unicode safe?

if n * 2 == words.len() as u32 {

remaining = &text[end as usize..];

break;

}

}

if n * 2 > words.len() as u32 {

panic!("n is greater than the number of words in text");

}

(words, remaining)

}

#[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_rev_fib_iter() {

let mut iter = FibIter::new();

iter.next();

iter.next();

iter.next();

iter.next();

iter.next();

iter.next();

iter.next();

let f = iter.next();

let mut rev_iter = iter.rev();

assert_eq!(rev_iter.next(), Some(f));

}

#[test]

fn test_fib_split_n_with_limit_and_remainder() {

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

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

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

}

#[test]

fn test_fib_split_empty_string() {

let result = fib_split("");

assert_eq!(result, Vec::<String>::new());

}

#[test]

fn test_fib_split_single_char() {

let result = fib_split("a");

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

}

#[test]

fn test_fib_split_two_chars() {

let result = fib_split("ab");

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

}

#[test]

fn test_fib_split_three_chars() {

let result = fib_split("abc");

assert_eq!(result, vec!["a", "b", "c"]);

}

#[test]

fn test_fib_split_exact_fibonacci_length() {

let result = fib_split("abcdefghij"); // Length 10, which fits 1, 1, 2, 3, 3

assert_eq!(result, vec!["a", "b", "cd", "efg", "hij"]);

}

#[test]

fn test_fib_split_non_exact_fibonacci_length() {

let result = fib_split("abcdefghijk"); // Length 11

assert_eq!(result, vec!["a", "b", "cd", "efg", "hijk"]);

}

#[test]

fn test_fib_split_fibonacci_boundaries() {

let result = fib_split("abcdefghijklmno"); // Length 15, which fits 1, 1, 2, 3, 5, 8

assert_eq!(result, vec!["a", "b", "cd", "efg", "hijkl", "mno"]);

}

#[test]

fn test_fib_split_multiple_full_fibonacci_series() {

let result = fib_split("abcdefghijklmnopqrstuvwxyz");

assert_eq!(

result,

vec![

"a", "b", "cd", "efg", "hijkl", "mnopqrst", "uvwxyz"

]

);

}

#[test]

fn test_fib_split_partial_fibonacci_slice() {

let result = fib_split("abcdefgh");

assert_eq!(result, vec!["a", "b", "cd", "efg", "h"]);

}

#[test]

fn test_fib_split_n_empty_string() {

let result = std::panic::catch_unwind(|| fib_split_n("", 5));

assert!(result.is_err());

}

#[test]

fn test_fib_split_n_short_text_panic() {

let result = std::panic::catch_unwind(|| fib_split_n("abc", 5));

assert!(result.is_err());

}

#[test]

fn test_fib_split_n_exact_n_elements() {

let (result, remainder) = fib_split_n("abcdefghijk", 4); // Length 11, n=5

assert_eq!(result, vec!["a", "b", "cd", "efg"]);

assert_eq!(remainder, "hijk");

}

#[test]

fn test_fib_split_n_less_than_required_length_panics() {

let result = std::panic::catch_unwind(|| fib_split_n("short", 5));

assert!(result.is_err(), "Expected panic but function did not panic");

}

#[test]

fn test_fib_split_n_with_long_enough_text() {

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

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

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

}

#[test]

fn test_fib_split_n_symmetric_exact_match() {

let (result, remainder) = 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!(remainder, "et.");

}

#[test]

fn test_fib_split_n_symmetric_empty_string() {

let result = std::panic::catch_unwind(|| fib_split_n_symmetric("", 5));

assert!(result.is_err(), "Expected panic on empty input for required `n` segments.");

}

#[test]

fn test_fib_split_n_symmetric_single_char() {

let result = std::panic::catch_unwind(|| fib_split_n_symmetric("a", 5));

assert!(result.is_err(), "Expected panic with insufficient characters for required `n` segments.");

}

#[test]

fn test_fib_split_n_symmetric_sufficient_text() {

let (result, remainder) = 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!(remainder, "et.");

}

#[test]

fn test_fib_split_n_symmetric_more_segments_than_text() {

let result = std::panic::catch_unwind(|| fib_split_n_symmetric("abcdef", 10));

assert!(result.is_err(), "Expected panic when `n` exceeds possible segments for given text.");

}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-17dtsm7/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.96s
     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_iter ... FAILED
test solution_test::fib_split_empty ... ok
test solution_test::fib_split_cyrillic ... FAILED
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 ... FAILED
test solution_test::fib_split_n_cyrillic ... FAILED
test solution_test::fib_split_n_cyrillic_exact ... FAILED
test solution_test::fib_split_n_symmetric_ascii ... ok
test solution_test::fib_split_n_cyrillic_panic ... 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 ... FAILED
test solution_test::fib_split_n_symmetric_cyrillic_panic ... ok
test solution_test::fib_split_n_symmetric_cyrillic_exact ... FAILED
test solution_test::fib_split_n_symmetric_zero ... FAILED
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::fib_iter stdout ----
thread 'solution_test::fib_iter' panicked at 'assertion failed: `(left == right)`
  left: `2`,
 right: `1`', tests/solution_test.rs:11:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

---- solution_test::fib_split_cyrillic stdout ----
thread 'solution_test::fib_split_cyrillic' panicked at 'byte index 1 is not a char boundary; it is inside 'м' (bytes 0..2) of `манджа с грозде`', src/lib.rs:63:20

---- solution_test::fib_split_n_ascii_panic stdout ----
thread 'solution_test::fib_split_n_ascii_panic' panicked at 'n is greater than the number of words in text', src/lib.rs:101:9
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 stdout ----
thread 'solution_test::fib_split_n_cyrillic' panicked at 'byte index 1 is not a char boundary; it is inside 'м' (bytes 0..2) of `манджа_with_грозде`', src/lib.rs:95:20

---- solution_test::fib_split_n_cyrillic_exact stdout ----
thread 'solution_test::fib_split_n_cyrillic_exact' panicked at 'byte index 1 is not a char boundary; it is inside 'м' (bytes 0..2) of `манджа_with_`', src/lib.rs:95:20

---- solution_test::fib_split_n_symmetric_cyrillic stdout ----
thread 'solution_test::fib_split_n_symmetric_cyrillic' panicked at 'byte index 1 is not a char boundary; it is inside 'м' (bytes 0..2) of `манджа_with_грозде`', src/lib.rs:120:20

---- solution_test::fib_split_n_symmetric_cyrillic_exact stdout ----
thread 'solution_test::fib_split_n_symmetric_cyrillic_exact' panicked at 'byte index 1 is not a char boundary; it is inside 'м' (bytes 0..2) of `манджа_with_гр`', src/lib.rs:120:20

---- solution_test::fib_split_n_symmetric_zero stdout ----
thread 'solution_test::fib_split_n_symmetric_zero' panicked at 'byte index 7 is not a char boundary; it is inside 'р' (bytes 6..8) of `abcdгрозде`', src/lib.rs:120:20

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

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


failures:
    solution_test::fib_iter
    solution_test::fib_split_cyrillic
    solution_test::fib_split_n_ascii_panic
    solution_test::fib_split_n_cyrillic
    solution_test::fib_split_n_cyrillic_exact
    solution_test::fib_split_n_symmetric_cyrillic
    solution_test::fib_split_n_symmetric_cyrillic_exact
    solution_test::fib_split_n_symmetric_zero
    solution_test::rev_fib_iter
    solution_test::rev_fib_iter_empty

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

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

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