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.



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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP for counting minimum de-arrangements present
// in an array.
#include<bits/stdc++.h>
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<n; i++)   
        if (arr[i] != v[i])
            count1++;        
      
    // reverse the sorted array
    reverse(arr,arr+n);    
  
    // 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 (min (count1, count2));
}
  
// driver program
int main()
{
    int arr[] = {5, 9, 21, 17, 13};
    int n = sizeof(arr)/sizeof(arr[0]);
    cout << "Minimum Dearrangement = " << countDe(arr, n);
    return 0;

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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.*/

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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".

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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