# Minimum De-arrangements present in array of AP (Arithmetic Progression)

Given an array of n-elements. Given array is a permutation of some Arithmetic Progression. Find the minimum number of De-arrangements present in that array so as to make that array an Arithmetic progression.

Examples:

```Input : arr[] = [8, 6, 10 ,4, 2]
Output : Minimum De-arrangement = 3
Explanation : arr[] = [10, 8, 6, 4, 2] is permutation
which forms an AP and has minimum de-arrangements.

Input : arr[] = [5, 10, 15, 25, 20]
Output : Minimum De-arrangement = 2
Explanation : arr[] = [5, 10, 15, 20, 25] is permutation
which forms an AP and has minimum de-arrangements.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

As per property of Arithmetic Progression our sequence will be either in increasing or decreasing manner. Also, we know that reverse of any Arithmetic Progression also form another Arithmetic Progression. So, we create a copy of original array and then once sort our given array in increase order and find total count of mismatch again after that we will reverse our sorted array and found new count of mismatch. Comparing both the counts of mismatch we can find the minimum number of de-arrangements. Time Complexity = O(nlogn).

## C++

 `// CPP for counting minimum de-arrangements present ` `// in an array. ` `#include ` `using` `namespace` `std; ` ` `  `// function to count Dearrangement ` `int` `countDe (``int` `arr[], ``int` `n) ` `{ ` `    ``// create a copy of original array ` `    ``vector <``int``> v (arr, arr+n); ` ` `  `    ``// sort the array ` `    ``sort(arr, arr+n); ` `     `  `    ``// traverse sorted array for counting mismatches ` `    ``int` `count1 = 0; ` `    ``for` `(``int` `i=0; i

## Java

 `// Java code for counting minimum  ` `// de-arrangements present in an array. ` `import` `java.util.*; ` `import` `java.lang.*; ` `import` `java.util.Arrays; ` ` `  `public` `class` `GeeksforGeeks{ ` `     `  `    ``// function to count Dearrangement ` `    ``public` `static` `int` `countDe(``int` `arr[], ``int` `n){ ` `        ``int` `v[] = ``new` `int``[n]; ` `         `  `        ``// create a copy of original array ` `        ``for``(``int` `i = ``0``; i < n; i++) ` `            ``v[i] = arr[i];  ` `             `  `        ``// sort the array ` `        ``Arrays.sort(arr); ` `     `  `        ``// traverse sorted array for  ` `        ``// counting mismatches ` `        ``int` `count1 = ``0``; ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `            ``if` `(arr[i] != v[i]) ` `            ``count1++;      ` `     `  `        ``// reverse the sorted array ` `        ``Collections.reverse(Arrays.asList(arr)); ` ` `  `        ``// traverse reverse sorted array  ` `        ``// for counting mismatches ` `        ``int` `count2 = ``0``; ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``if` `(arr[i] != v[i])      ` `                ``count2++; ` ` `  `        ``// return minimum mismatch count ` `        ``return` `(Math.min (count1, count2)); ` `    ``} ` ` `  `    ``// driver code ` `    ``public` `static` `void` `main(String argc[]){ ` `        ``int` `arr[] = {``5``, ``9``, ``21``, ``17``, ``13``}; ` `        ``int` `n = ``5``; ` `        ``System.out.println(``"Minimum Dearrangement = "``+ ` `                            ``countDe(arr, n)); ` `    ``} ` `} ` ` `  `/*This code is contributed by Sagar Shukla.*/`

## Python3

 `# Python3 code for counting minimum  ` `# de-arrangements present in an array. ` ` `  `# function to count Dearrangement ` `def` `countDe(arr, n): ` `        ``v ``=` `[``None``] ``*` `n ` `         `  `        ``i``=``0` `         `  `        ``# create a copy of  ` `        ``# original array ` `        ``while``(i < n): ` `            ``v[i] ``=` `arr[i] ` `            ``i ``=` `i ``+` `1` `             `  `        ``# sort the array ` `        ``arr.sort() ` `     `  `        ``# traverse sorted array for  ` `        ``# counting mismatches ` `        ``count1 ``=` `0` `        ``i ``=` `0` `        ``while``( i < n ):  ` `            ``if` `(arr[i] !``=` `v[i]): ` `                ``count1 ``=` `count1 ``+` `1` `            ``i ``=` `i ``+` `1` `     `  `        ``# reverse the sorted array ` `        ``arr.sort(reverse``=``True``) ` ` `  `        ``# traverse reverse sorted array  ` `        ``# for counting mismatches ` `        ``count2 ``=` `0` `        ``i ``=` `0` `        ``while``( i < n ): ` `            ``if` `(arr[i] !``=` `v[i]):      ` `                ``count2 ``=` `count2 ``+` `1` `            ``i ``=` `i ``+` `1` ` `  `        ``# return minimum mismatch count ` `        ``return` `(``min` `(count1, count2)) ` ` `  `# Driven code ` `arr ``=` `[``5``, ``9``, ``21``, ``17``, ``13``] ` `n ``=` `5` `print` `(``"Minimum Dearrangement ="``,countDe(arr, n)) ` ` `  `# This code is contributed by "rishabh_jain". `

## C#

 `// C# code for counting  ` `// minimum de-arrangements  ` `// present in an array. ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// function to count ` `// Dearrangement ` `public` `static` `int` `countDe(``int``[] arr,  ` `                          ``int` `n) ` `{ ` `    ``int``[] v = ``new` `int``[n]; ` `     `  `    ``// create a copy ` `    ``// of original array ` `    ``for``(``int` `i = 0; i < n; i++) ` `        ``v[i] = arr[i];  ` `         `  `    ``// sort the array ` `    ``Array.Sort(arr); ` ` `  `    ``// traverse sorted array for  ` `    ``// counting mismatches ` `    ``int` `count1 = 0; ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `        ``if` `(arr[i] != v[i]) ` `        ``count1++;  ` ` `  `    ``// reverse the sorted array ` `    ``Array.Reverse(arr); ` ` `  `    ``// traverse reverse sorted array  ` `    ``// for counting mismatches ` `    ``int` `count2 = 0; ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``if` `(arr[i] != v[i])  ` `            ``count2++; ` ` `  `    ``// return minimum  ` `    ``// mismatch count ` `    ``return` `(Math.Min (count1, count2)); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main() ` `{ ` `    ``int``[] arr = ``new` `int``[]{5, 9, 21, 17, 13}; ` `    ``int` `n = 5; ` `    ``Console.WriteLine(``"Minimum Dearrangement = "` `+  ` `                                 ``countDe(arr, n)); ` `} ` `} ` ` `  `// This code is contributed by mits `

## PHP

 ` `

Output:

```Minimum Dearrangement = 2
```

My Personal Notes arrow_drop_up

Discovering ways to develop a plane for soaring career goals

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : Mithun Kumar