# Minimize sum of numbers required to convert an array into a permutation of first N natural numbers

• Last Updated : 07 Jul, 2021

Given an array A[] of size N, the task is to find the minimum sum of numbers required to be added to array elements to convert the array into a permutation of 1 to N. If the array can not be converted to desired permutation, print -1.

Examples:

Input: A[] = {1, 1, 1, 1, 1}
Output: 10
Explanation: Increment A by 1, A by 2, A by 3, A by 4, thus A[] becomes {1, 2, 3, 4, 5}.
Minimum additions required = 1 + 2 + 3 + 4 = 10

Input: A[] = {2, 2, 3}
Output: -1

Approach: The idea is to use sorting. Follow these steps to solve this problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the minimum additions required ``// to convert the array into a permutation of 1 to N``int` `minimumAdditions(``int` `a[], ``int` `n)``{``    ``// Sort the array in increasing order``    ``sort(a, a + n);``    ``int` `ans = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If a[i] > i + 1, then return -1``        ``if` `((i + 1) - a[i] < 0) {``            ``return` `-1;``        ``}``        ``if` `((i + 1) - a[i] > 0) {` `            ``// Update answer``            ``ans += (i + 1 - a[i]);``        ``}``    ``}` `    ``// Return the required result``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``int` `A[] = { 1, 1, 1, 1, 1 };``    ``int` `n = ``sizeof``(A) / ``sizeof``(A);` `    ``// Function Call``    ``cout << minimumAdditions(A, n);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.Arrays;` `public` `class` `GFG {` `    ``// Function to find the minimum additions required ``    ``// to convert the array into a permutation of 1 to N``    ``static` `int` `minimumAdditions(``int` `a[], ``int` `n)``    ``{``        ``// Sort the array in increasing order``        ``Arrays.sort(a);``        ``int` `ans = ``0``;` `        ``// Traverse the array``        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// If a[i] > i + 1, then return -1``            ``if` `((i + ``1``) - a[i] < ``0``) {``                ``return` `-``1``;``            ``}``            ``if` `((i + ``1``) - a[i] > ``0``) {` `                ``// Update answer``                ``ans += (i + ``1` `- a[i]);``            ``}``        ``}` `        ``// Return the required result``        ``return` `ans;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``      ` `      ``// Given Input``        ``int` `A[] = { ``1``, ``1``, ``1``, ``1``, ``1` `};``        ``int` `n = A.length;` `        ``// Function Call``        ``System.out.println(minimumAdditions(A, n));``    ``}``}` `// This code is contributed by abhinavjain194`

## Python3

 `# Python3 program for the above approach` `# Function to find the minimum additions``# required to convert the array into a``# permutation of 1 to N``def` `minimumAdditions(a, n):``    ` `    ``# Sort the array in increasing order``    ``a ``=` `sorted``(a)``    ``ans ``=` `0` `    ``# Traverse the array``    ``for` `i ``in` `range``(n):` `        ``# If a[i] > i + 1, then return -1``        ``if` `((i ``+` `1``) ``-` `a[i] < ``0``):``            ``return` `-``1` `        ``if` `((i ``+` `1``) ``-` `a[i] > ``0``):` `            ``# Update answer``            ``ans ``+``=` `(i ``+` `1` `-` `a[i])` `    ``# Return the required result``    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given Input``    ``A ``=` `[ ``1``, ``1``, ``1``, ``1``, ``1` `]``    ``n ``=` `len``(A)` `    ``# Function Call``    ``print``(minimumAdditions(A, n))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to find the minimum additions``// required to convert the array into a``// permutation of 1 to N``static` `int` `minimumAdditions(``int` `[]a, ``int` `n)``{``    ` `    ``// Sort the array in increasing order``    ``Array.Sort(a);``    ``int` `ans = 0;` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ` `        ``// If a[i] > i + 1, then return -1``        ``if` `((i + 1) - a[i] < 0)``        ``{``            ``return` `-1;``        ``}``        ` `        ``if` `((i + 1) - a[i] > 0)``        ``{``            ` `            ``// Update answer``            ``ans += (i + 1 - a[i]);``        ``}``    ``}` `    ``// Return the required result``    ``return` `ans;``}` `// Driver code``static` `void` `Main()``{``    ` `    ``// Given Input``    ``int``[] A = { 1, 1, 1, 1, 1 };``    ``int` `n = A.Length;``    ` `    ``// Function Call``    ``Console.Write(minimumAdditions(A, n));``}``}` `// This code is contributed by SoumikMondal`

## Javascript

 ``

Output:

`10`

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

My Personal Notes arrow_drop_up