Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Count of elements in given Array divisible by all elements in their prefix

  • Last Updated : 24 Jan, 2022

Given an array arr[] containing N positive integers, the task is to find the total number of elements in the array that are divisible by all the elements present before them.

Examples:

Input: arr[] = {10, 6, 60, 120, 30, 360}
Output: 3
Explanation: 60, 120 and 360 are the required elements.

Input: arr[] = {2, 6, 5, 60}
Output: 2
Explanation: 6 and 60 are the elements.

 

Approach: As known, that any number X is divided by {X1, X2, X3, X4, . . ., Xn}, if X is divided by LCM of {X1, X2, X3, X4, …, Xn). And LCM of any number A, B is [(A*B)/gcd(A, B)]. Now to solve this problem, follow the below steps:

  1. Create a variable ans which stores the final answer and initialize it with 0.
  2. Create another variable lcm which stores LCM up to the ith element while iterating through the array. Initialize lcm with arr[0].
  3. Iterate over the array from i = 1 to i = N, and in each iteration, check if arr[i] is divided by lcm. If yes increment ans by 1. Also, update lcm with lcm up to ith element.
  4. Print ans as the final answer to this problem.

Below is the implementation of the above approach:

C++




// C++ code to implement the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return total number of
// elements which are divisible by
// all their previous elements
int countElements(int arr[], int N)
{
    int ans = 0;
    int lcm = arr[0];
    for (int i = 1; i < N; i++) {
 
        // To check if number is divisible
        // by lcm of all previous elements
        if (arr[i] % lcm == 0) {
            ans++;
        }
 
        // Updating LCM
        lcm = (lcm * arr[i]) / __gcd(lcm, arr[i]);
    }
    return ans;
}
 
// Driver code
int main()
{
    int arr[] = { 10, 6, 60, 120, 30, 360 };
 
    int N = sizeof(arr) / sizeof(int);
    cout << countElements(arr, N);
    return 0;
}
Java



// Java program for the above approach
import java.util.*;
public class GFG {
 
  // Recursive function to return gcd of a and b
  static int __gcd(int a, int b)
  {
 
    // Everything divides 0
    if (a == 0)
      return b;
    if (b == 0)
      return a;
 
    // base case
    if (a == b)
      return a;
 
    // a is greater
    if (a > b)
      return __gcd(a - b, b);
    return __gcd(a, b - a);
  }
 
  // Function to return total number of
  // elements which are divisible by
  // all their previous elements
  static int countElements(int arr[], int N)
  {
    int ans = 0;
    int lcm = arr[0];
    for (int i = 1; i < N; i++) {
 
      // To check if number is divisible
      // by lcm of all previous elements
      if (arr[i] % lcm == 0) {
        ans++;
      }
 
      // Updating LCM
      lcm = (lcm * arr[i]) / __gcd(lcm, arr[i]);
    }
    return ans;
  }
 
  public static void main(String args[])
  {
    int arr[] = { 10, 6, 60, 120, 30, 360 };
    int N = arr.length;
    System.out.print(countElements(arr, N));
  }
}
 
// This code is contributed by Samim Hossain Mondal.
Python3



# Python code for the above approach
 
# Recursive function to return gcd of a and b
def __gcd(a, b):
   
    # Everything divides 0
    if (a == 0):
        return b;
    if (b == 0):
        return a;
 
    # base case
    if (a == b):
        return a;
 
    # a is greater
    if (a > b):
        return __gcd(a - b, b);
    return __gcd(a, b - a);
 
# Function to return total number of
# elements which are divisible by
# all their previous elements
def countElements(arr, N):
    ans = 0;
    lcm = arr[0];
    for i in range(1, N):
 
        # To check if number is divisible
        # by lcm of all previous elements
        if (arr[i] % lcm == 0):
            ans += 1
 
        # Updating LCM
        lcm = (lcm * arr[i]) / __gcd(lcm, arr[i]);
    return ans;
 
# Driver code
arr = [10, 6, 60, 120, 30, 360];
 
N = len(arr)
print(countElements(arr, N));
 
# This code is contributed by Saurabh Jaiswal
C#



// C#program for the above approach
using System;
 
public class GFG {
 
  // Recursive function to return gcd of a and b
  static int __gcd(int a, int b)
  {
 
    // Everything divides 0
    if (a == 0)
      return b;
    if (b == 0)
      return a;
 
    // base case
    if (a == b)
      return a;
 
    // a is greater
    if (a > b)
      return __gcd(a - b, b);
    return __gcd(a, b - a);
  }
 
  // Function to return total number of
  // elements which are divisible by
  // all their previous elements
  static int countElements(int[] arr, int N)
  {
    int ans = 0;
    int lcm = arr[0];
    for (int i = 1; i < N; i++) {
 
      // To check if number is divisible
      // by lcm of all previous elements
      if (arr[i] % lcm == 0) {
        ans++;
      }
 
      // Updating LCM
      lcm = (lcm * arr[i]) / __gcd(lcm, arr[i]);
    }
    return ans;
  }
 
  public static void Main()
  {
    int[] arr = { 10, 6, 60, 120, 30, 360 };
    int N = arr.Length;
    Console.Write(countElements(arr, N));
  }
}
 
// This code is contributed by ukasp.
Javascript



<script>
      // JavaScript code for the above approach
 
      // Recursive function to return gcd of a and b
      function __gcd(a, b) {
          // Everything divides 0
          if (a == 0)
              return b;
          if (b == 0)
              return a;
 
          // base case
          if (a == b)
              return a;
 
          // a is greater
          if (a > b)
              return __gcd(a - b, b);
          return __gcd(a, b - a);
      }
 
 
      // Function to return total number of
      // elements which are divisible by
      // all their previous elements
      function countElements(arr, N) {
          let ans = 0;
          let lcm = arr[0];
          for (let i = 1; i < N; i++) {
 
              // To check if number is divisible
              // by lcm of all previous elements
              if (arr[i] % lcm == 0) {
                  ans++;
              }
 
              // Updating LCM
              lcm = (lcm * arr[i]) / __gcd(lcm, arr[i]);
          }
          return ans;
      }
 
      // Driver code
 
      let arr = [10, 6, 60, 120, 30, 360];
 
      let N = arr.length
      document.write(countElements(arr, N));
 
// This code is contributed by Potta Lokesh
  </script>
 
 
Output
3
 
Time complexity: O(N * logD) where D is the maximum array element
Auxiliary Space: O(N)
 

My Personal Notes
arrow_drop_up
Previous
Find two numbers B and C such that their product is A and their GCD is maximum
Next

Maximize sum of minimum and maximum of all groups in distribution
Recommended Articles
Page :
Count pairs from 1 to N such that their Sum is divisible by their XOR
17, Mar 20
Queries to find the length of the longest prefix from given array having all elements divisible by K
25, Dec 20
Check if count of substrings in S with string S1 as prefix and S2 as suffix is equal to that with S2 as prefix and S1 as suffix
13, Apr 21
Count of pairs in given Array with product of their values equal to sum of their indices (arr[i]*arr[j] = i+j)
18, Nov 21
Count of indices in Array having all prefix elements less than all in suffix
10, Mar 22
Prefix Factorials of a Prefix Sum Array
01, Jun 21
Count of binary strings of length N having equal count of 0's and 1's and count of 1's ≥ count of 0's in each prefix substring
25, Jul 20
Count of Array elements divisible by either their product or sum of digits
07, Jan 22
Count of pairs in a given range with sum of their product and sum equal to their concatenated number
14, Jun 20
Count of pairs in given range having their ratio equal to ratio of product of their digits
08, Sep 21
Construct Array of given size with elements at even positions divisible by their adjacent left
29, Mar 22
Queries to count numbers from a given range which are divisible the sum of their digits
01, Mar 21
Print all the combinations of N elements by changing sign such that their sum is divisible by M
07, Aug 18
Replace the odd positioned elements with their cubes and even positioned elements with their squares
26, Mar 19
Count clockwise array rotations required to maximize count of array elements present at indices same as their value
24, Nov 20
Find all Array elements that are smaller than all elements to their right
26, Dec 21
Construct an Array of length N containing exactly K elements divisible by their positions
08, Mar 22
Count the number of primes in the prefix sum array of the given array
08, May 19
Minimum prefix increments required to make all elements of an array multiples of another array
31, Jan 21
Count pairs of numbers from 1 to N with Product divisible by their Sum
22, Nov 18
Count integers in a range which are divisible by their euler totient value
13, Mar 19
Queries to count integers in a range [L, R] such that their digit sum is prime and divisible by K
20, Nov 19
Make all array elements even by replacing any pair of array elements with their sum
21, Dec 20
Make all array elements even by replacing adjacent pair of array elements with their sum
21, Dec 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
saurabh15899
@saurabh15899
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!