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

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

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

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

Към профила на Памела Славчева

Резултати

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

Код

pub struct FibIter
{
current: u32,
previous: u32
}
impl FibIter
{
pub fn new() -> FibIter
{
FibIter {current: 1, previous: 0}
}
pub fn next(&mut self) -> u32
{
let temp: u32 = self.current + self.previous;
self.previous = self.current;
self.current = temp;
self.previous
}
pub fn rev(self) -> RevFibIter
{
RevFibIter {current: self.current, previous: self.previous + self.current}
}
}
pub struct RevFibIter
{
current: u32,
previous: u32
}
impl RevFibIter
{
pub fn next(&mut self) -> Option<u32>
{
if self.previous - self.current <= 0
{
None
}
else
{
let temp: u32 = self.previous - self.current;
self.previous = self.current;
self.current = temp;
Some(self.current)
}
}
}
pub fn fib_split(text: &str) -> Vec<String>
{
let text:Vec<char> = text.chars().collect();
let mut words:Vec<String> = vec![];
let mut curr_length: FibIter = FibIter::new();
let mut curr_pos: usize = 0;
while (text.len() - curr_pos) >= (curr_length.current as usize)
{
let number: u32 = curr_length.next();
let temp:String = text[curr_pos..curr_pos + (number as usize)].iter().collect();
words.push(temp);
curr_pos = curr_pos + number as usize;
}
let temp: String = text[curr_pos..].iter().collect();
if temp != ""
{
words.push(temp);
}
words
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String)
{
let text_chars:Vec<char> = text.chars().collect();
let mut words:Vec<String> = vec![];
let mut curr_length: FibIter = FibIter::new();
let mut curr_pos: usize = 0;
for _ in 0..n
{
if !((text_chars.len() - curr_pos) >= (curr_length.current as usize))
{
panic!("Not long enough!");
}
let number: u32 = curr_length.next();
let temp:String = text_chars[curr_pos..curr_pos + (number as usize)].iter().collect();
words.push(temp);
curr_pos = curr_pos + number as usize;
}
let temp: String = text_chars[curr_pos..].iter().collect();
(words, temp)
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String)
{
let text_chars:Vec<char> = text.chars().collect();
let mut words:Vec<String> = vec![];
let mut curr_length: FibIter = FibIter::new();
let mut curr_pos: usize = 0;
for _ in 0..n
{
if !((text_chars.len() - curr_pos) >= (curr_length.current as usize))
{
panic!("Not long enough!");
}
let number: u32 = curr_length.next();
let temp:String = text_chars[curr_pos..curr_pos + (number as usize)].iter().collect();
words.push(temp);
curr_pos = curr_pos + number as usize;
}
let mut curr_length: RevFibIter = curr_length.rev();
for _ in 0..n
{
match curr_length.next()
{
None => panic!("Not long enough!"),
Some(number) =>
{
if !((text_chars.len() - curr_pos) >= (curr_length.current as usize))
{
panic!();
}
let temp:String = text_chars[curr_pos..curr_pos + (number as usize)].iter().collect();
words.push(temp);
curr_pos = curr_pos + number as usize;
}
}
}
let temp: String = text_chars[curr_pos..].iter().collect();
(words, temp)
}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-1mywkr3/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.09s
     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 версии и 0 коментара)

Памела качи първо решение на 27.10.2024 21:08 (преди 11 месеца)

Памела качи решение на 29.10.2024 16:14 (преди 11 месеца)

-pub struct FibIter {
+pub struct FibIter
+{
current: u32,
previous: u32
}
-impl FibIter {
- pub fn new() -> FibIter {
+impl FibIter
+{
+
+ pub fn new() -> FibIter
+ {
FibIter {current: 1, previous: 0}
}
- pub fn next(&mut self) -> u32 {
+ pub fn next(&mut self) -> u32
+ {
let temp: u32 = self.current + self.previous;
self.previous = self.current;
self.current = temp;
self.previous
}
- pub fn rev(self) -> RevFibIter {
+ pub fn rev(self) -> RevFibIter
+ {
RevFibIter {current: self.current, previous: self.previous + self.current}
}
}
-pub struct RevFibIter {
+pub struct RevFibIter
+{
current: u32,
previous: u32
}
-impl RevFibIter {
- pub fn next(&mut self) -> Option<u32> {
+impl RevFibIter
+{
+ pub fn next(&mut self) -> Option<u32>
+ {
if self.previous - self.current <= 0
{
None
}
else
{
let temp: u32 = self.previous - self.current;
self.previous = self.current;
self.current = temp;
Some(self.current)
}
}
}
-pub fn fib_split(text: &str) -> Vec<String> {
+pub fn fib_split(text: &str) -> Vec<String>
+{
+ let text:Vec<char> = text.chars().collect();
let mut words:Vec<String> = vec![];
let mut curr_length: FibIter = FibIter::new();
let mut curr_pos: usize = 0;
while (text.len() - curr_pos) >= (curr_length.current as usize)
{
let number: u32 = curr_length.next();
- let temp:String = text[curr_pos..curr_pos + (number as usize)].to_string();
+ let temp:String = text[curr_pos..curr_pos + (number as usize)].iter().collect();
words.push(temp);
curr_pos = curr_pos + number as usize;
}
- let temp: String = text[curr_pos..].to_string();
+ let temp: String = text[curr_pos..].iter().collect();
if temp != ""
{
words.push(temp);
}
words
}
-pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, &str) {
+pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String)
+{
+ let text_chars:Vec<char> = text.chars().collect();
let mut words:Vec<String> = vec![];
let mut curr_length: FibIter = FibIter::new();
let mut curr_pos: usize = 0;
for _ in 0..n
{
- if !((text.len() - curr_pos) >= (curr_length.current as usize))
+ if !((text_chars.len() - curr_pos) >= (curr_length.current as usize))
{
panic!("Not long enough!");
}
let number: u32 = curr_length.next();
- let temp:String = text[curr_pos..curr_pos + (number as usize)].to_string();
+ let temp:String = text_chars[curr_pos..curr_pos + (number as usize)].iter().collect();
words.push(temp);
curr_pos = curr_pos + number as usize;
}
- let temp: &str = &text[curr_pos..];
+ let temp: String = text_chars[curr_pos..].iter().collect();
(words, temp)
}
-pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, &str) {
- let (mut words, text):(Vec<String>, &str) = fib_split_n(text, n);
+
+pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String)
+{
+ let text_chars:Vec<char> = text.chars().collect();
+ let mut words:Vec<String> = vec![];
let mut curr_length: FibIter = FibIter::new();
+ let mut curr_pos: usize = 0;
+
for _ in 0..n
{
- curr_length.next();
+ if !((text_chars.len() - curr_pos) >= (curr_length.current as usize))
+ {
+ panic!("Not long enough!");
+ }
+ let number: u32 = curr_length.next();
+ let temp:String = text_chars[curr_pos..curr_pos + (number as usize)].iter().collect();
+ words.push(temp);
+ curr_pos = curr_pos + number as usize;
}
let mut curr_length: RevFibIter = curr_length.rev();
- let mut curr_pos: usize = 0;
for _ in 0..n
{
match curr_length.next()
{
None => panic!("Not long enough!"),
Some(number) =>
{
- if !((text.len() - curr_pos) >= (curr_length.current as usize))
+ if !((text_chars.len() - curr_pos) >= (curr_length.current as usize))
{
panic!();
}
- let temp:String = text[curr_pos..curr_pos + (number as usize)].to_string();
+ let temp:String = text_chars[curr_pos..curr_pos + (number as usize)].iter().collect();
words.push(temp);
curr_pos = curr_pos + number as usize;
}
}
}
- let temp: &str = &text[curr_pos..];
+ let temp: String = text_chars[curr_pos..].iter().collect();
(words, temp)
}