Problem:
Score : 200 points

Problem Statement

There are N gems. The value of the i-th gem is V_i.

You will choose some of these gems, possibly all or none, and get them.

However, you need to pay a cost of C_i to get the i-th gem.

Let X be the sum of the values of the gems obtained, and Y be the sum of the costs paid.

Find the maximum possible value of X-Y.

Constraints

All values in input are integers.

1 \leq N \leq 20

1 \leq C_i, V_i \leq 50

Input

Input is given from Standard Input in the following format:

N
V_1 V_2 ... V_N
C_1 C_2 ... C_N

Output

Print the maximum possible value of X-Y.

Sample Input 1

3
10 2 5
6 3 4

Sample Output 1

5

If we choose the first and third gems, X = 10 + 5 = 15 and Y = 6 + 4 = 10.
We have X-Y = 5 here, which is the maximum possible value.

Sample Input 2

4
13 21 6 19
11 30 6 15

Sample Output 2

6

Sample Input 3

1
1
50

Sample Output 3

0

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

use std::cmp::max;
use std::cmp::min;
use std::fmt;
use std::io::stdin;
use std::io::Error;
use std::io::ErrorKind;
use std::io::Read;

#[derive(Debug)]
struct Jewel {
    v: u32,
    c: u32,
}

struct Input {
    n: u32,
    j: Vec<Jewel>,
}

impl fmt::Display for Input {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let j = self.j[0..(self.n as usize)]
            .iter()
            .map(|j| format!("{:?}", j))
            .collect::<Vec<String>>()
            .join(", ");
        write!(f, "{{ n: {}, j: [{}] }}", self.n, j)
    }
}

fn handle_input(input_str: String) -> Result<Input, Error> {
    let mut iter = input_str.split_whitespace();
    let n: u32 = iter.next().unwrap().parse().unwrap();
    let mut v_vec = Vec::new();
    let mut c_vec = Vec::new();
    for _ in 0..n {
        let v: u32 = iter.next().unwrap().parse().unwrap();
        v_vec.push(v);
    }
    for _ in 0..n {
        let c: u32 = iter.next().unwrap().parse().unwrap();
        c_vec.push(c);
    }
    let j = v_vec
        .iter()
        .zip(c_vec.iter())
        .map(|(v, c)| Jewel { v: *v, c: *c })
        .collect::<Vec<Jewel>>();
    let input = Input { n: n, j: j };
    Ok(input)
}

fn handle_output(input: Input) -> Result<String, Error> {
    let valued_sum: u32 = input
        .j
        .iter()
        .filter(|j| j.v > j.c)
        .map(|j| j.v - j.c)
        .sum();
    Ok(format!("{}", valued_sum))
}

fn main() {
    let mut input_str = String::new();
    let stdin = stdin();
    stdin.lock().read_to_string(&mut input_str).unwrap();
    let input = handle_input(input_str).unwrap();
    let output = handle_output(input).unwrap();
    println!("{}", output);
}