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

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

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

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

Към профила на Юлиян Палов

Резултати

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

Код

pub fn add(left: u64, right: u64) -> u64 {
left + right
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_works() {
let result = add(2, 2);
assert_eq!(result, 4);
}
}
//Fibbonacci numbers struct
pub struct FibIter
{
current: u32,
next: u32,
}
//Reversed Fibonacci numbers struct
pub struct RevFibIter
{
last: u32,
prelast: u32,
}
impl FibIter
{
pub fn new() -> FibIter
{
FibIter {
current: 1,
next: 1,
}
}
pub fn next(&mut self) -> u32
{
let result: u32 = self.current;
let new_next = self.current + self.next;
self.current = self.next;
self.next = new_next;
result
}
}
//Function that splits text into substirngs with lenght as big as Fibonacci numbers until the end of the text
pub fn fib_split(text: &str) -> Vec<String>
{
let mut fibb_nums = FibIter::new();
let mut fibb_substrings: Vec<String> = Vec::new();
let chars: Vec<char> = text.chars().collect();
let text_len: usize = chars.len();
let mut start: usize = 0;
while start < text_len
{
let curr_fibb: usize = fibb_nums.next() as usize;
let end: usize = if start + curr_fibb < text_len {start + curr_fibb} else {text_len};
let curr_substr: String = chars[start..end].iter().collect();
fibb_substrings.push(curr_substr);
start = end;
}
fibb_substrings
}
//Function that takes number n and splits text into substrings with lenghts from 0th to (n - 1)th number of Fibbonacci
//and returns the rest of the text.
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String)
{
let mut fibb_nums: FibIter = FibIter::new();
let mut fibb_sum: u32 = 0;
let mut n_fibb_substrings: Vec<String> = Vec::new();
for _ in 0..n
{
fibb_sum += fibb_nums.next();
}
let chars: Vec<char> = text.chars().collect();
let text_len: usize = chars.len();
if text_len < fibb_sum as usize
{
panic!("The text isn't large enough");
}
let mut fibb: FibIter = FibIter::new();
let mut start: usize = 0;
for _ in 0..n
{
let curr_fibb: usize = fibb.next() as usize;
let end: usize = start + curr_fibb as usize;
let curr_substr: String = chars[start..end].iter().collect();
n_fibb_substrings.push(curr_substr);
start = end;
}
let left_text: String = chars[start..].iter().collect();
let result: (Vec<String>, String) = (n_fibb_substrings, left_text);
result
}
//Implementation of functionality that splits text symetrically into substrings with Fibonacci numbers lenghts
impl FibIter
{
pub fn rev(self) -> RevFibIter
{
RevFibIter
{
last: self.current,
prelast: self.next - self.current,
}
}
}
impl RevFibIter
{
pub fn next(&mut self) -> Option<u32>
{
let result = self.prelast;
if self.last == 1 && self.prelast == 1
{
self.last = 0;
}
else
{
let temp = self.last;
self.last = self.prelast;
self.prelast = temp - self.prelast;
}
if result == 0
{
return None;
}
Some(result)
}
}
//Symetrical separation function
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String)
{
let mut fibb_iter: FibIter = FibIter::new();
let mut fibb_sum: u32 = 0;
let mut n_sym_substrings: Vec<String> = Vec::new();
for _ in 0..n
{
fibb_sum += fibb_iter.next();
}
fibb_sum *= 2;
let chars: Vec<char> = text.chars().collect();
let text_len: usize = chars.len();
if text_len < fibb_sum as usize
{
panic!("The text isn't large enough");
}
let mut fibb_nums: FibIter = FibIter::new();
let mut start: usize = 0;
for _ in 0..n
{
let curr_fibb: usize = fibb_nums.next() as usize;
let curr_end: usize = start + curr_fibb as usize;
let curr_substr: String = chars[start..curr_end].iter().collect();
n_sym_substrings.push(curr_substr);
start = curr_end;
}
let mut rev_fibb_nums: RevFibIter = fibb_nums.rev();
for _ in 0..n
{
if let Some(curr_fibb) = rev_fibb_nums.next()
{
let curr_end: usize = start + curr_fibb as usize;
let curr_substr: String = chars[start..curr_end].iter().collect();
n_sym_substrings.push(curr_substr);
start = curr_end;
}
}
let left_text: String = chars[start..].iter().collect();
let result: (Vec<String>, String) = (n_sym_substrings, left_text);
result
}
#[test]
fn test_basic() {
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.");
}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-tby2gd/solution)
    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_cyrillic ... ok
test solution_test::fib_split_empty ... ok
test solution_test::fib_split_n_ascii_exact ... ok
test solution_test::fib_split_n_ascii ... 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_exact ... ok
test solution_test::fib_split_n_symmetric_ascii ... 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::rev_fib_iter stdout ----
thread 'solution_test::rev_fib_iter' panicked at 'attempt to subtract with overflow', src/lib.rs:155:28


failures:
    solution_test::rev_fib_iter

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

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

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

Юлиян качи първо решение на 28.10.2024 21:13 (преди 11 месеца)

Юлиян качи решение на 30.10.2024 23:24 (преди 11 месеца)

pub fn add(left: u64, right: u64) -> u64 {
left + right
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_works() {
let result = add(2, 2);
assert_eq!(result, 4);
}
}
//Fibbonacci numbers struct
pub struct FibIter
{
current: u32,
next: u32,
}
//Reversed Fibonacci numbers struct
pub struct RevFibIter
{
last: u32,
prelast: u32,
}
impl FibIter
{
pub fn new() -> FibIter
{
FibIter {
current: 1,
next: 1,
}
}
pub fn next(&mut self) -> u32
{
let result: u32 = self.current;
let new_next = self.current + self.next;
self.current = self.next;
self.next = new_next;
result
}
}
//Function that splits text into substirngs with lenght as big as Fibonacci numbers until the end of the text
pub fn fib_split(text: &str) -> Vec<String>
{
let mut fibb_nums = FibIter::new();
let mut fibb_substrings: Vec<String> = Vec::new();
let chars: Vec<char> = text.chars().collect();
let text_len: usize = chars.len();
let mut start: usize = 0;
while start < text_len
{
let curr_fibb: usize = fibb_nums.next() as usize;
let end: usize = if start + curr_fibb < text_len {start + curr_fibb} else {text_len};
let curr_substr: String = chars[start..end].iter().collect();
fibb_substrings.push(curr_substr);
start = end;
}
fibb_substrings
}
//Function that takes number n and splits text into substrings with lenghts from 0th to (n - 1)th number of Fibbonacci
//and returns the rest of the text.
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String)
{
let mut fibb_nums: FibIter = FibIter::new();
let mut fibb_sum: u32 = 0;
let mut n_fibb_substrings: Vec<String> = Vec::new();
for _ in 0..n
{
fibb_sum += fibb_nums.next();
}
let chars: Vec<char> = text.chars().collect();
let text_len: usize = chars.len();
if text_len < fibb_sum as usize
{
panic!("The text isn't large enough");
}
let mut fibb: FibIter = FibIter::new();
let mut start: usize = 0;
for _ in 0..n
{
let curr_fibb: usize = fibb.next() as usize;
let end: usize = start + curr_fibb as usize;
let curr_substr: String = chars[start..end].iter().collect();
n_fibb_substrings.push(curr_substr);
start = end;
}
let left_text: String = chars[start..].iter().collect();
let result: (Vec<String>, String) = (n_fibb_substrings, left_text);
result
}
//Implementation of functionality that splits text symetrically into substrings with Fibonacci numbers lenghts
impl FibIter
{
pub fn rev(self) -> RevFibIter
{
RevFibIter
{
last: self.current,
prelast: self.next - self.current,
}
}
}
impl RevFibIter
{
pub fn next(&mut self) -> Option<u32>
{
let result = self.prelast;
if self.last == 1 && self.prelast == 1
{
self.last = 0;
}
else
{
let temp = self.last;
self.last = self.prelast;
self.prelast = temp - self.prelast;
}
if result == 0
{
return None;
}
Some(result)
}
}
//Symetrical separation function
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String)
{
let mut fibb_iter: FibIter = FibIter::new();
let mut fibb_sum: u32 = 0;
let mut n_sym_substrings: Vec<String> = Vec::new();
for _ in 0..n
{
fibb_sum += fibb_iter.next();
}
fibb_sum *= 2;
let chars: Vec<char> = text.chars().collect();
let text_len: usize = chars.len();
if text_len < fibb_sum as usize
{
panic!("The text isn't large enough");
}
//
let mut fibb_nums: FibIter = FibIter::new();
let mut start: usize = 0;
for _ in 0..n
{
let curr_fibb: usize = fibb_nums.next() as usize;
let curr_end: usize = start + curr_fibb as usize;
let curr_substr: String = chars[start..curr_end].iter().collect();
n_sym_substrings.push(curr_substr);
start = curr_end;
}
let mut rev_fibb_nums: RevFibIter = fibb_nums.rev();
for _ in 0..n
{
if let Some(curr_fibb) = rev_fibb_nums.next()
{
let curr_end: usize = start + curr_fibb as usize;
let curr_substr: String = chars[start..curr_end].iter().collect();
n_sym_substrings.push(curr_substr);
start = curr_end;
}
}
let left_text: String = chars[start..].iter().collect();
let result: (Vec<String>, String) = (n_sym_substrings, left_text);
result
}
#[test]
fn test_basic() {
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!");
+ let words: Vec<String> = fib_split("Fibonacci words!");
+ assert_eq!(words, &["F", "i", "bo", "nac", "ci wo", "rds!"]);
- let (_words, _rest): (Vec<String>, String) =
- fib_split_n("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 1);
+ 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): (Vec<String>, String) =
- fib_split_n_symmetric("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 1);
+ 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.");
}

Юлиян качи решение на 30.10.2024 23:25 (преди 11 месеца)

pub fn add(left: u64, right: u64) -> u64 {
left + right
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_works() {
let result = add(2, 2);
assert_eq!(result, 4);
}
}
//Fibbonacci numbers struct
pub struct FibIter
{
current: u32,
next: u32,
}
//Reversed Fibonacci numbers struct
pub struct RevFibIter
{
last: u32,
prelast: u32,
}
impl FibIter
{
pub fn new() -> FibIter
{
FibIter {
current: 1,
next: 1,
}
}
pub fn next(&mut self) -> u32
{
let result: u32 = self.current;
let new_next = self.current + self.next;
self.current = self.next;
self.next = new_next;
result
}
}
//Function that splits text into substirngs with lenght as big as Fibonacci numbers until the end of the text
pub fn fib_split(text: &str) -> Vec<String>
{
let mut fibb_nums = FibIter::new();
let mut fibb_substrings: Vec<String> = Vec::new();
let chars: Vec<char> = text.chars().collect();
let text_len: usize = chars.len();
let mut start: usize = 0;
while start < text_len
{
let curr_fibb: usize = fibb_nums.next() as usize;
let end: usize = if start + curr_fibb < text_len {start + curr_fibb} else {text_len};
let curr_substr: String = chars[start..end].iter().collect();
fibb_substrings.push(curr_substr);
start = end;
}
fibb_substrings
}
//Function that takes number n and splits text into substrings with lenghts from 0th to (n - 1)th number of Fibbonacci
//and returns the rest of the text.
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, String)
{
let mut fibb_nums: FibIter = FibIter::new();
let mut fibb_sum: u32 = 0;
let mut n_fibb_substrings: Vec<String> = Vec::new();
for _ in 0..n
{
fibb_sum += fibb_nums.next();
}
let chars: Vec<char> = text.chars().collect();
let text_len: usize = chars.len();
if text_len < fibb_sum as usize
{
panic!("The text isn't large enough");
}
let mut fibb: FibIter = FibIter::new();
let mut start: usize = 0;
for _ in 0..n
{
let curr_fibb: usize = fibb.next() as usize;
let end: usize = start + curr_fibb as usize;
let curr_substr: String = chars[start..end].iter().collect();
n_fibb_substrings.push(curr_substr);
start = end;
}
let left_text: String = chars[start..].iter().collect();
let result: (Vec<String>, String) = (n_fibb_substrings, left_text);
result
}
//Implementation of functionality that splits text symetrically into substrings with Fibonacci numbers lenghts
impl FibIter
{
pub fn rev(self) -> RevFibIter
{
RevFibIter
{
last: self.current,
prelast: self.next - self.current,
}
}
}
impl RevFibIter
{
pub fn next(&mut self) -> Option<u32>
{
let result = self.prelast;
if self.last == 1 && self.prelast == 1
{
self.last = 0;
}
else
{
let temp = self.last;
self.last = self.prelast;
self.prelast = temp - self.prelast;
}
if result == 0
{
return None;
}
Some(result)
}
}
//Symetrical separation function
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, String)
{
let mut fibb_iter: FibIter = FibIter::new();
let mut fibb_sum: u32 = 0;
let mut n_sym_substrings: Vec<String> = Vec::new();
for _ in 0..n
{
fibb_sum += fibb_iter.next();
}
fibb_sum *= 2;
let chars: Vec<char> = text.chars().collect();
let text_len: usize = chars.len();
if text_len < fibb_sum as usize
{
panic!("The text isn't large enough");
}
- //
let mut fibb_nums: FibIter = FibIter::new();
let mut start: usize = 0;
for _ in 0..n
{
let curr_fibb: usize = fibb_nums.next() as usize;
let curr_end: usize = start + curr_fibb as usize;
let curr_substr: String = chars[start..curr_end].iter().collect();
n_sym_substrings.push(curr_substr);
start = curr_end;
}
let mut rev_fibb_nums: RevFibIter = fibb_nums.rev();
for _ in 0..n
{
if let Some(curr_fibb) = rev_fibb_nums.next()
{
let curr_end: usize = start + curr_fibb as usize;
let curr_substr: String = chars[start..curr_end].iter().collect();
n_sym_substrings.push(curr_substr);
start = curr_end;
}
}
let left_text: String = chars[start..].iter().collect();
let result: (Vec<String>, String) = (n_sym_substrings, left_text);
result
}
#[test]
fn test_basic() {
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.");
}