给定一个由N 个整数和一个整数K组成的数组arr[] ,任务是计算恰好具有K 个除数的数组元素的数量。
例子:
Input: N = 5, arr[] = { 3, 6, 2, 9, 4 }, K = 2
Output: 2
Explanation: arr[0] (= 3) and arr[2] (= 2) have exactly 2 divisors.
Input: N = 5, arr[] = { 3, 6, 2, 9, 4 }, K = 3
Output: 2
Explanation: arr[3] (= 9) and arr[4] (= 4) have exactly 3 divisors
方法:解决这个问题的想法是计算每个数组元素的除数总数并将它们存储在一个Map 中。然后,遍历数组,对于每个数组元素,检查是否正好有K 个除数。打印这些数字的计数。请按照以下步骤解决问题:
- 查找数组中存在的最大元素。
- 初始化一个数组prime[] 。
- 使用 Eratosthenes 筛将范围[2,数组中的最大元素]中存在的所有素数存储在数组prime[]中。
- 遍历数组并使用给定公式对每个数组元素进行素因数分解:
其中a i是质因数,而p i是它们的积分幂。
- 使用以下公式计算每个数组元素的除数总数:
- 初始化一个 Map 来存储每个数组元素的除数总数。
- 遍历数组并初始化一个变量,例如count ,以计算具有恰好K 个总除数的元素的数量。
- 打印恰好具有K 个除数的元素数。
下面是上述方法的实现:
C++
// C++ program for the above approach
#include
using namespace std;
// Stores prime numbers
// using Sieve of Eratosthenes
bool prime[100000];
// Function to find the maximum element
int maximumElement(int arr[], int N)
{
// Stores the maximum element
// of the array
int max = arr[0];
// Traverse the array
for (int i = 0; i < N; i++) {
// If current element
// is maximum so far
if (max < arr[i]) {
// Update maximum
max = arr[i];
}
}
// Return maximum element
return max;
}
// Function to find the prime numbers
// using sieve of eratosthenes algorithm
void sieveOfEratosthenes(int max)
{
// Calculate primes using Sieve
memset(prime, true, max+1);
for (int p = 2; p * p < max; p++)
// If current element is prime
if (prime[p] == true)
// Make all multiples non-prime
for (int i = p * 2; i < max; i += p)
prime[i] = false;
}
// Function to count divisors of n
int divCount(int n)
{
// Traversing through
// all prime numbers
int total = 1;
for (int p = 2; p <= n; p++) {
// If it is a prime number
if (prime[p]) {
// Calculate number of divisors
// with the formula
// number of diviors = (p1 + 1) * (p2 + 1)
// *.....* (pn + 1)
// n = (a1 ^ p1) * (a2 ^ p2) .... *(an ^ pn)
// ai: prime divisor of n
// pi: power in factorization
int count = 0;
if (n % p == 0) {
while (n % p == 0) {
n = n / p;
count++;
}
total = total * (count + 1);
}
}
}
// Return the total number of divisors
return total;
}
// Function to count array elements
// having exactly K diviors
int countElements(int arr[], int N, int K)
{
// Initialize a map to store
// count of divisors of array elements
map map;
// Traverse the array
for (int i = 0; i < N; i++) {
// If element is not already present in
// the Map, then insert it into the Map
if (map.find(arr[i]) == map.end()) {
// Function call to count the total
// number of divisors
map.insert({arr[i], divCount(arr[i])});
}
}
// Stores the number of
// elements with divisor K
int count = 0;
// Traverse the array
for (int i = 0; i < N; i++) {
// If current element
// has exactly K divisors
if (map.at(arr[i]) == K) {
count++;
}
}
// Return the number of
// elements having K divisors
return count;
}
// Driver Code
int main()
{
int arr[] = { 3, 6, 2, 9, 4 };
int N = sizeof(arr) / sizeof(arr[0]);
int K = 2;
// Find the maximum element
int max = maximumElement(arr, N);
// Generate all prime numbers
sieveOfEratosthenes(max);
cout << countElements(arr, N, K);
return 0;
}
// This code is contributed by Dharanendra L V
Java
// Java program for the above approach
import java.util.*;
class GFG {
// Stores prime numbers
// using Sieve of Eratosthenes
public static boolean prime[];
// Function to find the maximum element
public static int maximumElement(
int arr[], int N)
{
// Stores the maximum element
// of the array
int max = arr[0];
// Traverse the array
for (int i = 0; i < N; i++) {
// If current element
// is maximum so far
if (max < arr[i]) {
// Update maximum
max = arr[i];
}
}
// Return maximum element
return max;
}
// Function to find the prime numbers
// using sieve of eratosthenes algorithm
public static void sieveOfEratosthenes(int max)
{
// Initialize primes having
// size of maximum element + 1
prime = new boolean[max + 1];
// Calculate primes using Sieve
Arrays.fill(prime, true);
for (int p = 2; p * p < max; p++)
// If current element is prime
if (prime[p] == true)
// Make all multiples non-prime
for (int i = p * 2; i < max; i += p)
prime[i] = false;
}
// Function to count divisors of n
public static int divCount(int n)
{
// Traversing through
// all prime numbers
int total = 1;
for (int p = 2; p <= n; p++) {
// If it is a prime number
if (prime[p]) {
// Calculate number of divisors
// with the formula
// number of diviors = (p1 + 1) * (p2 + 1)
// *.....* (pn + 1)
// n = (a1 ^ p1) * (a2 ^ p2) .... *(an ^ pn)
// ai: prime divisor of n
// pi: power in factorization
int count = 0;
if (n % p == 0) {
while (n % p == 0) {
n = n / p;
count++;
}
total = total * (count + 1);
}
}
}
// Return the total number of divisors
return total;
}
// Function to count array elements
// having exactly K diviors
public static int countElements(
int arr[], int N, int K)
{
// Initialize a map to store
// count of divisors of array elements
Map map
= new HashMap();
// Traverse the array
for (int i = 0; i < N; i++) {
// If element is not already present in
// the Map, then insert it into the Map
if (!map.containsKey(arr[i])) {
// Function call to count the total
// number of divisors
map.put(arr[i], divCount(arr[i]));
}
}
// Stores the number of
// elements with divisor K
int count = 0;
// Traverse the array
for (int i = 0; i < N; i++) {
// If current element
// has exactly K divisors
if (map.get(arr[i]) == K) {
count++;
}
}
// Return the number of
// elements having K divisors
return count;
}
// Driver Code
public static void main(
String[] args)
{
int arr[] = { 3, 6, 2, 9, 4 };
int N = arr.length;
int K= 2;
// Find the maximum element
int max = maximumElement(arr, N);
// Generate all prime numbers
sieveOfEratosthenes(max);
System.out.println(countElements(arr, N, K));
}
}
Python3
# Python3 program for the above approach
# Stores prime numbers
# using Sieve of Eratosthenes
# Function to find the maximum element
def maximumElement(arr, N):
# Stores the maximum element
# of the array
max = arr[0]
# Traverse the array
for i in range(N):
# If current element
# is maximum so far
if (max < arr[i]):
# Update maximum
max = arr[i]
# Return maximum element
return max
# Function to find the prime numbers
# using sieve of eratosthenes algorithm
def sieveOfEratosthenes(max):
global prime
for p in range(2, max + 1):
if p * p > max:
break
# If current element is prime
if (prime[p] == True):
# Make all multiples non-prime
for i in range(2 * p, max, p):
prime[i] = False
return prime
# Function to count divisors of n
def divCount(n):
# Traversing through
# all prime numbers
total = 1
for p in range(2, n + 1):
# If it is a prime number
if (prime[p]):
# Calculate number of divisors
# with the formula
# number of diviors = (p1 + 1) * (p2 + 1)
# *.....* (pn + 1)
# n = (a1 ^ p1) * (a2 ^ p2) .... *(an ^ pn)
# ai: prime divisor of n
# pi: power in factorization
count = 0
if (n % p == 0):
while (n % p == 0):
n = n // p
count += 1
total = total * (count + 1)
# Return the total number of divisors
return total
# Function to count array elements
# having exactly K diviors
def countElements(arr, N, K):
# Initialize a map to store
# count of divisors of array elements
mp = {}
# Traverse the array
for i in range(N):
# If element is not already present in
# the Map, then insert it into the Map
if (arr[i] not in mp):
# Function call to count the total
# number of divisors
mp[arr[i]] = divCount(arr[i])
# Stores the number of
# elements with divisor K
count = 0
# Traverse the array
for i in range(N):
# If current element
# has exactly K divisors
if (mp[arr[i]] == K):
count += 1
# Return the number of
# elements having K divisors
return count
# Driver Code
if __name__ == '__main__':
prime = [True for i in range(10**6)]
arr = [3, 6, 2, 9, 4]
N = len(arr)
K= 2
# Find the maximum element
max = maximumElement(arr, N)
# Generate all prime numbers
prime = sieveOfEratosthenes(max)
print(countElements(arr, N, K))
# This code is contributed by mohit kumar 29
C#
// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG
{
// Stores prime numbers
// using Sieve of Eratosthenes
public static bool []prime;
// Function to find the maximum element
public static int maximumElement(
int []arr, int N)
{
// Stores the maximum element
// of the array
int max = arr[0];
// Traverse the array
for (int i = 0; i < N; i++)
{
// If current element
// is maximum so far
if (max < arr[i])
{
// Update maximum
max = arr[i];
}
}
// Return maximum element
return max;
}
// Function to find the prime numbers
// using sieve of eratosthenes algorithm
public static void sieveOfEratosthenes(int max)
{
// Initialize primes having
// size of maximum element + 1
prime = new bool[max + 1];
// Calculate primes using Sieve
for (int i = 0; i < prime.Length; i++)
prime[i] = true;
for (int p = 2; p * p < max; p++)
// If current element is prime
if (prime[p] == true)
// Make all multiples non-prime
for (int i = p * 2; i < max; i += p)
prime[i] = false;
}
// Function to count divisors of n
public static int divCount(int n)
{
// Traversing through
// all prime numbers
int total = 1;
for (int p = 2; p <= n; p++)
{
// If it is a prime number
if (prime[p])
{
// Calculate number of divisors
// with the formula
// number of diviors = (p1 + 1) * (p2 + 1)
// *.....* (pn + 1)
// n = (a1 ^ p1) * (a2 ^ p2) .... *(an ^ pn)
// ai: prime divisor of n
// pi: power in factorization
int count = 0;
if (n % p == 0)
{
while (n % p == 0)
{
n = n / p;
count++;
}
total = total * (count + 1);
}
}
}
// Return the total number of divisors
return total;
}
// Function to count array elements
// having exactly K diviors
public static int countElements(int []arr,
int N, int K)
{
// Initialize a map to store
// count of divisors of array elements
Dictionary map
= new Dictionary();
// Traverse the array
for (int i = 0; i < N; i++)
{
// If element is not already present in
// the Map, then insert it into the Map
if (!map.ContainsKey(arr[i]))
{
// Function call to count the total
// number of divisors
map.Add(arr[i], divCount(arr[i]));
}
}
// Stores the number of
// elements with divisor K
int count = 0;
// Traverse the array
for (int i = 0; i < N; i++)
{
// If current element
// has exactly K divisors
if (map[arr[i]] == K)
{
count++;
}
}
// Return the number of
// elements having K divisors
return count;
}
// Driver Code
public static void Main(String[] args)
{
int []arr = {3, 6, 2, 9, 4};
int N = arr.Length;
int K= 2;
// Find the maximum element
int max = maximumElement(arr, N);
// Generate all prime numbers
sieveOfEratosthenes(max);
Console.WriteLine(countElements(arr, N, K));
}
}
// This code is contributed by 29AjayKumar
Javascript
输出:
2
时间复杂度: O(N + maxlog(log(max) + log(max)),其中max是最大数组元素。
辅助空间: O(max),其中max是最大数组元素。
如果您想与行业专家一起参加直播课程,请参阅Geeks Classes Live