Problem:
Score : 300 points

Problem Statement

You are given three integers A, B and C. Find the minimum number of operations required to make A, B and C all equal by repeatedly performing the following two kinds of operations in any order:

Choose two among A, B and C, then increase both by 1.

Choose one among A, B and C, then increase it by 2.

It can be proved that we can always make A, B and C all equal by repeatedly performing these operations.

Constraints

0 \leq A,B,C \leq 50

All values in input are integers.

Input

Input is given from Standard Input in the following format:

A B C

Output

Print the minimum number of operations required to make A, B and C all equal.

Sample Input 1

2 5 4

Sample Output 1

2

We can make A, B and C all equal by the following operations:

Increase A and C by 1. Now, A, B, C are 3, 5, 5, respectively.

Increase A by 2. Now, A, B, C are 5, 5, 5, respectively.

Sample Input 2

2 6 3

Sample Output 2

5

Sample Input 3

31 41 5

Sample Output 3

23

Solution in Rust (1.15.1) (judge verdict: Accepted)

use std::io::*;
use std::str::*;
use std::collections::HashSet;

fn read<T: FromStr>() -> Option<T> {
    let stdin = stdin();
    let s = stdin
        .bytes()
        .map(|c| c.unwrap() as char)
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok()
}

fn main() {
    let A: i64 = read().unwrap();
    let B: i64 = read().unwrap();
    let C: i64 = read().unwrap();
    let mut v = Vec::new();
    v.push(A);
    v.push(B);
    v.push(C);
    v.sort_by(|a, b| b.cmp(a));
    let a = v[0];
    let b = v[1];
    let c = v[2];
    if (a - b) % 2 == 0 && (a - c) % 2 == 0 {
        println!(
            "{}",
            (((a - b) as f64 / 2.0).floor() as usize + ((a - c) as f64 / 2.0).floor() as usize)
                as usize,
        );
    } else if (a - b) % 2 == 1 && (a - c) % 2 == 1 {
        println!(
            "{}",
            (a - b + ((c + a - b) as f64 / 2.0).floor() as i64) as usize
        );
    } else if (a - b) % 2 == 1 && (a - c) % 2 == 0 {
        let a = a + 1;
        let c = c + 1;
        println!(
            "{}",
            (((a - c) as f64 / 2.0).floor() as usize + ((a - b) as f64 / 2.0).floor() as usize)
                as usize + 1,
        );
    } else {
        let a = a + 1;
        let b = b + 1;
        println!(
            "{}",
            (((a - b) as f64 / 2.0).floor() as usize + ((a - c) as f64 / 2.0).floor() as usize)
                as usize + 1,
        );
    }
}