Програмиране с Rust

Курс във Факултета по Математика и Информатика към СУ

Решение на Думи на Фибоначи от Божидар Кьоров

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

Към профила на Божидар Кьоров

Резултати

  • 10 точки от тестове
  • 0 бонус точки
  • 10 точки общо
  • 10 успешни тест(а)
  • 10 неуспешни тест(а)

Код

pub struct FibIter {
prev: u32,
curr: u32,
}
impl FibIter {
pub fn new() -> FibIter {
FibIter {
prev: 0,
curr: 1,
}
}
pub fn next(&mut self) -> u32 {
let temp: u32;
temp = self.curr;
self.curr = self.curr + self.prev;
self.prev = temp;
return self.prev;
}
pub fn rev(self) -> RevFibIter {
let rev_curr = self.prev as i32;
let rev_prev = self.curr as i32;
return RevFibIter {prev: rev_prev, curr: rev_curr};
}
}
pub struct RevFibIter {
prev: i32,
curr: i32,
}
impl RevFibIter {
pub fn next(&mut self) -> Option<i32> {
if self.curr <= 0 {
return None;
}
let temp: i32;
temp = self.curr;
self.curr = self.prev - self.curr;
self.prev = temp;
if self.curr <= 0 {
return None;
}
return Some(self.curr);
}
}
pub fn fib_split(text: &str) -> Vec<String> {
let mut text2 = text;
let mut vec = Vec::new();
let mut iter = FibIter::new();
let mut curr_fib : usize = iter.next() as usize;
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
text2 = &text2[(curr_fib)..];
curr_fib = iter.next() as usize;
}
vec.push(text2.to_string());
return vec;
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String) {
let mut text2 = text;
let mut vec = Vec::new();
let mut iter = FibIter::new();
let mut curr_fib : usize = iter.next() as usize;
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
text2 = &text2[(curr_fib)..];
curr_fib = iter.next() as usize;
if vec.len() == n.try_into().unwrap() {
break;
}
}
if vec.len() < n.try_into().unwrap() {
panic!("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
}
return (vec, text2.to_string());
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String) {
let mut text2 = text;
let mut vec = Vec::new();
let mut iter = FibIter::new();
let mut curr_fib : usize = iter.next() as usize;
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
//println!("{}", vec[vec.len() - 1]);
text2 = &text2[(curr_fib)..];
curr_fib = iter.next() as usize;
if vec.len() == n.try_into().unwrap() {
break;
}
}
let mut iter = iter.rev();
let mut curr_fib_option = iter.next();
let mut curr_fib : usize;
match curr_fib_option {
Some(val) => curr_fib = val as usize,
None => curr_fib = 0,
}
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
//println!("{}", vec[vec.len() - 1]);
text2 = &text2[(curr_fib)..];
curr_fib_option = iter.next();
match curr_fib_option {
Some(val) => curr_fib = val as usize,
None => curr_fib = 0,
}
if vec.len() == (n * 2).try_into().unwrap() {
break;
}
}
if vec.len() < (2*n as usize) {
panic!("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA vol 2");
}
return (vec, text2.to_string());
}

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

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

failures:

---- 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:67:18
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

---- solution_test::fib_split_n_ascii_exact stdout ----
thread 'solution_test::fib_split_n_ascii_exact' panicked at 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', src/lib.rs:100:9

---- 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:89:18

---- 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:89:18

---- solution_test::fib_split_n_symmetric_ascii_exact stdout ----
thread 'solution_test::fib_split_n_symmetric_ascii_exact' panicked at 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA vol 2', src/lib.rs:159:9

---- 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:117:18

---- 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:117:18

---- solution_test::fib_split_n_zero stdout ----
thread 'solution_test::fib_split_n_zero' panicked at 'byte index 3 is not a char boundary; it is inside 'р' (bytes 2..4) of `грозде`', src/lib.rs:89:18

---- solution_test::fib_split_n_symmetric_zero stdout ----
thread 'solution_test::fib_split_n_symmetric_zero' panicked at 'byte index 3 is not a char boundary; it is inside 'р' (bytes 2..4) of `грозде`', src/lib.rs:117:18

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


failures:
    solution_test::fib_split_cyrillic
    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_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::fib_split_n_zero
    solution_test::rev_fib_iter

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`

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

Божидар качи първо решение на 31.10.2024 17:03 (преди 11 месеца)

Божидар качи решение на 31.10.2024 17:42 (преди 11 месеца)

pub struct FibIter {
prev: u32,
curr: u32,
}
impl FibIter {
pub fn new() -> FibIter {
FibIter {
prev: 0,
curr: 1,
}
}
pub fn next(&mut self) -> u32 {
let temp: u32;
temp = self.curr;
self.curr = self.curr + self.prev;
self.prev = temp;
return self.prev;
}
pub fn rev(self) -> RevFibIter {
let rev_curr = (self.prev + self.curr) as i32;
let rev_prev = rev_curr + self.curr as i32;
return RevFibIter {prev: rev_prev, curr: rev_curr};
}
}
pub struct RevFibIter {
prev: i32,
curr: i32,
}
impl RevFibIter {
pub fn next(&mut self) -> Option<i32> {
if self.curr <= 0 {
return None;
}
let temp: i32;
temp = self.curr;
self.curr = self.prev - self.curr;
self.prev = temp;
if self.curr <= 0 {
return None;
}
return Some(self.curr);
}
}
pub fn fib_split(text: &str) -> Vec<String> {
let mut text2 = text;
let mut vec = Vec::new();
let mut iter = FibIter::new();
let mut curr_fib : usize = iter.next() as usize;
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
text2 = &text2[(curr_fib)..];
curr_fib = iter.next() as usize;
}
vec.push(text2.to_string());
return vec;
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String) {
let mut text2 = text;
let mut vec = Vec::new();
let mut iter = FibIter::new();
let mut curr_fib : usize = iter.next() as usize;
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
text2 = &text2[(curr_fib)..];
curr_fib = iter.next() as usize;
if vec.len() == n.try_into().unwrap() {
break;
}
}
if vec.len() < n.try_into().unwrap() {
panic!("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
}
return (vec, text2.to_string());
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String) {
let mut text2 = text;
let mut vec = Vec::new();
let mut iter = FibIter::new();
let mut curr_fib : usize = iter.next() as usize;
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
//println!("{}", vec[vec.len() - 1]);
text2 = &text2[(curr_fib)..];
curr_fib = iter.next() as usize;
if vec.len() == n.try_into().unwrap() {
break;
}
}
let mut iter = iter.rev();
iter.next();
+ iter.next();
let mut curr_fib_option = iter.next();
let mut curr_fib : usize;
match curr_fib_option {
Some(val) => curr_fib = val as usize,
None => curr_fib = 0,
}
+ //println!("asd");
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
//println!("{}", vec[vec.len() - 1]);
text2 = &text2[(curr_fib)..];
curr_fib_option = iter.next();
match curr_fib_option {
Some(val) => curr_fib = val as usize,
None => curr_fib = 0,
}
if vec.len() == (n * 2).try_into().unwrap() {
break;
}
}
if vec.len() < (2*n as usize) {
panic!("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA vol 2");
}
return (vec, text2.to_string());
}

Божидар качи решение на 31.10.2024 17:43 (преди 11 месеца)

pub struct FibIter {
prev: u32,
curr: u32,
}
impl FibIter {
pub fn new() -> FibIter {
FibIter {
prev: 0,
curr: 1,
}
}
pub fn next(&mut self) -> u32 {
let temp: u32;
temp = self.curr;
self.curr = self.curr + self.prev;
self.prev = temp;
return self.prev;
}
pub fn rev(self) -> RevFibIter {
- let rev_curr = (self.prev + self.curr) as i32;
- let rev_prev = rev_curr + self.curr as i32;
+ let rev_curr = self.prev as i32;
+ let rev_prev = self.curr as i32;
return RevFibIter {prev: rev_prev, curr: rev_curr};
}
}
pub struct RevFibIter {
prev: i32,
curr: i32,
}
impl RevFibIter {
pub fn next(&mut self) -> Option<i32> {
if self.curr <= 0 {
return None;
}
let temp: i32;
temp = self.curr;
self.curr = self.prev - self.curr;
self.prev = temp;
if self.curr <= 0 {
return None;
}
return Some(self.curr);
}
}
pub fn fib_split(text: &str) -> Vec<String> {
let mut text2 = text;
let mut vec = Vec::new();
let mut iter = FibIter::new();
let mut curr_fib : usize = iter.next() as usize;
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
text2 = &text2[(curr_fib)..];
curr_fib = iter.next() as usize;
}
vec.push(text2.to_string());
return vec;
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String) {
let mut text2 = text;
let mut vec = Vec::new();
let mut iter = FibIter::new();
let mut curr_fib : usize = iter.next() as usize;
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
text2 = &text2[(curr_fib)..];
curr_fib = iter.next() as usize;
if vec.len() == n.try_into().unwrap() {
break;
}
}
if vec.len() < n.try_into().unwrap() {
panic!("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
}
return (vec, text2.to_string());
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String) {
let mut text2 = text;
let mut vec = Vec::new();
let mut iter = FibIter::new();
let mut curr_fib : usize = iter.next() as usize;
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
//println!("{}", vec[vec.len() - 1]);
text2 = &text2[(curr_fib)..];
curr_fib = iter.next() as usize;
if vec.len() == n.try_into().unwrap() {
break;
}
}
let mut iter = iter.rev();
- iter.next();
- iter.next();
+ //iter.next();
+ // iter.next();
let mut curr_fib_option = iter.next();
let mut curr_fib : usize;
match curr_fib_option {
Some(val) => curr_fib = val as usize,
None => curr_fib = 0,
}
//println!("asd");
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
//println!("{}", vec[vec.len() - 1]);
text2 = &text2[(curr_fib)..];
curr_fib_option = iter.next();
match curr_fib_option {
Some(val) => curr_fib = val as usize,
None => curr_fib = 0,
}
if vec.len() == (n * 2).try_into().unwrap() {
break;
}
}
if vec.len() < (2*n as usize) {
panic!("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA vol 2");
}
return (vec, text2.to_string());
}

Божидар качи решение на 31.10.2024 17:44 (преди 11 месеца)

pub struct FibIter {
prev: u32,
curr: u32,
}
impl FibIter {
pub fn new() -> FibIter {
FibIter {
prev: 0,
curr: 1,
}
}
pub fn next(&mut self) -> u32 {
let temp: u32;
temp = self.curr;
self.curr = self.curr + self.prev;
self.prev = temp;
return self.prev;
}
pub fn rev(self) -> RevFibIter {
let rev_curr = self.prev as i32;
let rev_prev = self.curr as i32;
return RevFibIter {prev: rev_prev, curr: rev_curr};
}
}
pub struct RevFibIter {
prev: i32,
curr: i32,
}
impl RevFibIter {
pub fn next(&mut self) -> Option<i32> {
if self.curr <= 0 {
return None;
}
let temp: i32;
temp = self.curr;
self.curr = self.prev - self.curr;
self.prev = temp;
if self.curr <= 0 {
return None;
}
return Some(self.curr);
}
}
pub fn fib_split(text: &str) -> Vec<String> {
let mut text2 = text;
let mut vec = Vec::new();
let mut iter = FibIter::new();
let mut curr_fib : usize = iter.next() as usize;
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
text2 = &text2[(curr_fib)..];
curr_fib = iter.next() as usize;
}
vec.push(text2.to_string());
return vec;
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String) {
let mut text2 = text;
let mut vec = Vec::new();
let mut iter = FibIter::new();
let mut curr_fib : usize = iter.next() as usize;
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
text2 = &text2[(curr_fib)..];
curr_fib = iter.next() as usize;
if vec.len() == n.try_into().unwrap() {
break;
}
}
if vec.len() < n.try_into().unwrap() {
panic!("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
}
return (vec, text2.to_string());
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String) {
let mut text2 = text;
let mut vec = Vec::new();
let mut iter = FibIter::new();
let mut curr_fib : usize = iter.next() as usize;
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
//println!("{}", vec[vec.len() - 1]);
text2 = &text2[(curr_fib)..];
curr_fib = iter.next() as usize;
if vec.len() == n.try_into().unwrap() {
break;
}
}
let mut iter = iter.rev();
- //iter.next();
- // iter.next();
let mut curr_fib_option = iter.next();
let mut curr_fib : usize;
match curr_fib_option {
Some(val) => curr_fib = val as usize,
None => curr_fib = 0,
}
- //println!("asd");
while text2.chars().count() > curr_fib {
//println!("{}", curr_fib);
vec.push(text2[0..(curr_fib)].to_string());
//println!("{}", vec[vec.len() - 1]);
text2 = &text2[(curr_fib)..];
curr_fib_option = iter.next();
match curr_fib_option {
Some(val) => curr_fib = val as usize,
None => curr_fib = 0,
}
if vec.len() == (n * 2).try_into().unwrap() {
break;
}
}
if vec.len() < (2*n as usize) {
panic!("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA vol 2");
}
return (vec, text2.to_string());
}