Skip to content
Related Articles

Related Articles

Improve Article
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 DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :