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

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

Решение на Думи на Фибоначи от Николай Иванов

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

Към профила на Николай Иванов

Резултати

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

Код

pub struct FibIter {
curr: u32,
next: u32,
}
pub struct RevFibIter {
curr: u32,
prev: u32,
}
impl RevFibIter {
pub fn next(&mut self) -> Option<u32> {
if self.curr == 1 && self.prev == 0
{
return None;
}
let temp = self.curr;
self.curr = self.prev;
self.prev = temp - self.curr;
Some(self.curr)
}
}
impl FibIter {
pub fn new() -> FibIter
{
FibIter { curr: 1, next: 1 }
}
pub fn next(&mut self) -> u32
{
let temp = self.curr;
self.curr = self.next;
self.next = temp + self.curr;
temp
}
pub fn rev(self) -> RevFibIter
{
RevFibIter {
curr: self.curr,
prev: self.next - self.curr,
}
}
}
pub fn fib_split(text: &str) -> Vec<String>
{
let text_split: Vec<char> = text.chars().collect();
let mut fib_iter = FibIter::new();
let mut fib = fib_iter.next();
let mut vector = Vec::new();
let mut temp_str = String::new();
for c in text_split
{
temp_str.push(c);
fib -= 1;
if fib == 0
{
vector.push(temp_str.to_string().clone());
temp_str.clear();
fib=fib_iter.next();
}
}
if !temp_str.is_empty()
{
vector.push(temp_str.clone());
temp_str.clear();
}
vector
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String)
{
let mut text_split: Vec<char> = text.chars().collect();
let mut fib_iter = FibIter::new();
let mut vector = Vec::new();
let mut temp_str = String::new();
let mut sum = 0;
for _ in 0..n
{
sum += fib_iter.next();
}
if text_split.len() < sum as usize
{
panic!("Текста е твърде къс");
}
fib_iter = FibIter::new();
for _ in 0..n
{
let num = fib_iter.next();
for _ in 0..num
{
temp_str.push(text_split.remove(0));
}
vector.push(temp_str.clone());
temp_str.clear();
}
let quotient = text_split.iter().collect::<String>();
(vector , quotient)
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String)
{
let mut str_text : Vec<char> = text.chars().collect();
let mut iter1 = FibIter::new();
let mut vector = Vec::new();
let mut sum = 0;
for _ in 0..n
{
sum += iter1.next();
}
sum *= 2;
if text.len() < sum as usize
{
panic!("Много малка дължина");
}
let mut rev_iter = iter1.rev();
iter1 = FibIter::new();
let mut temp_str = String::new();
for _ in 0..n
{
let num = iter1.next();
for _ in 0..num
{
temp_str.push(str_text.remove(0));
}
vector.push(temp_str.clone());
temp_str.clear();
}
for _ in 0..n
{
let num = rev_iter.next();
for _ in 0..num.unwrap()
{
temp_str.push(str_text.remove(0));
}
vector.push(temp_str.clone());
temp_str.clear();
}
let quotient = str_text.iter().collect::<String>();
(vector , quotient)
}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-1slk39e/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.97s
     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_cyrillic ... ok
test solution_test::fib_split_empty ... 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 ... 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 ... ok
test solution_test::fib_split_n_zero ... ok
test solution_test::rev_fib_iter ... ok
test solution_test::rev_fib_iter_empty ... ok

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

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

Николай качи първо решение на 31.10.2024 02:06 (преди около 1 година)

Решението ти не се компилира заедно с пълния тест.

Структурите FibIter и RevFibIter трябва да са публично достъпни, т.е.
pub struct FibIter { ...
pub struct RevFibIter { ...

Функциите fib_split, fib_split_n и fib_split_n_symmetric трябва да са свободни функции, а не методи на FibIter. Само new, next и rev трябва да са методи.

Прочети отново указанията за предаване на домашни, там е написано как можеш да си тестваш проекта с базовия тест, за да си сигурен, че се компилира

За да пуснете теста:

  • Запазете тестовия файл като tests/test_basic.rs (в проекта, инициализиран по-горе с cargo new)
  • Изпълнете следната команда: cargo test

За пояснение главната директория на проекта трябва да съдържа Cargo.toml, src/, tests/.

Николай качи решение на 31.10.2024 14:03 (преди около 1 година)

-struct FibIter {
- curr : u32,
- next : u32
- }
-
- struct RevFibIter {
- curr : u32,
- prev : u32
- }
-
- impl RevFibIter {
- pub fn next(&mut self) -> Option<u32>
- {
- if self.curr == 1 && self.prev == 0
- {
- return None;
- }
-
- let temp = self.curr;
- self.curr = self.prev;
- self.prev = temp - self.curr;
- Some(self.curr)
- }
- }
- impl FibIter {
- pub fn new() -> FibIter
- {
- FibIter {curr : 1, next : 1}
- }
-
- pub fn next(&mut self) -> u32
- {
- let temp = self.curr;
- self.curr = self.next;
- self.next = temp + self.curr;
- temp
- }
-
-
- pub fn rev(self) -> RevFibIter
- {
- RevFibIter {curr: self.curr, prev: self.next - self.curr}
- }
-
- pub fn fib_split(text: &str) -> Vec<String>
- {
- let text_split: Vec<char> = text.chars().collect();
- let mut fib_iter = FibIter::new();
- let mut fib = fib_iter.next();
- let mut vector = Vec::new();
- let mut temp_str = String::new();
-
- for c in text_split
- {
- temp_str.push(c);
- fib -= 1;
-
- if fib == 0
- {
- vector.push(temp_str.to_string().clone());
- temp_str.clear();
- fib=fib_iter.next();
- }
- }
-
- if !temp_str.is_empty()
- {
- vector.push(temp_str.clone());
- temp_str.clear();
- }
-
- vector
- }
-
- pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String) {
- let mut text_split: Vec<char> = text.chars().collect();
- let mut fib_iter = FibIter::new();
- let mut vector = Vec::new();
- let mut temp_str = String::new();
- let mut sum = 0;
+pub struct FibIter {
+ curr: u32,
+ next: u32,
+}
- for _ in 0..n
+pub struct RevFibIter {
+ curr: u32,
+ prev: u32,
+}
+
+impl RevFibIter {
+ pub fn next(&mut self) -> Option<u32> {
+ if self.curr == 1 && self.prev == 0
{
- sum += fib_iter.next();
+ return None;
}
-
- if text_split.len() < sum as usize
- {
- panic!("Текста е твърде къс");
- }
- fib_iter = FibIter::new();
+ let temp = self.curr;
+ self.curr = self.prev;
+ self.prev = temp - self.curr;
+ Some(self.curr)
+ }
+}
- for _ in 0..n
- {
- let num = fib_iter.next();
- for _ in 0..num
- {
- temp_str.push(text_split.remove(0));
- }
- vector.push(temp_str.clone());
- temp_str.clear();
- }
- let quotient = text_split.iter().collect::<String>();
- (vector , quotient)
- }
-
- pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String)
- {
- let mut str_text : Vec<char> = text.chars().collect();
- let mut iter1 = FibIter::new();
- let mut vector = Vec::new();
- let mut sum = 0;
- for _ in 0..n
- {
- sum += iter1.next();
- }
-
- sum *= 2;
- if text.len() < sum as usize
- {
- panic!("Много малка дължина");
- }
-
- let mut rev_iter = iter1.rev();
- iter1 = FibIter::new();
- let mut temp_str = String::new();
- for _ in 0..n
- {
- let num = iter1.next();
- for _ in 0..num
- {
- temp_str.push(str_text.remove(0));
- }
- vector.push(temp_str.clone());
- temp_str.clear();
- }
-
- for _ in 0..n
- {
- let num = rev_iter.next();
- for _ in 0..num.unwrap()
- {
- temp_str.push(str_text.remove(0));
- }
- vector.push(temp_str.clone());
- temp_str.clear();
- }
-
- let quotient = str_text.iter().collect::<String>();
- (vector , quotient)
- }
- }
-
- fn main() {
+impl FibIter {
+ pub fn new() -> FibIter
+ {
+ FibIter { curr: 1, next: 1 }
+ }
- //fib_split
- let word = FibIter::fib_split("Fibonacci words!");
- assert_eq!(word, &["F", "i", "bo", "nac", "ci wo", "rds!"]);
+ pub fn next(&mut self) -> u32
+ {
+ let temp = self.curr;
+ self.curr = self.next;
+ self.next = temp + self.curr;
+ temp
+ }
- let word = FibIter::fib_split("Фибуначи думи!");
- assert_eq!(word, &["Ф", "и", "бу", "нач", "и дум", "и!"]);
+ pub fn rev(self) -> RevFibIter
+ {
+ RevFibIter {
+ curr: self.curr,
+ prev: self.next - self.curr,
+ }
+ }
+}
- //fib_split_n
- let (word, rest) = FibIter::fib_split_n("Лорем ипсум долор сит амет.", 6);
- assert_eq!(word, &["Л", "о", "ре", "м и", "псум ","долор си"]);
- assert_eq!(rest, "т амет.");
+pub fn fib_split(text: &str) -> Vec<String>
+{
+ let text_split: Vec<char> = text.chars().collect();
+ let mut fib_iter = FibIter::new();
+ let mut fib = fib_iter.next();
+ let mut vector = Vec::new();
+ let mut temp_str = String::new();
- let (word, rest) = FibIter::fib_split_n("Лорем ипсум долор сит амет.", 3);
- assert_eq!(word, &["Л", "о", "ре"]);
- assert_eq!(rest, "м ипсум долор сит амет.");
+ for c in text_split
+ {
+ temp_str.push(c);
+ fib -= 1;
- let (word, rest) = FibIter::fib_split_n("Lorem ipsum dolor sit amet.", 6);
- assert_eq!(word, &["L", "o", "re", "m i", "psum ", "dolor si"]);
- assert_eq!(rest,"t amet.");
+ if fib == 0
+ {
+ vector.push(temp_str.to_string().clone());
+ temp_str.clear();
+ fib=fib_iter.next();
+ }
+ }
+
+ if !temp_str.is_empty()
+ {
+ vector.push(temp_str.clone());
+ temp_str.clear();
+ }
- let (word, rest) = FibIter::fib_split_n("Lorem ipsum dolor sit amet.", 4);
- assert_eq!(word, &["L", "o", "re", "m i"]);
- assert_eq!(rest,"psum dolor sit amet.");
+ vector
+}
- //fib_split_n_symmetric
- let (word, rest) = FibIter::fib_split_n_symmetric("Lorem ipsum dolor sit amet.", 5);
- assert_eq!(word, &["L", "o", "re", "m i", "psum ", "dolor", " si", "t ", "a", "m"]);
- assert_eq!(rest,"et.");
+pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String)
+{
+ let mut text_split: Vec<char> = text.chars().collect();
+ let mut fib_iter = FibIter::new();
+ let mut vector = Vec::new();
+ let mut temp_str = String::new();
+ let mut sum = 0;
- let (word, rest) = FibIter::fib_split_n_symmetric("Лорем ипсум долор сит амет.", 5);
- assert_eq!(word, &["Л", "о", "ре", "м и", "псум ","долор", " си", "т ", "а", "м"]);
- assert_eq!(rest,"ет.");
+ for _ in 0..n
+ {
+ sum += fib_iter.next();
+ }
+
+ if text_split.len() < sum as usize
+ {
+ panic!("Текста е твърде къс");
+ }
- let (word, rest) = FibIter::fib_split_n_symmetric("Лорем ипсум долор сит амет.", 3);
- assert_eq!(word, &["Л", "о","ре", "м ", "и", "п"]);
- assert_eq!(rest,"сум долор сит амет.");
+ fib_iter = FibIter::new();
- let (word, rest) = FibIter::fib_split_n_symmetric("Lorem ipsum dolor sit amet.", 2);
- assert_eq!(word, &["L", "o", "r", "e"]);
- assert_eq!(rest,"m ipsum dolor sit amet.");
+ for _ in 0..n
+ {
+ let num = fib_iter.next();
+ for _ in 0..num
+ {
+ temp_str.push(text_split.remove(0));
+ }
+ vector.push(temp_str.clone());
+ temp_str.clear();
+ }
+ let quotient = text_split.iter().collect::<String>();
+ (vector , quotient)
+}
- }
+pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String)
+{
+ let mut str_text : Vec<char> = text.chars().collect();
+ let mut iter1 = FibIter::new();
+ let mut vector = Vec::new();
+ let mut sum = 0;
+ for _ in 0..n
+ {
+ sum += iter1.next();
+ }
+
+ sum *= 2;
+ if text.len() < sum as usize
+ {
+ panic!("Много малка дължина");
+ }
+
+ let mut rev_iter = iter1.rev();
+ iter1 = FibIter::new();
+ let mut temp_str = String::new();
+ for _ in 0..n
+ {
+ let num = iter1.next();
+ for _ in 0..num
+ {
+ temp_str.push(str_text.remove(0));
+ }
+ vector.push(temp_str.clone());
+ temp_str.clear();
+ }
+
+ for _ in 0..n
+ {
+ let num = rev_iter.next();
+ for _ in 0..num.unwrap()
+ {
+ temp_str.push(str_text.remove(0));
+ }
+ vector.push(temp_str.clone());
+ temp_str.clear();
+ }
+
+ let quotient = str_text.iter().collect::<String>();
+ (vector , quotient)
+}
+