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: Accepted)

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> {
    if n == 3 {
        vec![2, 5, 63]
    } else if n == 4 {
        vec![2, 5, 20, 63]
    } else {
        let mut set = Vec::<i64>::new();
        for i in 3..MAX_ELEMENT + 1 {
            if i % 2 == 0 || i % 3 == 0 || i % 5 == 0 {
                set.push(i);
            }
            if set.len() == n - 1 {
                break;
            }
        }

        let mut sum = set.iter().fold(0, |acc, v| acc + v);
        if sum % 2 != 0 {
            set[0] = 2;
            sum -= 1;
        }

        let last = if sum % 3 != 0 && sum % 5 == 0 {
            let mut v = 0;
            for k in 1..3 {
                if (MAX_ELEMENT - 30 + 10 * k) % 3 == 3 - (sum % 3) {
                    v = MAX_ELEMENT - 30 + 10 * k;
                    break;
                }
            }
            v
        } else if sum % 3 == 0 && sum % 5 != 0 {
            let mut v = 0;
            for k in 1..5 {
                if (MAX_ELEMENT - 30 + 6 * k) % 5 == 5 - (sum % 5) {
                    v = MAX_ELEMENT - 30 + 6 * k;
                    break;
                }
            }
            v
        } else if sum % 3 != 0 && sum % 5 != 0 {
            let mut v = 0;
            for k in 1..15 {
                if (MAX_ELEMENT - 30 + 2 * k) % 5 == 5 - (sum % 5)
                    && (MAX_ELEMENT - 30 + 2 * k) % 3 == 3 - (sum % 3)
                {
                    v = MAX_ELEMENT - 30 + 2 * k;
                    break;
                }
            }
            v
        } else {
            MAX_ELEMENT
        };
        set.push(last);
        set
    }
}

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 {
    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_special_set_5() {
        assert(5);
    }

    #[test]
    fn test_special_set_103() {
        assert(103);
    }

    #[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]));
    }
}