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 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 {
    let n = d.len();
    let mut max_diff = INF;
    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]);
            }
        }
    }
    max_diff
}

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

fn main() {
    input! {
        n: usize,
        mut d: [usize; n],
    }
    d.push(0);
    let mut count = HashMap::new();
    for &di in &d {
        *count.entry(di).or_insert(0) += 1;
    }
    let mut one = HashSet::new();
    let mut two = HashSet::new();
    for (&dk, &count) in count.iter() {
        if count > 2 {
            println!("0");
            return;
        } else if count == 2 {
            two.insert(dk);
        } else if count == 1 {
            one.insert(dk);
        }
    }
    let mut y = vec![];
    let mut checked = HashSet::new();
    for i in 0..=n {
        if two.contains(&d[i]) && !checked.contains(&d[i]) {
            checked.insert(d[i]);
            d[i] = reverse(d[i]);
        } else if one.contains(&d[i]) {
            y.push(i)
        }
    }
    // eprintln!("{:?} {:?}", one, two);
    // eprintln!("{:?}", d);
    let m = y.len();
    let mut e = d.clone();
    let mut result = min_diff(&d);
    for x in 0..2usize.pow(m as u32) {
        for i in 0..m {
            if x & 1 << i > 0 {
                e[y[i]] = reverse(d[y[i]]);
            } else {
                e[y[i]] = d[y[i]];
            }
            result = max(result, min_diff(&e));
        }
    }
    println!("{}", result);
}
*/

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