从不能被K整除的索引中找到具有最大数字乘积的数组元素

给定一个数组arr []和一个整数K ，任务是从不能被K整除的索引中找到该数组元素，该索引的数字乘积是一个复合数字。

例子：

Input: arr[] = {233, 144, 89, 71, 13, 21, 11, 34, 55, 23}, K = 3 
Output: 89 
Explanation: 
Following elements have product of digits as a composite number: 
arr[0] = 233 : Product of digits = 2 * 3 * 3 = 18 
arr[1] = 144 : Product of digits = 1 * 4 * 4 = 16 
arr[2] = 89 : Product of digits = 8 * 9 = 72 
arr[7] = 34 : Product of digits = 3 * 4 = 12 
arr[8] = 55 : Product of digits = 5 * 5 = 25 
Therefore, the largest composite product of digits of array elements at indices not divisible by K ( = 3) is 72.

Input: arr[] = {122, 566, 131, 211, 721, 19, 65, 1111, 111777}, K = 4 
Output: 566

方法：按照以下步骤解决问题

• 遍历给定数组arr [] 。
• 对于每个数组元素，请检查其数字的乘积是否为合成或数字的乘积小于或等于1 。
• 如果其数字的乘积是合成的，并且其位置可被k整除，则
  • 将元素插入ans变量中，并将其Composite DigitProduct插入向量pq中。
• 最后，在对向量pq中的元素进行排序之后，找到具有最大Composite DigitProduct的元素。

下面是上述方法的实现：

C++

// C++ program to implement
// the above approach
#include 
#include 
 
using namespace std;
 
// Function to check if a number
// is a composite number or not
bool isComposite(int n)
{
    // Corner cases
    if (n <= 1)
        return false;
    if (n <= 3)
        return false;
 
    // Check if number is divisible by 2 or 3
    if (n % 2 == 0 || n % 3 == 0)
        return true;
 
    // Check if number is a multiple
    // of any other prime number
    for (int i = 5; i * i <= n; i = i + 6)
        if (n % i == 0 || n % (i + 2) == 0)
            return true;
 
    return false;
}
 
// Function to calculate the product
// of digits of a number
int digitProduct(int number)
{
    // Stores the product of digits
    int product = 1;
 
    while (number > 0) {
 
        // Extract digits of a number
        product *= (number % 10);
 
        // Calculate product of digits
        number /= 10;
    }
    return product;
}
 
// Function to check if the product of digits
// of a number is a composite number or not
bool compositedigitProduct(int num)
{
    // Stores product of digits
    int res = digitProduct(num);
 
    // If product of digits is equal to 1
    if (res == 1) {
        return false;
    }
    // If product of digits is not prime
    if (isComposite(res)) {
        return true;
    }
 
    return false;
}
// Function to find the number with largest
// composite product of digits from the indices
// not divisible by k from the given array
int largestCompositeDigitProduct(int a[], int n, int k)
{
    vector > pq;
 
    // Traverse the array
    for (int i = 0; i < n; i++) {
 
        // If index is divisible by k
        if ((i % k) == 0) {
            continue;
        }
 
        // Check if product of digits
        // is a composite number or not
        if (compositedigitProduct(a[i])) {
            int b = digitProduct(a[i]);
            pq.push_back(make_pair(b, a[i]));
        }
    }
 
    // Sort the products
    sort(pq.begin(), pq.end());
 
    return pq.back().second;
}
 
// Driver Code
int main()
{
 
    int arr[] = { 233, 144, 89, 71, 13,
                  21, 11, 34, 55, 23 };
    int n = sizeof(arr)
            / sizeof(arr[0]);
    int k = 3;
 
    int ans = largestCompositeDigitProduct(
        arr, n, k);
 
    cout << ans << endl;
    return 0;
}

Java

// Java program to implement
// the above approach
import java.util.*;
class GFG
{
    static class pair
    {
        int first, second;
        public pair(int first, int second) 
        {
            this.first = first;
            this.second = second;
        }   
    }
   
// Function to check if a number
// is a composite number or not
static boolean isComposite(int n)
{
    // Corner cases
    if (n <= 1)
        return false;
    if (n <= 3)
        return false;
 
    // Check if number is divisible by 2 or 3
    if (n % 2 == 0 || n % 3 == 0)
        return true;
 
    // Check if number is a multiple
    // of any other prime number
    for (int i = 5; i * i <= n; i = i + 6)
        if (n % i == 0 || n % (i + 2) == 0)
            return true;
 
    return false;
}
 
// Function to calculate the product
// of digits of a number
static int digitProduct(int number)
{
    // Stores the product of digits
    int product = 1;
    while (number > 0) {
 
        // Extract digits of a number
        product *= (number % 10);
 
        // Calculate product of digits
        number /= 10;
    }
    return product;
}
 
// Function to check if the product of digits
// of a number is a composite number or not
static boolean compositedigitProduct(int num)
{
    // Stores product of digits
    int res = digitProduct(num);
 
    // If product of digits is equal to 1
    if (res == 1) {
        return false;
    }
   
    // If product of digits is not prime
    if (isComposite(res)) {
        return true;
    }
    return false;
}
// Function to find the number with largest
// composite product of digits from the indices
// not divisible by k from the given array
static int largestCompositeDigitProduct(int a[], int n, int k)
{
    Vector pq = new Vector();
 
    // Traverse the array
    for (int i = 0; i < n; i++) {
 
        // If index is divisible by k
        if ((i % k) == 0) {
            continue;
        }
 
        // Check if product of digits
        // is a composite number or not
        if (compositedigitProduct(a[i]))
        {
            int b = digitProduct(a[i]);
            pq.add(new pair(b, a[i]));
        }
    }
 
    // Sort the products
    Collections.sort(pq, (x, y) -> x.first - y.first);
 
    return pq.get(pq.size() - 1).second;
}
 
// Driver Code
public static void main(String[] args)
{
 
    int arr[] = { 233, 144, 89, 71, 13,
                  21, 11, 34, 55, 23 };
    int n = arr.length;
    int k = 3;
    int ans = largestCompositeDigitProduct(
        arr, n, k);
    System.out.print(ans +"\n");
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 program to implement
# the above approach
from math import ceil, sqrt
 
# Function to check if a number
# is a composite number or not
def isComposite(n):
   
    # Corner cases
    if (n <= 1):
        return False
    if (n <= 3):
        return False
 
    # Check if number is divisible by 2 or 3
    if (n % 2 == 0 or n % 3 == 0):
        return True
 
    # Check if number is a multiple
    # of any other prime number
    for i in range(5, ceil(sqrt(n)),6):
        if (n % i == 0 or n % (i + 2) == 0):
            return True
 
    return False
 
# Function to calculate the product
# of digits of a number
def digitProduct(number):
   
    # Stores the product of digits
    product = 1
 
    while (number > 0):
 
        # Extract digits of a number
        product *= (number % 10)
 
        # Calculate product of digits
        number //= 10
    return product
 
# Function to check if the product of digits
# of a number is a composite number or not
def compositedigitProduct(num):
   
    # Stores product of digits
    res = digitProduct(num)
 
    # If product of digits is equal to 1
    if (res == 1):
        return False
    # If product of digits is not prime
    if (isComposite(res)):
        return True
 
    return False
 
# Function to find the number with largest
# composite product of digits from the indices
# not divisible by k from the given array
def largestCompositeDigitProduct(a, n, k):
    pq = []
 
    # Traverse the array
    for i in range(n):
 
        # If index is divisible by k
        if ((i % k) == 0):
            continue
 
        # Check if product of digits
        # is a composite number or not
        if (compositedigitProduct(a[i])):
            b = digitProduct(a[i])
            pq.append([b, a[i]])
 
    # Sort the products
    pq = sorted (pq)
    return pq[-1][1]
 
# Driver Code
if __name__ == '__main__':
 
    arr = [233, 144, 89, 71, 13, 21, 11, 34, 55, 23]
    n = len(arr)
    k = 3
 
    ans = largestCompositeDigitProduct(arr, n, k)
    print (ans)
 
# This code is contributed by divyesh072019

C#

// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
 
class GFG
{
    class pair : IComparable
    {
        public int first, second;
        public pair(int first, int second) 
        {
            this.first = first;
            this.second = second;
        }
         public int CompareTo(pair p)
         {
             return this.second-p.first;
         }
    }
   
// Function to check if a number
// is a composite number or not
static bool isComposite(int n)
{
    // Corner cases
    if (n <= 1)
        return false;
    if (n <= 3)
        return false;
 
    // Check if number is divisible by 2 or 3
    if (n % 2 == 0 || n % 3 == 0)
        return true;
 
    // Check if number is a multiple
    // of any other prime number
    for (int i = 5; i * i <= n; i = i + 6)
        if (n % i == 0 || n % (i + 2) == 0)
            return true;
 
    return false;
}
 
// Function to calculate the product
// of digits of a number
static int digitProduct(int number)
{
   
    // Stores the product of digits
    int product = 1;
    while (number > 0)
    {
 
        // Extract digits of a number
        product *= (number % 10);
 
        // Calculate product of digits
        number /= 10;
    }
    return product;
}
 
// Function to check if the product of digits
// of a number is a composite number or not
static bool compositedigitProduct(int num)
{
   
    // Stores product of digits
    int res = digitProduct(num);
 
    // If product of digits is equal to 1
    if (res == 1) {
        return false;
    }
   
    // If product of digits is not prime
    if (isComposite(res)) {
        return true;
    }
    return false;
}
// Function to find the number with largest
// composite product of digits from the indices
// not divisible by k from the given array
static int largestCompositeDigitProduct(int []a, int n, int k)
{
    List pq = new List();
 
    // Traverse the array
    for (int i = 0; i < n; i++)
    {
 
        // If index is divisible by k
        if ((i % k) == 0)
        {
            continue;
        }
 
        // Check if product of digits
        // is a composite number or not
        if (compositedigitProduct(a[i]))
        {
            int b = digitProduct(a[i]);
            pq.Add(new pair(b, a[i]));
        }
    }
 
    // Sort the products
    pq.Sort();
    return pq[pq.Count - 1].second;
}
 
// Driver Code
public static void Main(String[] args)
{
 
    int []arr = { 233, 144, 89, 71, 13,
                  21, 11, 34, 55, 23 };
    int n = arr.Length;
    int k = 3;
    int ans = largestCompositeDigitProduct(
        arr, n, k);
    Console.Write(ans +"\n");
}
}
 
// This code is contributed by 29AjayKumar

输出：

89

时间复杂度： O(N)
辅助空间： O(N)