# Modify array to a permutation of consecutive numbers of longest length by at most K insertions

• Last Updated : 14 Sep, 2021

Given an array arr[] of length N and an integer K, the task is to find the maximize the length of the array by appending at most K elements such that the array becomes a permutation of consecutive numbers starting from 1. Once K elements are added, sum of two or more array elements can be inserted.

Note: Elements can be formed as sum of the elements originally present in the array or the appended elements. But elements added as the sum of two or more elements of the array cannot be used to generate further elements.

Examples:

Input: N = 3, K = 1, arr[] = {1, 2, 4}
Output: 8
Explanation:
Original array elements = {1, 2, 4}
Array elements that can be obtained using these elements are {3, 5, 6, 7}.
Insert 8 into the array.
Now, all numbers starting from 9 to 15 can be appended into the array.
Hence, the array becomes a consecutive sequence of 15 numbers.

Input : N = 5, K=4, arr[N] = {1, 3, 10, 3, 1}
Output : 223

Approach: The idea is to sort the array arr[] in ascending order and then use the fact that if the sum of array arr[] elements is sum then all the elements from 1 to sum can be formed and if not, then it is required to insert sum+1 element into the array arr[] and subtract the value of K by 1. Follow the steps below to solve the problem:

• Sort the array arr[].
• Initialize the variable index as 0 to maintain the index of the element in the array arr[] and x as 0 to store the answer.
• Iterate in a while loop till index is less than N and perform the following steps:
• If arr[index] is greater than x, and if K is equal to 0, then break.
• Else increase the value of x by x and subtract the value of k by 1.
• Else, add the value of arr[index] to the value of x and increase the value of index by 1.
• Iterate in a while loop till K is not equal to 0 and perform the following steps:
• Increase the value of x by x and subtract the value of k by 1.
• After performing the above steps, print the value of x-1 as the answer.

Below is the implementation of the above approach.

## C++14

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the maximum length``// possible``void` `findMaximumLength(``int` `n, ``int` `k, ``int` `arr[])``{``    ``// Sort the array``    ``sort(arr, arr + n);` `    ``// Initializing the variables``    ``int` `x = 1;``    ``int` `index = 0;` `    ``// Iterate over the range``    ``while` `(index < n) {``        ``if` `(arr[index] > x) {` `            ``// If k is 0, then no``            ``// element can be inserted``            ``if` `(k == 0)``                ``break``;` `            ``// Insert the element``            ``x = x + x;``            ``k--;``        ``}``        ``else` `{``            ``x += arr[index++];``        ``}``    ``}` `    ``// Insert the remaining``    ``// possible elements``    ``while` `(k != 0) {``        ``x = x + x;``        ``k--;``    ``}` `    ``// Print the answer``    ``cout << x - 1 << endl;``}` `// Driver Code``int` `main()``{``    ``int` `n = 5, k = 4;``    ``int` `arr[n] = { 1, 3, 10, 3, 1 };` `    ``findMaximumLength(n, k, arr);` `    ``return` `0;``}`

## Java

 `// Java code for the above approach``import` `java.io.*;``import` `java.util.Arrays;``class` `GFG``{``  ` `    ``// Function to find the maximum length``    ``// possible``    ``static` `void` `findMaximumLength(``int` `n, ``int` `k, ``int` `arr[])``    ``{``      ` `        ``// Sort the array``        ``Arrays.sort(arr);` `        ``// Initializing the variables``        ``int` `x = ``1``;``        ``int` `index = ``0``;` `        ``// Iterate over the range``        ``while` `(index < n) {``            ``if` `(arr[index] > x) {` `                ``// If k is 0, then no``                ``// element can be inserted``                ``if` `(k == ``0``)``                    ``break``;` `                ``// Insert the element``                ``x = x + x;``                ``k--;``            ``}``            ``else` `{``                ``x += arr[index++];``            ``}``        ``}` `        ``// Insert the remaining``        ``// possible elements``        ``while` `(k != ``0``) {``            ``x = x + x;``            ``k--;``        ``}` `        ``// Print the answer``        ``System.out.println(x - ``1``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``5``, k = ``4``;``        ``int` `arr[] = { ``1``, ``3``, ``10``, ``3``, ``1` `};` `        ``findMaximumLength(n, k, arr);``    ``}``}` `// This code is contributed by Potta Lokesh`

## Python3

 `# Python code for the above approach` `# Function to find the maximum length``# possible``def` `findMaximumLength(n, k, arr):` `    ``# Sort the array``    ``arr.sort();` `    ``# Initializing the variables``    ``x ``=` `1``;``    ``index ``=` `0``;` `    ``# Iterate over the range``    ``while` `(index < n):``        ``if` `(arr[index] > x):` `            ``# If k is 0, then no``            ``# element can be inserted``            ``if` `(k ``=``=` `0``):``                ``break``;` `            ``# Insert the element``            ``x ``=` `x ``+` `x;``            ``k``-``=``1``;``        ` `        ``else``:``            ``x ``+``=` `arr[index];``            ``index ``+``=` `1``;``        ` `    ``# Insert the remaining``    ``# possible elements``    ``while` `(k !``=` `0``):``        ``x ``=` `x ``+` `x;``        ``k ``-``=` `1``;``    ` `    ``# Print answer``    ``print``(x ``-` `1``);` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``n ``=` `5``; k ``=` `4``;``    ``arr ``=` `[ ``1``, ``3``, ``10``, ``3``, ``1` `];` `    ``findMaximumLength(n, k, arr);``    ` `# This code is contributed by 29AjayKumar`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to find the maximum length``// possible``static` `void` `findMaximumLength(``int` `n, ``int` `k, ``int` `[]arr)``{``    ` `    ``// Sort the array``    ``Array.Sort(arr);` `    ``// Initializing the variables``    ``int` `x = 1;``    ``int` `index = 0;` `    ``// Iterate over the range``    ``while` `(index < n)``    ``{``        ``if` `(arr[index] > x)``        ``{``            ` `            ``// If k is 0, then no``            ``// element can be inserted``            ``if` `(k == 0)``                ``break``;` `            ``// Insert the element``            ``x = x + x;``            ``k--;``        ``}``        ``else``        ``{``            ``x += arr[index++];``        ``}``    ``}` `    ``// Insert the remaining``    ``// possible elements``    ``while` `(k != 0)``    ``{``        ``x = x + x;``        ``k--;``    ``}` `    ``// Print the answer``    ``Console.Write(x - 1);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `n = 5, k = 4;``    ``int` `[]arr = { 1, 3, 10, 3, 1 };` `    ``findMaximumLength(n, k, arr);``}``}` `// This code is contributed by shivanisinghss2110`

## Javascript

 ``

Output:

`223`

Time Complexity : O(N*log(N))
Auxiliary Space : O(1)

My Personal Notes arrow_drop_up