# Primorial of a number

Given a number n, the task is to calculate its primorial. Primorial (denoted as P_{n}#) is a product of first n prime numbers. Primorial of a number is similar to the factorial of a number. In primorial, not all the natural numbers get multiplied only prime numbers are multiplied to calculate the primorial of a number. It is denoted with P#.**Examples:**

Input:n = 3Output:30 Priomorial = 2 * 3 * 5 = 30 As a side note, factorial is 2 * 3 * 4 * 5Input:n = 5Output:2310 Primorial = 2 * 3 * 5 * 7 * 11

A **naive approach **is to check all numbers from 1 to n one by one is prime or not, if yes then store the multiplication in result, similarly store the result of multiplication of primes till n.

An **efficient **method is to find all the prime up-to n using Sieve of Sundaram and then just calculate the primorial by multiplying them all.

## C++

`// C++ program to find Primorial of given numbers` `#include<bits/stdc++.h>` `using` `namespace` `std;` `const` `int` `MAX = 1000000;` `// vector to store all prime less than and equal to 10^6` `vector <` `int` `> primes;` `// Function for sieve of sundaram. This function stores all` `// prime numbers less than MAX in primes` `void` `sieveSundaram()` `{` ` ` `// In general Sieve of Sundaram, produces primes smaller` ` ` `// than (2*x + 2) for a number given number x. Since` ` ` `// we want primes smaller than MAX, we reduce MAX to half` ` ` `// This array is used to separate numbers of the form` ` ` `// i+j+2ij from others where 1 <= i <= j` ` ` `bool` `marked[MAX/2 + 1] = {0};` ` ` `// Main logic of Sundaram. Mark all numbers which` ` ` `// do not generate prime number by doing 2*i+1` ` ` `for` `(` `int` `i = 1; i <= (` `sqrt` `(MAX)-1)/2 ; i++)` ` ` `for` `(` `int` `j = (i*(i+1))<<1 ; j <= MAX/2 ; j += 2*i +1)` ` ` `marked[j] = ` `true` `;` ` ` `// Since 2 is a prime number` ` ` `primes.push_back(2);` ` ` `// Print other primes. Remaining primes are of the` ` ` `// form 2*i + 1 such that marked[i] is false.` ` ` `for` `(` `int` `i=1; i<=MAX/2; i++)` ` ` `if` `(marked[i] == ` `false` `)` ` ` `primes.push_back(2*i + 1);` `}` `// Function to calculate primorial of n` `int` `calculatePrimorial(` `int` `n)` `{` ` ` `// Multiply first n primes ` ` ` `int` `result = 1; ` ` ` `for` `(` `int` `i=0; i<n; i++)` ` ` `result = result * primes[i];` ` ` `return` `result;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `n = 5;` ` ` `sieveSundaram();` ` ` `for` `(` `int` `i = 1 ; i<= n; i++)` ` ` `cout << ` `"Primorial(P#) of "` `<< i << ` `" is "` ` ` `<< calculatePrimorial(i) <<endl;` ` ` `return` `0;` `}` |

## Java

`// Java program to find Primorial of given numbers ` `import` `java.util.*;` `class` `GFG{` `public` `static` `int` `MAX = ` `1000000` `;` `// vector to store all prime less than and equal to 10^6 ` `static` `ArrayList<Integer> primes = ` `new` `ArrayList<Integer>();` `// Function for sieve of sundaram. This function stores all ` `// prime numbers less than MAX in primes ` `static` `void` `sieveSundaram()` `{` ` ` `// In general Sieve of Sundaram, produces primes smaller ` ` ` `// than (2*x + 2) for a number given number x. Since ` ` ` `// we want primes smaller than MAX, we reduce MAX to half ` ` ` `// This array is used to separate numbers of the form ` ` ` `// i+j+2ij from others where 1 <= i <= j ` ` ` `boolean` `[] marked = ` `new` `boolean` `[MAX];` ` ` `// Main logic of Sundaram. Mark all numbers which ` ` ` `// do not generate prime number by doing 2*i+1 ` ` ` `for` `(` `int` `i = ` `1` `; i <= (Math.sqrt(MAX) - ` `1` `) / ` `2` `; i++)` ` ` `{` ` ` `for` `(` `int` `j = (i * (i + ` `1` `)) << ` `1` `; j <= MAX / ` `2` `; j += ` `2` `* i + ` `1` `)` ` ` `{` ` ` `marked[j] = ` `true` `;` ` ` `}` ` ` `}` ` ` `// Since 2 is a prime number ` ` ` `primes.add(` `2` `);` ` ` `// Print other primes. Remaining primes are of the ` ` ` `// form 2*i + 1 such that marked[i] is false. ` ` ` `for` `(` `int` `i = ` `1` `; i <= MAX / ` `2` `; i++)` ` ` `{` ` ` `if` `(marked[i] == ` `false` `)` ` ` `{` ` ` `primes.add(` `2` `* i + ` `1` `);` ` ` `}` ` ` `}` `}` `// Function to calculate primorial of n ` `static` `int` `calculatePrimorial(` `int` `n)` `{` ` ` `// Multiply first n primes ` ` ` `int` `result = ` `1` `;` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `{` ` ` `result = result * primes.get(i);` ` ` `}` ` ` `return` `result;` `}` `// Driver code ` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `n = ` `5` `;` ` ` `sieveSundaram();` ` ` `for` `(` `int` `i = ` `1` `; i <= n; i++)` ` ` `{` ` ` `System.out.println(` `"Primorial(P#) of "` `+i+` `" is "` `+calculatePrimorial(i));` ` ` `}` `}` `}` `// This Code is contributed by mits` |

## Python3

`# Python3 program to find Primorial of given numbers ` `import` `math` `MAX` `=` `1000000` `; ` `# vector to store all prime less than and equal to 10^6 ` `primes` `=` `[]; ` `# Function for sieve of sundaram. This function stores all ` `# prime numbers less than MAX in primes ` `def` `sieveSundaram():` ` ` ` ` `# In general Sieve of Sundaram, produces primes smaller ` ` ` `# than (2*x + 2) for a number given number x. Since ` ` ` `# we want primes smaller than MAX, we reduce MAX to half ` ` ` `# This array is used to separate numbers of the form ` ` ` `# i+j+2ij from others where 1 <= i <= j ` ` ` `marked` `=` `[` `False` `]` `*` `(` `int` `(` `MAX` `/` `2` `)` `+` `1` `); ` ` ` `# Main logic of Sundaram. Mark all numbers which ` ` ` `# do not generate prime number by doing 2*i+1 ` ` ` `for` `i ` `in` `range` `(` `1` `,` `int` `((math.sqrt(` `MAX` `)` `-` `1` `)` `/` `2` `)` `+` `1` `): ` ` ` `for` `j ` `in` `range` `(((i` `*` `(i` `+` `1` `))<<` `1` `),(` `int` `(` `MAX` `/` `2` `)` `+` `1` `),(` `2` `*` `i` `+` `1` `)): ` ` ` `marked[j] ` `=` `True` `; ` ` ` `# Since 2 is a prime number ` ` ` `primes.append(` `2` `); ` ` ` `# Print other primes. Remaining primes are of the ` ` ` `# form 2*i + 1 such that marked[i] is false. ` ` ` `for` `i ` `in` `range` `(` `1` `,` `int` `(` `MAX` `/` `2` `)): ` ` ` `if` `(marked[i] ` `=` `=` `False` `): ` ` ` `primes.append(` `2` `*` `i ` `+` `1` `); ` `# Function to calculate primorial of n ` `def` `calculatePrimorial(n): ` ` ` `# Multiply first n primes ` ` ` `result ` `=` `1` `; ` ` ` `for` `i ` `in` `range` `(n):` ` ` `result ` `=` `result ` `*` `primes[i]; ` ` ` `return` `result; ` `# Driver code ` `n ` `=` `5` `; ` `sieveSundaram(); ` `for` `i ` `in` `range` `(` `1` `,n` `+` `1` `):` ` ` `print` `(` `"Primorial(P#) of"` `,i,` `"is"` `,calculatePrimorial(i)); ` `# This code is contributed by mits` |

## C#

`// C# program to find Primorial of given numbers ` `using` `System; ` `using` `System.Collections;` `class` `GFG{` `public` `static` `int` `MAX = 1000000;` `// vector to store all prime less than and equal to 10^6 ` `static` `ArrayList primes = ` `new` `ArrayList();` `// Function for sieve of sundaram. This function stores all ` `// prime numbers less than MAX in primes ` `static` `void` `sieveSundaram()` `{` ` ` `// In general Sieve of Sundaram, produces primes smaller ` ` ` `// than (2*x + 2) for a number given number x. Since ` ` ` `// we want primes smaller than MAX, we reduce MAX to half ` ` ` `// This array is used to separate numbers of the form ` ` ` `// i+j+2ij from others where 1 <= i <= j ` ` ` `bool` `[] marked = ` `new` `bool` `[MAX];` ` ` `// Main logic of Sundaram. Mark all numbers which ` ` ` `// do not generate prime number by doing 2*i+1 ` ` ` `for` `(` `int` `i = 1; i <= (Math.Sqrt(MAX) - 1) / 2 ; i++)` ` ` `{` ` ` `for` `(` `int` `j = (i * (i + 1)) << 1 ; j <= MAX / 2 ; j += 2 * i + 1)` ` ` `{` ` ` `marked[j] = ` `true` `;` ` ` `}` ` ` `}` ` ` `// Since 2 is a prime number ` ` ` `primes.Add(2);` ` ` `// Print other primes. Remaining primes are of the ` ` ` `// form 2*i + 1 such that marked[i] is false. ` ` ` `for` `(` `int` `i = 1; i <= MAX / 2; i++)` ` ` `{` ` ` `if` `(marked[i] == ` `false` `)` ` ` `{` ` ` `primes.Add(2 * i + 1);` ` ` `}` ` ` `}` `}` `// Function to calculate primorial of n ` `static` `int` `calculatePrimorial(` `int` `n)` `{` ` ` `// Multiply first n primes ` ` ` `int` `result = 1;` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `result = result * (` `int` `)primes[i];` ` ` `}` ` ` `return` `result;` `}` `// Driver code ` `public` `static` `void` `Main()` `{` ` ` `int` `n = 5;` ` ` `sieveSundaram();` ` ` `for` `(` `int` `i = 1 ; i <= n; i++)` ` ` `{` ` ` `System.Console.WriteLine(` `"Primorial(P#) of "` `+i+` `" is "` `+calculatePrimorial(i));` ` ` `}` `}` `}` `// This Code is contributed by mits` |

## PHP

`<?php` `// PHP program to find Primorial ` `// of given numbers` `$MAX` `= 100000;` `// vector to store all prime less` `// than and equal to 10^6` `$primes` `= ` `array` `();` `// Function for sieve of sundaram. ` `// This function stores all prime ` `// numbers less than MAX in primes` `function` `sieveSundaram()` `{` ` ` `global` `$MAX` `, ` `$primes` `;` ` ` ` ` `// In general Sieve of Sundaram, ` ` ` `// produces primes smaller than ` ` ` `// (2*x + 2) for a number given ` ` ` `// number x. Since we want primes ` ` ` `// smaller than MAX, we reduce MAX ` ` ` `// to half. This array is used to ` ` ` `// separate numbers of the form` ` ` `// i+j+2ij from others where 1 <= i <= j` ` ` `$marked` `= ` `array_fill` `(0, ` `$MAX` `/ 2 + 1, 0);` ` ` `// Main logic of Sundaram. Mark all numbers which` ` ` `// do not generate prime number by doing 2*i+1` ` ` `for` `(` `$i` `= 1; ` `$i` `<= (sqrt(` `$MAX` `) - 1) / 2 ; ` `$i` `++)` ` ` `for` `(` `$j` `= (` `$i` `* (` `$i` `+ 1)) << 1 ;` ` ` `$j` `<= ` `$MAX` `/ 2 ; ` `$j` `+= 2 * ` `$i` `+ 1)` ` ` `$marked` `[` `$j` `] = true;` ` ` `// Since 2 is a prime number` ` ` `array_push` `(` `$primes` `, 2);` ` ` `// Print other primes. Remaining primes ` ` ` `// are of the form 2*i + 1 such that` ` ` `// marked[i] is false.` ` ` `for` `(` `$i` `= 1; ` `$i` `<= ` `$MAX` `/ 2; ` `$i` `++)` ` ` `if` `(` `$marked` `[` `$i` `] == false)` ` ` `array_push` `(` `$primes` `, (2 * ` `$i` `+ 1));` `}` `// Function to calculate primorial of n` `function` `calculatePrimorial(` `$n` `)` `{` ` ` `global` `$primes` `;` ` ` ` ` `// Multiply first n primes ` ` ` `$result` `= 1; ` ` ` `for` `(` `$i` `= 0; ` `$i` `< ` `$n` `; ` `$i` `++)` ` ` `$result` `= ` `$result` `* ` `$primes` `[` `$i` `];` ` ` `return` `$result` `;` `}` `// Driver code` `$n` `= 5;` `sieveSundaram();` `for` `(` `$i` `= 1 ; ` `$i` `<= ` `$n` `; ` `$i` `++)` ` ` `echo` `"Primorial(P#) of "` `. ` `$i` `. ` ` ` `" is "` `. calculatePrimorial(` `$i` `) . ` `"\n"` `;` `// This code is contributed by mits` `?>` |

## Javascript

`<script>` `// Javascript program to find Primorial` `// of given numbers` `let MAX = 100000;` `// vector to store all prime less` `// than and equal to 10^6` `let primes = ` `new` `Array();` `// Function for sieve of sundaram.` `// This function stores all prime` `// numbers less than MAX in primes` `function` `sieveSundaram()` `{` ` ` ` ` `// In general Sieve of Sundaram,` ` ` `// produces primes smaller than` ` ` `// (2*x + 2) for a number given` ` ` `// number x. Since we want primes` ` ` `// smaller than MAX, we reduce MAX` ` ` `// to half. This array is used to` ` ` `// separate numbers of the form` ` ` `// i+j+2ij from others where 1 <= i <= j` ` ` `let marked = ` `new` `Array(MAX / 2 + 1).fill(0);` ` ` `// Main logic of Sundaram. Mark all numbers which` ` ` `// do not generate prime number by doing 2*i+1` ` ` `for` `(let i = 1; i <= (Math.sqrt(MAX) - 1) / 2 ; i++)` ` ` `for` `(let j = (i * (i + 1)) << 1 ;` ` ` `j <= MAX / 2 ; j += 2 * i + 1)` ` ` `marked[j] = ` `true` `;` ` ` `// Since 2 is a prime number` ` ` `primes.push(2);` ` ` `// Print other primes. Remaining primes` ` ` `// are of the form 2*i + 1 such that` ` ` `// marked[i] is false.` ` ` `for` `(let i = 1; i <= MAX / 2; i++)` ` ` `if` `(marked[i] == ` `false` `)` ` ` `primes.push(2 * i + 1);` `}` `// Function to calculate primorial of n` `function` `calculatePrimorial(n)` `{ ` ` ` `// Multiply first n primes` ` ` `let result = 1;` ` ` `for` `(let i = 0; i < n; i++)` ` ` `result = result * primes[i];` ` ` `return` `result;` `}` `// Driver code` `let n = 5;` `sieveSundaram();` `for` `(let i = 1 ; i<= n; i++)` ` ` `document.write(` `"Primorial(P#) of "` `+ i + ` `" is "` `+ ` ` ` `calculatePrimorial(i) + ` `"<br>"` `);` `// This code is contributed by gfgking` `</script>` |

**Output:**

Primorial(P#) of 1 is 2 Primorial(P#) of 2 is 6 Primorial(P#) of 3 is 30 Primorial(P#) of 4 is 210 Primorial(P#) of 5 is 2310

This article is contributed by **Sahil Chhabra (KILLER)**. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.