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

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

Решение на Думи на Фибоначи от Милица Тончева

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

Към профила на Милица Тончева

Резултати

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

Код

pub struct FibIter {
current_fib_number: u32,
index: i32,
previous_fib_number: u32,
}
impl FibIter {
pub fn new() -> FibIter {
FibIter{
current_fib_number: 1,
index: -1,
previous_fib_number: 0,
}
}
pub fn next(&mut self) -> u32 {
if self.index == -1{
self.index = 0;
return self.current_fib_number;
}
else if self.index == 0{
self.previous_fib_number = 1;
self.index = self.index + 1;
return self.current_fib_number;
}
self.index = self.index + 1;
self.current_fib_number = self.current_fib_number + self.previous_fib_number;
self.previous_fib_number = self.current_fib_number - self.previous_fib_number;
self.current_fib_number
}
pub fn get_index(&self) -> i32{
self.index
}
}
pub fn fib_split(text: &str) -> Vec<String> {
let mut result = Vec::<String>::new();
let mut fib_iter = FibIter::new();
let mut curr_element = String::from("");
let mut curr_element_needed_len = fib_iter.next();
let chars = text.chars();
for c in chars{
curr_element.push(c);
if curr_element.chars().count() as u32 == curr_element_needed_len{
result.push(curr_element);
curr_element = String::from("");
curr_element_needed_len = fib_iter.next();
}
}
if curr_element != String::from(""){
result.push(curr_element);
}
result
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, &str) {
if n == 0{
return (Vec::<String>::new(), text);
}
let mut result_vec = Vec::<String>::new();
let mut fib_iter = FibIter::new();
let mut curr_element = String::from("");
let mut curr_element_needed_len = fib_iter.next();
let mut used_chars_count = 0;
let chars = text.chars();
for c in chars{
if fib_iter.get_index() == n as i32{
break;
}
curr_element.push(c);
if curr_element.chars().count() as u32 == curr_element_needed_len{
result_vec.push(curr_element);
curr_element = String::from("");
used_chars_count = used_chars_count + curr_element_needed_len;
curr_element_needed_len = fib_iter.next();
}
}
if curr_element != String::from("") || fib_iter.get_index() < n as i32 {
panic!("Given string is not long enough");
}
let mut indices = Vec::<usize>::new();
for (index, character) in text.char_indices() {
indices.push(index);
}
if used_chars_count as usize == text.len(){
return (result_vec, "");
}
let index:usize = indices[used_chars_count as usize];
(result_vec, &text[index..])
}
impl FibIter {
/* ... */
pub fn rev(self) -> RevFibIter {
let temp_current_fib_number = self.current_fib_number + self.previous_fib_number;
let next = self.current_fib_number + temp_current_fib_number;
RevFibIter{
current_fib_number: temp_current_fib_number,
next_fib_number: next,
index: self.index + 1,
}
}
}
pub struct RevFibIter {
current_fib_number:u32,
next_fib_number:u32,
index: i32,
}
impl RevFibIter {
pub fn next(&mut self) -> Option<u32> {
self.index = self.index - 1;
if self.index < 0{
return Option::<u32>::None;
}
self.current_fib_number = self.next_fib_number - self.current_fib_number;
self.next_fib_number = self.next_fib_number - self.current_fib_number;
Option::<u32>::Some(self.current_fib_number)
}
pub fn get_index(&self) -> i32{
self.index
}
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, &str) {
if n == 0{
return (Vec::<String>::new(), text);
}
let mut result_vec = Vec::<String>::new();
let mut fib_iter = FibIter::new();
let mut curr_element = String::from("");
let mut curr_element_needed_len = fib_iter.next();
let mut used_chars_count = 0;
let chars: Vec<char> = text.chars().collect();
let mut chars_index = 0;
let chars_len = chars.len();
for &c in &chars{
if fib_iter.get_index() == n as i32{
break;
}
curr_element.push(c);
chars_index = chars_index+1;
if curr_element.chars().count() as u32 == curr_element_needed_len{
result_vec.push(curr_element);
curr_element = String::from("");
used_chars_count = used_chars_count + curr_element_needed_len;
curr_element_needed_len = fib_iter.next();
}
}
if curr_element != String::from("") || fib_iter.get_index() < n as i32 || chars_index == chars_len {
panic!("Given string is not long enough");
}
let mut rev_fib_iter = fib_iter.rev();
rev_fib_iter.next();
if let Some(num) = rev_fib_iter.next(){
curr_element_needed_len = num ;
}
while chars_index < chars_len{
let c = chars[chars_index];
chars_index = chars_index + 1;
if rev_fib_iter.get_index() < 0{
break;
}
curr_element.push(c);
if curr_element.chars().count() as u32 == curr_element_needed_len{
result_vec.push(curr_element);
curr_element = String::from("");
used_chars_count = used_chars_count + curr_element_needed_len;
if let Some(num) = rev_fib_iter.next(){
curr_element_needed_len = num ;
}
}
}
if curr_element != String::from("") || rev_fib_iter.get_index() > -1 {
panic!("Given string is not long enough");
}
let mut indices = Vec::<usize>::new();
for (index, character) in text.char_indices() {
indices.push(index);
}
if used_chars_count as usize == text.len(){
return (result_vec, "");
}
let index:usize = indices[used_chars_count as usize];
(result_vec, &text[index..])
}

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

Compiling solution v0.1.0 (/tmp/d20241104-1739405-1xepiu3/solution)
warning: unused variable: `character`
  --> src/lib.rs:82:17
   |
82 |     for (index, character) in text.char_indices() {
   |                 ^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_character`
   |
   = note: `#[warn(unused_variables)]` on by default

warning: unused variable: `character`
   --> src/lib.rs:183:17
    |
183 |     for (index, character) in text.char_indices() {
    |                 ^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_character`

warning: `solution` (lib) generated 2 warnings
    Finished test [unoptimized + debuginfo] target(s) in 1.06s
     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_cyrillic ... ok
test solution_test::fib_split_n_ascii_panic ... ok
test solution_test::fib_split_n_cyrillic_exact ... FAILED
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 ... FAILED
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

failures:

---- solution_test::fib_split_n_cyrillic_exact stdout ----
thread 'solution_test::fib_split_n_cyrillic_exact' panicked at 'index out of bounds: the len is 12 but the index is 12', src/lib.rs:90:23

---- solution_test::fib_split_n_symmetric_cyrillic_exact stdout ----
thread 'solution_test::fib_split_n_symmetric_cyrillic_exact' panicked at 'index out of bounds: the len is 14 but the index is 14', src/lib.rs:191:23


failures:
    solution_test::fib_split_n_cyrillic_exact
    solution_test::fib_split_n_symmetric_cyrillic_exact

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 коментара)

Милица качи първо решение на 26.10.2024 20:07 (преди 11 месеца)

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

pub struct FibIter {
current_fib_number: u32,
index: i32,
previous_fib_number: u32,
}
impl FibIter {
pub fn new() -> FibIter {
FibIter{
current_fib_number: 1,
index: -1,
previous_fib_number: 0,
}
}
pub fn next(&mut self) -> u32 {
if self.index == -1{
self.index = 0;
return self.current_fib_number;
}
else if self.index == 0{
self.previous_fib_number = 1;
self.index = self.index + 1;
return self.current_fib_number;
}
self.index = self.index + 1;
self.current_fib_number = self.current_fib_number + self.previous_fib_number;
self.previous_fib_number = self.current_fib_number - self.previous_fib_number;
self.current_fib_number
}
pub fn get_index(&self) -> i32{
self.index
}
}
pub fn fib_split(text: &str) -> Vec<String> {
let mut result = Vec::<String>::new();
let mut fib_iter = FibIter::new();
let mut curr_element = String::from("");
let mut curr_element_needed_len = fib_iter.next();
let chars = text.chars();
for c in chars{
curr_element.push(c);
if curr_element.chars().count() as u32 == curr_element_needed_len{
result.push(curr_element);
curr_element = String::from("");
curr_element_needed_len = fib_iter.next();
}
}
if curr_element != String::from(""){
result.push(curr_element);
}
result
}
pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, &str) {
if n == 0{
return (Vec::<String>::new(), text);
}
let mut result_vec = Vec::<String>::new();
let mut fib_iter = FibIter::new();
let mut curr_element = String::from("");
let mut curr_element_needed_len = fib_iter.next();
let mut used_chars_count = 0;
let chars = text.chars();
for c in chars{
if fib_iter.get_index() == n as i32{
break;
}
curr_element.push(c);
if curr_element.chars().count() as u32 == curr_element_needed_len{
result_vec.push(curr_element);
curr_element = String::from("");
used_chars_count = used_chars_count + curr_element_needed_len;
curr_element_needed_len = fib_iter.next();
}
}
if curr_element != String::from("") || fib_iter.get_index() < n as i32 {
panic!("Given string is not long enough");
}
- (result_vec, &text[used_chars_count as usize..])
+ let mut indices = Vec::<usize>::new();
+ for (index, character) in text.char_indices() {
+ indices.push(index);
+ }
+
+ if used_chars_count as usize == text.len(){
+ return (result_vec, "");
+ }
+
+ let index:usize = indices[used_chars_count as usize];
+ (result_vec, &text[index..])
}
impl FibIter {
/* ... */
pub fn rev(self) -> RevFibIter {
let temp_current_fib_number = self.current_fib_number + self.previous_fib_number;
let next = self.current_fib_number + temp_current_fib_number;
RevFibIter{
current_fib_number: temp_current_fib_number,
next_fib_number: next,
index: self.index + 1,
}
}
}
pub struct RevFibIter {
current_fib_number:u32,
next_fib_number:u32,
index: i32,
}
impl RevFibIter {
pub fn next(&mut self) -> Option<u32> {
self.index = self.index - 1;
if self.index < 0{
return Option::<u32>::None;
}
self.current_fib_number = self.next_fib_number - self.current_fib_number;
self.next_fib_number = self.next_fib_number - self.current_fib_number;
Option::<u32>::Some(self.current_fib_number)
}
pub fn get_index(&self) -> i32{
self.index
}
}
pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, &str) {
if n == 0{
return (Vec::<String>::new(), text);
}
let mut result_vec = Vec::<String>::new();
let mut fib_iter = FibIter::new();
let mut curr_element = String::from("");
let mut curr_element_needed_len = fib_iter.next();
let mut used_chars_count = 0;
let chars: Vec<char> = text.chars().collect();
let mut chars_index = 0;
let chars_len = chars.len();
for &c in &chars{
if fib_iter.get_index() == n as i32{
break;
}
curr_element.push(c);
chars_index = chars_index+1;
if curr_element.chars().count() as u32 == curr_element_needed_len{
result_vec.push(curr_element);
curr_element = String::from("");
used_chars_count = used_chars_count + curr_element_needed_len;
curr_element_needed_len = fib_iter.next();
}
}
if curr_element != String::from("") || fib_iter.get_index() < n as i32 || chars_index == chars_len {
panic!("Given string is not long enough");
}
let mut rev_fib_iter = fib_iter.rev();
rev_fib_iter.next();
if let Some(num) = rev_fib_iter.next(){
curr_element_needed_len = num ;
}
while chars_index < chars_len{
let c = chars[chars_index];
chars_index = chars_index + 1;
if rev_fib_iter.get_index() < 0{
break;
}
curr_element.push(c);
if curr_element.chars().count() as u32 == curr_element_needed_len{
result_vec.push(curr_element);
curr_element = String::from("");
used_chars_count = used_chars_count + curr_element_needed_len;
if let Some(num) = rev_fib_iter.next(){
curr_element_needed_len = num ;
}
}
}
if curr_element != String::from("") || rev_fib_iter.get_index() > -1 {
panic!("Given string is not long enough");
}
- (result_vec, &text[used_chars_count as usize..])
+ let mut indices = Vec::<usize>::new();
+ for (index, character) in text.char_indices() {
+ indices.push(index);
+ }
+
+ if used_chars_count as usize == text.len(){
+ return (result_vec, "");
+ }
+
+ let index:usize = indices[used_chars_count as usize];
+ (result_vec, &text[index..])
}