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

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

Решение на Дигитален корен от Моника Киркова

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

Към профила на Моника Киркова

Резултати

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

Код

pub fn hex_to_dec(num: char)->u32{
if num == 'a'{
10
}
else if num == 'b'{
11
}
else if num == 'c'{
12
}
else if num == 'd'{
13
}
else if num == 'e'{
14
}
else if num == 'f'{
15
}
else{
0
}
}

Тази функция е малко странна. Променлива с име num е малко странно да е char. Може би digit щеше да е по-удачно примерно. Освен това, ако не е във валидния range, връща 0, което е странен failure case. Ако се извика като hex_to_dec('1'), ще върне 0, въпреки, че 1 е напълно валидна шестнадесетична цифра.

Ясно е, че ти просто викаш тази функция с правилния вход, но ако някой колега (или ти самата след седмици/месеци) решиш да я използваш, е много лесно да забравиш, че трябва да се вика само със символите 'a'..'f'. Функцията просто има неудобен интерфейс, позволява ти лесно да сбъркаш употребата ѝ.

Иначе, метода char::to_digit вероятно щеше да ти свърши работа.

Андрей
pub fn decimal(num: &str)-> Option<u32>{
let mut sum = 0;
for i in num.chars(){
if !(char::is_digit(i, 10)){
return None
}
let parsed = (char::to_digit(i,10)).unwrap();
sum += parsed;

Тези два реда, проверка за това дали е цифра, и конвертиране към цифра, няма нужда да са отделни. Метода to_digit вече прави това конвертиране и ти връща None ако не е валидна цифра:

match char::to_digit(i, 10) {
    None => return None,
    Some(parsed) => sum += parsed,
}

Този код е по-кратък и върши по-малко работа (не валидира два пъти).

Името на променливата също е малко misleading -- i обикновено се използва за числа, или индекс на итерация. Може би c щеше да е по-удачно.

Андрей
}
let mut str_sum = sum.to_string();;
if sum >= 10{
str_sum = sum.to_string();
decimal(&str_sum)
}
else{
let mut res : Option<u32> = Some(0);
for i in str_sum.chars(){
res = char::to_digit(i, 10);
}
res
}
}
pub fn hex(num: &str)-> Option<u32>{
let mut sum = 0;
for i in num.chars(){
if !(char::is_digit(i, 16)){
return None
}
if i >= 'a' && i <= 'f' {
sum += hex_to_dec(i);
}
else{
let parsed = (char::to_digit(i,10)).unwrap();
sum += parsed;
}
}
if sum > 15{
let str_sum = format!("{:x}", sum);
hex(&str_sum)
}
else{
let str_sum = format!("{:x}", sum);
let mut res : Option<u32> = Some(0);
for i in str_sum.chars(){
res = char::to_digit(i, 16);
}
res
}
}
pub fn octal(num: &str)-> Option<u32>{
let mut sum = 0;
for i in num.chars(){
if !(char::is_digit(i, 8)){
return None
}
let mut parsed = (char::to_digit(i,10)).unwrap();
sum += parsed;
}
let str_sum = format!("{:o}", sum);
if sum > 7{
octal(&str_sum)
}
else{
let mut res : Option<u32> = Some(0);
for i in str_sum.chars(){
res = char::to_digit(i, 8);
}
res
}
}
pub fn binary(num: &str)-> Option<u32>{
let mut sum = 0;
for i in num.chars(){
if !(char::is_digit(i, 2)){
return None
}
let mut parsed = (char::to_digit(i,10)).unwrap();
sum += parsed;
}
let str_sum = format!("{:b}", sum);
if sum > 1{
binary(&str_sum)
}
else{
let mut res : Option<u32> = Some(0);
for i in str_sum.chars(){
res = char::to_digit(i, 2);
}
res
}
}

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

Compiling solution v0.1.0 (/tmp/d20200111-2173579-1lwhuia/solution)
warning: unnecessary trailing semicolon
  --> src/lib.rs:33:39
   |
33 |     let mut str_sum = sum.to_string();;
   |                                       ^ help: remove this semicolon
   |
   = note: `#[warn(redundant_semicolon)]` on by default

warning: variable does not need to be mutable
  --> src/lib.rs:80:13
   |
80 |         let mut parsed = (char::to_digit(i,10)).unwrap();
   |             ----^^^^^^
   |             |
   |             help: remove this `mut`
   |
   = note: `#[warn(unused_mut)]` on by default

warning: variable does not need to be mutable
   --> src/lib.rs:101:13
    |
101 |         let mut parsed = (char::to_digit(i,10)).unwrap();
    |             ----^^^^^^
    |             |
    |             help: remove this `mut`

warning: unnecessary trailing semicolon
  --> src/lib.rs:33:39
   |
33 |     let mut str_sum = sum.to_string();;
   |                                       ^ help: remove this semicolon
   |
   = note: `#[warn(redundant_semicolon)]` on by default

warning: variable does not need to be mutable
  --> src/lib.rs:80:13
   |
80 |         let mut parsed = (char::to_digit(i,10)).unwrap();
   |             ----^^^^^^
   |             |
   |             help: remove this `mut`
   |
   = note: `#[warn(unused_mut)]` on by default

warning: variable does not need to be mutable
   --> src/lib.rs:101:13
    |
101 |         let mut parsed = (char::to_digit(i,10)).unwrap();
    |             ----^^^^^^
    |             |
    |             help: remove this `mut`

    Finished test [unoptimized + debuginfo] target(s) in 1.69s
     Running target/debug/deps/solution-a73e64ec87929bd0

running 0 tests

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

     Running target/debug/deps/solution_test-38971695424b36d5

running 6 tests
test solution_test::test_binary ... ok
test solution_test::test_decimal_basic ... ok
test solution_test::test_hex_basic ... ok
test solution_test::test_invalid ... ok
test solution_test::test_octal_basic ... ok
test solution_test::test_zeroes ... ok

test result: ok. 6 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

История (1 версия и 5 коментара)