Решение на Думи на Фибоначи от Енислав Енчев

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

Към профила на Енислав Енчев

Код

pub struct FibIter{

num1: u32,

num2: u32,

}

impl FibIter {

pub fn new() -> FibIter {

FibIter {num1: 0, num2: 1}

}

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

if self.num1 < 2 {

self.num2 = self.num1 + self.num2;

self.num1 = self.num2 - self.num1;

return self.num1;

}

self.num2 = self.num1 + self.num2;

self.num1 = self.num2 - self.num1;

self.num1

}

pub fn rev(self) -> RevFibIter {

RevFibIter{num1 : self.num1, num2 : self.num2}

}

}

pub struct RevFibIter {

num1 : u32,

num2 : u32,

}

impl RevFibIter {

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

if self.num1 == 0 {

return None;

}

self.num1 = self.num2 - self.num1;

self.num2 = self.num2 - self.num1;

Some(self.num2)

}

}

// trait MyIterator{

// fn next(&mut self) -> Option<u32>;

// }

// impl MyIterator for FibIter{

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

// Some(self.next())

// }

// }

// impl MyIterator for RevFibIter{

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

// self.next()

// }

// }

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

//sz might overflow

let mut sz : usize = 0;

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

let mut fi = FibIter::new();

let mut next_value : usize = fi.next() as usize;

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

let ln : usize = text_chars.len();

while sz + next_value < ln {

words.push(text_chars[sz..sz + next_value].into_iter().collect());

sz += next_value;

next_value = fi.next() as usize;

}

if sz < ln {

words.push(text_chars[sz..].into_iter().collect());

}

words

}

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

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

let mut sz : usize = 0;

let mut fi = FibIter::new();

let mut next_value : usize = fi.next() as usize;

let mut counter = n.clone();

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

let ln : usize = text_chars.len();

while counter > 0 {

if sz + next_value > ln {

panic!("Problemche!");

}

words.push(text_chars[sz..sz + next_value].into_iter().collect());

sz += next_value;

next_value = fi.next() as usize;

counter -= 1;

}

let temp_tuple: Option<(usize, char)> = text.char_indices().nth(sz);

let ind : usize = match temp_tuple {

Some((ind, _)) => ind,

None => ln - 1,

};

if ind == ln - 1 {

return (words, "");

}

(words, &text[ind..])

}

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

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

let mut sz : usize = 0;

let mut fi = FibIter::new();

let mut next_value : usize = fi.next() as usize;

let mut counter = n.clone();

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

let ln : usize = text_chars.len();

while counter > 0 {

if sz + next_value > ln {

panic!("Problemche!");

}

words.push(text_chars[sz..sz + next_value].into_iter().collect());

sz += next_value;

next_value = fi.next() as usize;

counter -= 1;

}

if 2*sz > ln {

panic!("Problemche!");

}

let mut refi = fi.rev();

next_value = match refi.next() {

Some(num) => num,

None => panic!("Nyama da stigne tozi red zaradi gornata proverka"),

}as usize;

//vtori put, zashtoto ot predishnoto izvikvane e s edno chislo po-napred

next_value = match refi.next() {

Some(num) => num,

None => panic!("Sushtoto kato gornoto :)"),

}as usize;

counter = n.clone();

while counter > 0 {

words.push(text_chars[sz..sz + next_value].into_iter().collect());

sz += next_value;

next_value = match refi.next() {

Some(num) => num,

None => 0,

}as usize;

counter -= 1;

}

let temp_tuple: Option<(usize, char)> = text.char_indices().nth(sz);

let ind : usize = match temp_tuple {

Some((ind, _)) => ind,

None => ln - 1,

};

if ind == ln - 1 {

return (words, "");

}

(words, &text[ind..])

}

// pub fn custom_split<'a, T: MyIterator>(text: &'a str, n: &u32, sz: &'a mut usize, fi: &'a mut T) -> (Vec<String>, &'a str){

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

// let mut next_value : usize = match fi.next() {

// Some(num) => num,

// None => panic!("Nyama da stigne tuk nikoga, no vse pak"),

// } as usize;

// let mut counter = n.clone();

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

// let ln : usize = text_chars.len();

// while counter > 0 {

// if *sz + next_value > ln {

// panic!("Problemche!");

// }

// words.push(text_chars[*sz..*sz + next_value].into_iter().collect());

// *sz += next_value;

// next_value = match fi.next() {

// Some(num) => num,

// None => panic!("Nyama da stigne tuk nikoga, no vse pak"),

// } as usize;

// counter -= 1;

// }

// let temp_tuple: Option<(usize, char)> = text.char_indices().nth(*sz);

// let ind : usize = match temp_tuple {

// Some((ind, _)) => ind,

// None => ln - 1,

// };

// (words, &text[ind..])

// }

//Problem s vrushtaneto na sz & fi pri purvoto izvikvane na custom_split

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

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

// let mut remainder : &str = text.clone();

// let mut sz : usize = 0;

// let mut fi : FibIter = FibIter::new();

// let tp1 : (Vec<String>, &str) = {

// custom_split(&mut remainder, &n, &mut sz, &mut fi)

// };

// words.extend(tp1.0);

// remainder = tp1.1.clone();

// let mut refi : RevFibIter = fi.rev();

// let tp2 : (Vec<String>, &str) = {

// custom_split(&mut remainder, &n, &mut sz, &mut refi);

// };

// words.extend(tp2.0);

// remainder = tp2.1.clone();

// (words, remainder)

// }

#[test]

fn main() {

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

let wd : Vec<String> = fib_split("Думи");

assert_eq!(wd, &["Д", "у", "ми"]);

let mut tp : (Vec<String>, &str) = fib_split_n("Lorem ипсум dolor si", 6);

assert_eq!(tp.0, &["L", "o", "re", "m и", "псум ", "dolor si"]);

assert_eq!(tp.1, "");

tp = fib_split_n("sd;f;стилеН &*(^ASLZX)(U! ) сайзь)_И!@Ассадй;ьц ьзпйоц ||ASZ}:X", 7);

assert_eq!(tp.0, &["s", "d", ";f", ";ст", "илеН ", "&*(^ASLZ", "X)(U! ) сайзь"]);

assert_eq!(tp.1, ")_И!@Ассадй;ьц ьзпйоц ||ASZ}:X");

tp = fib_split_n("неве$", 3);

assert_eq!(tp.0, &["н", "е", "ве"]);

assert_eq!(tp.1, "$");

tp = fib_split_n_symmetric("ПарАДоСъ()", 3);

assert_eq!(tp.0, &["П", "а", "рА", "До", "С", "ъ"]);

assert_eq!(tp.1, "()");

}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-11tibwn/solution)
warning: value assigned to `next_value` is never read
   --> src/lib.rs:129:5
    |
129 |     next_value = match refi.next() {
    |     ^^^^^^^^^^
    |
    = help: maybe it is overwritten before being read?
    = note: `#[warn(unused_assignments)]` on by default

warning: `solution` (lib) generated 1 warning
    Finished test [unoptimized + debuginfo] target(s) in 1.08s
     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 ... ok
test solution_test::fib_split_n_ascii_exact ... ok
test solution_test::fib_split_n_ascii ... FAILED
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_cyrillic_panic ... ok
test solution_test::fib_split_n_symmetric_zero ... FAILED
test solution_test::fib_split_n_zero ... FAILED
test solution_test::rev_fib_iter ... ok
test solution_test::rev_fib_iter_empty ... ok

failures:

---- solution_test::fib_split_n_ascii stdout ----
thread 'solution_test::fib_split_n_ascii' panicked at 'assertion failed: `(left == right)`
  left: `""`,
 right: `"3"`', tests/solution_test.rs:83:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

---- solution_test::fib_split_n_symmetric_zero stdout ----
thread 'solution_test::fib_split_n_symmetric_zero' panicked at 'Sushtoto kato gornoto :)', src/lib.rs:136:17

---- solution_test::fib_split_n_zero stdout ----
thread 'solution_test::fib_split_n_zero' panicked at 'attempt to subtract with overflow', src/lib.rs:99:17


failures:
    solution_test::fib_split_n_ascii
    solution_test::fib_split_n_symmetric_zero
    solution_test::fib_split_n_zero

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

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

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