 Open in App
Not now

# 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 ` `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 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

 ``

Output

`2 1 1 2 `

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

My Personal Notes arrow_drop_up
Related Articles