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 .

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

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

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

NO