# Generate a list of n consecutive composite numbers (An interesting method)

Given a number n, generate a list of n composite numbers.

Examples:

```Input : 5
Output : 122, 123, 124, 125

Input : 10
Output : 3628802, 3628803, 3628804, 3628805, 3628806,
3628807, 3628808, 3628809, 3628810
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The idea here is using the properties of . Since , then numbers , all divide . Therefore is divisible by 2, is divisible by 3 ….. is divisible by n. And by above pattern they are consecutive composites.

We find (n+1)!, then we print numbers (n+1)! + 2, (n+1)! + 3, …. (n+1)! + (n + 1).

Below is the implementation of above approach:

## C++

 `// CPP program to print n consecutive composite ` `// numbers. ` `#include ` `using` `namespace` `std; ` ` `  `// function to find factorial of given  ` `// number ` `unsigned ``long` `long` `int` `factorial(unsigned ``int` `n) ` `{     ` `    ``unsigned ``long` `long` `int` `res = 1; ` `    ``for` `(``int` `i=2; i<=n; i++) ` `        ``res *= i; ` `    ``return` `res; ` `} ` ` `  `// Prints n consecutive numbers.  ` `void` `printNComposite(``int` `n) ` `{ ` `    ``unsigned ``long` `long` `int` `fact = factorial(n+1); ` `    ``for` `(``int` `i = 2; i <= n+1; ++i)  ` `        ``cout << fact + i << ``" "``;  ` `} ` ` `  `// Driver program to test above function ` `int` `main() ` `{ ` `    ``int` `n = 4; ` `    ``printNComposite(n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to print n consecutive composite  ` `// numbers ` ` `  `class` `GFG { ` ` `  `// function to find factorial of given  ` `// number  ` `    ``static` `long` `factorial(``int` `n) { ` `        ``long` `res = ``1``; ` `        ``for` `(``int` `i = ``2``; i <= n; i++) { ` `            ``res *= i; ` `        ``} ` `        ``return` `res; ` `    ``} ` ` `  `// Prints n consecutive numbers.  ` `    ``static` `void` `printNComposite(``int` `n) { ` `        ``long` `fact = factorial(n + ``1``); ` `        ``for` `(``int` `i = ``2``; i <= n + ``1``; ++i) { ` `            ``System.out.print(fact + i + ``" "``); ` `        ``} ` `    ``} ` ` `  `// Driver program to test above function  ` `    ``public` `static` `void` `main(String[] args) { ` `        ``int` `n = ``4``; ` `        ``printNComposite(n); ` ` `  `    ``} ` `} `

/div>

## Python3

# Python3 program to print n consecutive
# composite numbers.

# function to find factorial
# of given number
def factorial( n):

res = 1;
for i in range(2, n + 1):
res *= i;
return res;

# Prints n consecutive numbers.
def printNComposite(n):
fact = factorial(n + 1);
for i in range(2, n + 2):
print(fact + i, end = ” “);

# Driver Code
n = 4;
printNComposite(n);

# This code is contributed by mits

## C#

 `// C# program to print n consecutive composite  ` `// numbers ` `using` `System; ` `                     `  `public` `class` `Program{ ` `  `  `// function to find factorial of given  ` `// number  ` `    ``static` `long` `factorial(``int` `n) { ` `        ``long` `res = 1; ` `        ``for` `(``int` `i = 2; i <= n; i++) { ` `            ``res *= i; ` `        ``} ` `        ``return` `res; ` `    ``} ` `  `  `// Prints n consecutive numbers.  ` `    ``static` `void` `printNComposite(``int` `n) { ` `        ``long` `fact = factorial(n + 1); ` `        ``for` `(``int` `i = 2; i <= n + 1; ++i) { ` `            ``Console.Write(fact + i + ``" "``); ` `        ``} ` `    ``} ` `  `  `// Driver program to test above function  ` `    ``public` `static` `void` `Main() { ` `        ``int` `n = 4; ` `        ``printNComposite(n); ` `  `  `    ``} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## PHP

 ` `

Output:

```122 123 124 125
```

The above solution causes overflow very soon (for small values of n). We can use technique to find factorial of large number to avoid overflow.

## tags:

Mathematical factorial Mathematical factorial