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)

#![allow(unused_imports)]
// using Rust(1.42.0)
// My Library Repo is at "https://github.com/Loptall/prcn_lib"
// check available crates on AtCoder at "https://atcoder.jp/contests/language-test-202001"

/*
    AtCoder Language Update 2020204 お疲れ様でした! 有難いです
*/

// Dep crates are...
use std::cmp::{max, min, Ordering};
use std::collections::{HashMap, HashSet, VecDeque};
use std::io::stdin;
use std::mem::swap;
use std::ops::*;
use std::str::FromStr;

fn input<T: FromStr>() -> Result<T, T::Err> {
    let mut buf = String::new();
    stdin().read_line(&mut buf).unwrap();
    buf.trim().parse()
}

fn input_vec<T: FromStr>() -> Result<Vec<T>, T::Err> {
    let mut buf = String::new();
    stdin().read_line(&mut buf).unwrap();
    buf.trim().split_whitespace().map(|x| x.parse()).collect()
}

// code...
fn main() {
    let (mut a, mut b, mut c) = {
        let v: Vec<usize> = input_vec().unwrap();
        (v[0], v[1], v[2])
    };

    let sum = a + b + c;
    if a > b { swap(&mut a, &mut b) }
    if b > c { swap(&mut b, &mut c) }
    if a > b { swap(&mut a, &mut b) }

    let ans = match (a % 2, b % 2, c % 2) {
        (1, 1, 1) => (3 * c - sum) / 2,
        (0, 0, 0) => (3 * c - sum) / 2,
        (1, 1, 0) => (3 * c - sum) / 2,
        (0, 0, 1) => (3 * c - sum) / 2,
        (1, 0, 1) => (3 * (c+1) - sum) / 2,
        (0, 1, 0) => (3 * (c+1) - sum) / 2,
        (1, 0, 0) =>(3 * (c+1) - sum) / 2,
        (0, 1, 1) => (3 * (c+1) - sum) / 2,
        _ => unreachable!()
    };

    println!("{}", ans);
}