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: Wrong Answer)

// This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::*;
#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
use std::collections::*;
#[allow(unused_imports)]
use std::f64::consts::*;

#[allow(unused)]
const INF: usize = std::usize::MAX / 4;
#[allow(unused)]
const M: usize = 1000000007;

fn diff(di: usize, dj: usize) -> usize {
    let d = max(di, dj) - min(di, dj);
    min(d, 24 - d)
}

fn min_diff(d: &Vec<usize>) -> (usize, (usize, usize)) {
    let n = d.len();
    let mut max_diff = INF;
    let mut min_index = (0, 0);
    for i in 0..n {
        for j in i + 1..n {
            if diff(d[i], d[j]) < max_diff {
                max_diff = diff(d[i], d[j]);
                min_index = (i, j);
            }
        }
    }
    (max_diff, min_index)
}

fn reverse(d: usize) -> usize {
    24 - d
}

fn main() {
    input! {
        n: usize,
        mut d: [usize; n],
    }
    d.push(0);
    let result = loop {
        let (d0, (i0, j0)) = min_diff(&d);
        d[i0] = reverse(d[i0]);
        let (d1, _) = min_diff(&d);
        d[i0] = reverse(d[i0]);
        d[j0] = reverse(d[j0]);
        let (d2, _) = min_diff(&d);
        d[j0] = reverse(d[j0]);
        // eprintln!("{} {} {} {} {}", d0, d1, d2, i0, j0);
        if d1 <= d0 && d2 <= d0 {
            break d0;
        }
        if d1 > d2 {
            d[i0] = reverse(d[i0]);
        } else {
            d[j0] = reverse(d[j0]);
        }
    };
    println!("{}", result);
}
*/

fn main() {
    let exe = "/tmp/bin07F88DAC";
    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>";