Count elements that are divisible by at-least one element in another array

Last Updated : 28 Dec, 2021

Given two arrays arr1[] and arr2[]. The task is to find the count of such elements in the first array whose at-least one factor is present in the second array.
Examples:

Input : arr1[] = {10, 2, 13, 4, 15} ; arr2[] = {2, 4, 5, 6}
Output : 4
There is no factor of 13 which is present in the 
second array. Except 13, factors of the rest 4 
elements of the first array is present in the 
second array.

Input : arr1[] = {11, 13, 17, 15} ; arr2[] = {3, 7, 9, 5}
Output : 1

The idea is to insert all elements of the second array into a hash such that the lookup for factors can be done in constant time. Now, traverse the first array and for every element generate all of the factors starting from 1 and check if any of the factors is present in the hash or not.
Below is the implementation of the above approach:

C++

// CPP program to find count of
// elements in first array whose
// atleast one factor is present
// in second array.
#include <bits/stdc++.h>
using namespace std;
 
// Util function to count the elements
// in first array whose atleast
// one factor is present in second array
int elementCount(int arr1[], int n1, int arr2[], int n2)
{
 
    // counter to count number of elements
    int count = 0;
 
    // Hash of second array elements
    unordered_set<int> hash;
    for (int i = 0; i < n2; i++)
        hash.insert(arr2[i]);
 
    // loop to traverse through array elements
    // and check for its factors
    for (int i = 0; i < n1; i++) {
 
        // generate factors of elements
        // of first array
        for (int j = 1; j * j <= arr1[i]; j++) { 
 
            // Check if j is a factor
            if (arr1[i] % j == 0) {
 
                // check if the factor is present in
                // second array using the hash
                if ((hash.find(j) != hash.end()) || 
                        (hash.find(arr1[i] / j) != hash.end())) {
                    count++;
                    break;
                }
            }
        }
    }
 
    return count;
}
 
// Driver code
int main()
{
    int arr1[] = { 10, 2, 13, 4, 15 };
    int arr2[] = { 2, 4, 5, 6 };
 
    int n1 = sizeof(arr1) / sizeof(arr1[0]);
    int n2 = sizeof(arr2) / sizeof(arr2[0]);
 
    cout << elementCount(arr1, n1, arr2, n2);
 
    return 0;
}

Java

// Java program to find count of
// elements in first array whose
// atleast one factor is present
// in second array. 
import java.util.*;
 
class GFG
{
 
    // Util function to count the elements
    // in first array whose atleast
    // one factor is present in second array
    static int elementCount(int arr1[], int n1,
                            int arr2[], int n2) 
    {
 
        // counter to count number of elements
        int count = 0;
 
        // Hash of second array element
        HashSet<Integer> hash = new HashSet<>();
        for (int i = 0; i < n2; i++) 
        {
            hash.add(arr2[i]);
        }
 
        // loop to traverse through array elements
        // and check for its factors
        for (int i = 0; i < n1; i++) 
        {
 
            // generate factors of elements
            // of first array
            for (int j = 1; j * j <= arr1[i]; j++) 
            {
 
                // Check if j is a factor
                if (arr1[i] % j == 0)
                {
 
                    // check if the factor is present in
                    // second array using the hash
                    if ((hash.contains(j) && j != 
                        (int) hash.toArray()[hash.size() - 1]) ||
                        (hash.contains(arr1[i] / j) && (arr1[i] / j) != 
                        (int) hash.toArray()[hash.size() - 1])) 
                    {
                        count++;
                        break;
                    }
                }
            }
        }
 
        return count;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr1[] = {10, 2, 13, 4, 15};
        int arr2[] = {2, 4, 5, 6};
 
        int n1 = arr1.length;
        int n2 = arr2.length;
        System.out.println(elementCount(arr1, n1, arr2, n2));
    }
}
 
/* This code contributed by PrinciRaj1992 */

Python3

# Python program to find count of
# elements in first array whose
# atleast one factor is present
# in second array.
  
# Importing sqrt() function
from math import sqrt
  
# Util function to count the 
# elements in first array 
# whose atleast one factor is
# present in second array
def elementCount(arr1, arr2):
    
  # counter to count
  # number of elements
  count = 0
    
  # Hash of second array elements
  hash = frozenset(arr2)
    
  # loop to traverse through array 
  # elements and check for its factors
  for x in arr1:
        
    # generate factors of 
    # elements of first array
    for j in range(1, int(sqrt(x)) + 1):
    
      # Check if j is a factor
      if x % j == 0:
  
        # check if the factor is present 
        # in second array using the hash
        if (j in hash or
            x / j in hash):
          count+=1
          break
    
  return count
  
# Driver code
arr1 = [ 10, 2, 13, 4, 15 ]
arr2 = [ 2, 4, 5, 6 ]
  
print(elementCount(arr1, arr2))
  
# This code is contributed 
# by vaibhav29498

C#

// C# program to find count of
// elements in first array whose
// atleast one factor is present
// in second array. 
using System;
using System.Linq;
using System.Collections.Generic;
 
class GFG
{
 
    // Util function to count the elements
    // in first array whose atleast
    // one factor is present in second array
    static int elementCount(int []arr1, int n1,
                            int []arr2, int n2) 
    {
 
        // counter to count number of elements
        int count = 0;
 
        // Hash of second array element
        HashSet<int> hash = new HashSet<int>();
        for (int i = 0; i < n2; i++) 
        {
            hash.Add(arr2[i]);
        }
 
        // loop to traverse through array elements
        // and check for its factors
        for (int i = 0; i < n1; i++) 
        {
 
            // generate factors of elements
            // of first array
            for (int j = 1; j * j <= arr1[i]; j++) 
            {
 
                // Check if j is a factor
                if (arr1[i] % j == 0)
                {
 
                    // check if the factor is present in
                    // second array using the hash
                    if ((hash.Contains(j) && j != 
                        (int) hash.ToArray()[hash.Count- 1]) ||
                        (hash.Contains(arr1[i] / j) && (arr1[i] / j) != 
                        (int) hash.ToArray()[hash.Count - 1])) 
                    {
                        count++;
                        break;
                    }
                }
            }
        }
 
        return count;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int []arr1 = {10, 2, 13, 4, 15};
        int []arr2 = {2, 4, 5, 6};
 
        int n1 = arr1.Length;
        int n2 = arr2.Length;
        Console.WriteLine(elementCount(arr1, n1, arr2, n2));
    }
}
 
// This code contributed by Rajput-Ji

PHP

<?php
// PHP program to find count of
// elements in first array whose
// atleast one factor is present
// in second array.
 
// Util function to count the 
// elements in first array 
// whose atleast one factor is
// present in second array
function elementCount($arr1, $arr2)
{ 
    // counter to count
    // number of elements
    $count = 0;
         
    // Hash of second array elements
    $hash = array_unique($arr2);
         
    // loop to traverse through array 
    // elements and check for its factors
    foreach($arr1 as &$x)
     
        // generate factors of 
        // elements of first array
        for ($j = 1; $j < (int)(sqrt($x)) + 1; $j++)
         
        // Check if j is a factor
        if ($x % $j == 0)
        {
             
            // check if the factor is present 
            // in second array using the hash
            if (in_array($j, $hash) || 
                in_array((int)($x / $j), $hash))
            {
                $count++;
                break;
            }
        }
         
    return $count;
}
 
// Driver code
$arr1 = array( 10, 2, 13, 4, 15 );
$arr2 = array( 2, 4, 5, 6 );
 
print(elementCount($arr1, $arr2));
 
// This code is contributed mits
?>

Javascript

<script>
// javascript program to find count of
// elements in first array whose
// atleast one factor is present
// in second array. 
 
    // Util function to count the elements
    // in first array whose atleast
    // one factor is present in second array
    function elementCount(arr1 , n1 , arr2 , n2) {
 
        // counter to count number of elements
        var count = 0;
 
        // Hash of second array element
        var hash = new Set();
        for (i = 0; i < n2; i++) {
            hash.add(arr2[i]);
        }
 
        // loop to traverse through array elements
        // and check for its factors
        for (i = 0; i < n1; i++) {
 
            // generate factors of elements
            // of first array
            for (j = 1; j * j <= arr1[i]; j++) {
 
                // Check if j is a factor
                if (arr1[i] % j == 0) {
 
                    // check if the factor is present in
                    // second array using the hash
                    if ((hash.has(j) && j != parseInt( hash[hash.length - 1])
                            || (hash.has(arr1[i] / j) && (arr1[i] / j) != parseInt( hash[hash.length - 1])))) {
                        count++;
                        break;
                    }
                }
            }
        }
 
        return count;
    }
 
    // Driver code
     
        var arr1 = [ 10, 2, 13, 4, 15 ];
        var arr2 = [ 2, 4, 5, 6 ];
 
        var n1 = arr1.length;
        var n2 = arr2.length;
        document.write(elementCount(arr1, n1, arr2, n2));
 
// This code contributed by umadevi9616 
</script>

Output:

Suggest improvement

Elements of an array that are not divisible by any element of another array

Share your thoughts in the comments

Count elements that are divisible by at-least one element in another array

C++

Java

Python3

C#

PHP

Javascript

Please Login to comment...

Similar Reads

What kind of Experience do you want to share?