Minimum Dearrangements present in array of AP (Arithmetic Progression) (original) (raw)

Last Updated : 13 Jun, 2022

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.

C++ `

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

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):

    i = 0

    # create a copy of 
    # original array
    v = arr.copy()
        
    # 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

JavaScript

`

Output:

Minimum Dearrangement = 2

Time Complexity: O(nlogn).

Auxiliary Space: O(n)