Related Articles

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

## C++

 `// C++ program to check if we can make``// neighbors distinct.``#include ``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);``    ``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 m = ``new` `HashMap();` `// 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

 ``

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.