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

namespace Contest
{
  class Program
  {
    static void Main(string[] args)
    {
      ABC169.E();
    }
    class ABC169
    {
      public static void A()
      {
        Console.WriteLine(Read.Int() * Read.Int());
      }
      public static void B()
      {
        var N = Read.Int();
        var A = Read.LongN();
        if (A.Contains(0)) { Console.WriteLine(0); return; }
        long max = (long)1e18;
        long ans = A[0];
        for(int i = 1; i < N; ++i)
        {
          if ((max + 0) / ans < A[i]) { Console.WriteLine(-1); return; }
          ans *= A[i];
        }
        Console.WriteLine(ans);
      }
      public static void C()
      {
        var A = Read.Long();
        var B = Read.Str();
        var B100 = Convert.ToInt32(B.Split('.')[0]) * 100 + Convert.ToInt32(B.Split('.')[1]);
        Console.WriteLine(A * B100 / 100);
      }
      public static void D()
      {
        var N = Read.Long();
        var fact = Util.Factorize(N);
        long count = 0;
        foreach(var kvp in fact)
        {
          var x = kvp.Value;
          int v = 1;
          while (x >= v)
          {
            count++;
            x -= v;
            v++;
          }
        }
        Console.WriteLine(count);
      }
      public static void E()
      {
        var N = Read.Int();
        var AB = Read.TupleLong(N);

        if (N % 2 == 1)
        {
          Func<int, bool> canBe = X =>
          {
            int countU = 0;
            int countD = 0;
            int countB = 0;
            foreach (var ab in AB)
            {
              if (ab.Item1 > X) { countD++; }
              else if (ab.Item2 < X) { countU++; }
              else { countB++; }
            }
            return countD <= N / 2 && countU <= N / 2;
          };
          var midA = AB.Select(x => x.Item1).OrderBy(x => x).ElementAt(N / 2);
          int maxX = -1, minX = -1;
          int min = 0;
          int max = (int)midA;
          while(min + 1 < max)
          {
            var mid = (min + max) / 2;
            if (canBe(mid))
            {
              max = mid;
            }
            else
            {
              min = mid;
            }
          }
          minX = max;
          min = (int)midA;
          max = (int)1e9 + 1;
          while (min + 1 < max)
          {
            var mid = (min + max) / 2;
            if (canBe(mid))
            {
              min = mid;
            }
            else
            {
              max = mid;
            }
          }
          maxX = min;
          Console.WriteLine(maxX - minX + 1);
        }
        else
        {
          Func<int, bool> canBeMed1 = X =>
          {
            int countU = 0;
            int countD = 0;
            int countB = 0;
            foreach (var ab in AB)
            {
              if (ab.Item1 > X) { countU++; }
              else if (ab.Item2 < X) { countD++; }
              else { countB++; }
            }
            return countD < N / 2 && countU <= N / 2;
          };
          Func<int, bool> canBeMed2 = X =>
          {
            int countU = 0;
            int countD = 0;
            int countB = 0;
            foreach (var ab in AB)
            {
              if (ab.Item1 > X) { countU++; }
              else if (ab.Item2 < X) { countD++; }
              else { countB++; }
            }
            return countD <= N / 2 && countU < N / 2;
          };
          var sortedA = AB.Select(x => x.Item1).OrderBy(x => x).ToArray();
          var med1 = sortedA[N / 2 - 1];
          var med2 = sortedA[N / 2];

          int maxX1 = -1, minX1 = -1, maxX2 = -1, minX2 = -1;
          {
            int min = 0;
            int max = (int)med1;
            while (min + 1 < max)
            {
              var mid = (min + max) / 2;
              if (canBeMed1(mid))
              {
                max = mid;
              }
              else
              {
                min = mid;
              }
            }
            minX1 = max;
            min = (int)med1;
            max = (int)1e9 + 1;
            while (min + 1 < max)
            {
              var mid = (min + max) / 2;
              if (canBeMed1(mid))
              {
                min = mid;
              }
              else
              {
                max = mid;
              }
            }
            maxX1 = min;
            
            min = 0;
            max = (int)med2;
            while (min + 1 < max)
            {
              var mid = (min + max) / 2;
              if (canBeMed2(mid))
              {
                max = mid;
              }
              else
              {
                min = mid;
              }
            }
            minX2 = max;
            min = (int)med2;
            max = (int)1e9 + 1;
            while (min + 1 < max)
            {
              var mid = (min + max) / 2;
              if (canBeMed2(mid))
              {
                min = mid;
              }
              else
              {
                max = mid;
              }
            }
            maxX2 = min;
          }
          Console.WriteLine((maxX1 + maxX2 - minX1 - minX2) + 1);
        }
      }
      public static void F()
      {

      }
    }

    class Util
    {
      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 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 class PriorityQueue<T> where T : IComparable
      {
        private IComparer<T> _comparer = null; private bool _isAsc = true; private T[] _heap; private int _sz = 0;
        public PriorityQueue(int maxSize, IComparer<T> comparer) { _heap = new T[maxSize]; _comparer = comparer; }
        public PriorityQueue(int maxSize, bool isAsc = true) { _heap = new T[maxSize]; _isAsc = isAsc; }
        private int Compare(T x, T y) { if (_comparer != null) { return _comparer.Compare(x, y); } return _isAsc ? x.CompareTo(y) : y.CompareTo(x); }
        public void Push(T x) { var i = _sz++; while (i > 0) { var p = (i - 1) / 2; if (Compare(_heap[p], x) <= 0) { break; } _heap[i] = _heap[p]; i = p; } _heap[i] = x; }
        public T Pop() { T ret = _heap[0]; T x = _heap[--_sz]; int i = 0; while (i * 2 + 1 < _sz) { int a = i * 2 + 1; int b = i * 2 + 2; if (b < _sz && Compare(_heap[b], _heap[a]) < 0) { a = b; } if (Compare(_heap[a], x) >= 0) { break; } _heap[i] = _heap[a]; i = a; } _heap[i] = x; return ret; }
        public int Count() { return _sz; }
        public T Peek() { return _heap[0]; }
        public bool Contains(T x) { for (int i = 0; i < _sz; i++) if (x.Equals(_heap[i])) return true; return false; }
      }
      public class BIT
      {
        int N; long[] array;
        public BIT(int m) { for (int n = 1; ; n *= 2) { if (n >= m) { N = n; array = new long[N + 1]; break; } } }
        public void Add(int idx, int v) { for (int x = idx; x <= N; x += x & -x) { array[x] += v; } }
        public long Sum(int idx) { long ret = 0; for (int x = idx; x > 0; x -= x & -x) { ret += array[x]; } return ret; }
      }
      public static bool IsPrime(long x)
      {
        var fact = Factorize(x);
        return fact.Count == 1 && fact.Values.ElementAt(0) == 1;
      }
      public static Dictionary<long, int> Factorize(long x)
      {
        var dict = new Dictionary<long, int>();
        long minp = 2;
        while (x > 1)
        {
          bool ok = false;
          for (long p = minp; p * p <= x; ++p)
          {
            if (x % p == 0)
            {
              if (!dict.ContainsKey(p))
              {
                dict.Add(p, 0);
              }
              dict[p]++;
              minp = p;
              x /= p;
              ok = true;
              break;
            }
          }
          if (!ok)
          {
            if (!dict.ContainsKey(x)) { dict.Add(x, 0); }
            dict[x]++;
            break;
          }
        }
        return dict;
      }

    }


    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;
}
}
    }
}


Measured memory_bytes: 40172