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

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

Решение на Думи на Фибоначи от Елис Шукри

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

Към профила на Елис Шукри

Резултати

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

Код

pub struct FibIter {
first: u32,
second: u32,
current: u32
}
impl FibIter {
pub fn new() -> FibIter {
FibIter {
first: 1,
second: 1,
current: 0
}
}
pub fn next(&mut self) -> u32 {
if self.current == 0 {
self.current = 1;
self.first
} else if self.current == 1 {
self.current = 2;
self.second
} else {
self.current += 1;
let tmp1: u32 = self.first;
let tmp2: u32 = self.second;
self.first = tmp2;
self.second = tmp1 + tmp2;
self.second
}
}
pub fn rev(&self) -> RevFibIter {
RevFibIter{rev_first: self.first, rev_second: self.second, rev_current: self.current, normal_current: self.current}
}
}
pub struct RevFibIter {
rev_first: u32,
rev_second: u32,
rev_current: u32,
normal_current: u32
}
impl RevFibIter {
pub fn next(&mut self) -> Option<u32> {
if self.rev_current == self.normal_current {
self.rev_current -= 1;
Some(self.rev_second)
} else if self.rev_current == self.normal_current - 1 {
self.rev_current -= 1;
Some(self.rev_first)
} else {
let tmp: u32 = self.rev_second - self.rev_first;
if tmp > 0 {
self.rev_second = self.rev_first;
self.rev_first = tmp;
self.rev_current -= 1;
Some(tmp)
}
else {
None
}
}
}
}
fn substring(start: usize, end: usize, text: &str) -> &str {
let mut index = 0;
let mut bytes = 0;
let mut char = text.chars();
while index < start {
if let Some(c) = char.next() {
index += 1;
let my_char = c.to_string();
let my_char_bytes = my_char.as_bytes();
bytes += my_char_bytes.len();
}
else {
break;
}
}
let mut end_bytes = bytes;
while index < end {
if let Some(c) = char.next() {
index += 1;
let my_char = c.to_string();
let my_char_bytes = my_char.as_bytes();
end_bytes += my_char_bytes.len();
}
else {
break;
}
}
&text[bytes..end_bytes]
}
pub fn fib_split(text: &str) -> Vec<String> {
let mut result: Vec<String> = Vec::new();
let mut iter = FibIter::new();
let mut length: usize = 0;
loop {
let fib: usize = iter.next() as usize;
if length + fib >= text.chars().count() {
let word = substring(length, text.chars().count(), text);
result.push(word.to_string());
break;
}
let word = substring(length, length + fib, text);
result.push(word.to_string());
length = length + fib;
}
result
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, &str) {
let mut result_v: Vec<String> = Vec::new();
let mut iter = FibIter::new();
let mut length: usize = 0;
let mut count: u32 = 0;
while count < n {
let fib: usize = iter.next() as usize;
if length + fib > text.chars().count() {
panic!("The text is too short!")
}
let word = substring(length, length + fib, text);
result_v.push(word.to_string());
length = length + fib;
count += 1;
}
let left: &str = substring(length, text.chars().count(), text);
(result_v, left)
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, &str) {
let mut result_v: Vec<String> = Vec::new();
let mut iter = FibIter::new();
let mut rev_iter: RevFibIter = iter.rev();
let mut length: usize = 0;
let mut count: u32 = 0;
let mut fib: usize;
while count < 2 * n {
if count < n {
fib = iter.next() as usize;
} else {
if count == n {
rev_iter = iter.rev();
}
let rev_val: Option<u32> = rev_iter.next();
match rev_val {
Some(x) => {fib = x as usize;},
None => panic!("The text is too short!")
}
}
if length + fib > text.chars().count() {
panic!("The text is too short!")
}
let word = substring(length, length + fib, text);
result_v.push(word.to_string());
length = length + fib;
count += 1;
}
let left: &str = substring(length, text.chars().count(), text);
(result_v, left)
}

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

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

failures:

---- solution_test::rev_fib_iter_empty stdout ----
thread 'solution_test::rev_fib_iter_empty' panicked at 'attempt to subtract with overflow', src/lib.rs:48:13


failures:
    solution_test::rev_fib_iter_empty

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 17:54 (преди 11 месеца)

Елис качи решение на 29.10.2024 21:13 (преди 11 месеца)

pub struct FibIter {
first: u32,
second: u32,
current: u32
}
impl FibIter {
pub fn new() -> FibIter {
FibIter {
first: 1,
second: 1,
current: 0
}
}
pub fn next(&mut self) -> u32 {
if self.current == 0 {
self.current = 1;
self.first
} else if self.current == 1 {
self.current = 2;
self.second
} else {
self.current += 1;
let tmp1: u32 = self.first;
let tmp2: u32 = self.second;
self.first = tmp2;
self.second = tmp1 + tmp2;
self.second
}
}
pub fn rev(&self) -> RevFibIter {
RevFibIter{rev_first: self.first, rev_second: self.second, rev_current: self.current, normal_current: self.current}
}
}
pub struct RevFibIter {
rev_first: u32,
rev_second: u32,
rev_current: u32,
normal_current: u32
}
impl RevFibIter {
pub fn next(&mut self) -> Option<u32> {
if self.rev_current == self.normal_current {
self.rev_current -= 1;
Some(self.rev_second)
} else if self.rev_current == self.normal_current - 1 {
self.rev_current -= 1;
Some(self.rev_first)
} else {
let tmp: u32 = self.rev_second - self.rev_first;
if tmp > 0 {
self.rev_second = self.rev_first;
self.rev_first = tmp;
self.rev_current -= 1;
- Some(tmp);
+ Some(tmp)
}
- None
+ else {
+ None
+ }
+
}
}
}
fn substring(start: usize, end: usize, text: &str) -> &str {
let mut index = 0;
let mut bytes = 0;
let mut char = text.chars();
while index < start {
if let Some(c) = char.next() {
index += 1;
let my_char = c.to_string();
let my_char_bytes = my_char.as_bytes();
bytes += my_char_bytes.len();
}
else {
break;
}
}
let mut end_bytes = bytes;
while index < end {
if let Some(c) = char.next() {
index += 1;
let my_char = c.to_string();
let my_char_bytes = my_char.as_bytes();
end_bytes += my_char_bytes.len();
}
else {
break;
}
}
&text[bytes..end_bytes]
}
+
pub fn fib_split(text: &str) -> Vec<String> {
let mut result: Vec<String> = Vec::new();
let mut iter = FibIter::new();
let mut length: usize = 0;
loop {
let fib: usize = iter.next() as usize;
if length + fib >= text.chars().count() {
let word = substring(length, text.chars().count(), text);
result.push(word.to_string());
break;
}
let word = substring(length, length + fib, text);
result.push(word.to_string());
length = length + fib;
}
result
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, &str) {
let mut result_v: Vec<String> = Vec::new();
let mut iter = FibIter::new();
let mut length: usize = 0;
let mut count: u32 = 0;
while count < n {
let fib: usize = iter.next() as usize;
if length + fib >= text.chars().count() {
panic!("The text is too short!")
}
let word = substring(length, length + fib, text);
result_v.push(word.to_string());
length = length + fib;
count += 1;
}
let left: &str = substring(length, text.chars().count(), text);
(result_v, left)
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, &str) {
let mut result_v: Vec<String> = Vec::new();
let mut iter = FibIter::new();
-
+ let mut rev_iter: RevFibIter = iter.rev();
let mut length: usize = 0;
let mut count: u32 = 0;
let mut fib: usize;
while count < 2 * n {
if count < n {
fib = iter.next() as usize;
} else {
- let mut rev_iter: RevFibIter = iter.rev();
+ if count == n {
+ rev_iter = iter.rev();
+ }
+
let rev_val: Option<u32> = rev_iter.next();
match rev_val {
Some(x) => {fib = x as usize;},
None => panic!("The text is too short!")
}
}
if length + fib >= text.chars().count() {
panic!("The text is too short!")
}
let word = substring(length, length + fib, text);
result_v.push(word.to_string());
length = length + fib;
count += 1;
}
let left: &str = substring(length, text.chars().count(), text);
(result_v, left)
-}
+}

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

pub struct FibIter {
first: u32,
second: u32,
current: u32
}
impl FibIter {
pub fn new() -> FibIter {
FibIter {
first: 1,
second: 1,
current: 0
}
}
pub fn next(&mut self) -> u32 {
if self.current == 0 {
self.current = 1;
self.first
} else if self.current == 1 {
self.current = 2;
self.second
} else {
self.current += 1;
let tmp1: u32 = self.first;
let tmp2: u32 = self.second;
self.first = tmp2;
self.second = tmp1 + tmp2;
self.second
}
}
pub fn rev(&self) -> RevFibIter {
RevFibIter{rev_first: self.first, rev_second: self.second, rev_current: self.current, normal_current: self.current}
}
}
pub struct RevFibIter {
rev_first: u32,
rev_second: u32,
rev_current: u32,
normal_current: u32
}
impl RevFibIter {
pub fn next(&mut self) -> Option<u32> {
if self.rev_current == self.normal_current {
self.rev_current -= 1;
Some(self.rev_second)
} else if self.rev_current == self.normal_current - 1 {
self.rev_current -= 1;
Some(self.rev_first)
} else {
let tmp: u32 = self.rev_second - self.rev_first;
if tmp > 0 {
self.rev_second = self.rev_first;
self.rev_first = tmp;
self.rev_current -= 1;
Some(tmp)
}
else {
None
}
}
}
}
fn substring(start: usize, end: usize, text: &str) -> &str {
let mut index = 0;
let mut bytes = 0;
let mut char = text.chars();
while index < start {
if let Some(c) = char.next() {
index += 1;
let my_char = c.to_string();
let my_char_bytes = my_char.as_bytes();
bytes += my_char_bytes.len();
}
else {
break;
}
}
let mut end_bytes = bytes;
while index < end {
if let Some(c) = char.next() {
index += 1;
let my_char = c.to_string();
let my_char_bytes = my_char.as_bytes();
end_bytes += my_char_bytes.len();
}
else {
break;
}
}
&text[bytes..end_bytes]
}
-
pub fn fib_split(text: &str) -> Vec<String> {
let mut result: Vec<String> = Vec::new();
let mut iter = FibIter::new();
let mut length: usize = 0;
loop {
let fib: usize = iter.next() as usize;
if length + fib >= text.chars().count() {
let word = substring(length, text.chars().count(), text);
result.push(word.to_string());
break;
}
let word = substring(length, length + fib, text);
result.push(word.to_string());
length = length + fib;
}
result
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, &str) {
let mut result_v: Vec<String> = Vec::new();
let mut iter = FibIter::new();
let mut length: usize = 0;
let mut count: u32 = 0;
while count < n {
let fib: usize = iter.next() as usize;
- if length + fib >= text.chars().count() {
+ if length + fib > text.chars().count() {
panic!("The text is too short!")
}
let word = substring(length, length + fib, text);
result_v.push(word.to_string());
length = length + fib;
count += 1;
}
let left: &str = substring(length, text.chars().count(), text);
(result_v, left)
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, &str) {
let mut result_v: Vec<String> = Vec::new();
let mut iter = FibIter::new();
let mut rev_iter: RevFibIter = iter.rev();
let mut length: usize = 0;
let mut count: u32 = 0;
let mut fib: usize;
while count < 2 * n {
if count < n {
fib = iter.next() as usize;
} else {
if count == n {
rev_iter = iter.rev();
}
let rev_val: Option<u32> = rev_iter.next();
match rev_val {
Some(x) => {fib = x as usize;},
None => panic!("The text is too short!")
}
}
- if length + fib >= text.chars().count() {
+ if length + fib > text.chars().count() {
panic!("The text is too short!")
}
let word = substring(length, length + fib, text);
result_v.push(word.to_string());
length = length + fib;
count += 1;
}
let left: &str = substring(length, text.chars().count(), text);
(result_v, left)
-}
+}