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

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

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

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

Към профила на Калоян Рибаров

Резултати

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

Код

use std::vec;
pub struct FibIter {
prev: u32,
curr: u32,
next: u32
}
pub struct RevFibIter {
curr: u32,
prev: u32
}
impl FibIter {
pub fn new() -> FibIter {
FibIter { prev: 0, curr: 1, next: 1 }
}
pub fn next(&mut self) -> u32 {
let s = self.curr;
self.next = self.prev + self.curr;
self.prev = self.curr;
self.curr = self.next;
s
}
pub fn rev(self) -> RevFibIter {
RevFibIter { curr: self.curr, prev: self.prev }
}
}
impl RevFibIter {
pub fn next(&mut self) -> Option<u32> {
let x = self.curr;
self.curr = self.prev;
self.prev = x - self.prev;
if self.curr > 0 { Some(self.curr) } else { None }
}
}
pub fn fib_split(text: &str) -> Vec<String> {
let mut iter = FibIter::new();
let mut curr_text = text.to_string();
let mut acc: Vec<String> = vec![];
let mut curr_i = iter.next() as usize;
while curr_i <= curr_text.len() {
let word = curr_text.chars().take(curr_i).collect();
acc.push(word);
curr_text = curr_text.chars().skip(curr_i).collect();
curr_i = iter.next() as usize;
};
if !curr_text.is_empty() { acc.push(curr_text) }
acc
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String) {
let i = FibIter::new();
let (v, rest, _) = fib_split_n_recur(text, vec![], i, n);
(v, rest)
}
fn fib_split_n_recur(text: &str, mut acc: Vec<String>, mut i: FibIter, n: u32) -> (Vec<String>, String, FibIter) {
let ith = i.curr;
if n == 0 {
(acc, text.to_string(), i)
} else if text.len() < ith as usize {
panic!()
} else {
let x: String = text.chars().take(ith as usize).collect();
acc.push(x);
let t: String = text.chars().skip(ith as usize).collect();
i.next();
fib_split_n_recur(&t, acc, i, n-1)
}
}
fn fib_split_n_rev_recur(text: &str, mut acc: Vec<String>, mut i: RevFibIter) -> (Vec<String>, String, RevFibIter) {
return match i.next() {
None => { return (acc, text.to_string(), i)}
Some(n) => {
let n_as_usize = n as usize;
if text.len() < n_as_usize as usize {
panic!()
} else {
let word: String = text.chars().take(n_as_usize).collect();
let rest: String = text.chars().skip(n_as_usize).collect();
acc.push(word);
fib_split_n_rev_recur(&rest, acc, i)
}
}
}
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String) {
let i = FibIter::new();
let acc: Vec<String> = vec![];
let (v, rest, new_iter) = fib_split_n_recur(text, acc, i, n);
let rev_i = FibIter::rev(new_iter);
let (x, y, _) = fib_split_n_rev_recur(&rest, v, rev_i);
(x, y)
}
#[test]
fn test_iter_rev() {
let iter = FibIter::new();
let mut rev_iter = iter.rev();
assert_eq!(rev_iter.next(), None);
}
#[test]
fn test_iter_rev_iter_equals_iter() {
let mut iter = FibIter::new();
iter.next();
let snd = iter.next();
let mut rev_iter = iter.rev();
assert_eq!(rev_iter.next().is_some_and(|x| x == snd), true);
}
#[test]
fn test_fib_split_works_with_cyrilic() {
let text = "абвгдеёжзийклмнопрсту";
let ans = fib_split(text);
assert_eq!(ans.len(), 7 as usize);
assert_eq!(ans, ["а", "б", "вг", "деё", "жзийк", "лмнопрст", "у"])
}
#[test]
fn test_fib_split() {
let text = "абвгдеёжзийклмнопрст";
let ans = fib_split(text);
assert_eq!(ans, ["а", "б", "вг", "деё", "жзийк", "лмнопрст"])
}
#[test]
fn test_fib_split_ends_in_newline() {
let text = "абвгдеёжзийклмнопрс\n";
let ans = fib_split(text);
assert_eq!(ans, ["а", "б", "вг", "деё", "жзийк", "лмнопрс\n"])
}
#[test]
fn test_fib_split_n() {
let text = "Lorem ipsum dolor sit amet,\n";
let (v, rest) = fib_split_n(text, 5);
assert_eq!(v, ["L", "o", "re", "m i", "psum "]);
assert_eq!(rest, "dolor sit amet,\n")
}
#[test]
fn test_fib_split_n_no_rest_no_panick() {
let text = "абвгдеёжзийклмнопрст";
let (_, rest) = fib_split_n(text, 6);
assert_eq!(rest, "")
}
#[test]
#[should_panic]
fn test_fib_split_n_panicks() {
let text = "a";
fib_split_n(text, 3);
}
#[test]
fn test_fib_split_n_special_characters() {
let text = "hell🥳o there 👋🏻";
let (v, rest) = fib_split_n(text, 5);
assert_eq!(v, ["h", "e", "ll", "🥳o ", "there"]);
assert_eq!(rest, " 👋🏻")
}
#[test]
fn test_fib_split_n_symmetric() {
let text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
let (v, rest) = fib_split_n_symmetric(text, 5);
assert_eq!(v, ["L", "o", "re", "m i", "psum ", "dolor", " si", "t ", "a", "m"]);
assert_eq!(rest, "et, consectetur adipiscing elit.")
}
#[test]
#[should_panic]
fn test_fib_split_n_symmetric_panics() {
let text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
fib_split_n_symmetric(text, 10);
}
#[test]
#[should_panic]
fn test_fib_split_symmetric_panics() {
let text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
fib_split_n_symmetric(text, 7);
}
#[test]
fn test_fib_split_n_symmetric_special_characters_no_rest() {
let text = "⏩➤⬆👇";
let (v, rest) = fib_split_n_symmetric(text, 2);
assert_eq!(v, ["⏩", "➤", "⬆" , "👇"]);
assert_eq!(rest, "");
}

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

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

failures:

---- solution_test::fib_split_n_cyrillic_panic stdout ----
thread 'solution_test::fib_split_n_cyrillic_panic' panicked at 'assertion failed: catch_unwind(|| fib_split_n(\"манджа_with_грозде\", 6)).is_err()', tests/solution_test.rs:119:5

---- solution_test::rev_fib_iter stdout ----
thread 'solution_test::rev_fib_iter' panicked at 'attempt to subtract with overflow', src/lib.rs:38:21


failures:
    solution_test::fib_split_n_cyrillic_panic
    solution_test::rev_fib_iter

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

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

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

Калоян качи първо решение на 30.10.2024 17:21 (преди 11 месеца)

Калоян качи решение на 30.10.2024 18:51 (преди 11 месеца)

use std::vec;
pub struct FibIter {
prev: u32,
curr: u32,
next: u32
}
pub struct RevFibIter {
curr: u32,
prev: u32
}
impl FibIter {
pub fn new() -> FibIter {
FibIter { prev: 0, curr: 1, next: 1 }
}
pub fn next(&mut self) -> u32 {
let s = self.curr;
self.next = self.prev + self.curr;
self.prev = self.curr;
self.curr = self.next;
s
}
pub fn rev(self) -> RevFibIter {
RevFibIter { curr: self.curr, prev: self.prev }
}
}
impl RevFibIter {
pub fn next(&mut self) -> Option<u32> {
let x = self.curr;
self.curr = self.prev;
self.prev = x - self.prev;
if self.curr > 0 { Some(self.curr) } else { None }
}
}
pub fn fib_split(text: &str) -> Vec<String> {
let mut iter = FibIter::new();
let mut curr_text = text.to_string();
let mut acc: Vec<String> = vec![];
let mut curr_i = iter.next() as usize;
while curr_i <= curr_text.len() {
let word = curr_text.chars().take(curr_i).collect();
acc.push(word);
curr_text = curr_text.chars().skip(curr_i).collect();
curr_i = iter.next() as usize;
};
- acc.push(curr_text);
+ if !curr_text.is_empty() { acc.push(curr_text) }
acc
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String) {
let i = FibIter::new();
let (v, rest, _) = fib_split_n_recur(text, vec![], i, n);
(v, rest)
}
fn fib_split_n_recur(text: &str, mut acc: Vec<String>, mut i: FibIter, n: u32) -> (Vec<String>, String, FibIter) {
let ith = i.curr;
if n == 0 {
(acc, text.to_string(), i)
} else if text.len() < ith as usize {
panic!()
} else {
let x: String = text.chars().take(ith as usize).collect();
acc.push(x);
let t: String = text.chars().skip(ith as usize).collect();
i.next();
fib_split_n_recur(&t, acc, i, n-1)
}
}
fn fib_split_n_rev_recur(text: &str, mut acc: Vec<String>, mut i: RevFibIter) -> (Vec<String>, String, RevFibIter) {
return match i.next() {
None => { return (acc, text.to_string(), i)}
Some(n) => {
let n_as_usize = n as usize;
if text.len() < n_as_usize as usize {
panic!()
} else {
let word: String = text.chars().take(n_as_usize).collect();
let rest: String = text.chars().skip(n_as_usize).collect();
acc.push(word);
fib_split_n_rev_recur(&rest, acc, i)
}
}
}
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String) {
let i = FibIter::new();
let acc: Vec<String> = vec![];
let (v, rest, new_iter) = fib_split_n_recur(text, acc, i, n);
let rev_i = FibIter::rev(new_iter);
let (x, y, _) = fib_split_n_rev_recur(&rest, v, rev_i);
(x, y)
+}
+
+#[test]
+fn test_iter_rev() {
+ let iter = FibIter::new();
+
+ let mut rev_iter = iter.rev();
+
+ assert_eq!(rev_iter.next(), None);
+}
+
+#[test]
+fn test_iter_rev_iter_equals_iter() {
+ let mut iter = FibIter::new();
+ iter.next();
+ let snd = iter.next();
+
+ let mut rev_iter = iter.rev();
+ assert_eq!(rev_iter.next().is_some_and(|x| x == snd), true);
+}
+
+#[test]
+fn test_fib_split_works_with_cyrilic() {
+ let text = "абвгдеёжзийклмнопрсту";
+
+ let ans = fib_split(text);
+
+ assert_eq!(ans.len(), 7 as usize);
+ assert_eq!(ans, ["а", "б", "вг", "деё", "жзийк", "лмнопрст", "у"])
+}
+
+#[test]
+fn test_fib_split() {
+ let text = "абвгдеёжзийклмнопрст";
+ let ans = fib_split(text);
+ assert_eq!(ans, ["а", "б", "вг", "деё", "жзийк", "лмнопрст"])
+}
+
+#[test]
+fn test_fib_split_ends_in_newline() {
+ let text = "абвгдеёжзийклмнопрс\n";
+ let ans = fib_split(text);
+ assert_eq!(ans, ["а", "б", "вг", "деё", "жзийк", "лмнопрс\n"])
+}
+
+#[test]
+fn test_fib_split_n() {
+ let text = "Lorem ipsum dolor sit amet,\n";
+
+ let (v, rest) = fib_split_n(text, 5);
+
+ assert_eq!(v, ["L", "o", "re", "m i", "psum "]);
+ assert_eq!(rest, "dolor sit amet,\n")
+}
+
+#[test]
+fn test_fib_split_n_no_rest_no_panick() {
+ let text = "абвгдеёжзийклмнопрст";
+
+ let (_, rest) = fib_split_n(text, 6);
+ assert_eq!(rest, "")
+}
+
+#[test]
+#[should_panic]
+fn test_fib_split_n_panicks() {
+ let text = "a";
+ fib_split_n(text, 3);
+}
+
+#[test]
+fn test_fib_split_n_special_characters() {
+ let text = "hell🥳o there 👋🏻";
+
+ let (v, rest) = fib_split_n(text, 5);
+ assert_eq!(v, ["h", "e", "ll", "🥳o ", "there"]);
+ assert_eq!(rest, " 👋🏻")
+}
+
+#[test]
+fn test_fib_split_n_symmetric() {
+ let text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+ let (v, rest) = fib_split_n_symmetric(text, 5);
+
+ assert_eq!(v, ["L", "o", "re", "m i", "psum ", "dolor", " si", "t ", "a", "m"]);
+ assert_eq!(rest, "et, consectetur adipiscing elit.")
+}
+
+#[test]
+#[should_panic]
+fn test_fib_split_n_symmetric_panics() {
+ let text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+ fib_split_n_symmetric(text, 10);
+}
+
+#[test]
+#[should_panic]
+fn test_fib_split_symmetric_panics() {
+ let text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+ fib_split_n_symmetric(text, 7);
+}
+
+#[test]
+fn test_fib_split_n_symmetric_special_characters_no_rest() {
+ let text = "⏩➤⬆👇";
+ let (v, rest) = fib_split_n_symmetric(text, 2);
+ assert_eq!(v, ["⏩", "➤", "⬆" , "👇"]);
+ assert_eq!(rest, "");
}