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

Given two arrays A[] and B[], write an efficient code to determine if every element of B[] is divisible by at least 1 element of A[]. Display those elements of B[], which are not divisible by any of the element in A[].

Examples :

```Input : A[] = {100, 200, 400, 100, 600}
B[] = {45, 90, 48, 1000, 3000}
Output : 45, 90, 48
The output elements are those that are
not divisible by any element of A[].
```

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

Method I (Naive Implementation)

• Iterate through every single element of B[].
• Check if it is divisible by at-least 1 element of A[] or not. If not divisible by any, then print it.

## C++

 `// C++ code for naive implementation ` `#include ` `using` `namespace` `std; ` ` `  `// Function for checking the condition ` `// with 2 loops ` `void` `printNonDivisible(``int` `A[], ``int` `B[], ` `                          ``int` `n, ``int` `m) ` `{ ` `    ``for` `(``int` `i = 0; i < m; i++) ` `    ``{ ` `        ``int` `j = 0; ` `        ``for` `(j = 0; j < n; j++) ` `            ``if``( B[i] % A[j] == 0 ) ` `                ``break``; ` ` `  `        ``// If none of the elements in A[] ` `        ``// divided B[i] ` `        ``if` `(j == n) ` `            ``cout << B[i] << endl; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `A[] = {100, 200, 400, 100}; ` `    ``int` `n = ``sizeof``(A)/``sizeof``(A); ` `    ``int` `B[] = {190, 200, 87, 600, 800}; ` `    ``int` `m = ``sizeof``(B)/``sizeof``(B); ` `    ``printNonDivisible(A, B, n, m); ` `    ``return` `0; ` `} `

## Java

 `// Java code for naive implementation ` `import` `java.io.*; ` ` `  `public` `class` `GFG { ` `     `  `// Function for checking the condition ` `// with 2 loops ` `static` `void` `printNonDivisible(``int` `[]A, ``int` `[]B, ` `                              ``int` `n, ``int` `m) ` `{ ` `     `  `    ``for` `(``int` `i = ``0``; i < m; i++) ` `    ``{ ` `        ``int` `j = ``0``; ` `        ``for` `(j = ``0``; j < n; j++) ` `            ``if``( B[i] % A[j] == ``0` `) ` `                ``break``; ` ` `  `        ``// If none of the elements  ` `        ``// in A[] divided B[i] ` `        ``if` `(j == n) ` `            ``System.out.println(B[i]); ` `    ``} ` `} ` ` `  `    ``// Driver code ` `    ``static` `public` `void` `main (String[] args) ` `    ``{ ` `        ``int` `[]A = {``100``, ``200``, ``400``, ``100``}; ` `        ``int` `n = A.length; ` `         `  `        ``int` `[]B = {``190``, ``200``, ``87``, ``600``, ``800``}; ` `        ``int` `m = B.length; ` `         `  `        ``printNonDivisible(A, B, n, m); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m . `

## Python3

 `# Python3 code for naive implementation ` `import` `math as mt ` ` `  `# Function for checking the condition ` `# with 2 loops ` `def` `printNonDivisible(A, B, n, m): ` ` `  `    ``for` `i ``in` `range``(m): ` `        ``j ``=` `0` `        ``for` `j ``in` `range``(n): ` `            ``if``(B[i] ``%` `A[j] ``=``=` `0``): ` `                ``break` ` `  `        ``# If none of the elements in A[] ` `        ``# divided B[i] ` `        ``if` `(j ``=``=` `n ``-` `1``): ` `            ``print``(B[i]) ` ` `  `# Driver code ` `A ``=` `[``100``, ``200``, ``400``, ``100``] ` `n ``=` `len``(A) ` `B ``=` `[``190``, ``200``, ``87``, ``600``, ``800``] ` `m ``=` `len``(B) ` `printNonDivisible(A, B, n, m) ` ` `  `# This code is contributed by# ` `# mohit kumar 29 `

## C#

 `// C# code for naive implementation ` `using` `System; ` ` `  `public` `class` `GFG { ` `     `  `// Function for checking the  ` `// condition with 2 loops ` `static` `void` `printNonDivisible(``int` `[]A, ``int` `[]B, ` `                              ``int` `n, ``int` `m) ` `{ ` `     `  `    ``for` `(``int` `i = 0; i < m; i++) ` `    ``{ ` `        ``int` `j = 0; ` `        ``for` `(j = 0; j < n; j++) ` `            ``if``( B[i] % A[j] == 0 ) ` `                ``break``; ` ` `  `        ``// If none of the elements  ` `        ``// in A[] divided B[i] ` `        ``if` `(j == n) ` `            ``Console.WriteLine(B[i]); ` `    ``} ` `} ` ` `  `    ``// Driver code ` `    ``static` `public` `void` `Main () ` `    ``{ ` `        ``int` `[]A = {100, 200, 400, 100}; ` `        ``int` `n = A.Length; ` `        ``int` `[]B = {190, 200, 87, 600, 800}; ` `        ``int` `m = B.Length; ` `        ``printNonDivisible(A, B, n, m); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m . `

## PHP

 ` `

Output :

```190
87
```

Time Complexity :- O(n*m)
Auxiliary Space :- O(1)

Method 2 (Efficient when elements in are small)

• Maintain an array mark[] to mark the multiples of the numbers in A[].
• Mark all the multiples of all the elements in A[], till max of B[].
• Check if mark[B[i]] value for every element n in B[] is not 0 and print if not marked.

## C++

 `// CPP code for improved implementation ` `#include ` `using` `namespace` `std; ` ` `  `// Function for printing all elements of B[] ` `// that are not divisible by any element of A[] ` `void` `printNonDivisible(``int` `A[], ``int` `B[], ``int` `n, ` `                                         ``int` `m) ` `{ ` `    ``// Find maximum element in B[] ` `    ``int` `maxB = 0; ` `    ``for` `(``int` `i = 0; i < m; i++) ` `        ``if` `(B[i] > maxB) ` `            ``maxB = B[i]; ` ` `  `    ``// Initialize all multiples as marked ` `    ``int` `mark[maxB]; ` `    ``memset``(mark, 0, ``sizeof``(mark)); ` ` `  `    ``// Marking the multiples of all the ` `    ``// elements of the array. ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``for` `(``int` `x = A[i]; x <= maxB; x += A[i]) ` `            ``mark[x]++; ` ` `  `    ``// Print not marked elements ` `    ``for` `(``int` `i = 0; i < m; i++) ` `        ``if` `(! mark[B[i]]) ` `            ``cout << B[i] << endl; ` `} ` ` `  `// Driver function ` `int` `main() ` `{ ` `    ``int` `A[] = {100, 200, 400, 100}; ` `    ``int` `n = ``sizeof``(A)/``sizeof``(A); ` `    ``int` `B[] = {190, 200, 87, 600, 800}; ` `    ``int` `m = ``sizeof``(B)/``sizeof``(B); ` `    ``printNonDivisible(A, B, n, m); ` `    ``return` `0; ` `} `

## Java

 `// Java code for improved implementation ` `import` `java.io.*; ` ` `  `class` `GFG ` `{ ` `     `  `// Function for printing all elements of B[] ` `// that are not divisible by any element of A[] ` `static` `void` `printNonDivisible(``int` `[]A, ``int` `[]B,  ` `                                    ``int` `n,``int` `m) ` `{ ` `    ``// Find maximum element in B[] ` `    ``int` `maxB = ``0``; ` `    ``for` `(``int` `i = ``0``; i < m; i++) ` `        ``if` `(B[i] > maxB) ` `            ``maxB = B[i]; ` ` `  `    ``// Initialize all multiples as marked ` ` `  `    ``int` `[] mark = ``new` `int``[maxB + ``1``]; ` `    ``for``(``int` `i = ``0``; i < maxB; i++) ` `        ``mark[i]=``0``; ` ` `  `    ``// Marking the multiples of all the ` `    ``// elements of the array. ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``for` `(``int` `x = A[i]; x <= maxB; x += A[i]) ` `            ``mark[x]++; ` ` `  `    ``// Print not marked elements ` `    ``for` `(``int` `i = ``0``; i < m; i++) ` `        ``if` `(mark[B[i]] == ``0``) ` `            ``System.out.println(B[i]); ` `} ` ` `  `// Driver code ` `static` `public` `void` `main(String[] args) ` `{ ` `    ``int` `[]A= {``100``, ``200``, ``400``, ``100``}; ` `    ``int` `n = A.length; ` `    ``int` `[]B= {``190``, ``200``, ``87``, ``600``, ``800``}; ` `    ``int` `m = B.length; ` `    ``printNonDivisible(A, B, n, m); ` `} ` `} ` ` `  `// This code is contributed by Mohit Kumar. `

## Python3

 `# Python 3 code for improved implementation ` ` `  `# Function for printing all elements of B[] ` `# that are not divisible by any element of A[] ` `def` `printNonDivisible(A, B, n, m): ` `     `  `    ``# Find maximum element in B[] ` `    ``maxB ``=` `0` `    ``for` `i ``in` `range``(``0``, m, ``1``): ` `        ``if` `(B[i] > maxB): ` `            ``maxB ``=` `B[i] ` ` `  `    ``# Initialize all multiples as marked ` `    ``mark ``=` `[``0` `for` `i ``in` `range``(maxB)] ` ` `  `    ``# Marking the multiples of all  ` `    ``# the elements of the array. ` `    ``for` `i ``in` `range``(``0``, n, ``1``): ` `        ``for` `x ``in` `range``(A[i], maxB, A[i]): ` `            ``mark[x] ``+``=` `1` ` `  `    ``# Print not marked elements ` `    ``for` `i ``in` `range``(``0``, m ``-` `1``, ``1``): ` `        ``if` `(mark[B[i]] ``=``=` `0``): ` `            ``print``(B[i]) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``A ``=` `[``100``, ``200``, ``400``, ``100``] ` `    ``n ``=` `len``(A) ` `    ``B ``=` `[``190``, ``200``, ``87``, ``600``, ``800``] ` `    ``m ``=` `len``(B) ` `    ``printNonDivisible(A, B, n, m) ` ` `  `# This code is contributed by ` `# Shashank_Sharma `

## C#

 `// C# code for improved implementation ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `// Function for printing all elements of []B ` `// that are not divisible by any element of []A ` `static` `void` `printNonDivisible(``int` `[]A, ``int` `[]B,  ` `                                    ``int` `n, ``int` `m) ` `{ ` `    ``// Find maximum element in []B ` `    ``int` `maxB = 0; ` `    ``for` `(``int` `i = 0; i < m; i++) ` `        ``if` `(B[i] > maxB) ` `            ``maxB = B[i]; ` ` `  `    ``// Initialize all multiples as marked ` `    ``int` `[] mark = ``new` `int``[maxB + 1]; ` `    ``for``(``int` `i = 0; i < maxB; i++) ` `        ``mark[i] = 0; ` ` `  `    ``// Marking the multiples of all the ` `    ``// elements of the array. ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``for` `(``int` `x = A[i]; x <= maxB; x += A[i]) ` `            ``mark[x]++; ` ` `  `    ``// Print not marked elements ` `    ``for` `(``int` `i = 0; i < m; i++) ` `        ``if` `(mark[B[i]] == 0) ` `            ``Console.WriteLine(B[i]); ` `} ` ` `  `// Driver code ` `static` `public` `void` `Main(String[] args) ` `{ ` `    ``int` `[]A= {100, 200, 400, 100}; ` `    ``int` `n = A.Length; ` `    ``int` `[]B= {190, 200, 87, 600, 800}; ` `    ``int` `m = B.Length; ` `    ``printNonDivisible(A, B, n, m); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## PHP

 ` ``\$maxB``) ` `            ``\$maxB` `= ``\$B``[``\$i``]; ` `    ``} ` `     `  `    ``// Initialize all multiples as marked ` `    ``\$mark` `= ``array``(); ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$maxB``; ``\$i``++) ` `    ``{ ` `        ``\$mark``[] = ``"0"``; ` `    ``} ` ` `  `    ``// Marking the multiples of all ` `    ``// the elements of the array. ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `    ``{ ` `        ``for` `(``\$x` `= ``\$A``[``\$i``]; ``\$x` `< ``\$maxB``; ` `                          ``\$x` `+= ``\$A``[``\$i``]) ` `        ``{ ` `            ``\$mark``[``\$x``] += 1; ` `        ``} ` `    ``} ` `     `  `    ``// Print not marked elements ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$m` `- 1; ``\$i``++) ` `    ``{ ` `        ``if` `(``\$mark``[``\$B``[``\$i``]] == 0) ` `            ``echo` `"\$B[\$i]\n"``; ` `    ``} ` `} ` ` `  `// Driver Code ` `\$A` `= ``array``(100, 200, 400, 100); ` `\$n` `= ``count``(``\$A``); ` `\$B` `= ``array``(190, 200, 87, 600, 800); ` `\$m` `= ``count``(``\$B``); ` `printNonDivisible(``\$A``, ``\$B``, ``\$n``, ``\$m``); ` ` `  `// This code is contributed by ` `// Srathore ` `?> `

Output :

```190
87
```

Time Complexity :- O(m + n*(max(B[]/min(A[])))
Auxiliary Space :- O(n) + O(m) + O(max(B[]))

This article is contributed by Sakshi Tiwari .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.