First element of every K sets having consecutive elements with exactly K prime factors less than N
Last Updated :
02 Nov, 2023
Given two integers N and K, the task is to find the first element for every set of K consecutive elements which have exactly K prime factors and are less than N.
Examples:
Input: N = 30, K = 2
Output: 14 20 21
Explanation:
Numbers which have prime factors equals to 2 less than 30 = { 14, 15, 18, 20, 21, 22, 24, 26, 28 }.
In the above examples, for K = 2 (14, 15) (20, 21) (21, 22) only forms such sets and therefore the series is 14, 20, 21.
Input: N = 1000, K = 3
Output: 644 740 804 986
Naive Approach: The naive approach is to iterate from 2 to N and check that every K consecutive number forms a set having K prime factors for each element in the set. If “Yes” then print the first element of this set and check for next K elements.
Time Complexity: O(N*K)
Auxiliary Space: O(1)
Efficient Approach: The above approach can be optimized by precomputing the number of prime factors till N and check for every K consecutive elements count having K prime factors. Below are the steps:
- Create a smallest prime factor array spf[] which stores the smallest prime factors for every number till N using Sieve of Eratosthenes.
- Using the above step, count the number of prime factors till each number N
- Store the number in the array(say result[]) whose count of prime factor is K.
- For each element of the array result[] check if there exists K consecutive numbers then print the first element of K consecutive numbers.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
#define x 2000021
using namespace std;
long long int v[x];
void sieve()
{
v[1] = 1;
for ( long long int i = 2; i < x; i++)
v[i] = i;
for ( long long int i = 4; i < x; i += 2)
v[i] = 2;
for ( long long int i = 3; i * i < x; i++) {
if (v[i] == i) {
for ( long long int j = i * i;
j < x; j += i) {
if (v[j] == j) {
v[j] = i;
}
}
}
}
}
long long int prime_factors( long long n)
{
set< long long int > s;
while (n != 1) {
s.insert(v[n]);
n = n / v[n];
}
return s.size();
}
void distinctPrimes( long long int m,
long long int k)
{
vector< long long int > result;
for ( long long int i = 14;
i < m + k; i++) {
long long count
= prime_factors(i);
if (count == k) {
result.push_back(i);
}
}
long long int p = result.size();
for ( long long int index = 0;
index < p - 1; index++) {
long long element = result[index];
long long count = 1, z = index;
while (z < p - 1 && count <= k
&& result[z] + 1
== result[z + 1]) {
count++;
z++;
}
if (count >= k)
cout << element << ' ' ;
}
}
int main()
{
sieve();
long long int N = 1000, K = 3;
distinctPrimes(N, K);
return 0;
}
|
Java
import java.util.*;
class GFG{
static final int x = 2000021 ;
static int []v = new int [x];
static void sieve()
{
v[ 1 ] = 1 ;
for ( int i = 2 ; i < x; i++)
v[i] = i;
for ( int i = 4 ; i < x; i += 2 )
v[i] = 2 ;
for ( int i = 3 ; i * i < x; i++)
{
if (v[i] == i)
{
for ( int j = i * i; j < x; j += i)
{
if (v[j] == j)
{
v[j] = i;
}
}
}
}
}
static int prime_factors( int n)
{
HashSet<Integer> s = new HashSet<Integer>();
while (n != 1 )
{
s.add(v[n]);
n = n / v[n];
}
return s.size();
}
static void distinctPrimes( int m, int k)
{
Vector<Integer> result = new Vector<Integer>();
for ( int i = 14 ; i < m + k; i++)
{
long count = prime_factors(i);
if (count == k)
{
result.add(i);
}
}
int p = result.size();
for ( int index = 0 ;
index < p - 1 ; index++)
{
long element = result.get(index);
int count = 1 , z = index;
while (z < p - 1 && count <= k &&
result.get(z) + 1 ==
result.get(z + 1 ))
{
count++;
z++;
}
if (count >= k)
System.out.print(element + " " );
}
}
public static void main(String[] args)
{
sieve();
int N = 1000 , K = 3 ;
distinctPrimes(N, K);
}
}
|
Python3
x = 2000021
v = [ 0 ] * x
def sieve():
v[ 1 ] = 1
for i in range ( 2 , x):
v[i] = i
for i in range ( 4 , x, 2 ):
v[i] = 2
i = 3
while (i * i < x):
if (v[i] = = i):
for j in range (i * i, x, i):
if (v[j] = = j):
v[j] = i
i + = 1
def prime_factors(n):
s = set ()
while (n ! = 1 ):
s.add(v[n])
n = n / / v[n]
return len (s)
def distinctPrimes(m, k):
result = []
for i in range ( 14 , m + k):
count = prime_factors(i)
if (count = = k):
result.append(i)
p = len (result)
for index in range (p - 1 ):
element = result[index]
count = 1
z = index
while (z < p - 1 and count < = k and
result[z] + 1 = = result[z + 1 ]):
count + = 1
z + = 1
if (count > = k):
print (element, end = ' ' )
if __name__ = = '__main__' :
sieve()
N = 1000
K = 3
distinctPrimes(N, K)
|
C#
using System;
using System.Collections.Generic;
class GFG{
static readonly int x = 2000021;
static int []v = new int [x];
static void sieve()
{
v[1] = 1;
for ( int i = 2; i < x; i++)
v[i] = i;
for ( int i = 4; i < x; i += 2)
v[i] = 2;
for ( int i = 3; i * i < x; i++)
{
if (v[i] == i)
{
for ( int j = i * i; j < x; j += i)
{
if (v[j] == j)
{
v[j] = i;
}
}
}
}
}
static int prime_factors( int n)
{
HashSet< int > s = new HashSet< int >();
while (n != 1)
{
s.Add(v[n]);
n = n / v[n];
}
return s.Count;
}
static void distinctPrimes( int m, int k)
{
List< int > result = new List< int >();
for ( int i = 14; i < m + k; i++)
{
long count = prime_factors(i);
if (count == k)
{
result.Add(i);
}
}
int p = result.Count;
for ( int index = 0;
index < p - 1; index++)
{
long element = result[index];
int count = 1, z = index;
while (z < p - 1 && count <= k &&
result[z] + 1 == result[z + 1])
{
count++;
z++;
}
if (count >= k)
Console.Write(element + " " );
}
}
public static void Main(String[] args)
{
sieve();
int N = 1000, K = 3;
distinctPrimes(N, K);
}
}
|
Javascript
<script>
let x = 2000021
let v = new Array(x);
function sieve()
{
v[1] = 1;
for (let i = 2; i < x; i++)
v[i] = i;
for (let i = 4; i < x; i += 2)
v[i] = 2;
for (let i = 3; i * i < x; i++) {
if (v[i] == i) {
for (let j = i * i;
j < x; j += i) {
if (v[j] == j) {
v[j] = i;
}
}
}
}
}
function prime_factors(n)
{
let s = new Set();
while (n != 1) {
s.add(v[n]);
n = n / v[n];
}
return s.size;
}
function distinctPrimes(m, k)
{
let result = new Array();
for (let i = 14;
i < m + k; i++) {
let count
= prime_factors(i);
if (count == k) {
result.push(i);
}
}
let p = result.length;
for (let index = 0;
index < p - 1; index++) {
let element = result[index];
let count = 1, z = index;
while (z < p - 1 && count <= k
&& result[z] + 1
== result[z + 1]) {
count++;
z++;
}
if (count >= k)
document.write(element + ' ' );
}
}
sieve();
let N = 1000, K = 3;
distinctPrimes(N, K);
</script>
|
Time Complexity: O(N*log(log N))
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...