Решение на Думи на Фибоначи от Максим Георгиев

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

Към профила на Максим Георгиев

Код

pub struct FibIter{

f0: u32,

f1: u32,

counter: u32

}

impl FibIter {

pub fn new () -> FibIter{

FibIter{

f0 : 1,

f1 : 1,

counter: 0

}

}

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

if self.counter < 2 { self.counter+= 1; return 1; }

let swap = self.f1;

self.f1 = self.f1 + self.f0;

self.f0 = swap;

self.counter += 1;

self.f1

}

pub fn rev(self) -> RevFibIter {

return RevFibIter::new(self.f0, self.f1);

}

}

pub struct RevFibIter {

f0: u32,

f1: u32,

flag: bool

}

impl RevFibIter {

pub fn new (_f0:u32, _f1:u32 ) -> RevFibIter{

return RevFibIter{

f0 : _f0,

f1 : _f1,

flag: false

};

}

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

if !self.flag { self.flag = true; return Some(self.f1) }

let swap = self.f0;

self.f0 = self.f1 - self.f0;

self.f1 = swap;

Some(self.f1)

}

}

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

let mut res: Vec<String> = Vec::new();

let mut i: usize = 0;

let mut gen: FibIter = FibIter::new();

let string: String = String::from(text).chars().collect();

let mut chars = string.chars();

let mut j = i;

loop {

let size: usize = gen.next() as usize;

if gen.f0 + gen.f1 < (text.chars().count() - j) as u32 {

let mut curr = "".to_string();

j = i;

while i < j + size{

let c = chars.next();

curr.push(Option::unwrap(c));

i+=1;

}

res.push(curr);

}

else {

let mut off: String = "".to_string();

loop{

let c = chars.next();

if c != Option::None{

off.push(Option::unwrap(c));

i+=1;

}

else { break };

}

res.push(off.to_string());

break;

}

i += size;

}

return res;

}

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

let left: &str;

let mut vec: Vec<String> = Vec::new();

let mut i: usize = 0;

let mut gen: FibIter = FibIter::new();

let mut j: u32 = 0;

let string: String = String::from(text).chars().collect();

let mut chars = string.chars();

let mut k: usize;

let res: Vec<String> = fib_split(text);

if res.len() <= n as usize { panic!("Not enough words!"); }

while j < n {

let size: usize = gen.next() as usize;

if (gen.f0 + gen.f1 as u32) < (text.chars().count() - i) as u32 {

let mut curr = "".to_string();

k = i;

while i < (k + size) as usize{

let c = chars.next();

curr.push(Option::unwrap(c));

i+=1;

}

vec.push(curr.to_string());

i += size;

j += 1;

}

}

left = &text[i..];

return (vec, left);

}

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

let mut gen: FibIter = FibIter::new();

let vec: Vec<String> = Vec::new();

let mut res: (Vec<String>, &str) = (vec, "");

let mut i: usize = 0;

let mut j: u32 = 0;

//check if n is too big

let mut check_fib: FibIter = FibIter::new();

let mut k = 0;

let mut sum = 0;

while k < n {

sum += check_fib.next();

k += 1;

}

if (sum * 2) as usize> text.chars().count() {

panic!("Not enough text!");

}

let string: String = String::from(text).chars().collect();

let mut chars = string.chars();

let mut l: usize;

while j < n {

let size: usize = gen.next() as usize;

if (gen.f0 + gen.f1 as u32) < (text.chars().count() - i) as u32 {

//let curr:&str = &text[i..(i + size)];

let mut curr = "".to_string();

l = i;

while i < (l + size) as usize{

let c = chars.next();

curr.push(Option::unwrap(c));

i+=1;

}

res.0.push(curr.to_string());

i += size;

j += 1;

}

}

let mut rev_gen: RevFibIter = gen.rev();

while j > 0 {

let size: usize = Option::unwrap_or_default(rev_gen.next()) as usize;

if rev_gen.f1 - rev_gen.f0 < (text.chars().count() - i) as u32 {

let mut curr = "".to_string();

l = i;

while i < (l + size) as usize{

let c = chars.next();

curr.push(Option::unwrap(c));

i+=1;

}

res.0.push(curr.to_string());

}

i += size;

j -= 1;

}

res = (res.0, &text[i..]);

return res;

}

#[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);

}

//use solution::*;

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-zv7asn/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.05s
     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_empty ... ok
test solution_test::fib_split_cyrillic ... FAILED
test solution_test::fib_split_n_ascii ... FAILED
test solution_test::fib_split_n_ascii_exact ... FAILED
test solution_test::fib_split_n_ascii_panic ... ok
test solution_test::fib_split_n_cyrillic ... FAILED
test solution_test::fib_split_n_cyrillic_panic ... ok
test solution_test::fib_split_n_cyrillic_exact ... FAILED
test solution_test::fib_split_n_symmetric_ascii ... FAILED
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 ... 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 ... 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::fib_split_cyrillic stdout ----
thread 'solution_test::fib_split_cyrillic' panicked at 'assertion failed: `(left == right)`
  left: `["м", "а", "нд", "жа ", "с грозде"]`,
 right: `["м", "а", "нд", "жа ", "с гро", "зде"]`', tests/solution_test.rs:61:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

---- solution_test::fib_split_n_ascii stdout ----
thread 'solution_test::fib_split_n_ascii' panicked at 'assertion failed: `(left == right)`
  left: `"cd_123"`,
 right: `"bcd_123"`', tests/solution_test.rs:79:5

---- solution_test::fib_split_n_ascii_exact stdout ----
thread 'solution_test::fib_split_n_ascii_exact' panicked at 'Not enough words!', src/lib.rs:116:35

---- solution_test::fib_split_n_cyrillic stdout ----
thread 'solution_test::fib_split_n_cyrillic' panicked at 'attempt to add with overflow', src/lib.rs:121:13

---- solution_test::fib_split_n_cyrillic_exact stdout ----
thread 'solution_test::fib_split_n_cyrillic_exact' panicked at 'Not enough words!', src/lib.rs:116:35

---- solution_test::fib_split_n_symmetric_ascii stdout ----
thread 'solution_test::fib_split_n_symmetric_ascii' panicked at 'assertion failed: `(left == right)`
  left: `"1234"`,
 right: `"cd1234"`', tests/solution_test.rs:137:5

---- solution_test::fib_split_n_symmetric_ascii_exact stdout ----
thread 'solution_test::fib_split_n_symmetric_ascii_exact' panicked at 'attempt to subtract with overflow', src/lib.rs:192:39

---- solution_test::fib_split_n_symmetric_cyrillic stdout ----
thread 'solution_test::fib_split_n_symmetric_cyrillic' panicked at 'attempt to subtract with overflow', src/lib.rs:192:39

---- solution_test::fib_split_n_symmetric_cyrillic_exact stdout ----
thread 'solution_test::fib_split_n_symmetric_cyrillic_exact' panicked at 'attempt to subtract with overflow', src/lib.rs:192:39

---- 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(1)`,
 right: `None`', tests/solution_test.rs:43:5


failures:
    solution_test::fib_split_cyrillic
    solution_test::fib_split_n_ascii
    solution_test::fib_split_n_ascii_exact
    solution_test::fib_split_n_cyrillic
    solution_test::fib_split_n_cyrillic_exact
    solution_test::fib_split_n_symmetric_ascii
    solution_test::fib_split_n_symmetric_ascii_exact
    solution_test::fib_split_n_symmetric_cyrillic
    solution_test::fib_split_n_symmetric_cyrillic_exact
    solution_test::rev_fib_iter
    solution_test::rev_fib_iter_empty

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

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

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