Distinct adjacent elements in an array

Difficulty Level : Medium
Last Updated : 23 Jun, 2021

Given an array, find whether it is possible to obtain an array having distinct neighbouring elements by swapping two neighbouring array elements.
Examples:

Input : 1 1 2
Output : YES
swap 1 (second last element) and 2 (last element), 
to obtain 1 2 1, which has distinct neighbouring 
elements .

Input : 7 7 7 7
Output : NO
We can't swap to obtain distinct elements in 
neighbor .

To obtain an array having distinct neighbouring elements is possible only, when the frequency of most occurring element is less than or equal to half of size of array i.e ( <= (n+1)/2 ). To make it more clear consider different examples
1st Example : a[] = {1, 1, 2, 3, 1}
We can obtain array {1, 2, 1, 3, 1} by
swapping (2nd and 3rd) element from array a.
Here 1 occurs most and its frequency is
3 . So that 3 <= ((5+1)/2) .
Hence, it is possible.
Below is the implementation of this approach.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

C++

// C++ program to check if we can make
// neighbors distinct.
#include <bits/stdc++.h>
using namespace std;
 
void distinctAdjacentElement(int a[], int n)
{
    // map used to count the frequency
    // of each element occurring in the
    // array
    map<int, int> m;
 
    // In this loop we count the frequency
    // of element through map m .
    for (int i = 0; i < n; ++i)
        m[a[i]]++;
 
    // mx store the frequency of element which
    // occurs most in array .
    int mx = 0;
 
    // In this loop we calculate the maximum
    // frequency and store it in variable mx.
    for (int i = 0; i < n; ++i)
        if (mx < m[a[i]])
            mx = m[a[i]];
 
    // By swapping we can adjust array only
    // when the frequency of the element
    // which occurs most is less than or
    // equal to (n + 1)/2 .
    if (mx > (n + 1) / 2)
        cout << "NO" << endl;
    else
        cout << "YES" << endl;
}
 
// Driver program to test the above function
int main()
{
    int a[] = { 7, 7, 7, 7 };
    int n = sizeof(a) / sizeof(a[0]);
    distinctAdjacentElement(a, n);
    return 0;
}

Python3

# Python program to check if we can make
# neighbors distinct.
def distantAdjacentElement(a, n):
 
    # dict used to count the frequency
    # of each element occurring in the
    # array
    m = dict()
 
    # In this loop we count the frequency
    # of element through map m
    for i in range(n):
        if a[i] in m:
            m[a[i]] += 1
        else:
            m[a[i]] = 1
 
    # mx store the frequency of element which
    # occurs most in array .
    mx = 0
 
    # In this loop we calculate the maximum
    # frequency and store it in variable mx.
    for i in range(n):
        if mx < m[a[i]]:
            mx = m[a[i]]
 
    # By swapping we can adjust array only
    # when the frequency of the element
    # which occurs most is less than or
    # equal to (n + 1)/2 .
    if mx > (n+1) // 2:
        print("NO")
    else:
        print("YES")
 
 
# Driver Code
if __name__ == "__main__":
    a = [7, 7, 7, 7]
    n = len(a)
    distantAdjacentElement(a, n)
 
# This code is contributed by
# sanjeev2552

C#

// C# program to check if we can make
// neighbors distinct.
using System;
using System.Collections.Generic;
 
class GFG {
 
public static void distinctAdjacentElement(int[] a, int n)
{
    // map used to count the frequency
    // of each element occurring in the
    // array
    Dictionary<int, int> m = new Dictionary<int, int>();
 
    // In this loop we count the frequency
    // of element through map m .
    for (int i = 0; i < n; ++i)
    {
 
        // checks if map already
        // contains a[i] then
        // update the previous
        // value by incrementing
        // by 1
        if (m.ContainsKey(a[i]))
        {
            int x = m[a[i]] + 1;
            m[a[i]] = x;
        }
        else
        {
            m[a[i]] = 1;
        }
 
    }
 
    // mx store the frequency
    // of element which
    // occurs most in array .
    int mx = 0;
 
    // In this loop we calculate
    // the maximum frequency and
    // store it in variable mx.
    for (int i = 0; i < n; ++i)
    {
        if (mx < m[a[i]])
        {
            mx = m[a[i]];
        }
    }
 
    // By swapping we can adjust array only
    // when the frequency of the element
    // which occurs most is less than or
    // equal to (n + 1)/2 .
    if (mx > (n + 1) / 2)
    {
        Console.WriteLine("NO");
    }
    else
    {
        Console.WriteLine("YES");
    }
}
 
    // Main Method
    public static void Main(string[] args)
    {
        int[] a = new int[] {7, 7, 7, 7};
        int n = 4;
        distinctAdjacentElement(a, n);
    }
}
 
// This code is contributed
// by Shrikant13

Java

// Java program to check if we can make
// neighbors distinct.
import java.io.*;
import java.util.HashMap;
import java.util.Map;
class GFG {
 
static void distinctAdjacentElement(int a[], int n)
{
// map used to count the frequency
// of each element occurring in the
// array
HashMap<Integer,Integer> m = new HashMap<Integer,
Integer>();
 
// In this loop we count the frequency
// of element through map m .
for (int i = 0; i < n; ++i){
 
// checks if map already contains a[i] then
// update the previous value by incrementing
// by 1
if(m.containsKey(a[i])){
int x = m.get(a[i]) + 1;
m.put(a[i],x);
}
else{
m.put(a[i],1);
}
 
}
 
// mx store the frequency of element which
// occurs most in array .
int mx = 0;
 
// In this loop we calculate the maximum
// frequency and store it in variable mx.
for (int i = 0; i < n; ++i)
if (mx < m.get(a[i]))
mx = m.get(a[i]);
 
// By swapping we can adjust array only
// when the frequency of the element
// which occurs most is less than or
// equal to (n + 1)/2 .
if (mx > (n + 1) / 2)
System.out.println("NO");
else
System.out.println("YES");
}
 
// Driver program to test the above function
public static void main (String[] args) {
int a[] = { 7, 7, 7, 7 };
int n = 4;
distinctAdjacentElement(a, n);
}
}
// This code is contributed by Amit Kumar

Javascript

<script>
 
// JavaScript program to check if we can make
// neighbors distinct.
 
 
function distinctAdjacentElement(a, n) {
    // map used to count the frequency
    // of each element occurring in the
    // array
    let m = new Map();
 
    // In this loop we count the frequency
    // of element through map m .
    for (let i = 0; i < n; ++i) {
        m[a[i]]++;
        if (m.has(a[i])) {
            m.set(a[i], m.get(a[i]) + 1)
        } else {
            m.set(a[i], 1)
        }
    }
    // mx store the frequency of element which
    // occurs most in array .
    let mx = 0;
 
    // In this loop we calculate the maximum
    // frequency and store it in variable mx.
    for (let i = 0; i < n; ++i)
        if (mx < m.get(a[i]))
            mx = m.get(a[i]);
 
    // By swapping we can adjust array only
    // when the frequency of the element
    // which occurs most is less than or
    // equal to (n + 1)/2 .
    if (mx > Math.floor((n + 1) / 2))
        document.write("NO" + "<br>");
    else
        document.write("YES<br>");
}
 
// Driver program to test the above function
 
let a = [7, 7, 7, 7];
let n = a.length;
distinctAdjacentElement(a, n);
 
</script>

Output:

NO

This article is contributed by Surya Priy. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

My Personal Notes

Related Articles

Related Articles

Distinct adjacent elements in an array

C++

Python3

C#

Java

Javascript