Problem:
Score : 500 points

Problem 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.

Constraints

1 \leq N \leq 50

0 \leq D_i \leq 12

All input values are integers.

Input

Input is given from Standard Input in the following format:

N
D_1 D_2 ... D_N

Output

Print the maximum possible value of s.

Sample Input 1

3
7 12 8

Sample Output 1

4

For example, consider the situation where it is 7, 12 and 16 o'clock in each person's city at the moment when it is 0 o'clock in Takahashi's city. In this case, the time gap between the second and third persons' cities is 4 hours.

Sample Input 2

2
11 11

Sample Output 2

2

Sample Input 3

1
0

Sample Output 3

0

Note that Takahashi himself is also a participant.

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

// This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
use competitive::prelude::*;

#[proconio::fastout]
fn main() {
    input! {
        n: usize,
        d: [i32; n],
    }
    let mut a = [0; 13];
    for i in 0..n {
        a[d[i] as usize] += 1;
    }
    let mut same_place = false;
    for i in 0..a.len() {
        if a[i] >= 3 {
            same_place = true;
        }
    }
    if a[0] > 0 {
        same_place = true;
    }
    if a[12] >= 2 {
        same_place = true;
    }
    if same_place {
        echo!(0);
        return;
    }
    let mut b = vec![];
    for i in 0..a.len() {
        for _ in 0..a[i] {
            b.push(i);
        }
    }
    if b.len() > 11 {
        echo!(1);
        return;
    }
    let mut ans = 0;
    for i in 0..1 << b.len() {
        let mut v = vec![];
        for j in 0..b.len() {
            if ((i >> j) & 1) == 1 {
                v.push(b[j]);
            }
        }
        for j in (0..b.len()).rev() {
            if ((i >> j) & 1) != 1 {
                v.push(24 - b[j]);
            }
        }
        let mut m = min(v[0], 24 - v[0]);
        m = min(m, min(v[v.len() - 1], 24 - v[v.len() - 1]));
        for j in 0..v.len() - 1 {
            m = min(m, v[j + 1] - v[j]);
        }
        ans = max(ans, m);
    }
    echo!(ans);
}
*/

fn main() {
    let exe = "/tmp/bin6897BD80";
    std::io::Write::write_all(&mut std::fs::File::create(exe).unwrap(), &decode(BIN)).unwrap();
    std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    std::process::exit(std::process::Command::new(exe).status().unwrap().code().unwrap())
}

fn decode(v: &str) -> Vec<u8> {
    let mut ret = vec![];
    let mut buf = 0;
    let mut tbl = vec![64; 256];
    for i in 0..64 { tbl[TBL[i] as usize] = i as u8; }
    for (i, c) in v.bytes().filter_map(|c| { let c = tbl[c as usize]; if c < 64 { Some(c) } else { None } }).enumerate() {
        match i % 4 {
            0 => buf = c << 2,
            1 => { ret.push(buf | c >> 4); buf = c << 4; }
            2 => { ret.push(buf | c >> 2); buf = c << 6; }
            3 => ret.push(buf | c),
            _ => unreachable!(),
        }
    }
    ret
}

const TBL: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const BIN: &'static str = "<base64-encoded ELF executable removed>";