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 C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Linq;
using System.Collections.Generic;
using System.Text;

namespace Program
{
    interface Output
    {
        void Write(object str);
        void WriteLine(object str);
    }

    interface Input
    {
        int NextInt();
        string NextString();
    }

    class Console_ : Input, Output
    {
        Queue<string> param = new Queue<string>();
        int Input.NextInt()
        {
            if (param.Count == 0)
            {
                foreach (var item in Console.ReadLine().Split(' '))
                {
                    param.Enqueue(item);
                }
            }
            return int.Parse(param.Dequeue());
        }
        string Input.NextString()
        {
            if (param.Count == 0)
            {
                foreach (var item in Console.ReadLine().Split(' '))
                {
                    param.Enqueue(item);
                }
            }
            return param.Dequeue();
        }
        void Output.Write(object str) => System.Console.Write(str.ToString());
        void Output.WriteLine(object str) => System.Console.WriteLine(str.ToString());
    }

    class Debug_ : Input, Output
    {
        int i = 0;
        StringBuilder sb = new StringBuilder();
        public object[] data;
        public string result
        {
            get
            {
                return sb.ToString();
            }
            private set { }
        }
        int Input.NextInt() => (int)data[i++];
        string Input.NextString() => (string)data[i++];

        public void Write(object str) => sb.Append(str.ToString());

        public void WriteLine(object str) => sb.AppendLine(str.ToString());
    }

    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length > 0 && args[0] == "debug")
            {
                try
                {
                    Action<string, object[], string[]> test = (name, input, output) =>
                    {

                        var debug = new Debug_();
                        debug.data = input;
                        new Solver(debug, debug).Run();
                        var res = debug.result.Split("\r\n".ToArray()).ToArray();
                        for (int i = 0; i < res.Length; ++i)
                        {
                            if (i >= output.Length)
                            {
                                if (res[i].Trim() != "")
                                {
                                    Console.WriteLine("failed: " + name);
                                    return;
                                }
                            }
                            else
                            {
                                if (res[i] != output[i])
                                {
                                    Console.WriteLine("failed: " + name);
                                    return;
                                }
                            }
                        }
                        return;
                    };

                    test("case1",
                         new object[] { 3,
10,2,5,
6,3,4 },
                         new string[] { "5" });
                    test("case2",
                         new object[] { 4,
13,21,6,19,
11,30,6,15,
 },
                         new string[] { "6" });
                    test("case3",
                         new object[] { 1,
1,
50,
 },
                         new string[] { "0" });
                }
                finally
                {
                    Console.WriteLine("end");
                    Console.ReadLine();
                }
            }
            else
            {
                new Solver(new Console_(), new Console_()).Run();
            }
        }
    }

    class Solver
    {
        Input input;
        Output output;
        public Solver(Input input, Output output)
        {
            this.input = input;
            this.output = output;
        }

        public void Run()
        {
            var N = input.NextInt();
            var Vary = new int[N];
            for (int i = 0; i < N; ++i)
            {
                Vary[i] = input.NextInt();
            }
            for (int i = 0; i < N; ++i)
            {
                Vary[i] -= input.NextInt();
                if (Vary[i] < 0)
                {
                    Vary[i] = 0;
                }
            }

            output.WriteLine(Vary.Sum());
        }
    }
}