# Maximum count of elements divisible on the left for any element

Given an array arr[] of N elements. The good value of an element arr[i] is the number of valid indices j<i such that arr[j] is divisible by arr[i].

Example:

Input: arr[] = {9, 6, 2, 3}
Output: 2
9 doesn’t has any element on its left.
6 doesn’t divide any element on its left.
2 divides 6.
3 divides 6 and 9.

Input: arr[] = {8, 1, 28, 4, 2, 6, 7}
Output: 3

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive approach: For every element, find the count of numbers divisible by it on its left and print the maximum of these values.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the maximum count  ` `// of required elements  ` `int` `findMax(``int` `arr[], ``int` `n) ` `{  ` `    ``int` `res = 0; ` `    ``int` `i, j; ` `     `  `    ``// For every element in the array starting  ` `    ``// from the second element  ` `    ``for``(i = 0; i < n ; i++) ` `    ``{ ` `         `  `        ``// Check all the elements on the left  ` `        ``// of current element which are divisible  ` `        ``// by the current element  ` `        ``int` `count = 0; ` `        ``for``(j = 0; j < i; j++) ` `        ``{  ` `            ``if` `(arr[j] % arr[i] == 0)  ` `                ``count += 1; ` `        ``} ` `        ``res = max(count, res); ` `    ``} ` `    ``return` `res; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 8, 1, 28, 4, 2, 6, 7 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``); ` ` `  `    ``cout << findMax(arr, n); ` ` `  `    ``return` `0; ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Java

 `// Java implementation of the approach  ` `class` `GFG  ` `{ ` ` `  `// Function to return the maximum count  ` `// of required elements  ` `static` `int` `findMax(``int` `arr[], ``int` `n) ` `{  ` `    ``int` `res = ``0``; ` `    ``int` `i, j; ` `     `  `    ``// For every element in the array starting  ` `    ``// from the second element  ` `    ``for``(i = ``0``; i < n ; i++) ` `    ``{ ` `         `  `        ``// Check all the elements on the left  ` `        ``// of current element which are divisible  ` `        ``// by the current element  ` `        ``int` `count = ``0``; ` `        ``for``(j = ``0``; j < i; j++) ` `        ``{  ` `            ``if` `(arr[j] % arr[i] == ``0``)  ` `                ``count += ``1``; ` `        ``} ` `        ``res = Math.max(count, res); ` `    ``} ` `    ``return` `res; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main (String[] args) ` `{ ` `    ``int` `arr[] = {``8``, ``1``, ``28``, ``4``, ``2``, ``6``, ``7``}; ` `    ``int` `n = arr.length;  ` `    ``System.out.println(findMax(arr, n)); ` `} ` `} ` ` `  `// This code is contributed by AnkitRai01 `

## Python3

 `# Python3 implementation of the approach ` ` `  `# Function to return the maximum count  ` `# of required elements ` `def` `findMax(arr, n): ` `    ``res ``=` `0` `     `  `    ``# For every element in the array starting  ` `    ``# from the second element ` `    ``for` `i ``in` `range``(``1``, n): ` `         `  `        ``# Check all the elements on the left  ` `        ``# of current element which are divisible  ` `        ``# by the current element ` `        ``count ``=` `0` `        ``for` `j ``in` `range``(``0``, i): ` `            ``if` `arr[j] ``%` `arr[i] ``=``=` `0``: ` `                ``count ``+``=` `1` `        ``res ``=` `max``(count, res) ` `    ``return` `res ` ` `  `# Driver code ` `arr ``=` `[``8``, ``1``, ``28``, ``4``, ``2``, ``6``, ``7``] ` `n ``=` `len``(arr) ` `print``(findMax(arr, n)) `

## C#

 `// C# implementation of the above approach  ` `using` `System; ` `     `  `class` `GFG  ` `{ ` ` `  `// Function to return the maximum count  ` `// of required elements  ` `static` `int` `findMax(``int` `[]arr, ``int` `n) ` `{  ` `    ``int` `res = 0; ` `    ``int` `i, j; ` `     `  `    ``// For every element in the array   ` `    ``// starting from the second element  ` `    ``for``(i = 0; i < n ; i++) ` `    ``{ ` `         `  `        ``// Check all the elements on the left  ` `        ``// of current element which are divisible  ` `        ``// by the current element  ` `        ``int` `count = 0; ` `        ``for``(j = 0; j < i; j++) ` `        ``{  ` `            ``if` `(arr[j] % arr[i] == 0)  ` `                ``count += 1; ` `        ``} ` `        ``res = Math.Max(count, res); ` `    ``} ` `    ``return` `res; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main (String[] args) ` `{ ` `    ``int` `[]arr = {8, 1, 28, 4, 2, 6, 7}; ` `    ``int` `n = arr.Length;  ` `    ``Console.WriteLine(findMax(arr, n)); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:

```3
```

Time Complexity: O(N2)

Efficient approach: It can be observed that for any element pair (arr[i], arr[j]) where i < j and (arr[i] % arr[j]) = 0, if the count of elements divisible by arr[i] on its left is X then the count of elements divisible by arr[j] on its left will definitely be greater than X as all the elements which are divisible by arr[i] will also be divisible by arr[j]. So, for every element which is divisible by any other element on its right, the count of elements on its left which are divisible by it doesn’t need to be calculated which will improve the time complexity of the overall program but it should be noted that for the input where no element is divisible by any other element (for example, when all the lements are prime), the worst-case time complexity would still be O(N2).

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the maximum count ` `// of required elements ` `int` `findMax(``int` `arr[], ``int` `n) ` `{ ` ` `  `    ``// divisible[i] will store true ` `    ``// if arr[i] is divisible by ` `    ``// any element on its right ` `    ``bool` `divisible[n] = { ``false` `}; ` ` `  `    ``// To store the maximum required count ` `    ``int` `res = 0; ` ` `  `    ``// For every element of the array ` `    ``for` `(``int` `i = n - 1; i > 0; i--) { ` ` `  `        ``// If the current element is ` `        ``// divisible by any element ` `        ``// on its right ` `        ``if` `(divisible[i]) ` `            ``continue``; ` ` `  `        ``// Find the count of element ` `        ``// on the left which are divisible ` `        ``// by the current element ` `        ``int` `cnt = 0; ` `        ``for` `(``int` `j = 0; j < i; j++) { ` ` `  `            ``// If arr[j] is divisible then ` `            ``// set divisible[j] to true ` `            ``if` `((arr[j] % arr[i]) == 0) { ` `                ``divisible[j] = ``true``; ` `                ``cnt++; ` `            ``} ` `        ``} ` ` `  `        ``// Update the maximum required count ` `        ``res = max(res, cnt); ` `    ``} ` ` `  `    ``return` `res; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 8, 1, 28, 4, 2, 6, 7 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``); ` ` `  `    ``cout << findMax(arr, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `class` `GFG ` `{ ` ` `  `// Function to return the maximum count ` `// of required elements ` `static` `int` `findMax(``int` `arr[], ``int` `n) ` `{ ` ` `  `    ``// divisible[i] will store true ` `    ``// if arr[i] is divisible by ` `    ``// any element on its right ` `    ``boolean` `[]divisible = ``new` `boolean``[n]; ` ` `  `    ``// To store the maximum required count ` `    ``int` `res = ``0``; ` ` `  `    ``// For every element of the array ` `    ``for` `(``int` `i = n - ``1``; i > ``0``; i--) ` `    ``{ ` ` `  `        ``// If the current element is ` `        ``// divisible by any element ` `        ``// on its right ` `        ``if` `(divisible[i]) ` `            ``continue``; ` ` `  `        ``// Find the count of element ` `        ``// on the left which are divisible ` `        ``// by the current element ` `        ``int` `cnt = ``0``; ` `        ``for` `(``int` `j = ``0``; j < i; j++)  ` `        ``{ ` ` `  `            ``// If arr[j] is divisible then ` `            ``// set divisible[j] to true ` `            ``if` `((arr[j] % arr[i]) == ``0``) ` `            ``{ ` `                ``divisible[j] = ``true``; ` `                ``cnt++; ` `            ``} ` `        ``} ` ` `  `        ``// Update the maximum required count ` `        ``res = Math.max(res, cnt); ` `    ``} ` `    ``return` `res; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `arr[] = { ``8``, ``1``, ``28``, ``4``, ``2``, ``6``, ``7` `}; ` `    ``int` `n = arr.length; ` ` `  `    ``System.out.println(findMax(arr, n)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Python3

 `# Python3 implementation of the approach  ` ` `  `# Function to return the maximum count  ` `# of required elements  ` `def` `findMax(arr, n) :  ` ` `  `    ``# divisible[i] will store true  ` `    ``# if arr[i] is divisible by  ` `    ``# any element on its right  ` `    ``divisible ``=` `[ ``False` `] ``*` `n;  ` ` `  `    ``# To store the maximum required count  ` `    ``res ``=` `0``;  ` ` `  `    ``# For every element of the array  ` `    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``) :  ` ` `  `        ``# If the current element is  ` `        ``# divisible by any element  ` `        ``# on its right  ` `        ``if` `(divisible[i]) : ` `            ``continue``;  ` ` `  `        ``# Find the count of element  ` `        ``# on the left which are divisible  ` `        ``# by the current element  ` `        ``cnt ``=` `0``;  ` `        ``for` `j ``in` `range``(i) : ` ` `  `            ``# If arr[j] is divisible then  ` `            ``# set divisible[j] to true  ` `            ``if` `((arr[j] ``%` `arr[i]) ``=``=` `0``) : ` `                ``divisible[j] ``=` `True``;  ` `                ``cnt ``+``=` `1``;  ` ` `  `        ``# Update the maximum required count  ` `        ``res ``=` `max``(res, cnt);  ` ` `  `    ``return` `res;  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``arr ``=` `[ ``8``, ``1``, ``28``, ``4``, ``2``, ``6``, ``7` `];  ` `    ``n ``=` `len``(arr);  ` ` `  `    ``print``(findMax(arr, n));  ` ` `  `# This code is contributed by kanugargng `

## C#

 `// C# implementation of the approach ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// Function to return the maximum count ` `// of required elements ` `static` `int` `findMax(``int` `[]arr, ``int` `n) ` `{ ` ` `  `    ``// divisible[i] will store true ` `    ``// if arr[i] is divisible by ` `    ``// any element on its right ` `    ``bool` `[]divisible = ``new` `bool``[n]; ` ` `  `    ``// To store the maximum required count ` `    ``int` `res = 0; ` ` `  `    ``// For every element of the array ` `    ``for` `(``int` `i = n - 1; i > 0; i--) ` `    ``{ ` ` `  `        ``// If the current element is ` `        ``// divisible by any element ` `        ``// on its right ` `        ``if` `(divisible[i]) ` `            ``continue``; ` ` `  `        ``// Find the count of element ` `        ``// on the left which are divisible ` `        ``// by the current element ` `        ``int` `cnt = 0; ` `        ``for` `(``int` `j = 0; j < i; j++)  ` `        ``{ ` ` `  `            ``// If arr[j] is divisible then ` `            ``// set divisible[j] to true ` `            ``if` `((arr[j] % arr[i]) == 0) ` `            ``{ ` `                ``divisible[j] = ``true``; ` `                ``cnt++; ` `            ``} ` `        ``} ` ` `  `        ``// Update the maximum required count ` `        ``res = Math.Max(res, cnt); ` `    ``} ` `    ``return` `res; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args)  ` `{ ` `    ``int` `[]arr = { 8, 1, 28, 4, 2, 6, 7 }; ` `    ``int` `n = arr.Length; ` ` `  `    ``Console.WriteLine(findMax(arr, n)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```3
```

My Personal Notes arrow_drop_up If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.