output_description: Print the maximum possible value of s.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      D_1 D_2 ... D_N
attempt: #include <iostream>
  #include <bits/stdc++.h>
  
  #include <ext/pb_ds/assoc_container.hpp>
  #include <ext/pb_ds/tree_policy.hpp>
  
  #define rep(i, n) for (int i = 0; i < (int)(n); i++)
  #define rep_r(i, n) for (int i = n - 1; i >= 0; i--)
  #define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
  #define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
  #define all(x) (x).begin(), (x).end()
  #define SZ(x) ((ll)(x).size())
  #define bit(n) (1LL << (n))
  #define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
  
  #define INF bit(60)
  #define pb push_back
  #define mod 1000000007
  
  using namespace std;
  using uif = uint_fast64_t;
  using ll = long long int;
  using tTree = __gnu_pbds::tree<ll, __gnu_pbds::null_type, less<ll>, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update>;
  
  ll dx[4] = {1, 0, -1, 0};
  ll dy[4] = {0, 1, 0, -1};
  
  #define FACSIZE 200002
  
  ll invfac[FACSIZE];
  ll fac[FACSIZE];
  
  template <class T>
  bool chmax(T &, const T &);
  template <class T>
  bool chmin(T &, const T &);
  ll gcd(ll, ll);
  ll powLL(ll x, ll y);
  
  ll mod_pow(ll, ll);
  ll mod_add(ll, ll);
  ll mod_mul(ll, ll);
  ll mod_div(ll, ll);
  ll comb(ll, ll);
  void make_fact(ll);
  void make_invfact(ll);
  void fact_init();
  
  int main(void)
  {
    ll n;
    cin >> n;
    vector<ll> D(n);
    rep(i, n) cin >> D[i];
  
    vector<ll> vec;
    vec.push_back(0);
    vec.push_back(D[0]);
  
    for (ll i = 1; i < n; i++)
    {
      ll d1, d2;
      d1 = D[i];
      d2 = (24 - D[i]) % 24;
      ll min1 = 100, min2 = 100;
      for (auto x : vec)
      {
        ll diff = abs(x - d1);
        min1 = min(diff, min1);
      }
      for (auto x : vec)
      {
        ll diff = abs(x - d2);
        min2 = min(diff, min2);
      }
      if (min1 < min2)
        vec.push_back(d2);
      else
        vec.push_back(d1);
    }
  
    ll ans = 100;
    rep(i, n + 1)
    {
      for (ll j = i + 1; j < n + 1; j++)
      {
        ans = min(ans, abs(vec[i] - vec[j]) % 24);
      }
    }
    cout << ans << endl;
  
    return 0;
  }
  
  ll mod_pow(ll x, ll r)
  {
    if (r == 0)
      return 1;
    else if (r == 1)
      return x % mod;
    else if (r % 2 == 0)
    {
      ll t = mod_pow(x, r / 2) % mod;
      return mod_mul(t, t);
    }
    else
    {
      ll t = mod_pow(x, r / 2) % mod;
      ll k = mod_mul(t, t);
      return (k % mod) * (x % mod);
    }
  }
  ll mod_add(ll a, ll b)
  {
    return ((a % mod) + (b % mod)) % mod;
  }
  
  ll mod_mul(ll a, ll b)
  {
    return ((a % mod) * (b % mod)) % mod;
  }
  
  ll mod_div(ll a, ll b)
  {
    return mod_mul(a, mod_pow(b, mod - 2));
  }
  
  void fact_init()
  {
    make_fact(FACSIZE - 1);
    make_invfact(FACSIZE);
  }
  
  void make_fact(ll n)
  {
    fac[0] = 1;
    rep(i, n)
    {
      fac[i + 1] = mod_mul(fac[i], i + 1);
    }
  }
  
  void make_invfact(ll n)
  {
    invfac[n] = mod_pow(fac[n], mod - 2);
    for (int i = n - 1; i >= 0; i--)
    {
      invfac[i] = mod_mul(invfac[i + 1], i + 1);
    }
  }
  
  ll comb(ll n, ll r)
  {
  
    return mod_mul(mod_mul(fac[n], invfac[r]), invfac[n - r]);
  }
  template <class T>
  bool chmax(T &a, const T &b)
  {
    if (a < b)
    {
      a = b;
      return 1;
    }
    return 0;
  }
  template <class T>
  bool chmin(T &a, const T &b)
  {
    if (b < a)
    {
      a = b;
      return 1;
    }
    return 0;
  }
  
  ll qp(ll a, ll b)
  {
    ll ans = 1LL;
    do
    {
      if (b & 1LL)
        ans = 1LL * mod_mul(ans, a) % mod;
      a = 1LL * mod_mul(a, a) % mod;
    } while (b >>= 1LL);
    return ans;
  }
  ll qp(ll a, ll b, ll mo)
  {
    ll ans = 1LL;
    do
    {
      if (b & 1LL)
        ans = 1LL * (ans % mo) * (a % mo);
      a = 1LL * (a % mo) * (a % mo);
    } while (b >>= 1LL);
    return ans;
  }
  ll gcd(ll a, ll b)
  {
    return b ? gcd(b, a % b) : a;
  }
  ll powLL(ll x, ll y)
  {
    ll ans = 1LL;
    for (ll i = 0LL; i < y; i++)
      ans *= x;
    return ans;
  }
problem_description: Statement
  
  In CODE FESTIVAL XXXX, there are N+1 participants from all over the world,
  including Takahashi.
  
  Takahashi checked and found that the _time gap_ (defined below) between the
  local times in his city and the i-th person's city was D_i hours. The time gap
  between two cities is defined as follows. For two cities A and B, if the local
  time in city B is d o'clock at the moment when the local time in city A is 0
  o'clock, then the time gap between these two cities is defined to be
  min(d,24-d) hours. Here, we are using 24-hour notation. That is, the local
  time in the i-th person's city is either d o'clock or 24-d o'clock at the
  moment when the local time in Takahashi's city is 0 o'clock, for example.
  
  Then, for each pair of two people chosen from the N+1 people, he wrote out the
  time gap between their cities. Let the smallest time gap among them be s
  hours.
  
  Find the maximum possible value of s.
samples: [{"input": "3\n    7 12 8", "output": "4\n    \n\nFor example, consider the situation where it is 7, 12 and 16 o'clock in each\nperson's city at the moment when it is 0 o'clock in Takahashi's city. In this\ncase, the time gap between the second and third persons' cities is 4 hours.\n\n* * *"}, {"input": "2\n    11 11", "output": "2\n    \n\n* * *"}, {"input": "1\n    0", "output": "0\n    \n\nNote that Takahashi himself is also a participant."}]