Related Articles

# Generate an array of size K which satisfies the given conditions

• Last Updated : 27 Apr, 2021

Given two integers N and K, the task is to generate an array arr[] of length K such that:

1. arr[0] + arr[1] + … + arr[K – 1] = N.
2. arr[i] > 0 for 0 ≤ i < K.
3. arr[i] < arr[i + 1] ≤ 2 * arr[i] for 0 ≤ i < K – 1.

If there are multiple answers find any one of them, otherwise, print -1.

Examples:

Input: N = 26, K = 6
Output: 1 2 4 5 6 8
The generated array satisfies all of the given conditions.
Input: N = 8, K = 3
Output: -1

Approach: Let r = n – k * (k + 1) / 2. If r < 0 then answer is -1 already. Otherwise, let’s construct the array arr[], where all arr[i] are floor(r / k) except for rightmost r % k values, they are ceil(r / k)
It is easy to see that the sum of this array is r, it is sorted in non-decreasing order and the difference between the maximum and the minimum element is not greater than 1.
Let’s add 1 to arr[1], 2 to arr[2], and so on (this is what we subtract from n at the beginning).
Then, if r != k – 1 or k = 1 then arr[] is our required array. Otherwise, we got some array of kind 1, 3, ….., arr[k]. For k = 2 or k = 3, there is no answer for this case. Otherwise, we can subtract 1 from arr[2] and add it to arr[k] and this answer will be correct.

Below is the implementation of the above approach:

## C++

 // C++ implementation of the approach#include using namespace std; // Function to generate and print// the required arrayvoid generateArray(int n, int k){     // Initializing the array    vector array(k, 0);     // Finding r (from above approach)    int remaining = n - int(k * (k + 1) / 2);     // If r<0    if (remaining < 0)        cout << ("NO");     int right_most = remaining % k;     // Finding ceiling and floor values    int high = ceil(remaining / (k * 1.0));    int low = floor(remaining / (k * 1.0));     // Fill the array with ceiling values    for (int i = k - right_most; i < k; i++)        array[i]= high;     // Fill the array with floor values    for (int i = 0; i < (k - right_most); i++)        array[i]= low;     // Add 1, 2, 3, ... with corresponding values    for (int i = 0; i < k; i++)        array[i] += i + 1;     if (k - 1 != remaining or k == 1)    {        for(int u:array) cout << u << " ";    }         // There is no solution for below cases    else if (k == 2 or k == 3)        printf("-1\n");    else    {         // Modify A[1] and A[k-1] to get        // the required array        array[1] -= 1;        array[k - 1] += 1;        for(int u:array) cout << u << " ";    }} // Driver Codeint main(){    int n = 26, k = 6;    generateArray(n, k);    return 0;} // This code is contributed// by Mohit Kumar

## Java

 // Java implementation of the approachclass GFG{ // Function to generate and print// the required arraystatic void generateArray(int n, int k){     // Initializing the array    int []array = new int[k];     // Finding r (from above approach)    int remaining = n - (k * (k + 1) / 2);     // If r < 0    if (remaining < 0)        System.out.print("NO");     int right_most = remaining % k;     // Finding ceiling and floor values    int high = (int) Math.ceil(remaining / (k * 1.0));    int low = (int) Math.floor(remaining / (k * 1.0));     // Fill the array with ceiling values    for (int i = k - right_most; i < k; i++)        array[i] = high;     // Fill the array with floor values    for (int i = 0; i < (k - right_most); i++)        array[i] = low;     // Add 1, 2, 3, ... with corresponding values    for (int i = 0; i < k; i++)        array[i] += i + 1;     if (k - 1 != remaining || k == 1)    {        for(int u:array)            System.out.print(u + " ");    }         // There is no solution for below cases    else if (k == 2 || k == 3)        System.out.printf("-1\n");    else    {         // Modify A[1] and A[k-1] to get        // the required array        array[1] -= 1;        array[k - 1] += 1;        for(int u:array)            System.out.print(u + " ");    }} // Driver Codepublic static void main(String[] args){    int n = 26, k = 6;    generateArray(n, k);}} // This code is contributed by PrinciRaj1992

## Python3

 # Python3 implementation of the approachimport sysfrom math import floor, ceil # Function to generate and print# the required arraydef generateArray(n, k):     # Initializing the array    array = [0] * k         # Finding r (from above approach)    remaining = n-int(k*(k + 1)/2)     # If r<0    if remaining<0:        print("NO")        sys.exit()     right_most = remaining % k     # Finding ceiling and floor values    high = ceil(remaining / k)    low = floor(remaining / k)     # Fill the array with ceiling values    for i in range(k-right_most, k):        array[i]= high     # Fill the array with floor values    for i in range(k-right_most):        array[i]= low     # Add 1, 2, 3, ... with corresponding values    for i in range(k):        array[i]+= i + 1     if k-1 != remaining or k == 1:        print(*array)        sys.exit()     # There is no solution for below cases    elif k == 2 or k == 3:        print("-1")        sys.exit()    else:         # Modify A[1] and A[k-1] to get        # the required array        array[1]-= 1        array[k-1]+= 1        print(*array)        sys.exit() # Driver Codeif __name__=="__main__":    n, k = 26, 6    generateArray(n, k)

## C#

 // C# implementation of the approachusing System; class GFG{ // Function to generate and print// the required arraystatic void generateArray(int n, int k){     // Initializing the array    int []array = new int[k];     // Finding r (from above approach)    int remaining = n - (k * (k + 1) / 2);     // If r < 0    if (remaining < 0)        Console.Write("NO");     int right_most = remaining % k;     // Finding ceiling and floor values    int high = (int) Math.Ceiling(remaining /                                 (k * 1.0));    int low = (int) Math.Floor(remaining /                              (k * 1.0));     // Fill the array with ceiling values    for (int i = k - right_most; i < k; i++)        array[i] = high;     // Fill the array with floor values    for (int i = 0;             i < (k - right_most); i++)        array[i] = low;     // Add 1, 2, 3, ... with    // corresponding values    for (int i = 0; i < k; i++)        array[i] += i + 1;     if (k - 1 != remaining || k == 1)    {        foreach(int u in array)            Console.Write(u + " ");    }         // There is no solution for below cases    else if (k == 2 || k == 3)        Console.Write("-1\n");    else    {         // Modify A[1] and A[k-1] to get        // the required array        array[1] -= 1;        array[k - 1] += 1;        foreach(int u in array)            Console.Write(u + " ");    }} // Driver Codepublic static void Main(String[] args){    int n = 26, k = 6;    generateArray(n, k);}} // This code is contributed by PrinciRaj1992

## Javascript


Output:
1 2 4 5 6 8

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up