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++
#include <bits/stdc++.h>
using namespace std;
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];
cout << "The required element is " << ans << "\n" ;
}
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;
}
|
Java
import java.io.*;
class GFG {
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 ];
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
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 ]
print ( "The required element is" , ans)
arr = [ 1 , 1 , 2 , 4 , 4 , 5 , 5 , 6 , 6 ]
Len = len (arr)
search(arr, Len )
|
C#
using System;
class GFG {
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];
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);
}
}
|
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 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++
#include <bits/stdc++.h>
using namespace std;
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" ;
}
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;
}
|
Java
import java.io.*;
class GFG {
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);
}
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
def search(arr, n) :
XOR = 0
for i in range (n) :
XOR = XOR ^ arr[i]
print ( "The required element is" , XOR)
arr = [ 1 , 1 , 2 , 4 , 4 , 5 , 5 , 6 , 6 ]
Len = len (arr)
search(arr, Len )
|
C#
using System;
class GFG{
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);
}
public static void Main(String[] args)
{
int []arr = { 1, 1, 2, 4, 4, 5, 5, 6, 6 };
int len = arr.Length;
search(arr, len);
}
}
|
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 in the input array.
All elements before the required have the first occurrence at even index (0, 2, ..) and next occurrence at odd index (1, 3, …). And all elements after the required elements have the first occurrence at odd index and next occurrence at 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’ 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’ else before mid.
Below is the implementation based on the above idea:
C++
#include <iostream>
using namespace std;
void search( int arr[], int low, int high)
{
if (low > high)
return ;
if (low == high) {
cout << "The required element is " << arr[low];
return ;
}
int mid = (low + high) / 2;
if (mid % 2 == 0) {
if (arr[mid] == arr[mid + 1])
search(arr, mid + 2, high);
else
search(arr, low, mid);
}
else {
if (arr[mid] == arr[mid - 1])
search(arr, mid + 1, high);
else
search(arr, low, mid - 1);
}
}
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;
}
|
C
#include <stdio.h>
void search( int * arr, int low, int high)
{
if (low > high)
return ;
if (low == high) {
printf ( "The required element is %d " , arr[low]);
return ;
}
int mid = (low + high) / 2;
if (mid % 2 == 0) {
if (arr[mid] == arr[mid + 1])
search(arr, mid + 2, high);
else
search(arr, low, mid);
}
else
{
if (arr[mid] == arr[mid - 1])
search(arr, mid + 1, high);
else
search(arr, low, mid - 1);
}
}
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
public class Main {
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 ;
}
int mid = (low + high) / 2 ;
if (mid % 2 == 0 ) {
if (arr[mid] == arr[mid + 1 ])
search(arr, mid + 2 , high);
else
search(arr, low, mid);
}
else if (mid % 2 == 1 ) {
if (arr[mid] == arr[mid - 1 ])
search(arr, mid + 1 , high);
else
search(arr, low, mid - 1 );
}
}
public static void main(String[] args)
{
int [] arr = { 1 , 1 , 2 , 4 , 4 , 5 , 5 , 6 , 6 };
search(arr, 0 , arr.length - 1 );
}
}
|
Python
def search(arr, low, high):
if low > high:
return None
if low = = high:
return arr[low]
mid = low + (high - low) / 2
if mid % 2 = = 0 :
if arr[mid] = = arr[mid + 1 ]:
return search(arr, mid + 2 , high)
else :
return search(arr, low, mid)
else :
if arr[mid] = = arr[mid - 1 ]:
return search(arr, mid + 1 , high)
else :
return search(arr, low, mid - 1 )
arr = [ 1 , 1 , 2 , 4 , 4 , 5 , 5 , 6 , 6 ]
result = search(arr, 0 , len (arr) - 1 )
if result is not None :
print "The required element is %d" % result
else :
print "Invalid Array"
|
C#
using System;
class GFG {
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 ;
}
int mid = (low + high) / 2;
if (mid % 2 == 0) {
if (arr[mid] == arr[mid + 1])
search(arr, mid + 2, high);
else
search(arr, low, mid);
}
else if (mid % 2 == 1) {
if (arr[mid] == arr[mid - 1])
search(arr, mid + 1, high);
else
search(arr, low, mid - 1);
}
}
public static void Main(String[] args)
{
int [] arr = { 1, 1, 2, 4, 4, 5, 5, 6, 6 };
search(arr, 0, arr.Length - 1);
}
}
|
PHP
<?php
function search( $arr , $low , $high )
{
if ( $low > $high )
return ;
if ( $low == $high )
{
echo ( "The required element is " );
echo $arr [ $low ] ;
return ;
}
$mid = ( $low + $high ) / 2;
if ( $mid % 2 == 0)
{
if ( $arr [ $mid ] == $arr [ $mid + 1])
search( $arr , $mid + 2, $high );
else
search( $arr , $low , $mid );
}
else
{
if ( $arr [ $mid ] == $arr [ $mid - 1])
search( $arr , $mid + 1, $high );
else
search( $arr , $low , $mid - 1);
}
}
$arr = array (1, 1, 2, 4, 4, 5, 5, 6, 6);
$len = sizeof( $arr );
search( $arr , 0, $len - 1);
?>
|
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.