不能被 Array 的任何其他元素整除的元素计数

给定一个数组arr[] ，任务是确定数组中不能被给定数组中的任何其他元素整除的元素的数量。
例子：

Input: arr[] = {86, 45, 18, 4, 8, 28, 19, 33, 2} 
Output: 4 
Explanation: 
The elements are {2, 19, 33, 45} are not divisible by any other array element.

Input: arr[] = {3, 3, 3} 
Output: 0 
 

朴素的方法：朴素的方法是遍历整个数组并计算不能被给定数组中的任何其他元素整除的元素的数量并打印计数。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
#define ll long long int
using namespace std;
 
// Function to count the number of
// elements of array which are not
// divisible by any other element
// in the array arr[]
int count(int a[], int n)
{
    int countElements = 0;
 
    // Iterate over the array
    for (int i = 0; i < n; i++) {
 
        bool flag = true;
        for (int j = 0; j < n; j++) {
 
            // Check if the element
            // is itself or not
            if (i == j)
                continue;
 
            // Check for divisibility
            if (a[i] % a[j] == 0) {
                flag = false;
                break;
            }
        }
 
        if (flag == true)
            ++countElements;
    }
 
    // Return the final result
    return countElements;
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 86, 45, 18, 4, 8,
                  28, 19, 33, 2 };
    int n = sizeof(arr) / sizeof(int);
 
    // Function Call
    cout << count(arr, n);
    return 0;
}

Java

// Java program for the above approach
class GFG{
 
// Function to count the number of
// elements of array which are not
// divisible by any other element
// in the array arr[]
static int count(int a[], int n)
{
    int countElements = 0;
 
    // Iterate over the array
    for(int i = 0; i < n; i++)
    {
        boolean flag = true;
        for(int j = 0; j < n; j++)
        {
 
            // Check if the element
            // is itself or not
            if (i == j)
                continue;
 
            // Check for divisibility
            if (a[i] % a[j] == 0)
            {
                flag = false;
                break;
            }
        }
 
        if (flag == true)
            ++countElements;
    }
 
    // Return the final result
    return countElements;
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given array
    int arr[] = { 86, 45, 18, 4, 8,
                  28, 19, 33, 2 };
                   
    int n = arr.length;
 
    // Function call
    System.out.print(count(arr, n));
}
}
 
// This code is contributed by Amit Katiyar

Python3

# Python3 program for
# the above approach
 
# Function to count the number of
# elements of array which are not
# divisible by any other element
# in the array arr[]
def count(a, n):
 
    countElements = 0
 
    # Iterate over the array
    for i in range (n):
 
        flag = True
        for j in range (n):
 
            # Check if the element
            # is itself or not
            if (i == j):
                continue
 
            # Check for divisibility
            if (a[i] % a[j] == 0):
                flag = False
                break
          
        if (flag == True):
            countElements += 1
    
    # Return the final result
    return countElements
 
# Driver Code
if __name__ == "__main__":
   
    # Given array
    arr = [86, 45, 18, 4,
           8, 28, 19, 33, 2]
    n = len(arr)
 
    # Function Call
    print( count(arr, n))
 
# This code is contributed by Chitranayal

C#

// C# program for the
// above approach
using System;
class GFG{
 
// Function to count the
// number of elements of
// array which are not
// divisible by any other
// element in the array []arr
static int count(int []a,
                 int n)
{
  int countElements = 0;
 
  // Iterate over the array
  for(int i = 0; i < n; i++)
  {
    bool flag = true;
    for(int j = 0; j < n; j++)
    {
      // Check if the element
      // is itself or not
      if (i == j)
        continue;
 
      // Check for divisibility
      if (a[i] % a[j] == 0)
      {
        flag = false;
        break;
      }
    }
 
    if (flag == true)
      ++countElements;
  }
 
  // Return the readonly result
  return countElements;
}
 
// Driver Code
public static void Main(String[] args)
{
  // Given array
  int []arr = {86, 45, 18, 4, 8,
               28, 19, 33, 2};
 
  int n = arr.Length;
 
  // Function call
  Console.Write(count(arr, n));
}
}
 
// This code is contributed by Rajput-Ji

Javascript

// Javascript program for the above approach
 
// Function to count the number of
// elements of array which are not
// divisible by any other element
// in the array arr[]
function count(a, n)
{
    let countElements = 0;
 
    // Iterate over the array
    for (let i = 0; i < n; i++) {
 
        let flag = true;
        for (let j = 0; j < n; j++) {
 
            // Check if the element
            // is itself or not
            if (i == j)
                continue;
 
            // Check for divisibility
            if (a[i] % a[j] == 0) {
                flag = false;
                break;
            }
        }
 
        if (flag == true)
            ++countElements;
    }
 
    // Return the final result
    return countElements;
}
 
// Driver Code
    // Given array
    let arr = [ 86, 45, 18, 4, 8,
                  28, 19, 33, 2 ];
    let n = arr.length;
 
    // Function Call
    document.write(count(arr, n));
 

输出

4

时间复杂度： O(N ² )
辅助空间： O(1)

高效方法：为了优化上述方法，我们将使用埃拉托色尼筛法的概念。以下是步骤：

1. 初始化一个布尔数组(比如v[] )，其大小等于数组中存在的最大元素 + 1，每个索引都为true 。
2. 遍历给定的数组arr[]并将数组v[]中多个当前元素的索引处的值更改为false 。
3. 创建一个 Hashmap 并将每个元素的频率存储在其中。
4. 对于数组中的每个元素(比如current_element )，如果v[current_element]为真，那么该元素不能被给定数组中的任何其他元素整除，并增加当前元素的计数。
5. 经过上述步骤后，打印count的最终值。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to count the number of
// elements of array which are not
// divisible by any other element
// of same array
int countEle(int a[], int n)
{
    // Length for boolean array
    int len = 0;
 
    // Hash map for storing the
    // element and it's frequency
    unordered_map hmap;
    for (int i = 0; i < n; i++) {
 
        // Update the maximum element
        len = max(len, a[i]);
        hmap[a[i]]++;
    }
 
    // Boolean array of size
    // of the max element + 1
    bool v[len + 1];
 
    for (int i = 0; i <= len; i++) {
        v[i] = true;
    }
 
    // Marking the multiples as false
    for (int i = 0; i < n; i++) {
 
        if (v[a[i]] == false)
            continue;
 
        for (int j = 2 * a[i];
             j <= len; j += a[i]) {
            v[j] = false;
        }
    }
 
    // To store the final count
    int count = 0;
 
    // Traverse boolean array
    for (int i = 1; i <= len; i++) {
 
        // Check if i is not divisible by
        // any other array elements and
        // appears in the array only once
        if (v[i] == true
            && hmap.count(i) == 1
            && hmap[i] == 1) {
            count += 1;
        }
    }
 
    // Return the final Count
    return count;
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 86, 45, 18, 4, 8,
                  28, 19, 33, 2 };
    int n = sizeof(arr) / sizeof(int);
 
    // Function Call
    cout << countEle(arr, n);
 
    return 0;
}

Java

// Java program for
// the above approach
import java.util.*;
class GFG{
 
// Function to count the
// number of elements of
// array which are not
// divisible by any other
// element of same array
static int countEle(int a[],
                    int n)
{
  // Length for boolean array
  int len = 0;
 
  // Hash map for storing the
  // element and it's frequency
  HashMap hmap = new HashMap<>();
   
  for (int i = 0; i < n; i++)
  {
    // Update the maximum element
    len = Math.max(len, a[i]);
     
    if(hmap.containsKey(a[i]))
    {
      hmap.put(a[i],
      hmap.get(a[i]) + 1);
    }
    else
    {
      hmap.put(a[i], 1);
    }
  }
 
  // Boolean array of size
  // of the max element + 1
  boolean []v = new boolean[len + 1];
 
  for (int i = 0; i <= len; i++)
  {
    v[i] = true;
  }
 
  // Marking the multiples
  // as false
  for (int i = 0; i < n; i++)
  {
    if (v[a[i]] == false)
      continue;
 
    for (int j = 2 * a[i];
             j <= len; j += a[i])
    {
      v[j] = false;
    }
  }
 
  // To store the
  // final count
  int count = 0;
 
  // Traverse boolean array
  for (int i = 1; i <= len; i++)
  {
    // Check if i is not divisible by
    // any other array elements and
    // appears in the array only once
    if (v[i] == true &&
        hmap.containsKey(i) &&
        hmap.get(i) == 1 &&
        hmap.get(i) == 1)
    {
      count += 1;
    }
  }
 
  // Return the final
  // Count
  return count;
}
 
// Driver Code
public static void main(String[] args)
{
  // Given array
  int arr[] = {86, 45, 18, 4, 8,
               28, 19, 33, 2};
  int n = arr.length;
 
  // Function Call
  System.out.print(countEle(arr, n));
}
}
 
// This code is contributed by Princi Singh

蟒蛇3

# Python3 program for the above approach
 
# Function to count the number of
# elements of array which are not
# divisible by any other element
# of same array
def countEle(a, n):
     
    # Length for boolean array
    len = 0
 
    # Hash map for storing the
    # element and it's frequency
    hmap = {}
    for i in range(n):
         
        # Update the maximum element
        len = max(len, a[i])
        hmap[a[i]] = hmap.get(a[i], 0) + 1
 
    # Boolean array of size
    # of the max element + 1
    v = [True for i in range(len + 1)]
 
    # Marking the multiples as false
    for i in range(n):
 
        if (v[a[i]] == False):
            continue
 
        for j in range(2 * a[i], len + 1, a[i]):
            v[j] = False
 
    # To store the final count
    count = 0
 
    # Traverse boolean array
    for i in range(1, len + 1):
 
        # Check if i is not divisible by
        # any other array elements and
        # appears in the array only once
        if (v[i] == True and (i in hmap) and hmap[i] == 1):
            count += 1
 
    # Return the final Count
    return count
 
# Driver Code
if __name__ == '__main__':
   
    # Given array
    arr = [86, 45, 18, 4, 8, 28, 19, 33, 2]
    n = len(arr)
 
    # Function Call
    print(countEle(arr, n))
 
    # This code is contributed by mohit kumar 29

C＃

// C# program for
// the above approach
using System;
using System.Collections.Generic;
class GFG{
 
// Function to count the
// number of elements of
// array which are not
// divisible by any other
// element of same array
static int countEle(int []a,
                    int n)
{
  // Length for bool array
  int len = 0;
 
  // Hash map for storing the
  // element and it's frequency
  Dictionary hmap =
             new Dictionary();
   
  for (int i = 0; i < n; i++)
  {
    // Update the maximum
    // element
    len = Math.Max(len, a[i]);
     
    if(hmap.ContainsKey(a[i]))
    {
      hmap[a[i]]++;
    }
    else
    {
      hmap.Add(a[i], 1);
    }
  }
 
  // Boolean array of size
  // of the max element + 1
  bool []v = new bool[len + 1];
 
  for (int i = 0; i <= len; i++)
  {
    v[i] = true;
  }
 
  // Marking the multiples
  // as false
  for (int i = 0; i < n; i++)
  {
    if (v[a[i]] == false)
      continue;
 
    for (int j = 2 * a[i];
             j <= len; j += a[i])
    {
      v[j] = false;
    }
  }
 
  // To store the
  // readonly count
  int count = 0;
 
  // Traverse bool array
  for (int i = 1; i <= len; i++)
  {
    // Check if i is not divisible by
    // any other array elements and
    // appears in the array only once
    if (v[i] == true &&
        hmap.ContainsKey(i) &&
        hmap[i] == 1 &&
        hmap[i] == 1)
    {
      count += 1;
    }
  }
 
  // Return the readonly
  // Count
  return count;
}
 
// Driver Code
public static void Main(String[] args)
{
  // Given array
  int []arr = {86, 45, 18, 4, 8,
               28, 19, 33, 2};
  int n = arr.Length;
 
  // Function Call
  Console.Write(countEle(arr, n));
}
}
 
// This code is contributed by gauravrajput1

Javascript

 
// Javascript program for
// the above approach
 
// Function to count the
// number of elements of
// array which are not
// divisible by any other
// element of same array
function countEle(a, n)
{
  // Length for boolean array
  let len = 0;
  
  // Hash map for storing the
  // element and it's frequency
  let hmap = new Map();
    
  for (let i = 0; i < n; i++)
  {
    // Update the maximum element
    len = Math.max(len, a[i]);
      
    if(hmap.has(a[i]))
    {
      hmap.set(a[i],
      hmap.get(a[i]) + 1);
    }
    else
    {
      hmap.set(a[i], 1);
    }
  }
  
  // Boolean array of size
  // of the max element + 1
  let v = Array.from({length: len + 1}, (_, i) => 0);
  
  for (let i = 0; i <= len; i++)
  {
    v[i] = true;
  }
  
  // Marking the multiples
  // as false
  for (let i = 0; i < n; i++)
  {
    if (v[a[i]] == false)
      continue;
  
    for (let j = 2 * a[i];
             j <= len; j += a[i])
    {
      v[j] = false;
    }
  }
  
  // To store the
  // final count
  let count = 0;
  
  // Traverse boolean array
  for (let i = 1; i <= len; i++)
  {
    // Check if i is not divisible by
    // any other array elements and
    // appears in the array only once
    if (v[i] == true &&
        hmap.has(i) &&
        hmap.get(i) == 1 &&
        hmap.get(i) == 1)
    {
      count += 1;
    }
  }
  
  // Return the final
  // Count
  return count;
}
 
 
// Driver code
 
     // Given array
  let arr = [86, 45, 18, 4, 8,
               28, 19, 33, 2];
  let n = arr.length;
  
  // Function Call
  document.write(countEle(arr, n));
 
// This code is contributed by souravghosh0416.

输出

4

时间复杂度： O(N*log(M)) ，其中 N 是给定数组中的元素数，M 是给定数组中的最大元素。
辅助空间： O(M + N) ，其中 N 是给定数组中的元素数，M 是给定数组中的最大元素。

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live