Skip to content
Related Articles

Related Articles

Improve Article

Find the element that appears once in a sorted array

  • Difficulty Level : Medium
  • Last Updated : 27 May, 2021

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 <bits/stdc++.h>
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; 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




<script>
 
// JavaScript program to find the element that
// appears only once
 
// A Linear Search based function to find
// the element that appears only once
function search(arr, n)
{
    let ans = -1;
    for (let 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.
    document.write("The required element is " + ans + "<br>");
}
 
// Driver code
    let arr = [ 1, 1, 2, 4, 4, 5, 5, 6, 6 ];
    let len = arr.length;
 
    search(arr, len);
 
     
// This code is contributed by Surbhi Tyagi
 
</script>
Output



The required element is 2

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

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 <bits/stdc++.h>
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




<script>
// JavaScript program to find the element that
// appears only once
 
// A XOR based function to find
// the element that appears only once
function search(arr, n)
{
    let XOR = 0;
    for (let i = 0; i < n; i++) {
        XOR = XOR ^ arr[i];
    }
    document.write("The required element is " + XOR + "<br>");
}
 
// Driver code
    let arr = [ 1, 1, 2, 4, 4, 5, 5, 6, 6 ];
    let len = arr.length;
 
    search(arr, len);
 
 
 
 
// This code is contributed by Surbhi Tyagi.
</script>
Output
The required element is 2

Time Complexity: O(n)
Space Complexity: 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 <iostream>
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 <stdio.h>
 
// 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




<?php
// PHP program to find the element
// that appears only once
 
// A Binary Search based function
// to find the element that
// appears only once
function search($arr, $low, $high)
{
     
    // Base cases
    if ($low > $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




<script>
// Javascript implementation
 
// A Binary Search based function to find
// the element that appears only once
function search( arr, low, high)
{
  
    // Base cases
    if (low > high)
        return;
  
    if (low == high) {
        document.write("The required element is " + arr[low]);
        return;
    }
  
    // Find the middle point
    var mid = Math.floor((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
var arr = [1, 1, 2, 4, 4, 5, 5, 6, 6];
var len = arr.length;
 
search(arr, 0, len - 1)
 
// This is code is contributed
// by shubhamsingh10
</script>
Output
The required element is 2

Time Complexity: O(Log n)
Note: Other Solutions to the question are slight variations of the approaches discussed in this post.

This article is contributed by Mehboob Elahi. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :