Skip to content
Related Articles

Related Articles

Minimum and Maximum element of an array which is divisible by a given number k
  • Difficulty Level : Basic
  • Last Updated : 21 Apr, 2021

Given an array, the task is to find the minimum and maximum elements in the array which are divisible by a given number k.
Examples: 
 

Input: arr[] = {12, 1235, 45, 67, 1}, k=5
Output: Minimum = 45, Maximum = 1235

Input: arr[] = {10, 1230, 45, 67, 1}, k=10
Output: Minimum = 10, Maximum = 1230

 

Approach: 
 

  1. Take a min variable that stores the minimum element and initialize it with INT_MAX and compare it with every element of the array and update the next minimum element which is divisible by k.
  2. Take a max variable that stores the maximum element and initialize it with INT_MIN and compare it with every element of the array and update the next maximum element which is divisible by k.

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum element
int getMin(int arr[], int n, int k)
{
    int res = INT_MAX;
    for (int i = 0; i < n; i++) {
        if (arr[i] % k == 0)
            res = min(res, arr[i]);
    }
    return res;
}
 
// Function to find the maximum element
int getMax(int arr[], int n, int k)
{
    int res = INT_MIN;
    for (int i = 1; i < n; i++) {
        if (arr[i] % k == 0)
            res = max(res, arr[i]);
    }
    return res;
}
 
// Driver code
int main()
{
    int arr[] = { 10, 1230, 45, 67, 1 };
    int k = 10;
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Minimum element of array which is divisible by k: "
         << getMin(arr, n, k) << "\n";
    cout << "Maximum element of array which is divisible by k: "
         << getMax(arr, n, k);
 
    return 0;
}

Java




//Java implementation of the above approach
 
class GFG {
 
// Function to find the minimum element
    static int getMin(int arr[], int n, int k) {
        int res = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            if (arr[i] % k == 0) {
                res = Math.min(res, arr[i]);
            }
        }
        return res;
    }
 
// Function to find the maximum element
    static int getMax(int arr[], int n, int k) {
        int res = Integer.MIN_VALUE;
        for (int i = 1; i < n; i++) {
            if (arr[i] % k == 0) {
                res = Math.max(res, arr[i]);
            }
        }
        return res;
    }
 
// Driver code
    public static void main(String[] args) {
        int arr[] = {10, 1230, 45, 67, 1};
        int k = 10;
        int n = arr.length;
        System.out.println("Minimum element of array which is divisible by k: "
                + getMin(arr, n, k));
        System.out.println("Maximum element of array which is divisible by k: "
                + getMax(arr, n, k));
    }
}
//This code contribute by Shikha Singh

Python 3




# Python 3 implementation of the
# above approach
import sys
 
# Function to find the minimum element
def getMin(arr, n, k):
 
    res = sys.maxsize
    for i in range(n):
        if (arr[i] % k == 0):
            res = min(res, arr[i])
    return res
 
# Function to find the maximum element
def getMax(arr, n, k):
 
    res = 0
    for i in range(1, n):
        if (arr[i] % k == 0):
            res = max(res, arr[i])
    return res
 
# Driver code
if __name__ == "__main__":
     
    arr = [ 10, 1230, 45, 67, 1 ]
    k = 10
    n = len(arr)
    print("Minimum element of array which",
          "is divisible by k: ", getMin(arr, n, k))
    print( "Maximum element of array which",
           "is divisible by k: ", getMax(arr, n, k))
 
# This code is contributed
# by ChitraNayal

C#




// C# implementation of the above approach
using System;
 
class GFG
{
// Function to find the minimum element
static int getMin(int []arr, int n, int k)
{
    int res = int.MaxValue;
    for (int i = 0; i < n; i++)
    {
        if (arr[i] % k == 0)
        {
            res = Math.Min(res, arr[i]);
        }
    }
    return res;
}
 
// Function to find the maximum element
static int getMax(int []arr, int n, int k)
{
    int res = int.MinValue;
    for (int i = 1; i < n; i++)
    {
        if (arr[i] % k == 0)
        {
            res = Math.Max(res, arr[i]);
        }
    }
    return res;
}
 
// Driver code
static public void Main ()
{
    int []arr = {10, 1230, 45, 67, 1};
    int k = 10;
    int n = arr.Length;
    Console.WriteLine("Minimum element of array " +
                      "which is divisible by k: " +
                                getMin(arr, n, k));
    Console.WriteLine("Maximum element of array " +
                      "which is divisible by k: " +
                                getMax(arr, n, k));
}
}
 
// This code is contributes by ajit

PHP




<?php
// PHP implementation of the above approach
 
// Function to find the minimum element
function getMin($arr, $n, $k)
{
    $res = PHP_INT_MAX;
    for ($i = 0; $i < $n; $i++)
    {
        if ($arr[$i] % $k == 0)
            $res = min($res, $arr[$i]);
    }
    return $res;
}
 
// Function to find the maximum element
function getMax($arr, $n, $k)
{
    $res = PHP_INT_MIN;
    for ($i = 1; $i < $n; $i++)
    {
        if ($arr[$i] % $k == 0)
            $res = max($res, $arr[$i]);
    }
    return $res;
}
 
// Driver code
$arr = array( 10, 1230, 45, 67, 1 );
$k = 10;
$n = sizeof($arr);
echo "Minimum element of array which is " .
     "divisible by k: ", getMin($arr, $n, $k) , "\n";
echo "Maximum element of array which is " .
     "divisible by k: ", getMax($arr, $n, $k);
 
// This code is contributed by akt_mit
?>

Javascript




<script>
// Javascript implementation of the above approach
 
// Function to find the minimum element
function getMin(arr, n, k)
{
    let res = Number.MAX_VALUE;
    for (let i = 0; i < n; i++) {
        if (arr[i] % k == 0)
            res = Math.min(res, arr[i]);
    }
    return res;
}
 
// Function to find the maximum element
function getMax(arr, n, k)
{
    let res = Number.MIN_VALUE;
    for (let i = 1; i < n; i++) {
        if (arr[i] % k == 0)
            res = Math.max(res, arr[i]);
    }
    return res;
}
 
// Driver code
    let arr = [ 10, 1230, 45, 67, 1 ];
    let k = 10;
    let n = arr.length;
    document.write("Minimum element of array which is divisible by k: "
         + getMin(arr, n, k) + "<br>");
    document.write("Maximum element of array which is divisible by k: "
         + getMax(arr, n, k));
 
</script>
Output: 
Minimum element of array which is divisible by k: 10
Maximum element of array which is divisible by k: 1230

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :