Wednesday, January 22, 2025
Google search engine
HomeData Modelling & AIPrint digits for each array element that does not divide any digit...

Print digits for each array element that does not divide any digit of that element

Given an array arr[] consisting of N positive integers, the task for each array element arr[i] is to find all the digits from [0, 9] that do not divide any digit present in arr[i].

Examples:

Input: arr[] = {4162, 1152, 99842}
Output:
4162 -> 5 7 8 9
1152 -> 3 4 6 7 8 9
99842 -> 5 6 7
Explanation:
For arr[0] ( = 4162): None of the digits of the element 4162 are divisible by 5, 7, 8, 9.
For arr[1]( = 1152): None of the digits of the element 1152 are divisible by 9, 8, 7, 6, 4, 3.
For arr[2]( = 99842): None of the digits of the element 99842 are divisible by 7, 6, 5.

Input: arr[] = {2021}
Output:
2021 -> 3 4 5 6 7 8 9

 

Approach: Follow the steps below to solve the problem:

  • Traverse the given array arr[] and perform the following steps:
    • Iterate over the range [2, 9] using the variable i, and if there doesn’t exist any digit in the element arr[i] that is divisible by i, then print the digit i.
    • Otherwise, continue for the next iteration.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find digits for each array
// element that doesn't divide any digit
// of the that element
void indivisibleDigits(int arr[], int N)
{
    // Traverse the array arr[]
    for (int i = 0; i < N; i++) {
 
        int num = 0;
 
        cout << arr[i] << ": ";
 
        // Iterate over the range [2, 9]
        for (int j = 2; j < 10; j++) {
 
            int temp = arr[i];
 
            // Stores if there exists any digit
            // in arr[i] which is divisible by j
            bool flag = true;
 
            while (temp > 0) {
 
                // If any digit of the number
                // is divisible by j
                if ((temp % 10) != 0
                    && (temp % 10) % j == 0) {
 
                    flag = false;
                    break;
                }
 
                temp /= 10;
            }
 
            // If the digit j doesn't
            // divide any digit of arr[i]
            if (flag) {
                cout << j << ' ';
            }
        }
 
        cout << endl;
    }
}
 
// Driver Code
int main()
{
    int arr[] = { 4162, 1152, 99842 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    indivisibleDigits(arr, N);
 
    return 0;
}


Java




// Java program for the above approach
import java.io.*;
import java.util.*;
class GFG
{
 
  // Function to find digits for each array
  // element that doesn't divide any digit
  // of the that element
  static void indivisibleDigits(int[] arr, int N)
  {
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++)
    {
      System.out.print(arr[i] + ": ");
 
      // Iterate over the range [2, 9]
      for (int j = 2; j < 10; j++)
      {
        int temp = arr[i];
 
        // Stores if there exists any digit
        // in arr[i] which is divisible by j
        boolean flag = true;
        while (temp > 0) {
 
          // If any digit of the number
          // is divisible by j
          if ((temp % 10) != 0
              && (temp % 10) % j == 0) {
 
            flag = false;
            break;
          }
 
          temp /= 10;
        }
 
        // If the digit j doesn't
        // divide any digit of arr[i]
        if (flag) {
          System.out.print(j + " ");
        }
      }
 
      System.out.println();
    }
  }
 
 
  // Driver Code
  public static void main(String[] args)
  {
    int[] arr = { 4162, 1152, 99842 };
    int N = arr.length;
 
    indivisibleDigits(arr, N);
  }
}
 
// This code is contributed by sanjoy_62.


Python3




# Python3 program for the above approach
 
# Function to find digits for each array
# element that doesn't divide any digit
# of the that element
def indivisibleDigits(arr, N) :
     
    # Traverse the array arr[]
    for i in range(N):
 
        num = 0
 
        print(arr[i], end = ' ')
 
        # Iterate over the range [2, 9]
        for j in range(2, 10):
 
            temp = arr[i]
 
            # Stores if there exists any digit
            # in arr[i] which is divisible by j
            flag = True
 
            while (temp > 0) :
 
                # If any digit of the number
                # is divisible by j
                if ((temp % 10) != 0
                    and (temp % 10) % j == 0) :
 
                    flag = False
                    break
                 
 
                temp //= 10
             
 
            # If the digit j doesn't
            # divide any digit of arr[i]
            if (flag) :
                print(j, end = ' ')
 
        print()
     
# Driver Code
 
arr = [ 4162, 1152, 99842 ]
N = len(arr)
 
indivisibleDigits(arr, N)
 
# This code is contributed by susmitakundugoaldanga.


C#




// C# program for the above approach
using System;
class GFG
{
 
  // Function to find digits for each array
  // element that doesn't divide any digit
  // of the that element
  static void indivisibleDigits(int[] arr, int N)
  {
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++)
    {
      Console.Write(arr[i] + ": ");
 
      // Iterate over the range [2, 9]
      for (int j = 2; j < 10; j++)
      {
        int temp = arr[i];
 
        // Stores if there exists any digit
        // in arr[i] which is divisible by j
        bool flag = true;
        while (temp > 0) {
 
          // If any digit of the number
          // is divisible by j
          if ((temp % 10) != 0
              && (temp % 10) % j == 0) {
 
            flag = false;
            break;
          }
 
          temp /= 10;
        }
 
        // If the digit j doesn't
        // divide any digit of arr[i]
        if (flag) {
          Console.Write(j + " ");
        }
      }
 
      Console.WriteLine();
    }
  }
 
  // Driver Code
  public static void Main()
  {
    int[] arr = { 4162, 1152, 99842 };
    int N = arr.Length;
 
    indivisibleDigits(arr, N);
  }
}
 
// This code is contributed by rishavmahato348.


Javascript




<script>
 
// javascript program for the above approach
// Function to find digits for each array
    // element that doesn't divide any digit
    // of the that element
    function indivisibleDigits(arr , N) {
 
        // Traverse the array arr
        for (i = 0; i < N; i++) {
            document.write(arr[i] + ": ");
 
            // Iterate over the range [2, 9]
            for (j = 2; j < 10; j++) {
                var temp = arr[i];
 
                // Stores if there exists any digit
                // in arr[i] which is divisible by j
                var flag = true;
                while (temp > 0) {
 
                    // If any digit of the number
                    // is divisible by j
                    if ((temp % 10) != 0 && (temp % 10) % j == 0) {
 
                        flag = false;
                        break;
                    }
 
                    temp = parseInt(temp/10);
                }
 
                // If the digit j doesn't
                // divide any digit of arr[i]
                if (flag) {
                    document.write(j + " ");
                }
            }
 
            document.write("<br/>");
        }
    }
 
    // Driver Code
     
        var arr = [ 4162, 1152, 99842 ];
        var N = arr.length;
 
        indivisibleDigits(arr, N);
 
// This code contributed by aashish1995
</script>


Output: 

4162: 5 7 8 9 
1152: 3 4 6 7 8 9 
99842: 5 6 7

 

Time Complexity: O(10*N*log10N)
Auxiliary Space: O(1)

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

Most Popular

Recent Comments