GFG App
Open App
Browser
Continue

# Find the element that appears once in a sorted array

Given a sorted array in which all elements appear twice (one after one) and one element appears only once. Find that element in O(log n) complexity.

Example:

```Input:   arr[] = {1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8}
Output:  4

Input:   arr[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8}
Output:  8```

A Simple Solution is to traverse the array from left to right. Since the array is sorted, we can easily figure out the required element.

Below is the implementation of the above approach.

## C++

 `// C++ program to find the element that` `// appears only once` `#include ` `using` `namespace` `std;`   `// A Linear Search based function to find` `// the element that appears only once` `void` `search(``int` `arr[], ``int` `n)` `{` `    ``int` `ans = -1;` `    ``for` `(``int` `i = 0; i < n; i += 2) {` `        ``if` `(arr[i] != arr[i + 1]) {` `            ``ans = arr[i];` `            ``break``;` `        ``}` `    ``}` `  `  `    ``if` `(arr[n - 2] != arr[n - 1])` `            ``ans = arr[n-1];` `  `  `    ``// ans = -1 if no such element is present.` `    ``cout << ``"The required element is "` `<< ans << ``"\n"``;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 1, 2, 4, 4, 5, 5, 6, 6 };` `    ``int` `len = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``search(arr, len);`   `    ``return` `0;` `}`   `// This code is contributed by yashbeersingh42`

## Java

 `// Java program to find the element that` `// appears only once` `import` `java.io.*;`   `class` `GFG {` `    ``// A Linear Search based function to find` `    ``// the element that appears only once` `    ``static` `void` `search(``int` `arr[], ``int` `n)` `    ``{` `        ``int` `ans = -``1``;` `        ``for` `(``int` `i = ``0``; i < n-``1``; i += ``2``) {` `            ``if` `(arr[i] != arr[i + ``1``]) {` `                ``ans = arr[i];` `                ``break``;` `            ``}` `        ``}` `      `  `        ``if` `(arr[n - ``2``] != arr[n - ``1``])` `            ``ans = arr[n-``1``];` `     `  `        ``// ans = -1 if no such element is present.` `        ``System.out.println(``"The required element is "` `                           ``+ ans);` `    ``}` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = { ``1``, ``1``, ``2``, ``4``, ``4``, ``5``, ``5``, ``6``, ``6` `};` `        ``int` `len = arr.length;`   `        ``search(arr, len);` `    ``}` `}`

## Python3

 `# Python3 program to find the element that` `# appears only once`   `# A Linear Search based function to find` `# the element that appears only once`     `def` `search(arr, n):`   `    ``ans ``=` `-``1` `    ``for` `i ``in` `range``(``0``, n, ``2``):` `        ``if` `(arr[i] !``=` `arr[i ``+` `1``]):` `            ``ans ``=` `arr[i]` `            ``break` `    ``if``(arr[n``-``2``] !``=` `arr[n``-``1``]):` `        ``ans ``=` `arr[n``-``1``]`   `    ``# ans = -1 if no such element is present.` `    ``print``(``"The required element is"``, ans)`     `# Driver code` `arr ``=` `[``1``, ``1``, ``2``, ``4``, ``4``, ``5``, ``5``, ``6``, ``6``]` `Len` `=` `len``(arr)`   `search(arr, ``Len``)`   `# This code is contributed by divyesh072019`

## C#

 `// C# program to find the element that` `// appears only once` `using` `System;`   `class` `GFG {` `    ``// A Linear Search based function to find` `    ``// the element that appears only once` `    ``static` `void` `search(``int``[] arr, ``int` `n)` `    ``{` `        ``int` `ans = -1;` `        ``for` `(``int` `i = 0; i < n; i += 2) {` `            ``if` `(arr[i] != arr[i + 1]) {` `                ``ans = arr[i];` `                ``break``;` `            ``}` `        ``}`   `        ``if` `(arr[n - 2] != arr[n - 1])` `            ``ans = arr[n-1];` `      `  `        ``// ans = -1 if no such element is present.` `        ``Console.Write(``"The required element is "` `                        ``+ ans);` `    ``}` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int``[] arr = { 1, 1, 2, 4, 4, 5, 5, 6, 6 };` `        ``int` `len = arr.Length;`   `        ``search(arr, len);` `    ``}` `}`   `// This code is contributed by shivanisinghss2110`

## Javascript

 ``

Output

`The required element is 2`

Time Complexity: O(n)
Auxiliary Space: O(1),  since no extra space has been taken.

Another Simple Solution is to use the properties of XOR (a ^ a = 0 & a ^ 0 = a). The idea is to find the XOR of the complete array. The XOR of the array is the required answer.

Below is the implementation of the above approach.

## C++

 `// C++ program to find the element that` `// appears only once` `#include ` `using` `namespace` `std;`   `// A XOR based function to find` `// the element that appears only once` `void` `search(``int` `arr[], ``int` `n)` `{` `    ``int` `XOR = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``XOR = XOR ^ arr[i];` `    ``}` `    ``cout << ``"The required element is "` `<< XOR << ``"\n"``;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 1, 2, 4, 4, 5, 5, 6, 6 };` `    ``int` `len = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``search(arr, len);`   `    ``return` `0;` `}`   `// This code is contributed by yashbeersingh42`

## Java

 `// Java program to find the element that` `// appears only once` `import` `java.io.*;`   `class` `GFG {` `    ``// A XOR based function to find` `    ``// the element that appears only once` `    ``static` `void` `search(``int` `arr[], ``int` `n)` `    ``{` `        ``int` `XOR = ``0``;` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``XOR = XOR ^ arr[i];` `        ``}` `        ``System.out.println(``"The required element is "` `                           ``+ XOR);` `    ``}` `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = { ``1``, ``1``, ``2``, ``4``, ``4``, ``5``, ``5``, ``6``, ``6` `};` `        ``int` `len = arr.length;`   `        ``search(arr, len);` `    ``}` `}`   `// This code is contributed by yashbeersingh42`

## Python3

 `# Python3 program to find the element that` `# appears only once`   `# A XOR based function to find` `# the element that appears only once` `def` `search(arr, n) :`   `    ``XOR ``=` `0` `    ``for` `i ``in` `range``(n) :` `        ``XOR ``=` `XOR ^ arr[i]`   `    ``print``(``"The required element is"``, XOR)`   `# Driver code` `arr ``=` `[ ``1``, ``1``, ``2``, ``4``, ``4``, ``5``, ``5``, ``6``, ``6` `]` `Len` `=` `len``(arr)`   `search(arr, ``Len``)`   `# This code is contributed by divyesh072019`

## C#

 `// C# program to find the element that` `// appears only once` `using` `System;`   `class` `GFG{` `    `  `// A XOR based function to find` `// the element that appears only once` `static` `void` `search(``int` `[]arr, ``int` `n)` `{` `    ``int` `XOR = 0;` `    `  `    ``for``(``int` `i = 0; i < n; i++)` `    ``{` `        ``XOR = XOR ^ arr[i];` `    ``}` `    ``Console.Write(``"The required element is "` `+ XOR);` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `[]arr = { 1, 1, 2, 4, 4, 5, 5, 6, 6 };` `    ``int` `len = arr.Length;` `    `  `    ``search(arr, len);` `}` `}`   `// This code is contributed by shivanisinghss2110`

## Javascript

 ``

Output

`The required element is 2`

Time Complexity: O(n)
Auxiliary Space: O(1)

An Efficient Solution can find the required element in O(Log n) time. The idea is to use Binary Search. Below is an observation on the input array.
All elements before the required have the first occurrence at even index (0, 2, ..) and the next occurrence at odd index (1, 3, …). And all elements after the required elements have the first occurrence at an odd index and the next occurrence at an even index.

1. Find the middle index, say ‘mid’.
2. If ‘mid’ is even, then compare arr[mid] and arr[mid + 1]. If both are the same, then the required element after ‘mid’ and else before mid.
3. If ‘mid’ is odd, then compare arr[mid] and arr[mid – 1]. If both are the same, then the required element after ‘mid’ and else before mid.

Below is the implementation based on the above idea:

## C++

 `// C++ program to find the element that` `// appears only once` `#include ` `using` `namespace` `std;`   `// A Binary Search based function to find` `// the element that appears only once` `void` `search(``int` `arr[], ``int` `low, ``int` `high)` `{`   `    ``// Base cases` `    ``if` `(low > high)` `        ``return``;`   `    ``if` `(low == high) {` `        ``cout << ``"The required element is "` `<< arr[low];` `        ``return``;` `    ``}`   `    ``// Find the middle point` `    ``int` `mid = (low + high) / 2;`   `    ``// If mid is even and element next to mid is` `    ``// same as mid, then output element lies on` `    ``// right side, else on left side` `    ``if` `(mid % 2 == 0) {` `        ``if` `(arr[mid] == arr[mid + 1])` `            ``search(arr, mid + 2, high);` `        ``else` `            ``search(arr, low, mid);` `    ``}`   `    ``// If mid is odd` `    ``else` `{` `        ``if` `(arr[mid] == arr[mid - 1])` `            ``search(arr, mid + 1, high);` `        ``else` `            ``search(arr, low, mid - 1);` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 1, 2, 4, 4, 5, 5, 6, 6 };` `    ``int` `len = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``search(arr, 0, len - 1);`   `    ``return` `0;` `}`   `// This code is contributed by ShubhamCoder`

## C

 `// C program to find the element that appears only once` `#include `   `// A Binary Search based function to find the element` `// that appears only once` `void` `search(``int``* arr, ``int` `low, ``int` `high)` `{` `    ``// Base cases` `    ``if` `(low > high)` `        ``return``;`   `    ``if` `(low == high) {` `        ``printf``(``"The required element is %d "``, arr[low]);` `        ``return``;` `    ``}`   `    ``// Find the middle point` `    ``int` `mid = (low + high) / 2;`   `    ``// If mid is even and element next to mid is` `    ``// same as mid, then output element lies on` `    ``// right side, else on left side` `    ``if` `(mid % 2 == 0) {` `        ``if` `(arr[mid] == arr[mid + 1])` `            ``search(arr, mid + 2, high);` `        ``else` `            ``search(arr, low, mid);` `    ``}` `    ``else` `// If mid is odd` `    ``{` `        ``if` `(arr[mid] == arr[mid - 1])` `            ``search(arr, mid + 1, high);` `        ``else` `            ``search(arr, low, mid - 1);` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 1, 2, 4, 4, 5, 5, 6, 6 };` `    ``int` `len = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``search(arr, 0, len - 1);` `    ``return` `0;` `}`

## Java

 `// Java program to find the element that appears only once`   `public` `class` `Main {` `    ``// A Binary Search based method to find the element` `    ``// that appears only once` `    ``public` `static` `void` `search(``int``[] arr, ``int` `low, ``int` `high)` `    ``{` `        ``if` `(low > high)` `            ``return``;` `        ``if` `(low == high) {` `            ``System.out.println(``"The required element is "` `                               ``+ arr[low]);` `            ``return``;` `        ``}`   `        ``// Find the middle point` `        ``int` `mid = (low + high) / ``2``;`   `        ``// If mid is even and element next to mid is` `        ``// same as mid, then output element lies on` `        ``// right side, else on left side` `        ``if` `(mid % ``2` `== ``0``) {` `            ``if` `(arr[mid] == arr[mid + ``1``])` `                ``search(arr, mid + ``2``, high);` `            ``else` `                ``search(arr, low, mid);` `        ``}` `        ``// If mid is odd` `        ``else` `if` `(mid % ``2` `== ``1``) {` `            ``if` `(arr[mid] == arr[mid - ``1``])` `                ``search(arr, mid + ``1``, high);` `            ``else` `                ``search(arr, low, mid - ``1``);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int``[] arr = { ``1``, ``1``, ``2``, ``4``, ``4``, ``5``, ``5``, ``6``, ``6` `};` `        ``search(arr, ``0``, arr.length - ``1``);` `    ``}` `}` `// This code is contributed by Tanisha Mittal`

## Python

 `# A Binary search based function to find` `# the element that appears only once`     `def` `search(arr, low, high):`   `    ``# Base cases` `    ``if` `low > high:` `        ``return` `None`   `    ``if` `low ``=``=` `high:` `        ``return` `arr[low]`   `    ``# Find the middle point` `    ``mid ``=` `low ``+` `(high ``-` `low)``/``2`   `    ``# If mid is even and element next to mid is` `    ``# same as mid, then output element lies on` `    ``# right side, else on left side` `    ``if` `mid ``%` `2` `=``=` `0``:`   `        ``if` `arr[mid] ``=``=` `arr[mid``+``1``]:` `            ``return` `search(arr, mid``+``2``, high)` `        ``else``:` `            ``return` `search(arr, low, mid)`   `    ``else``:` `        ``# if mid is odd` `        ``if` `arr[mid] ``=``=` `arr[mid``-``1``]:` `            ``return` `search(arr, mid``+``1``, high)` `        ``else``:` `            ``return` `search(arr, low, mid``-``1``)`   `# Driver Code` `# Test Array` `arr ``=` `[``1``, ``1``, ``2``, ``4``, ``4``, ``5``, ``5``, ``6``, ``6``]`   `# Function call` `result ``=` `search(arr, ``0``, ``len``(arr)``-``1``)`   `if` `result ``is` `not` `None``:` `    ``print` `"The required element is %d"` `%` `result` `else``:` `    ``print` `"Invalid Array"`

## C#

 `// C# program to find the element` `// that appears only once` `using` `System;`   `class` `GFG {`   `    ``// A Binary Search based` `    ``// method to find the element` `    ``// that appears only once` `    ``public` `static` `void` `search(``int``[] arr, ``int` `low, ``int` `high)` `    ``{`   `        ``if` `(low > high)` `            ``return``;` `        ``if` `(low == high) {` `            ``Console.WriteLine(``"The required element is "` `                              ``+ arr[low]);` `            ``return``;` `        ``}`   `        ``// Find the middle point` `        ``int` `mid = (low + high) / 2;`   `        ``// If mid is even and element` `        ``// next to mid is same as mid` `        ``// then output element lies on` `        ``// right side, else on left side` `        ``if` `(mid % 2 == 0) {` `            ``if` `(arr[mid] == arr[mid + 1])` `                ``search(arr, mid + 2, high);` `            ``else` `                ``search(arr, low, mid);` `        ``}`   `        ``// If mid is odd` `        ``else` `if` `(mid % 2 == 1) {` `            ``if` `(arr[mid] == arr[mid - 1])` `                ``search(arr, mid + 1, high);` `            ``else` `                ``search(arr, low, mid - 1);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int``[] arr = { 1, 1, 2, 4, 4, 5, 5, 6, 6 };` `        ``search(arr, 0, arr.Length - 1);` `    ``}` `}`   `// This code is contributed by Nitin Mittal.`

## PHP

 ` ``\$high``)` `        ``return``;`   `    ``if` `(``\$low``==``\$high``)` `    ``{` `        ``echo``(``"The required element is "` `);` `        ``echo` `\$arr``[``\$low``] ;` `        ``return``;` `    ``}`   `    ``// Find the middle point` `    ``\$mid` `= (``\$low` `+ ``\$high``) / 2;`   `    ``// If mid is even and element ` `    ``// next to mid is same as mid,` `    ``// then output element lies on` `    ``// right side, else on left side` `    ``if` `(``\$mid` `% 2 == 0)` `    ``{` `        ``if` `(``\$arr``[``\$mid``] == ``\$arr``[``\$mid` `+ 1])` `            ``search(``\$arr``, ``\$mid` `+ 2, ``\$high``);` `        ``else` `            ``search(``\$arr``, ``\$low``, ``\$mid``);` `    ``}` `    `  `    ``// If mid is odd` `    ``else` `    ``{` `        ``if` `(``\$arr``[``\$mid``] == ``\$arr``[``\$mid` `- 1])` `            ``search(``\$arr``, ``\$mid` `+ 1, ``\$high``);` `        ``else` `            ``search(``\$arr``, ``\$low``, ``\$mid` `- 1);` `    ``}` `}`   `    ``// Driver Code` `    ``\$arr` `= ``array``(1, 1, 2, 4, 4, 5, 5, 6, 6);` `    ``\$len` `= sizeof(``\$arr``);` `    ``search(``\$arr``, 0, ``\$len` `- 1);`   `// This code is contributed by nitin mittal` `?>`

## Javascript

 ``

Output

`The required element is 2`

Time Complexity: O(Log n)
Auxiliary Space: O(1)

Note: Other Solutions to the question are slight variations of the approaches discussed in this post.

Another Approach: An Efficient Solution can find the required element in O(Log n) time. The idea is to use Binary Search without recursion. All elements before the required have the first occurrence at even index (0, 2, ..and so on) and the next occurrence at odd index (1, 3, ..and so on).

The approach will be as follows:

Find the middle index assuming mid using start pointer and end pointer. And check the mid element in the following cases

• Case 1) If mid element is not equal to mid+1 element  and mid-1 element. This case returns the answer.
• Case 2) When mid element is even and equal to mid+1 element this means number is not present in the left side of the array. In this case start pointer will change to mid+1.
• Case 3) When mid element is odd and equal to mid-1 element this means number is not present in the left side of the array. In this case start pointer will change to mid+1.
• Case 4) When mid element is odd and equal to mid+1 element this means number is not present in the right side of the array. In this case end pointer will change to mid-1.
• Case 5) When mid element is even and equal to mid-1 element this means number is not present in the right side of the array. In this case end pointer will change to mid-1.

Check for all case for possible values of mid till start<=end..

If all checks fail there is no such element.

This solution requires extra checks for edge cases.

• Edge Case 1) If only one element is present in the array. Therefore return the only element of the array.
• Edge Case 2) If last element of the array is the required element. Therefore return the last element of the array.
• Edge Case 3) If first element of the array is the required element. Therefore return the first element of the array.

Below is the implementation based on the above idea:

## C++

 `#include ` `using` `namespace` `std;` `int` `search(``int` `nums[], ``int` `n)` `{` `  `  `    ``// A Binary Search based method to find the element` `    ``// that appears only once` `    ``int` `start = 0, end = n - 1, mid;`   `    ``// For Edge Cases` `    ``if` `(n == 1) ``// If only one element is in the array` `        ``return` `nums[0];`   `    ``if` `(nums[start]` `        ``!= nums[start + 1]) ``// If the first element` `                            ``// is the element that` `                            ``// appears only once` `        ``return` `nums[start];`   `    ``if` `(nums[end]` `        ``!= nums[end - 1]) ``// If Last element is the element` `                          ``// that appears only once` `        ``return` `nums[end];`   `    ``// Binary Search` `    ``while` `(start <= end)` `    ``{` `        ``mid = start + (end - start) / 2;` `      `  `        ``// CASE 1` `        ``if` `(nums[mid] != nums[mid - 1]` `            ``&& nums[mid] != nums[mid + 1])` `            ``return` `nums[mid];` `      `  `        ``// CASE 2 and CASE 3` `        ``else` `if` `((nums[mid] == nums[mid + 1]` `                  ``&& mid % 2 == 0)` `                 ``|| (nums[mid] == nums[mid - 1]` `                     ``&& mid % 2 != 0))` `            ``start = mid + 1;` `      `  `        ``// CASE 4 and CASE 5` `        ``else` `            ``end = mid - 1;` `    ``}` `  `  `    ``// If no such element found` `    ``return` `-1;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 1, 2, 4, 4, 5, 5, 6, 6 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `element = search(arr, n);`   `    ``if` `(element != -1)` `        ``cout << ``"The required element is "` `<< element;` `    ``else` `        ``cout << ``"There is no such element"``;` `}`   `// This code is contributed by umadevi9616`

## Java

 `class` `GFG {` `    ``public` `static` `int` `search(``int``[] nums)` `    ``{` `        ``// A Binary Search based method to find the element` `        ``// that appears only once` `        ``int` `start = ``0``, end = nums.length - ``1``, mid;`   `        ``// For Edge Cases` `        ``if` `(nums.length` `            ``== ``1``) ``// If only one element is in the array` `            ``return` `nums[``0``];`   `        ``if` `(nums[start]` `            ``!= nums[start + ``1``]) ``// If the first element` `                                ``// is the element that` `                                ``// appears only once` `            ``return` `nums[start];`   `        ``if` `(nums[end]` `            ``!= nums[end` `                    ``- ``1``]) ``// If Last element is the element` `                          ``// that appears only once` `            ``return` `nums[end];`   `        ``// Binary Search` `        ``while` `(start <= end) {` `            ``mid = start + (end - start) / ``2``;` `            ``// CASE 1` `            ``if` `(nums[mid] != nums[mid - ``1``]` `                ``&& nums[mid] != nums[mid + ``1``])` `                ``return` `nums[mid];` `            ``// CASE 2 and CASE 3` `            ``else` `if` `((nums[mid] == nums[mid + ``1``]` `                      ``&& mid % ``2` `== ``0``)` `                     ``|| (nums[mid] == nums[mid - ``1``]` `                         ``&& mid % ``2` `!= ``0``))` `                ``start = mid + ``1``;` `            ``// CASE 4 and CASE 5` `            ``else` `                ``end = mid - ``1``;` `        ``}` `        ``// If no such element found` `        ``return` `-``1``;` `    ``}` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int``[] arr = { ``1``, ``1``, ``2``, ``4``, ``4``, ``5``, ``5``, ``6``, ``6` `};`   `        ``int` `element = search(arr);`   `        ``if` `(element != -``1``)` `            ``System.out.println(``"The required element is "` `                               ``+ element);` `        ``else` `            ``System.out.println(``"There is no such element"``);` `    ``}` `}`   `// Code Contributed by Arnav Sharma`

## Python3

 `def` `search(nums):` `    ``# A Binary Search based method to find the element` `    ``# that appears only once` `    ``start ``=` `0``;` `    ``end ``=` `len``(nums)``-``1``;` `    ``mid ``=` `0``;`   `    ``# For Edge Cases` `    ``if` `(``len``(nums) ``=``=` `1``): ``# If only one element is in the array` `        ``return` `nums[``0``];`   `    ``if` `(nums[start] !``=` `nums[start ``+` `1``]): ``# If the first element` `                                        ``# is the element that` `                                        ``# appears only once` `        ``return` `nums[start];`   `    ``if` `(nums[end] !``=` `nums[end ``-` `1``]): ``# If Last element is the element` `                                    ``# that appears only once` `        ``return` `nums[end];`   `    ``# Binary Search` `    ``while` `(start <``=` `end):` `        ``mid ``=` `start ``+` `(end ``-` `start) ``/``/` `2``;` `        `  `        ``# CASE 1` `        ``if` `(nums[mid] !``=` `nums[mid ``-` `1``] ``and` `nums[mid] !``=` `nums[mid ``+` `1``]):` `          `  `            ``return` `nums[mid];` `        ``# CASE 2 and CASE 3` `        ``elif``((nums[mid] ``=``=` `nums[mid ``+` `1``] ``and` `mid ``%` `2` `=``=` `0``) ``or` `(nums[mid] ``=``=` `nums[mid ``-` `1``] ``and` `mid ``%` `2` `!``=` `0``)):` `            ``start ``=` `mid ``+` `1``;` `            `  `        ``# CASE 4 and CASE 5` `        ``else``:` `            ``end ``=` `mid ``-` `1``;` `    `  `    ``# If no such element found` `    ``return` `-``1``;`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[ ``1``, ``1``, ``2``, ``4``, ``4``, ``5``, ``5``, ``6``, ``6` `];`   `    ``element ``=` `search(arr);`   `    ``if` `(element !``=` `-``1``):` `        ``print``(``"The required element is "` `, element);` `    ``else``:` `        ``print``(``"There is no such element"``);`   `# This code is contributed by umadevi9616 `

## C#

 `using` `System;` `public` `class` `GFG {` `    ``public` `static` `int` `search(``int``[] nums)` `    ``{` `      `  `        ``// A Binary Search based method to find the element` `        ``// that appears only once` `        ``int` `start = 0, end = nums.Length - 1, mid;`   `        ``// For Edge Cases` `        ``if` `(nums.Length` `            ``== 1) ``// If only one element is in the array` `            ``return` `nums[0];`   `        ``if` `(nums[start]` `            ``!= nums[start + 1]) ``// If the first element` `                                ``// is the element that` `                                ``// appears only once` `            ``return` `nums[start];`   `        ``if` `(nums[end]` `            ``!= nums[end` `                    ``- 1]) ``// If Last element is the element` `                          ``// that appears only once` `            ``return` `nums[end];`   `        ``// Binary Search` `        ``while` `(start <= end) ` `        ``{` `            ``mid = start + (end - start) / 2;` `          `  `            ``// CASE 1` `            ``if` `(nums[mid] != nums[mid - 1]` `                ``&& nums[mid] != nums[mid + 1])` `                ``return` `nums[mid];` `          `  `            ``// CASE 2 and CASE 3` `            ``else` `if` `((nums[mid] == nums[mid + 1]` `                      ``&& mid % 2 == 0)` `                     ``|| (nums[mid] == nums[mid - 1]` `                         ``&& mid % 2 != 0))` `                ``start = mid + 1;` `          `  `            ``// CASE 4 and CASE 5` `            ``else` `                ``end = mid - 1;` `        ``}` `      `  `        ``// If no such element found` `        ``return` `-1;` `    ``}` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int``[] arr = { 1, 1, 2, 4, 4, 5, 5, 6, 6 };`   `        ``int` `element = search(arr);`   `        ``if` `(element != -1)` `            ``Console.WriteLine(``"The required element is "` `                               ``+ element);` `        ``else` `            ``Console.WriteLine(``"There is no such element"``);` `    ``}` `}`   `// This code is contributed by gauravrajput1 `

## Javascript

 ``

Output

`The required element is 2`

This solution is contributed by Arnav Sharma.

Time Complexity: O(logn)
Auxiliary Space: O(1)

Another Approach:-

We can simply use hashmap to store the frequency of the elements and after that we can just traverse the hashmap to find the element with frequency 1.

Implementation:

## C++

 `// C++ program to find the element that` `// appears only once` `#include ` `using` `namespace` `std;`   `// function to find element using hashmap` `void` `search(``int` `arr[], ``int` `n)` `{` `    ``// taking hashmap to store frequency` `    ``unordered_map<``int``, ``int``> mm;`   `    ``// iterating over array` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// storing frequency` `        ``mm[arr[i]]++;` `    ``}`   `    ``// iterating over map` `    ``for` `(``auto` `x : mm) {` `        ``// if element found` `        ``if` `(x.second == 1) {` `            ``// printing element` `            ``cout << x.first << endl;` `            ``break``;` `        ``}` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 1, 2, 4, 4, 5, 5, 6, 6 };` `    ``int` `len = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``search(arr, len);`   `    ``return` `0;` `}`   `// This code is contributed by shubhamrajput6156`

## Java

 `// Java program to find the element that` `// appears only once` `import` `java.util.*;` `class` `GFG {`   `  ``// function to find element using hashmap` `  ``static` `void` `search(``int` `arr[], ``int` `n)` `  ``{` `    ``// taking hashmap to store frequency` `    ``HashMap mm=``new` `HashMap();`   `    ``// iterating over array` `    ``for``(``int` `i = ``0``; i < arr.length; i++) {` `      ``if` `(mm.containsKey(arr[i])) {` `        ``int` `count = mm.get(arr[i]) +``1``;` `        ``mm.put(arr[i], count);` `      ``} ``else``{` `        ``mm.put(arr[i],``1``);` `      ``}` `    ``}`   `    ``// iterating over map` `    ``for``(Map.Entry x : mm.entrySet()){    ` `      ``int` `c= x.getValue();` `      ``// if element found` `      ``if``(c == ``1``){` `        ``// printing element` `        ``System.out.println(x.getKey());` `        ``break``;` `      ``}    ` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args) {` `    ``int` `arr[] = { ``1``, ``1``, ``2``, ``4``, ``4``, ``5``, ``5``, ``6``, ``6` `};` `    ``int` `len = arr.length;`   `    ``// function calling` `    ``search(arr, len);`   `    ``return` `;` `  ``}` `}`   `// This code is contributed by bhardwajji`

## Python3

 `# Python3 program to find the element that` `# appears only once`   `# function to find element using dictionary`     `def` `search(arr):` `    ``# taking dictionary to store frequency` `    ``freq ``=` `{}`   `    ``# iterating over array` `    ``for` `i ``in` `arr:` `        ``# storing frequency` `        ``if` `i ``in` `freq:` `            ``freq[i] ``+``=` `1` `        ``else``:` `            ``freq[i] ``=` `1`   `    ``# iterating over dictionary` `    ``for` `key, value ``in` `freq.items():` `        ``# if element found` `        ``if` `value ``=``=` `1``:` `            ``# printing element` `            ``print``(key)` `            ``break`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[``1``, ``1``, ``2``, ``4``, ``4``, ``5``, ``5``, ``6``, ``6``]`   `    ``search(arr)`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG {`   `  ``// function to find element using Dictionary` `  ``static` `void` `Search(``int``[] arr, ``int` `n) {` `    ``// taking Dictionary to store frequency` `    ``Dictionary<``int``,``int``> mm = ``new` `Dictionary<``int``,``int``>();`   `    ``// iterating over array` `    ``for``(``int` `i = 0; i < arr.Length; i++) {` `      ``if` `(mm.ContainsKey(arr[i])) {` `        ``int` `count = mm[arr[i]] + 1;` `        ``mm[arr[i]] = count;` `      ``} ``else``{` `        ``mm.Add(arr[i], 1);` `      ``}` `    ``}`   `    ``// iterating over Dictionary` `    ``foreach``(KeyValuePair<``int``,``int``> x ``in` `mm) {    ` `      ``int` `c = x.Value;` `      ``// if element found` `      ``if``(c == 1){` `        ``// printing element` `        ``Console.WriteLine(x.Key);` `        ``break``;` `      ``}    ` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(``string``[] args) {` `    ``int``[] arr = { 1, 1, 2, 4, 4, 5, 5, 6, 6 };` `    ``int` `len = arr.Length;`   `    ``// function calling` `    ``Search(arr, len);`   `    ``return` `;` `  ``}` `}`

## Javascript

 `// Javascript equivalent of above code`   `// function to find element using dictionary` `function` `search(arr){` `    ``// taking dictionary to store frequency` `    ``let freq = {};`   `    ``// iterating over array` `    ``for` `(let i of arr){` `        ``// storing frequency` `        ``if` `(i ``in` `freq){ ` `            ``freq[i] += 1;` `        ``}` `        ``else``{` `            ``freq[i] = 1;` `        ``}` `    ``}`   `    ``// iterating over dictionary` `    ``for` `(let [key, value] of Object.entries(freq)){` `        ``// if element found` `        ``if` `(value == 1){` `            ``// printing element` `            ``console.log(key);` `            ``break``;` `        ``}` `    ``}` `}`   `// Driver code`   `    ``arr = [1, 1, 2, 4, 4, 5, 5, 6, 6];`   `    ``search(arr);`

Output

`2`

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

Another Approach Using Stacks:

We know that the given array is sorted in non-decreasing (ascending) order, and that every element occurs twice except for 1 element. The approach involves using a stack while iterating through the entire array. While pushing in elements, we may push this singular element on to the stack. By the end of the iteration we will have that singular element on the top of the stack which is returned.

While iterating through the array, if we have no element in the stack, or the consective element is not equal to the top most element in the stack, we can push that element to the stack. Else we can pop the top element from the stack. Finally, we can return the top most element, which is the singular element in the array.

## C++

 `// C++ program to find the element that` `// appears only once` `#include ` `using` `namespace` `std;`   `// function to find element using stack` `int` `singleNonDuplicate(vector<``int``>& nums) {` `         ``//declaring the stack for stroing elements` `        ``stack<``int``> stk;` `          ``//traversing linearly over the entire array` `        ``for` `(``int` `i = 0; i < nums.size(); i++) {` `              ``/*checking if element is presnt in the stack ` `          ``or the current array element equal to stack's top element*/` `            ``if` `(stk.empty() or nums[i] != stk.top()) {` `              ``//pushing the element in the stack if conditions satisfied` `                ``stk.push(nums[i]);` `            ``} ``else` `{` `              ``//If condition doesn't match pop elements from the stack` `                ``stk.pop();` `            ``}` `        ``}` `          ``//return the topmost element from the stack` `        ``return` `stk.top();` `    ``}`   `// Driver code` `int` `main()` `{` `  ``//declaring a vector` `    ``vector<``int``> arr{ 1, 1, 2, 4, 4, 5, 5, 6, 6 };` `    ``//calling function` `    ``cout<

Output:

2

Time Complexity:- O(N) for traversing through entire array linearly.
Auxiliary Space:- O(N) for stroing the elements in stack.

My Personal Notes arrow_drop_up