Given an integer **N**, the task is to print **N** integers **≤ 10 ^{9}** such that no two consecutive of these integers are co-prime and every 3 consecutive are co-prime.

**Examples:**

Input:N = 3

Output:6 15 10

Input:N = 4

Output:6 15 35 14

**Approach:**

- We can just multiply consecutive primes and for the last number just multiply the
**gcd(last, last-1) * 2**. We do this so that the**(n – 1)**number,_{th}**nth**and**1st**number can also follow the property mentioned in the problem statement. - Another important part of the problem is the fact that the numbers should be
**≤ 10**. If you just multiply consecutive prime numbers, after around 3700 numbers the value will cross 10^{9}^{9}. So we need to only use those prime numbers whose product wont cross 10^{9}. - To do this in an efficient way, consider a small number of primes say the first 550 primes and select them in a way such that on making a product no number gets repeated. We first choose every prime consecutively and then choose the primes with an interval of 2 and then 3 and so on, doing that we already make sure that no number gets repeated.

So we will select

5, 11, 17, …

Next time, we can start with 7 and select,

7, 13, 19, …

Below is the implementation of the above approach:

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `#define limit 1000000000 ` `#define MAX_PRIME 2000000 ` `#define MAX 1000000 ` `#define I_MAX 50000 ` ` ` `map<` `int` `, ` `int` `> mp; ` ` ` `int` `b[MAX]; ` `int` `p[MAX]; ` `int` `j = 0; ` `bool` `prime[MAX_PRIME + 1]; ` ` ` `// Function to generate Sieve of ` `// Eratosthenes ` `void` `SieveOfEratosthenes(` `int` `n) ` `{ ` ` ` `memset` `(prime, ` `true` `, ` `sizeof` `(prime)); ` ` ` ` ` `for` `(` `int` `p = 2; p * p <= n; p++) { ` ` ` ` ` `// If prime[p] is not changed, ` ` ` `// then it is a prime ` ` ` `if` `(prime[p] == ` `true` `) { ` ` ` `for` `(` `int` `i = p * p; i <= n; i += p) ` ` ` `prime[i] = ` `false` `; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Add the prime numbers to the array b ` ` ` `for` `(` `int` `p = 2; p <= n; p++) { ` ` ` `if` `(prime[p]) { ` ` ` `b[j++] = p; ` ` ` `} ` ` ` `} ` `} ` ` ` `// Function to return the gcd of a and b ` `int` `gcd(` `int` `a, ` `int` `b) ` `{ ` ` ` `if` `(b == 0) ` ` ` `return` `a; ` ` ` `return` `gcd(b, a % b); ` `} ` ` ` `// Function to print the required ` `// sequence of integers ` `void` `printSeries(` `int` `n) ` `{ ` ` ` `SieveOfEratosthenes(MAX_PRIME); ` ` ` ` ` `int` `i, g, k, l, m, d; ` ` ` `int` `ar[I_MAX + 2]; ` ` ` ` ` `for` `(i = 0; i < j; i++) { ` ` ` `if` `((b[i] * b[i + 1]) > limit) ` ` ` `break` `; ` ` ` ` ` `// Including the primes in a series ` ` ` `// of primes which will be later ` ` ` `// multiplied ` ` ` `p[i] = b[i]; ` ` ` ` ` `// This is done to mark a product ` ` ` `// as existing ` ` ` `mp[b[i] * b[i + 1]] = 1; ` ` ` `} ` ` ` ` ` `// Maximum number of primes that we consider ` ` ` `d = 550; ` ` ` `bool` `flag = ` `false` `; ` ` ` ` ` `// For different interval ` ` ` `for` `(k = 2; (k < d - 1) && !flag; k++) { ` ` ` ` ` `// For different starting index of jump ` ` ` `for` `(m = 2; (m < d) && !flag; m++) { ` ` ` ` ` `// For storing the numbers ` ` ` `for` `(l = m + k; l < d; l += k) { ` ` ` ` ` `// Checking for occurrence of a ` ` ` `// product. Also checking for the ` ` ` `// same prime occurring consecutively ` ` ` `if` `(((b[l] * b[l + k]) < limit) ` ` ` `&& (l + k) < d && p[i - 1] != b[l + k] ` ` ` `&& p[i - 1] != b[l] && mp[b[l] * b[l + k]] != 1) { ` ` ` `if` `(mp[p[i - 1] * b[l]] != 1) { ` ` ` ` ` `// Including the primes in a ` ` ` `// series of primes which will ` ` ` `// be later multiplied ` ` ` `p[i] = b[l]; ` ` ` `mp[p[i - 1] * b[l]] = 1; ` ` ` `i++; ` ` ` `} ` ` ` `} ` ` ` ` ` `if` `(i >= I_MAX) { ` ` ` `flag = ` `true` `; ` ` ` `break` `; ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` ` ` `for` `(i = 0; i < n; i++) ` ` ` `ar[i] = p[i] * p[i + 1]; ` ` ` ` ` `for` `(i = 0; i < n - 1; i++) ` ` ` `cout << ar[i] << ` `" "` `; ` ` ` ` ` `g = gcd(ar[n - 1], ar[n - 2]); ` ` ` `cout << g * 2 << endl; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `int` `n = 4; ` ` ` ` ` `printSeries(n); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

6 15 35 14

## Recommended Posts:

- 1 to n bit numbers with no consecutive 1s in binary representation.
- Expressing factorial n as sum of consecutive numbers
- Fibbinary Numbers (No consecutive 1s in binary)
- Express a number as sum of consecutive numbers
- Prove that atleast one of three consecutive even numbers is divisible by 6
- Check if a number can be expressed as a sum of consecutive numbers
- Find the number of consecutive zero at the end after multiplying n numbers
- Find the prime numbers which can written as sum of most consecutive primes
- Count ways to express a number as sum of consecutive numbers
- Generate a list of n consecutive composite numbers (An interesting method)
- Print N lines of 4 numbers such that every pair among 4 numbers has a GCD K
- Composite XOR and Coprime AND
- Largest number less than or equal to N/2 which is coprime to N
- Finding a Non Transitive Coprime Triplet in a Range
- Numbers less than N which are product of exactly two distinct prime numbers