# Distinct adjacent elements in an array

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 .```
Recommended Practice

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[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 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`

Time Complexity: O(N)
Auxiliary Space: O(N)

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.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next