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

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

Решение на FMI Buzz от Иван Камбуров

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

Към профила на Иван Камбуров

Резултати

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

Код

/// Вход: променлива `n`, която описва броя елементи, които ще генерираме в резултата.
///
/// За всяко число от 1 до `n` включително, искаме съответстващия елемент в резултата да е:
///
/// - String със съдържание "Fizz" ако числото се дели на 3, но не на 5
/// - String със съдържание "Buzz" ако числото се дели на 5, но не на 3
/// - String със съдържание "Fizzbuzz" ако числото се дели и на 3, и на 5
/// - Числото конвертирано до низ, във всички други случаи
///
/// Тоест, във `fizzbuzz(3)`, първия елемент ще бъде `String::from("1")`, втория
/// `String::from("2")`, последния `String::from("Fizz")`.
///
/// Ако `n` е 0, очакваме празен вектор за резултат.
///
pub fn fizzbuzzer(n: usize, k1: usize, k2: usize, labels: &[String; 3]) -> String {
match (n%k1, n%k2) {
(0, 0) => labels[2].clone(),
(_, 0) => labels[1].clone(),
(0, _) => labels[0].clone(),
(_, _) => n.to_string()
}
}
pub fn fizzbuzz(n: usize) -> Vec<String> {
let labels: [String; 3] = ["Fizz".to_string(), "Buzz".to_string(), "Fizzbuzz".to_string()];
(1..n+1).map(|x| fizzbuzzer(x, 3, 5, &labels)).collect()
}
/// Вход:
/// - променлива `n`, която описва броя елементи, които ще генерираме в резултата.
/// - променливи `k1` и `k2`, които са двата делителя, които ще използваме за заместване.
///
/// За всяко число от 1 до `n` включително, искаме съответстващия елемент в резултата да е:
///
/// - String със съдържание "Fizz" ако числото се дели на k1, но не на k2
/// - String със съдържание "Buzz" ако числото се дели на k2, но не на k1
/// - String със съдържание "Fizzbuzz" ако числото се дели и на k1, и на k2
/// - Числото конвертирано до низ, във всички други случаи
///
/// Ако `n` е 0, очакваме празен вектор за резултат.
/// Ако `k1` или `k2` са 0 или 1, очакваме функцията да panic-не с каквото съобщение изберете.
///
pub fn custom_buzz(n: usize, k1: u8, k2: u8) -> Vec<String> {
let forbiden = [0, 1];
let should_panic = forbiden.contains(&k1) || forbiden.contains(&k2);
if should_panic {
panic!("Invalid value for k1 and/or k2!")
}
let labels: [String; 3] = ["Fizz".to_string(), "Buzz".to_string(), "Fizzbuzz".to_string()];
(1..n+1).map(|x| fizzbuzzer(x, k1.into(), k2.into(), &labels)).collect()
}
/// Параметри:
/// - полета `k1` и `k2`, които са двата делителя, които ще използваме за заместване.
/// - поле `labels`, които са трите етикета, които съответстват на коефициентите
///
pub struct FizzBuzzer {
pub k1: u8,
pub k2: u8,
pub labels: [String; 3],
}
impl FizzBuzzer {
/// За всяко число от 1 до `n` включително, искаме съответстващия елемент в резултата да е:
///
/// - Първия String от полето `labels` ако числото се дели на k1, но не на k2
/// - Втория String от полето `labels` ако числото се дели на k2, но не на k1
/// - Третия String от полето `labels` ако числото се дели и на k1, и на k2
/// - Числото конвертирано до низ, във всички други случаи
///
/// Ако `n` е 0, очакваме празен вектор за резултат.
/// Ако `k1` или `k2` са 0 или 1, очакваме функцията да panic-не с каквото съобщение изберете.
///
pub fn take(&self, n: usize) -> Vec<String> {
let forbiden = [0, 1];
let should_panic = forbiden.contains(&self.k1) || forbiden.contains(&self.k2);
if should_panic {
panic!("Invalid value for k1 and/or k2!")
}
(1..n+1).map(|x| fizzbuzzer(x, self.k1.into(), self.k2.into(), &self.labels)).collect()
}
/// Параметъра `index` указва кой етикет от полето `labels` променяме, от 0 до 2. Ако подадения
/// `index` е извън тези рамки, очакваме функцията да panic-не.
///
/// Стойността `value` е низа, който ще сложим на този индекс в полето `labels`.
///
pub fn change_label(&mut self, index: usize, value: &String) {
if index > 2 {
panic!("Label index out of bounds!")
}
self.labels[index] = value.clone();
}
}
// fn main() {
// println!("{:?}", fizzbuzz(0));
// println!("{:?}", custom_buzz(0, 2, 7));
// println!("{:?}", fizzbuzz(25));
// println!("{:?}", custom_buzz(25, 2, 7));
//
// // Panic tests:
// // println!("{:?}", custom_buzz(0, 0, 2));
// // println!("{:?}", custom_buzz(0, 1, 2));
// // println!("{:?}", custom_buzz(0, 2, 0));
// // println!("{:?}", custom_buzz(0, 2, 1));
//
// let f = FizzBuzzer {
// k1: 3,
// k2: 5,
// labels: ["Fizz".to_string(), "Buzz".to_string(), "Fizzbuzz".to_string()],
// };
//
// let mut mf = FizzBuzzer {
// k1: 3,
// k2: 5,
// labels: ["Fizz".to_string(), "Buzz".to_string(), "Fizzbuzz".to_string()],
// };
//
// println!("{:?}", f.take(0));
// println!("{:?}", f.take(25));
// mf.change_label(0, &"Aazz".to_string());
// mf.change_label(2, &"AazzBuzz".to_string());
// println!("{:?}", mf.take(25));
// // mf.change_label(5, &"Aazz".to_string()); // thread 'main' panicked at 'Label index out of bounds!', src/main.rs:95:13
// }

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

Compiling solution v0.1.0 (/tmp/d20201028-2816268-10d82u5/solution)
    Finished test [unoptimized + debuginfo] target(s) in 2.20s
     Running target/debug/deps/solution-ebb42508826ef2b4

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

     Running target/debug/deps/solution_test-9e954a53ed808c89

running 10 tests
test solution_test::test_change_label_basic ... ok
test solution_test::test_change_label_invalid ... ok
test solution_test::test_classic1 ... ok
test solution_test::test_classic2 ... ok
test solution_test::test_coefficients1 ... ok
test solution_test::test_coefficients2 ... ok
test solution_test::test_coefficients_invalid ... ok
test solution_test::test_struct_basic ... ok
test solution_test::test_struct_invalid ... ok
test solution_test::test_zeroes ... ok

test result: ok. 10 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

   Doc-tests solution

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

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

Иван качи първо решение на 28.10.2020 16:05 (преди почти 5 години)

Иван качи решение на 28.10.2020 16:10 (преди почти 5 години)

/// Вход: променлива `n`, която описва броя елементи, които ще генерираме в резултата.
///
/// За всяко число от 1 до `n` включително, искаме съответстващия елемент в резултата да е:
///
/// - String със съдържание "Fizz" ако числото се дели на 3, но не на 5
/// - String със съдържание "Buzz" ако числото се дели на 5, но не на 3
/// - String със съдържание "Fizzbuzz" ако числото се дели и на 3, и на 5
/// - Числото конвертирано до низ, във всички други случаи
///
/// Тоест, във `fizzbuzz(3)`, първия елемент ще бъде `String::from("1")`, втория
/// `String::from("2")`, последния `String::from("Fizz")`.
///
/// Ако `n` е 0, очакваме празен вектор за резултат.
///
pub fn fizzbuzzer(n: usize, k1: usize, k2: usize, labels: &[String; 3]) -> String {
match (n%k1, n%k2) {
(0, 0) => labels[2].clone(),
(_, 0) => labels[1].clone(),
(0, _) => labels[0].clone(),
(_, _) => n.to_string()
}
}
pub fn fizzbuzz(n: usize) -> Vec<String> {
let labels: [String; 3] = ["Fizz".to_string(), "Buzz".to_string(), "Fizzbuzz".to_string()];
(1..n).map(|x| fizzbuzzer(x, 3, 5, &labels)).collect()
}
/// Вход:
/// - променлива `n`, която описва броя елементи, които ще генерираме в резултата.
/// - променливи `k1` и `k2`, които са двата делителя, които ще използваме за заместване.
///
/// За всяко число от 1 до `n` включително, искаме съответстващия елемент в резултата да е:
///
/// - String със съдържание "Fizz" ако числото се дели на k1, но не на k2
/// - String със съдържание "Buzz" ако числото се дели на k2, но не на k1
/// - String със съдържание "Fizzbuzz" ако числото се дели и на k1, и на k2
/// - Числото конвертирано до низ, във всички други случаи
///
/// Ако `n` е 0, очакваме празен вектор за резултат.
/// Ако `k1` или `k2` са 0 или 1, очакваме функцията да panic-не с каквото съобщение изберете.
///
pub fn custom_buzz(n: usize, k1: u8, k2: u8) -> Vec<String> {
let forbiden = [0, 1];
let should_panic = forbiden.contains(&k1) || forbiden.contains(&k2);
if should_panic {
panic!("Invalid value for k1 and/or k2!")
}
let labels: [String; 3] = ["Fizz".to_string(), "Buzz".to_string(), "Fizzbuzz".to_string()];
(1..n).map(|x| fizzbuzzer(x, k1.into(), k2.into(), &labels)).collect()
}
/// Параметри:
/// - полета `k1` и `k2`, които са двата делителя, които ще използваме за заместване.
/// - поле `labels`, които са трите етикета, които съответстват на коефициентите
///
pub struct FizzBuzzer {
pub k1: u8,
pub k2: u8,
pub labels: [String; 3],
}
impl FizzBuzzer {
/// За всяко число от 1 до `n` включително, искаме съответстващия елемент в резултата да е:
///
/// - Първия String от полето `labels` ако числото се дели на k1, но не на k2
/// - Втория String от полето `labels` ако числото се дели на k2, но не на k1
/// - Третия String от полето `labels` ако числото се дели и на k1, и на k2
/// - Числото конвертирано до низ, във всички други случаи
///
/// Ако `n` е 0, очакваме празен вектор за резултат.
/// Ако `k1` или `k2` са 0 или 1, очакваме функцията да panic-не с каквото съобщение изберете.
///
pub fn take(&self, n: usize) -> Vec<String> {
let forbiden = [0, 1];
let should_panic = forbiden.contains(&self.k1) || forbiden.contains(&self.k2);
if should_panic {
panic!("Invalid value for k1 and/or k2!")
}
(1..n).map(|x| fizzbuzzer(x, self.k1.into(), self.k2.into(), &self.labels)).collect()
}
/// Параметъра `index` указва кой етикет от полето `labels` променяме, от 0 до 2. Ако подадения
/// `index` е извън тези рамки, очакваме функцията да panic-не.
///
/// Стойността `value` е низа, който ще сложим на този индекс в полето `labels`.
///
pub fn change_label(&mut self, index: usize, value: &String) {
if index > 2 {
panic!("Label index out of bounds!")
}
self.labels[index] = value.clone();
}
}
// fn main() {
// println!("{:?}", fizzbuzz(0));
// println!("{:?}", custom_buzz(0, 2, 7));
// println!("{:?}", fizzbuzz(25));
// println!("{:?}", custom_buzz(25, 2, 7));
// // Panic tests:
// // println!("{:?}", custom_buzz(0, 0, 2));
// // println!("{:?}", custom_buzz(0, 1, 2));
// // println!("{:?}", custom_buzz(0, 2, 0));
// // println!("{:?}", custom_buzz(0, 2, 1));
// let f = FizzBuzzer {
// k1: 3,
// k2: 5,
// labels: ["Fizz".to_string(), "Buzz".to_string(), "Fizzbuzz".to_string()],
// };
// let mut mf = FizzBuzzer {
// k1: 3,
// k2: 5,
// labels: ["Fizz".to_string(), "Buzz".to_string(), "Fizzbuzz".to_string()],
// };
// println!("{:?}", f.take(0));
// println!("{:?}", f.take(25));
// mf.change_label(0, &"Aazz".to_string());
+// mf.change_label(2, &"AazzBuzz".to_string());
// println!("{:?}", mf.take(25));
// // mf.change_label(5, &"Aazz".to_string()); // thread 'main' panicked at 'Label index out of bounds!', src/main.rs:95:13
// }

Иван качи решение на 28.10.2020 16:25 (преди почти 5 години)

/// Вход: променлива `n`, която описва броя елементи, които ще генерираме в резултата.
///
/// За всяко число от 1 до `n` включително, искаме съответстващия елемент в резултата да е:
///
/// - String със съдържание "Fizz" ако числото се дели на 3, но не на 5
/// - String със съдържание "Buzz" ако числото се дели на 5, но не на 3
/// - String със съдържание "Fizzbuzz" ако числото се дели и на 3, и на 5
/// - Числото конвертирано до низ, във всички други случаи
///
/// Тоест, във `fizzbuzz(3)`, първия елемент ще бъде `String::from("1")`, втория
/// `String::from("2")`, последния `String::from("Fizz")`.
///
/// Ако `n` е 0, очакваме празен вектор за резултат.
///
pub fn fizzbuzzer(n: usize, k1: usize, k2: usize, labels: &[String; 3]) -> String {
match (n%k1, n%k2) {
(0, 0) => labels[2].clone(),
(_, 0) => labels[1].clone(),
(0, _) => labels[0].clone(),
(_, _) => n.to_string()
}
}
pub fn fizzbuzz(n: usize) -> Vec<String> {
let labels: [String; 3] = ["Fizz".to_string(), "Buzz".to_string(), "Fizzbuzz".to_string()];
- (1..n).map(|x| fizzbuzzer(x, 3, 5, &labels)).collect()
+ (1..n+1).map(|x| fizzbuzzer(x, 3, 5, &labels)).collect()
}
/// Вход:
/// - променлива `n`, която описва броя елементи, които ще генерираме в резултата.
/// - променливи `k1` и `k2`, които са двата делителя, които ще използваме за заместване.
///
/// За всяко число от 1 до `n` включително, искаме съответстващия елемент в резултата да е:
///
/// - String със съдържание "Fizz" ако числото се дели на k1, но не на k2
/// - String със съдържание "Buzz" ако числото се дели на k2, но не на k1
/// - String със съдържание "Fizzbuzz" ако числото се дели и на k1, и на k2
/// - Числото конвертирано до низ, във всички други случаи
///
/// Ако `n` е 0, очакваме празен вектор за резултат.
/// Ако `k1` или `k2` са 0 или 1, очакваме функцията да panic-не с каквото съобщение изберете.
///
pub fn custom_buzz(n: usize, k1: u8, k2: u8) -> Vec<String> {
let forbiden = [0, 1];
let should_panic = forbiden.contains(&k1) || forbiden.contains(&k2);
if should_panic {
panic!("Invalid value for k1 and/or k2!")
}
let labels: [String; 3] = ["Fizz".to_string(), "Buzz".to_string(), "Fizzbuzz".to_string()];
- (1..n).map(|x| fizzbuzzer(x, k1.into(), k2.into(), &labels)).collect()
+ (1..n+1).map(|x| fizzbuzzer(x, k1.into(), k2.into(), &labels)).collect()
}
/// Параметри:
/// - полета `k1` и `k2`, които са двата делителя, които ще използваме за заместване.
/// - поле `labels`, които са трите етикета, които съответстват на коефициентите
///
pub struct FizzBuzzer {
pub k1: u8,
pub k2: u8,
pub labels: [String; 3],
}
impl FizzBuzzer {
/// За всяко число от 1 до `n` включително, искаме съответстващия елемент в резултата да е:
///
/// - Първия String от полето `labels` ако числото се дели на k1, но не на k2
/// - Втория String от полето `labels` ако числото се дели на k2, но не на k1
/// - Третия String от полето `labels` ако числото се дели и на k1, и на k2
/// - Числото конвертирано до низ, във всички други случаи
///
/// Ако `n` е 0, очакваме празен вектор за резултат.
/// Ако `k1` или `k2` са 0 или 1, очакваме функцията да panic-не с каквото съобщение изберете.
///
pub fn take(&self, n: usize) -> Vec<String> {
let forbiden = [0, 1];
let should_panic = forbiden.contains(&self.k1) || forbiden.contains(&self.k2);
if should_panic {
panic!("Invalid value for k1 and/or k2!")
}
- (1..n).map(|x| fizzbuzzer(x, self.k1.into(), self.k2.into(), &self.labels)).collect()
+ (1..n+1).map(|x| fizzbuzzer(x, self.k1.into(), self.k2.into(), &self.labels)).collect()
}
/// Параметъра `index` указва кой етикет от полето `labels` променяме, от 0 до 2. Ако подадения
/// `index` е извън тези рамки, очакваме функцията да panic-не.
///
/// Стойността `value` е низа, който ще сложим на този индекс в полето `labels`.
///
pub fn change_label(&mut self, index: usize, value: &String) {
if index > 2 {
panic!("Label index out of bounds!")
}
self.labels[index] = value.clone();
}
}
// fn main() {
// println!("{:?}", fizzbuzz(0));
// println!("{:?}", custom_buzz(0, 2, 7));
// println!("{:?}", fizzbuzz(25));
// println!("{:?}", custom_buzz(25, 2, 7));
-
+//
// // Panic tests:
// // println!("{:?}", custom_buzz(0, 0, 2));
// // println!("{:?}", custom_buzz(0, 1, 2));
// // println!("{:?}", custom_buzz(0, 2, 0));
// // println!("{:?}", custom_buzz(0, 2, 1));
-
+//
// let f = FizzBuzzer {
// k1: 3,
// k2: 5,
// labels: ["Fizz".to_string(), "Buzz".to_string(), "Fizzbuzz".to_string()],
// };
-
+//
// let mut mf = FizzBuzzer {
// k1: 3,
// k2: 5,
// labels: ["Fizz".to_string(), "Buzz".to_string(), "Fizzbuzz".to_string()],
// };
-
+//
// println!("{:?}", f.take(0));
// println!("{:?}", f.take(25));
// mf.change_label(0, &"Aazz".to_string());
// mf.change_label(2, &"AazzBuzz".to_string());
// println!("{:?}", mf.take(25));
// // mf.change_label(5, &"Aazz".to_string()); // thread 'main' panicked at 'Label index out of bounds!', src/main.rs:95:13
-// }
+// }