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

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 = 5Output:5Explanation:Sum of all elements = 5 and 5 is divisible by 5.

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

Input:N = 7, K = 6Output: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)

*O(N)*

**Auxiliary Space:**