Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Construct an Array of size N with sum divisible by K and array maximum is minimized

  • Last Updated : 24 Jan, 2022

Given integers N and K. The task is to construct an array of size N such that sum of all elements is divisible by K and the maximum element is as minimum as possible.

Note: There can be many possible arrays. Printing any one of them is acceptable

Examples:

Input: N = 1, K = 5
Output: 5
Explanation: Sum of all elements = 5 and  5 is divisible by 5.

Input: N = 4, K = 3
Output: 2 1 1 2
Explanation: Sum of all elements = 6 and  6 is divisible by 3.

Input: N = 7, K = 6
Output: 2 2 2 2 1 1 2

 

Approach: The solution is based on the idea that the smaller the sum of the array the smaller the maximum element. Follow the steps:

  • Calculate the required sum of resultant array by using sum equals factor times K.
  • The factor equals floor division of (N/K).
  • Finally, calculate the maximum element of the array which is ceil division of (sum/N).

Below is the implementation of the above approach.

C++




// C++ code to implement above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to construct the array
void buildArray(int N, int K)
{
    // arr to store solution
    vector<int> arr;
 
    // Calculating factor
    int cf = (N + K - 1) / K;
 
    // Calculating sum
    int sum = cf * K;
 
    // Maximum element of array
    int maxi = (sum + N - 1) / N;
 
    // Initializing count variable from N
    int c = N;
    while (c * maxi >= sum) {
        c--;
    }
    c--;
 
    // Add maxi c times in arr
    for (int i = 0; i < c; i++) {
        arr.push_back(maxi);
    }
 
    // Out of N, c positions are filled
    // in arr remaining position are
    int rem_pos = N - c;
 
    // Required remaining sum
    int rem_sum = sum - (c * maxi);
 
    // Finding last element
    // by which arr should be filled
    // on the remaining position
    int last = (rem_sum / rem_pos);
 
    // Pushing last element rem_pos-1 times
    for (int i = 0; i < rem_pos - 1;
         i++) {
        arr.push_back(last);
    }
 
    // As 'last' element is floor division,
    // so there would be possibility that
    // last element would not satisfy
    // given conditions
    // If last element satisfies condition
    if (last * (rem_pos) == rem_sum) {
        arr.push_back(last);
    }
    else {
        arr.push_back(rem_sum
                      - (last * (rem_pos - 1)));
    }
 
    // Printing the required array
    for (auto it : arr) {
        cout << it << ' ';
    }
}
 
// Driver code
int main()
{
    int N = 4, K = 3;
    buildArray(N, K);
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG {
 
  // Function to construct the array
  static void buildArray(int N, int K)
  {
    // arr to store solution
    ArrayList<Integer> arr = new ArrayList<>();
 
    // Calculating factor
    int cf = (N + K - 1) / K;
 
    // Calculating sum
    int sum = cf * K;
 
    // Maximum element of array
    int maxi = (sum + N - 1) / N;
 
    // Initializing count variable from N
    int c = N;
    while (c * maxi >= sum) {
      c--;
    }
    c--;
 
    // Add maxi c times in arr
    for (int i = 0; i < c; i++) {
      arr.add(maxi);
    }
 
    // Out of N, c positions are filled
    // in arr remaining position are
    int rem_pos = N - c;
 
    // Required remaining sum
    int rem_sum = sum - (c * maxi);
 
    // Finding last element
    // by which arr should be filled
    // on the remaining position
    int last = (rem_sum / rem_pos);
 
    // Pushing last element rem_pos-1 times
    for (int i = 0; i < rem_pos - 1; i++) {
      arr.add(last);
    }
 
    // As 'last' element is floor division,
    // so there would be possibility that
    // last element would not satisfy
    // given conditions
    // If last element satisfies condition
    if (last * (rem_pos) == rem_sum) {
      arr.add(last);
    }
    else {
      arr.add(rem_sum  - (last * (rem_pos - 1)));
    }
 
    // Printing the required array
    for(int i = 0; i < arr.size(); i++){
      System.out.print(arr.get(i) + " ");
    }
  }
 
  public static void main (String[] args) {
    int N = 4, K = 3;
    buildArray(N, K);
  }
}
 
// This code is contributed by hrithikgarg03188

Python3




# Python code to implement above approach
 
# Function to construct the array
def buildArray (N, K):
 
    # arr to store solution
    arr = [];
 
    # Calculating factor
    cf = (N + K - 1) // K;
 
    # Calculating sum
    sum = cf * K;
 
    # Maximum element of array
    maxi = (sum + N - 1) // N;
 
    # Initializing count variable from N
    c = N;
    while (c * maxi >= sum):
        c -= 1
    c -= 1
 
    # Add maxi c times in arr
    for i in range(c):
        arr.append(maxi);
 
    # Out of N, c positions are filled
    # in arr remaining position are
    rem_pos = N - c;
 
    # Required remaining sum
    rem_sum = sum - (c * maxi);
 
    # Finding last element
    # by which arr should be filled
    # on the remaining position
    last = (rem_sum // rem_pos);
 
    # Pushing last element rem_pos-1 times
    for i in range(rem_pos - 1):
        arr.append(last);
 
    # As 'last' element is floor division,
    # so there would be possibility that
    # last element would not satisfy
    # given conditions
    # If last element satisfies condition
    if (last * (rem_pos) == rem_sum):
        arr.append(last);
    else:
        arr.append(rem_sum - (last * (rem_pos - 1)));
 
    # Printing the required array
    for it in arr:
        print(it, end=" ");
 
# Driver code
N = 4
K = 3;
buildArray(N, K);
 
# This code is contributed by gfgking

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG
{
 
  // Function to construct the array
  static void buildArray(int N, int K)
  {
     
    // arr to store solution
    List<int> arr = new List<int>();
 
    // Calculating factor
    int cf = (N + K - 1) / K;
 
    // Calculating sum
    int sum = cf * K;
 
    // Maximum element of array
    int maxi = (sum + N - 1) / N;
 
    // Initializing count variable from N
    int c = N;
    while (c * maxi >= sum)
    {
      c--;
    }
    c--;
 
    // Add maxi c times in arr
    for (int i = 0; i < c; i++)
    {
      arr.Add(maxi);
    }
 
    // Out of N, c positions are filled
    // in arr remaining position are
    int rem_pos = N - c;
 
    // Required remaining sum
    int rem_sum = sum - (c * maxi);
 
    // Finding last element
    // by which arr should be filled
    // on the remaining position
    int last = (rem_sum / rem_pos);
 
    // Pushing last element rem_pos-1 times
    for (int i = 0; i < rem_pos - 1; i++)
    {
      arr.Add(last);
    }
 
    // As 'last' element is floor division,
    // so there would be possibility that
    // last element would not satisfy
    // given conditions
    // If last element satisfies condition
    if (last * (rem_pos) == rem_sum)
    {
      arr.Add(last);
    }
    else
    {
      arr.Add(rem_sum - (last * (rem_pos - 1)));
    }
 
    // Printing the required array
    for (int i = 0; i < arr.Count; i++)
    {
      Console.Write(arr[i] + " ");
    }
  }
 
  public static void Main()
  {
    int N = 4, K = 3;
    buildArray(N, K);
  }
}
 
// This code is contributed by gfgking

Javascript




<script>
    // JavaScript code to implement above approach
 
    // Function to construct the array
    const buildArray = (N, K) => {
     
        // arr to store solution
        arr = [];
 
        // Calculating factor
        let cf = parseInt((N + K - 1) / K);
 
        // Calculating sum
        let sum = cf * K;
 
        // Maximum element of array
        let maxi = parseInt((sum + N - 1) / N);
 
        // Initializing count variable from N
        let c = N;
        while (c * maxi >= sum) {
            c--;
        }
        c--;
 
        // Add maxi c times in arr
        for (let i = 0; i < c; i++) {
            arr.push(maxi);
        }
 
        // Out of N, c positions are filled
        // in arr remaining position are
        let rem_pos = N - c;
 
        // Required remaining sum
        let rem_sum = sum - (c * maxi);
 
        // Finding last element
        // by which arr should be filled
        // on the remaining position
        let last = parseInt((rem_sum / rem_pos));
 
        // Pushing last element rem_pos-1 times
        for (let i = 0; i < rem_pos - 1;
            i++) {
            arr.push(last);
        }
 
        // As 'last' element is floor division,
        // so there would be possibility that
        // last element would not satisfy
        // given conditions
        // If last element satisfies condition
        if (last * (rem_pos) == rem_sum) {
            arr.push(last);
        }
        else {
            arr.push(rem_sum
                - (last * (rem_pos - 1)));
        }
 
        // Printing the required array
        for (let it in arr) {
            document.write(`${arr[it]} `);
        }
    }
 
    // Driver code
    let N = 4, K = 3;
    buildArray(N, K);
 
// This code is contributed by rakeshsahni
 
</script>

 
 

Output
2 1 1 2 

 

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

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!