Make all array elements divisible by a number K

Last Updated : 23 Dec, 2022

Given an array arr[] and a number K, the task is to make all elements of array divisible by K. To make elements divisible by K, one can perform following operation:

Choose any index C in the array.
You are allowed to subtract any value from any of the numbers up to the index C and you are allowed to add any value to any of the elements present after index C.
The only condition required for the above operation is total sum of values subtracted up to index C can be added to the elements after index C.

Print the value of index C and the difference of subtracted numbers to the numbers added after index C.
Examples:

Input: arr[] = {1, 14, 4, 41, 1}, K = 7
Output: C = 3, difference = 5
Explanation:
Please Refer below for explanation.
Input: arr[] = {1, 10, 19}, K=9
Output: C = 2, difference = 2

Explanation:

Approach:

Create two auxiliary arrays arr1[] and arr2[].
The first array arr1[] stores the value of element that can be subtracted from every element to make it divisible by K in arr[].
The second array arr2[] stores the value of element that can be added to make the element divisible by K.
Then Iterate over the possible values for the C and find the index in which the sum of subtracted values from arr1[] up to that index is greater than or equal to the sum of the added values to the index after C in arr2[].

Below is the implementation of the above approach:

C++

// C++ implementation to make
// the array elements divisible by K
#include <bits/stdc++.h>
using namespace std;

// Function to make array divisible
pair<int,int> makeDivisble(int arr[], int n, int k)
{
    
    vector<int>b1; 
    vector<int>b2;
    int c, suml, sumr, index, rem;
    
    // For each element of array
    // how much number to be subtracted
    // to make it divisible by k 
    for (int i = 0; i < n; i++)
        b1.push_back(arr[i] % k);
    
    // For each element of array
    // how much number to be added
    // to make it divisible by K 
    for (int j = 0; j < n; j++)
        if ((arr[j] % k) != 0)
            b2.push_back(k - (arr[j] % k));
        else
            b2.push_back(0);
            
    c = 0;
    float mini = INT_MAX;
    suml = 0;
    sumr = 0;
    index = -1;
    
    // Calculate minimum difference 
    for (int c = 0; c < n; c++)
    {
        suml = accumulate(b1.begin(),b1.begin() + c + 1, 0);
        sumr = accumulate(b2.begin() + c + 1 , b2.end(), 0);
        if (suml >= sumr)
        {
            rem = suml - sumr;
            if (rem < mini)
            {
                mini = rem;
                index = c;
            }
        }
    }
    
    return make_pair(index, mini);

}

// Driver Code
int main() {
    int arr[] = {1, 14, 4, 41, 1};
    int k = 7;
    int n=sizeof(arr)/sizeof(arr[0]);
    
    pair<int ,int>ans;
    ans = makeDivisble(arr, n, k);
    cout << ans.first << " " << ans.second;
    
    return 0;
}

// This code is contributed by Atul_kumar_Shrivastava

Java

/*package whatever //do not write package name here */

import java.util.*;

class GFG {

  static class Pair{

    int first;
    int second;

    Pair(int f,int s){
      first = f;
      second = s;
    }

  }


  // Function to make array divisible
  static Pair makeDivisble(int arr[], int n, int k)
  {

    ArrayList<Integer> b1  = new ArrayList<>(); 
    ArrayList<Integer> b2  = new ArrayList<>(); 
    int c, suml, sumr, index, rem;

    // For each element of array
    // how much number to be subtracted
    // to make it divisible by k 
    for (int i = 0; i < n; i++)
      b1.add(arr[i] % k);

    // For each element of array
    // how much number to be added
    // to make it divisible by K 
    for (int j = 0; j < n; j++)
      if ((arr[j] % k) != 0)
        b2.add(k - (arr[j] % k));
    else
      b2.add(0);

    c = 0;
    double mini = Integer.MAX_VALUE;
    suml = 0;
    sumr = 0;
    index = -1;

    // Calculate minimum difference 
    for (c = 0; c < n; c++)
    {
      suml = accumulate(b1,0,c + 1);
      sumr = accumulate(b2,c + 1 ,b2.size());
      if (suml >= sumr)
      {
        rem = suml - sumr;
        if (rem < mini)
        {
          mini = rem;
          index = c;
        }
      }
    }

    return new Pair(index, (int)mini);

  }

  static int accumulate(ArrayList<Integer> ll,int i,int j){

    int sum = 0;

    while(i<j){
      sum += ll.get(i);
      i++;
    }

    return sum;
  }

  public static void main (String[] args) {
    int arr[] = {1, 14, 4, 41, 1};
    int k = 7;
    int n= arr.length;

    Pair ans = makeDivisble(arr, n, k);
    System.out.println(ans.first + " " + ans.second);
  }
}

// This code is contributed by aadityaburujwale.

Python3

# Python implementation to make
# the array elements divisible by K

# Function to make array divisible
def makeDivisble(arr, k):
    n = len(arr)
    b1 =[]
    b2 =[]
    
    # For each element of array
    # how much number to be subtracted
    # to make it divisible by k 
    for i in range (n):
        b1.append(arr[i]% k)
    
    # For each element of array
    # how much number to be added
    # to make it divisible by K 
    for j in range(n):
        if ((arr[j]% k)!= 0):
            b2.append(k-(arr[j]% k))
        else:
            b2.append(0) 
    c = 0
    mini = float('inf')
    suml = 0
    sumr = 0
    index = -1
    
    # Calculate minimum difference 
    for c in range(0, n+1, 1):
        suml = sum(b1[ : c + 1])
        sumr = sum(b2[c+1 : ])
        if suml>= sumr:
            rem = suml-sumr
            if rem<mini:
                mini = rem
                index = c
    return index, mini

# Driver Code
if __name__ == "__main__":
    arr = [1, 14, 4, 41, 1]
    k = 7
    index, diff = makeDivisble(arr, k)
    print(index, diff)

using System;
using System.Collections.Generic;

public class GFG {

  public static int accumulate(List<int> ll, int i, int j)
  {

    int sum = 0;

    while (i < j) {
      sum += ll[i];
      i++;
    }

    return sum;
  }

  // Function to make array divisible
  public static List<int> makeDivisble(int[] arr, int n,
                                       int k)
  {
    List<int> b1 = new List<int>();
    List<int> b2 = new List<int>();
    int c, suml, sumr, index, rem;

    // For each element of array
    // how much number to be subtracted
    // to make it divisible by k
    for (int i = 0; i < n; i++)
      b1.Add(arr[i] % k);

    // For each element of array
    // how much number to be added
    // to make it divisible by K
    for (int j = 0; j < n; j++)
      if ((arr[j] % k) != 0)
        b2.Add(k - (arr[j] % k));
    else
      b2.Add(0);

    c = 0;
    int mini = Int32.MaxValue;
    suml = 0;
    sumr = 0;
    index = -1;

    // Calculate minimum difference
    for (c = 0; c < n; c++) {
      suml = accumulate(b1, 0, c + 1);
      sumr = accumulate(b2, c + 1, b2.Count);
      if (suml >= sumr) {
        rem = suml - sumr;
        if (rem < mini) {
          mini = rem;
          index = c;
        }
      }
    }
    List<int> ans = new List<int>();
    ans.Add(index);
    ans.Add(mini);
    return ans;
  }

  static public void Main()
  {

    int[] arr = { 1, 14, 4, 41, 1 };
    int k = 7;
    int n = arr.Length;

    List<int> ans = new List<int>();
    ans = makeDivisble(arr, n, k);
    Console.WriteLine(ans[0] + " " + ans[1]);
  }
}

// This code is contributed by akashish__

JavaScript

// JS implementation to make
// the array elements divisible by K

function accumulate(ll, i, j){

    let sum = 0;

    while(i<j){
      sum += ll[i];
      i++;
    }

    return sum;
  }

// Function to make array divisible
function makeDivisble(arr, n, k)
{
    // vector<int>b1; 
    // vector<int>b2;
    let b1 = [], b2 = [];
    let c, suml, sumr, index, rem;
    
    // For each element of array
    // how much number to be subtracted
    // to make it divisible by k 
    for (let i = 0; i < n; i++)
        b1.push(arr[i] % k);
    
    // For each element of array
    // how much number to be added
    // to make it divisible by K 
    for (let j = 0; j < n; j++)
        if ((arr[j] % k) != 0)
            b2.push(k - (arr[j] % k));
        else
            b2.push(0);
            
    c = 0;
    let mini = Number.MAX_VALUE;
    suml = 0;
    sumr = 0;
    index = -1;
    
    // Calculate minimum difference 
    for (let c = 0; c < n; c++)
    {
        suml = accumulate(b1,0,c + 1);
        sumr = accumulate(b2,c + 1 ,b2.length);
        if (suml >= sumr)
        {
            rem = suml - sumr;
            if (rem < mini)
            {
                mini = rem;
                index = c;
            }
        }
    }
    
    return {"first":index, "second":mini};

}

// Driver Code
let arr = [1, 14, 4, 41, 1];
let k = 7;
let n=arr.length;

let ans = [];
ans = makeDivisble(arr, n, k);
console.log(ans.first,ans.second);

// This code is contributed by akashish__

Output:

3 5

Time Complexity: O(N^2)
Auxiliary Space: O(N)

Analysis of Algorithms

madarsh986

Improve

Article Tags :

Make all array elements divisible by a number K

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?