# Find prime factors of Z such that Z is product of all even numbers till N that are product of two distinct prime numbers

Given a number **N (N > 6)**, the task is to print the prime factorization of a number **Z**, where **Z** is the product of all numbers ≤ **N** that are even and** **can be expressed as the product of two distinct prime numbers.

**Example:**

Input:N = 6Output:2→1

3→1Explanation:6 is the only number ≤ N, which is even and a product of two distinct prime numbers (2 and 3).Therefore,Z=6.

Now, prime factorization ofZ=2×3

Input:N = 5Output:2→2

3→1

5→1Explanation:The only even numbers ≤N, which can be expressed as the product of two distinct prime numbers, are 6 (2×3) and 10 (2×5). Therefore,Z= 6*10=60 = 2x2x3x5

**Observation: **The following observation helps to solve the problem:

- Since the required numbers need to be even and product of two distinct prime numbers, they will be of the form
**2×P**, where**P is a****prime number****≤ N / 2.** - Thus, the prime factorization of
**Z**will be of the form 2^{x}.3^{1}.5^{1}…P^{1}, where**P**is the last prime number**≤ N/2**and**X**is the number of**prime numbers**in the range**[3, N / 2].**

**Approach:** Follow the steps to solve the problem:

- Store all
**prime numbers ≤ N / 2**, using Sieve of Eratosthenes in a vector, say**prime**. - Store the number of primes in the range
**[3, N/2]**in a variable, say**x**. - Print the prime factorization, where the coefficient of 2 is
**x**and the coefficients of all other primes in the range**[3, N/2]**is 1.

Below is the implementation of the above approach:

## C++

`// C++ implementation for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to print the prime factorization of the product` `// of all numbers <=N that are even and can be expressed as a` `// product of two distinct prime numbers` `void` `primeFactorization(` `int` `N)` `{` ` ` `// sieve of Eratosthenese` ` ` `int` `sieve[N / 2 + 1] = { 0 };` ` ` `for` `(` `int` `i = 2; i <= N / 2; i++) {` ` ` `if` `(sieve[i] == 0) {` ` ` `for` `(` `int` `j = i * i; j <= N / 2; j += i) {` ` ` `sieve[j] = 1;` ` ` `}` ` ` `}` ` ` `}` ` ` `// Store prime numbers in the range [3, N/2]` ` ` `vector<` `int` `> prime;` ` ` `for` `(` `int` `i = 3; i <= N / 2; i++)` ` ` `if` `(sieve[i] == 0)` ` ` `prime.push_back(i);` ` ` `// print the coefficient of 2 in the prime` ` ` `// factorization` ` ` `int` `x = prime.size();` ` ` `cout << ` `"2->"` `<< x << endl;` ` ` `// print the coefficients of other primes` ` ` `for` `(` `int` `i : prime)` ` ` `cout << i << ` `"->1"` `<< endl;` `}` `// Driver code` `int` `main()` `{` ` ` `// Input` ` ` `int` `N = 18;` ` ` `// Function calling` ` ` `primeFactorization(N);` ` ` `return` `0;` `}` |

## Java

`// Java implementation of` `// the above approach` `import` `java.util.*;` `import` `java.util.HashMap;` `class` `GFG{` ` ` `// Function to print the prime factorization` `// of the product of all numbers <=N that are` `// even and can be expressed as a product of` `// two distinct prime numbers` `static` `void` `primeFactorization(` `int` `N)` `{` ` ` ` ` `// Sieve of Eratosthenese` ` ` `int` `[] sieve = ` `new` `int` `[N / ` `2` `+ ` `1` `];` ` ` `for` `(` `int` `i = ` `0` `; i <= N / ` `2` `; i++)` ` ` `{` ` ` `sieve[i] = ` `0` `;` ` ` `}` ` ` `for` `(` `int` `i = ` `2` `; i <= N / ` `2` `; i++)` ` ` `{` ` ` `if` `(sieve[i] == ` `0` `)` ` ` `{` ` ` `for` `(` `int` `j = i * i; j <= N / ` `2` `; j += i)` ` ` `{` ` ` `sieve[j] = ` `1` `;` ` ` `}` ` ` `}` ` ` `}` ` ` ` ` `// Store prime numbers in the range [3, N/2]` ` ` `ArrayList<Integer> prime = ` `new` `ArrayList<Integer>();` ` ` `for` `(` `int` `i = ` `3` `; i <= N / ` `2` `; i++)` ` ` `if` `(sieve[i] == ` `0` `)` ` ` `prime.add(i);` ` ` ` ` `// Print the coefficient of 2 in the prime` ` ` `// factorization` ` ` `int` `x = prime.size();` ` ` `System.out.println(` `"2->"` `+ x);` ` ` ` ` `// Print the coefficients of other primes` ` ` `for` `(` `int` `i : prime)` ` ` `System.out.println(i + ` `"->1"` `);` `}` `// Driver Code` `public` `static` `void` `main(String args[])` `{` ` ` ` ` `// Input` ` ` `int` `N = ` `18` `;` ` ` ` ` `// Function calling` ` ` `primeFactorization(N);` `}` `}` `// This code is contributed by sanjoy_62` |

## Python3

`# Python3 implementation for the above approach` `# Function to print the prime factorization` `# of the product of all numbers <=N that are` `# even and can be expressed as a product of` `# two distinct prime numbers` `def` `primeFactorization(N):` ` ` ` ` `# Sieve of Eratosthenese` ` ` `sieve ` `=` `[` `0` `for` `i ` `in` `range` `(N ` `/` `/` `2` `+` `1` `)]` ` ` `for` `i ` `in` `range` `(` `2` `, N ` `/` `/` `2` `+` `1` `, ` `1` `):` ` ` `if` `(sieve[i] ` `=` `=` `0` `):` ` ` `for` `j ` `in` `range` `(i ` `*` `i, N ` `/` `/` `2` `+` `1` `, i):` ` ` `sieve[j] ` `=` `1` ` ` `# Store prime numbers in the range [3, N/2]` ` ` `prime ` `=` `[]` ` ` `for` `i ` `in` `range` `(` `3` `, N ` `/` `/` `2` `+` `1` `, ` `1` `):` ` ` `if` `(sieve[i] ` `=` `=` `0` `):` ` ` `prime.append(i)` ` ` `# Print the coefficient of 2 in the` ` ` `# prime factorization` ` ` `x ` `=` `len` `(prime)` ` ` `print` `(` `"2->"` `, x)` ` ` `# Print the coefficients of other primes` ` ` `for` `i ` `in` `prime:` ` ` `print` `(i, ` `"->1"` `)` `# Driver code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `# Input` ` ` `N ` `=` `18` ` ` `# Function calling` ` ` `primeFactorization(N)` ` ` `# This code is contributed by ipg2016107` |

## C#

`// C# implementation of` `// the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` `// Function to print the prime factorization` `// of the product of all numbers <=N that are` `// even and can be expressed as a product of` `// two distinct prime numbers` `static` `void` `primeFactorization(` `int` `N)` `{` ` ` ` ` `// sieve of Eratosthenese` ` ` `int` `[] sieve = ` `new` `int` `[N / 2 + 1];` ` ` `for` `(` `int` `i = 0; i <= N / 2; i++)` ` ` `{` ` ` `sieve[i] = 0;` ` ` `}` ` ` `for` `(` `int` `i = 2; i <= N / 2; i++)` ` ` `{` ` ` `if` `(sieve[i] == 0)` ` ` `{` ` ` `for` `(` `int` `j = i * i; j <= N / 2; j += i)` ` ` `{` ` ` `sieve[j] = 1;` ` ` `}` ` ` `}` ` ` `}` ` ` ` ` `// Store prime numbers in the range [3, N/2]` ` ` `List<` `int` `> prime = ` `new` `List<` `int` `>();` ` ` `for` `(` `int` `i = 3; i <= N / 2; i++)` ` ` `if` `(sieve[i] == 0)` ` ` `prime.Add(i);` ` ` ` ` `// Print the coefficient of 2 in the prime` ` ` `// factorization` ` ` `int` `x = prime.Count;` ` ` `Console.WriteLine(` `"2->"` `+ x);` ` ` ` ` `// Print the coefficients of other primes` ` ` `foreach` `(` `int` `i ` `in` `prime)` ` ` `Console.WriteLine(i + ` `"->1"` `);` `}` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` ` ` `// Input` ` ` `int` `N = 18;` ` ` ` ` `// Function calling` ` ` `primeFactorization(N);` `}` `}` `// This code is contributed by avijitmondal1998` |

## Javascript

`<script>` `// JavaScript program for the above approach` `// Function to print the prime factorization` `// of the product of all numbers <=N that are` `// even and can be expressed as a product of` `// two distinct prime numbers` `function` `primeFactorization(N)` `{` ` ` ` ` `// Sieve of Eratosthenese` ` ` `let sieve = ` `new` `Array(parseInt(N / 2) + 1).fill(0);` ` ` `for` `(let i = 2; i <= N / 2; i++)` ` ` `{` ` ` `if` `(sieve[i] == 0)` ` ` `{` ` ` `for` `(let j = i * i; j <= N / 2; j += i)` ` ` `{` ` ` `sieve[j] = 1;` ` ` `}` ` ` `}` ` ` `}` ` ` `// Store prime numbers in the range [3, N/2]` ` ` `let prime = [];` ` ` `for` `(let i = 3; i <= N / 2; i++)` ` ` `if` `(sieve[i] == 0)` ` ` `prime.push(i);` ` ` `// Print the coefficient of 2 in the prime` ` ` `// factorization` ` ` `let x = prime.length;` ` ` `document.write(` `"2->"` `+ x);` ` ` `document.write(` `"<br>"` `)` ` ` `// Print the coefficients of other primes` ` ` `for` `(let i of prime)` ` ` `{` ` ` `document.write(i + ` `"->1"` `);` ` ` `document.write(` `"<br>"` `);` ` ` `}` `}` `// Driver code` `// Input` `let N = 18;` `// Function calling` `primeFactorization(N);` `// This code is contributed by Potta Lokesh` `</script>` |

**Output**

2->3 3->1 5->1 7->1

**Time Complexity: **O(N * log(log(N)))**Auxiliary Space:** O(N)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**