Problem:
Score : 600 points

Problem Statement

Nagase is a top student in high school. One day, she's analyzing some properties of special sets of positive integers.

She thinks that a set S = \{a_{1}, a_{2}, ..., a_{N}\} of distinct positive integers is called special if for all 1 \leq i \leq N, the gcd (greatest common divisor) of a_{i} and the sum of the remaining elements of S is not 1.

Nagase wants to find a special set of size N. However, this task is too easy, so she decided to ramp up the difficulty. Nagase challenges you to find a special set of size N such that the gcd of all elements are 1 and the elements of the set does not exceed 30000.

Constraints

3 \leq N \leq 20000

Input

Input is given from Standard Input in the following format:

N

Output

Output N space-separated integers, denoting the elements of the set S. S must satisfy the following conditions :

The elements must be distinct positive integers not exceeding 30000.

The gcd of all elements of S is 1, i.e. there does not exist an integer d > 1 that divides all elements of S.

S is a special set.

If there are multiple solutions, you may output any of them. The elements of S may be printed in any order. It is guaranteed that at least one solution exist under the given contraints.

Sample Input 1

3

Sample Output 1

2 5 63

\{2, 5, 63\} is special because gcd(2, 5 + 63) = 2, gcd(5, 2 + 63) = 5, gcd(63, 2 + 5) = 7. Also, gcd(2, 5, 63) = 1. Thus, this set satisfies all the criteria.

Note that \{2, 4, 6\} is not a valid solution because gcd(2, 4, 6) = 2 > 1.

Sample Input 2

4

Sample Output 2

2 5 20 63

\{2, 5, 20, 63\} is special because gcd(2, 5 + 20 + 63) = 2, gcd(5, 2 + 20 + 63) = 5, gcd(20, 2 + 5 + 63) = 10, gcd(63, 2 + 5 + 20) = 9. Also, gcd(2, 5, 20, 63) = 1. Thus, this set satisfies all the criteria.

Solution in Rust (1.15.1) (judge verdict: Time Limit Exceeded)

use std::io;

const MAX_ELEMENT: i64 = 30000;

fn main() {
    let mut line = String::new();
    io::stdin().read_line(&mut line).unwrap();
    let inputs = line.as_str().split(' ').collect::<Vec<&str>>();
    let input0 = inputs[0].trim().parse::<usize>().unwrap();

    print!(
        "{}",
        special_set(input0)
            .into_iter()
            .map(|v| format!("{}", v))
            .collect::<Vec<String>>()
            .join(" ")
    );
}

fn special_set(n: usize) -> Vec<i64> {
    let base: Vec<i64> = vec![2, 5];
    for v in (base.last().unwrap() + 1) * (n as i64 - 2)..(MAX_ELEMENT + 1) * (n as i64 - 2) {
        if is_special_set(&[2, 5, v]) {
            match search_special_set(n - 2, vec![2, 5], v, v + 7) {
                Some(set) => return set,
                None => (),
            };
        }
    }
    panic!("not found");
}

fn search_special_set(n: usize, base: Vec<i64>, sum: i64, condition: i64) -> Option<Vec<i64>> {
    if n == 1 {
        if *base.last().unwrap() < sum && sum < MAX_ELEMENT && gcd(condition - sum, sum) > 1 {
            Some(base.clone().into_iter().chain(vec![sum]).collect())
        } else {
            None
        }
    } else {
        for v in base.last().unwrap() + 1..MAX_ELEMENT + 1 {
            if sum > v && gcd(condition - v, v) > 1 {
                match search_special_set(
                    n - 1,
                    base.clone().into_iter().chain(vec![v]).collect(),
                    sum - v,
                    condition,
                ) {
                    Some(set) => return Some(set),
                    None => (),
                };
            }
        }
        None
    }
}

fn is_special_set(set: &[i64]) -> bool {
    let mut flag = true;
    for i in 0..set.len() {
        let sum = set.iter()
            .enumerate()
            .fold(0, |acc, (j, v)| if j == i { acc } else { acc + v });
        flag &= gcd(sum, set[i]) > 1;
    }
    flag
}

fn gcd(a: i64, b: i64) -> i64 {
    assert!(a >= 0 && b >= 0);
    let (m, n) = if a >= b { (a, b) } else { (b, a) };
    if n == 0 {
        m
    } else {
        gcd(n, m % n)
    }
}

#[cfg(test)]
mod test {
    use super::*;

    fn assert(input: usize) {
        let output = special_set(input);
        assert!(
            is_special_set(&output),
            "{:?} is not a special set",
            &output
        )
    }

    #[test]
    fn test_special_set_3() {
        assert(3);
    }

    #[test]
    fn test_special_set_4() {
        assert(4);
    }

    #[test]
    fn test_gcd() {
        assert_eq!(gcd(6, 9), 3);
    }

    #[test]
    fn test_is_special_set_2_5_63_should_be_true() {
        assert!(is_special_set(&[2, 5, 63]));
    }

    #[test]
    fn test_is_special_set_2_4_7_should_be_false() {
        assert!(!is_special_set(&[2, 4, 7]));
    }
}