Problem:
Score : 200 points

Problem Statement

It is only six months until Christmas, and AtCoDeer the reindeer is now planning his travel to deliver gifts.

There are N houses along TopCoDeer street. The i-th house is located at coordinate a_i. He has decided to deliver gifts to all these houses.

Find the minimum distance to be traveled when AtCoDeer can start and end his travel at any positions.

Constraints

1 ≤ N ≤ 100

0 ≤ a_i ≤ 1000

a_i is an integer.

Input

Input is given from Standard Input in the following format:

N
a_1 a_2 ... a_N

Output

Print the minimum distance to be traveled.

Sample Input 1

4
2 3 7 9

Sample Output 1

7

The travel distance of 7 can be achieved by starting at coordinate 9 and traveling straight to coordinate 2.

It is not possible to do with a travel distance of less than 7, and thus 7 is the minimum distance to be traveled.

Sample Input 2

8
3 1 4 1 5 9 2 6

Sample Output 2

8

There may be more than one house at a position.

Solution in C# (Mono-csc 3.5.0) (judge verdict: Accepted)

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

namespace Contest
{
  class Program
  {
    static void Main(string[] args)
    {
      ABC064.B();
    }
    class ABC064
    {
      public static void A()
      {
        var R = Read.Int();
        var G = Read.Int();
        var B = Read.Int();
        Console.WriteLine((G * 10 + B) % 4 == 0 ? "YES" : "NO");
      }
      public static void B()
      {
        var N = Read.Int();
        var A = Read.IntN();
        Console.WriteLine(A.Max() - A.Min());
      }
      public static void C()
      {
        var N = Read.Int();
        var A = Read.IntN();
        var count = new int[9];
        foreach(var a in A) { count[Math.Min(a, 3200) / 400]++; }
        var c = count.Take(8).Count(x => x > 0);
        Console.WriteLine("{0} {1}", Math.Max(1, c), c + count[8]);
      }
      public static void D()
      {
        var N = Read.Int();
        var S = Read.Str();
        int c1 = S.Count(x => x == '(');
        int c2 = S.Count(x => x == ')');
        int x = 0, max = 0;
        foreach(var s in S)
        {
          if (s == '(') { x--; } else { x++; max = Math.Max(max, x); }
        }
        Console.WriteLine("{0}{1}{2}", String.Join("", Enumerable.Range(0, max).Select(x => '(')), S, String.Join("", Enumerable.Range(0, c1 + max - c2).Select(x => ')')));
      }
    }
    class Util
    {
      public static T[,] Gen<T>(int r, int c, T v)
      {
        var matrix = new T[r, c];
        for (int i = 0; i < r; ++i)
        {
          for (int j = 0; j < c; ++j)
          {
            matrix[i, j] = v;
          }
        }
        return matrix;
      }
      public static long[] ASum(long[] array)
      {
        var res = new long[array.Length + 1];
        for (int i = 0; i < array.Length; ++i)
        {
          res[i + 1] = res[i] + array[i];
        }
        return res;
      }
      public static long[,] ASum(long[,] matrix)
      {
        var N = matrix.GetLength(0);
        var M = matrix.GetLength(1);
        var res = new long[N + 1, M + 1];
        for(int i = 0; i < N; ++i)
        {
          for(int j = 0; j < M; ++j)
          {
            res[i + 1, j + 1] = res[i, j + 1] + res[i + 1, j] - res[i, j] + matrix[i, j];
          }
        }
        return res;
      }
      public static Dictionary<T, long> Frequency<T>(T[] array)
      {
        var dict = new Dictionary<T, long>();
        foreach (var a in array)
        {
          if (!dict.ContainsKey(a)) { dict.Add(a, 0); }
          dict[a]++;
        }
        return dict;
      }
      public static long GCD(long a, long b)
      {
        while (b > 0)
        {
          var c = a % b;
          a = b;
          b = c;
        }
        return a;
      }
    }
    class Graph
    {
      public static HashSet<int> ConnectedComponent(Dictionary<int, HashSet<int>> adj, int idx)
      {
        HashSet<int> comp = new HashSet<int>();
        comp.Add(idx);
        List<int> target = new List<int>();
        target.Add(idx);
        while (target.Count > 0)
        {
          List<int> next = new List<int>();
          foreach (var p in target)
          {
            foreach (var f in adj[p])
            {
              if (!comp.Contains(f))
              {
                next.Add(f);
                comp.Add(f);
              }
            }
          }
          target = next;
        }
        return comp;
      }
      public static int[] CalcDistance_OnTree(Dictionary<int, HashSet<int>> adj, int N, int start)
      {
        var dist = Enumerable.Range(0, N + 1).Select(i => -1).ToArray();
        dist[start] = 0;
        Queue<int> queue = new Queue<int>();
        queue.Enqueue(start);
        while (queue.Count > 0)
        {
          var v = queue.Dequeue();
          foreach (var w in adj[v])
          {
            if (dist[w] < 0)
            {
              dist[w] = dist[v] + 1;
              queue.Enqueue(w);
            }
          }
        }
        return dist;
      }
      public static long[] CalcDistance_OnTree(Dictionary<int, Dictionary<int, long>> adj, int N, int start)
      {
        var dist = Enumerable.Range(0, N + 1).Select(i => -1L).ToArray();
        dist[start] = 0;
        Queue<int> queue = new Queue<int>();
        queue.Enqueue(start);
        while (queue.Count > 0)
        {
          var v = queue.Dequeue();
          foreach (var t in adj[v])
          {
            var w = t.Key;
            var c = t.Value;
            if (dist[w] < 0)
            {
              dist[w] = dist[v] + c;
              queue.Enqueue(w);
            }
          }
        }
        return dist;
      }
    }

    static class Read
{
static Queue<string> queue = new Queue<string>();
static void Enqueue() { var ss = Console.ReadLine().Split(' '); foreach (var s in ss) { queue.Enqueue(s); } }
public static int Int() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt32(queue.Dequeue()); }
public static long Long() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt64(queue.Dequeue()); }
public static string Str() { if (queue.Count == 0) { Enqueue(); } return queue.Dequeue(); }
public static int[] IntN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt32(s)).ToArray(); }
public static long[] LongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt64(s)).ToArray(); }
public static ulong[] ULongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToUInt64(s)).ToArray(); }
public static string[] StrN() { return Console.ReadLine().Split(' '); }
public static Tuple<int, int>[] TupleInt(int n) { List<Tuple<int, int>> list = new List<Tuple<int, int>>(); for (int i = 0; i < n; ++i) { var ab = Read.IntN(); list.Add(new Tuple<int, int>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<long, long>[] TupleLong(int n) { List<Tuple<long, long>> list = new List<Tuple<long, long>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<long, long>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<string, string>[] TupleStr(int n) { List<Tuple<string, string>> list = new List<Tuple<string, string>>(); for (int i = 0; i < n; ++i) { var ab = Read.StrN(); list.Add(new Tuple<string, string>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<double, double>[] TupleDouble(int n) { List<Tuple<double, double>> list = new List<Tuple<double, double>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<double, double>(ab[0], ab[1])); } return list.ToArray(); }
public static long[,] LongMatrix(int r, int c) { var mat = new long[r, c]; for (int i = 0; i < r; ++i) { var x = Read.LongN(); for (int j = 0; j < c; ++j) { mat[i, j] = x[j]; } } return mat; }
public static Dictionary<int, HashSet<int>> AdjacencyList(int N, int M, bool isDirectional = false)
{
Dictionary<int, HashSet<int>> dict = new Dictionary<int, HashSet<int>>();
for (int i = 0; i <= N; ++i) { dict.Add(i, new HashSet<int>()); }
        for (int i = 0; i < M; ++i) { var ab = Read.IntN(); if (!dict[ab[0]].Contains(ab[1])) { dict[ab[0]].Add(ab[1]); } if (!isDirectional && !dict[ab[1]].Contains(ab[0])) { dict[ab[1]].Add(ab[0]); } }
        return dict;
}
public static Dictionary<int, Dictionary<int, long>> AdjacencyListWithWeight(int N, int M)
{
Dictionary<int, Dictionary<int, long>> dict = new Dictionary<int, Dictionary<int, long>>(); for (int i = 0; i <= N; ++i) { dict.Add(i, new Dictionary<int, long>()); }
for (int i = 0; i < M; ++i) { var ab = Read.IntN(); dict[ab[0]].Add(ab[1], ab[2]); dict[ab[1]].Add(ab[0], ab[2]); }
return dict;
}
}
    }
}