Leaders in an array

Unique Number I

Last Updated : 21 Apr, 2025

Try it on GfG Practice

Given an array of integers, every element in the array appears twice except for one element which appears only once. The task is to identify and return the element that occurs only once.

Examples:

Input: arr[] = [2, 3, 5, 4, 5, 3, 4]
Output: 2
Explanation: Since 2 occurs once, while other numbers occur twice, 2 is the answer.

Input: arr[] = [2, 2, 5, 5, 20, 30, 30]
Output: 20
Explanation: Since 20 occurs once, while other numbers occur twice, 20 is the answer.

Table of Content

[Naive Approach] Nested Loop Frequency Counting – O(n^2) Time and O(1) Space
[Better Approach] Using Hash Map – O(n) Time and O(n) Space
[Expected Approach] Using XOR Operation – O(n) Time and O(1) Space

[Naive Approach] Nested Loop Frequency Counting – O(n^2) Time and O(1) Space

This approach iterates through the array and counts the frequency of each element using a nested loop. For each element, the inner loop counts how many times it appears in the array. If an element appears exactly once, it is returned as the result. This method ensures that the correct element is identified but is inefficient due to the nested loop.

C++

#include <iostream>
#include <vector>
using namespace std;


int findUnique(vector<int>& arr) {
    int n = arr.size();

    // Iterate over every element
    for (int i = 0; i < n; i++) {

        // Initialize count to 0
        int count = 0;

        for (int j = 0; j < n; j++) {

            // Count the frequency of the element
            if (arr[i] == arr[j]) {
                count++;
            }
        }

        // If the frequency of the element is one
        if (count == 1) {
            return arr[i];
        }
    }

    // If no element exists at most once
    return -1;
}

int main() {
    vector<int> arr = { 2, 3, 5, 4, 5, 3, 4 };
    cout << findUnique(arr) << endl;
    return 0;
}

Java

import java.util.*;

class GfG {

    static int findUnique(int[] arr) {
        int n = arr.length;

        // Iterate over every element
        for (int i = 0; i < n; i++) {

            // Initialize count to 0
            int count = 0;

            for (int j = 0; j < n; j++) {

                // Count the frequency of the element
                if (arr[i] == arr[j]) {
                    count++;
                }
            }

            // If the frequency of the element is one
            if (count == 1) {
                return arr[i];
            }
        }

        // If no element exists at most once
        return -1;
    }

    public static void main(String[] args) {
        int[] arr = {2, 3, 5, 4, 5, 3, 4};
        System.out.println(findUnique(arr));
    }
}

Python

def findUnique(arr):
    n = len(arr)

    # Iterate over every element
    for i in range(n):

        # Initialize count to 0
        count = 0

        for j in range(n):

            # Count the frequency of the element
            if arr[i] == arr[j]:
                count += 1

        # If the frequency of the element is one
        if count == 1:
            return arr[i]

    # If no element exists at most once
    return -1

if __name__ == "__main__":
    arr = [2, 3, 5, 4, 5, 3, 4]
    print(findUnique(arr))

C#

using System;

class GfG {

    static int findUnique(int[] arr) {
        int n = arr.Length;

        // Iterate over every element
        for (int i = 0; i < n; i++) {

            // Initialize count to 0
            int count = 0;

            for (int j = 0; j < n; j++) {

                // Count the frequency of the element
                if (arr[i] == arr[j]) {
                    count++;
                }
            }

            // If the frequency of the element is one
            if (count == 1) {
                return arr[i];
            }
        }

        // If no element exists at most once
        return -1;
    }

    static void Main(string[] args) {
        int[] arr = {2, 3, 5, 4, 5, 3, 4};
        Console.WriteLine(findUnique(arr));
    }
}

JavaScript

function findUnique(arr) {
    let n = arr.length;

    // Iterate over every element
    for (let i = 0; i < n; i++) {

        // Initialize count to 0
        let count = 0;

        for (let j = 0; j < n; j++) {

            // Count the frequency of the element
            if (arr[i] === arr[j]) {
                count++;
            }
        }

        // If the frequency of the element is one
        if (count === 1) {
            return arr[i];
        }
    }

    // If no element exists at most once
    return -1;
}

let arr = [2, 3, 5, 4, 5, 3, 4];
console.log(findUnique(arr));

Output

[Better Approach] Using Hash Map – O(n) Time and O(n) Space

This approach uses a hash map (or dictionary) to track the frequency of each element in the array. First, we iterate through the array to record how many times each element appears. Then, we scan the hash map to find the element that appears exactly once. If such an element is found, it is returned; otherwise, the function returns -1. This method efficiently solves the problem in linear time with a linear space complexity.

Step by step approach:

Traverse all elements and insert them into a hash table. Element is used as key and the frequency is used as the value in the hash table.
Iterate through the map and return the value with count equal to 1.

C++

#include <iostream>
#include <unordered_map>
#include <vector>
using namespace std;

int findUnique(vector<int>& arr) {
    int n = arr.size();
    
    // Hash map to store the count of each element
    unordered_map<int, int> cnt;

    // Store frequency of each element
    for (int i = 0; i < n; i++) {
        cnt[arr[i]]++;
    }
    
    // Return the value with count = 1
    for (auto p : cnt) {
        if (p.second == 1) {
            return p.first;
        }
    }

    // If no element exists that appears only once
    return -1;
}

int main() {
    vector<int> arr = { 2, 3, 5, 4, 5, 3, 4 };
    cout << findUnique(arr) << endl;
    return 0;
}

Java

import java.util.HashMap;
import java.util.Map;

public class GfG {
    public static int findUnique(int[] arr) {
        
        // Hash map to store the count of each element
        HashMap<Integer, Integer> cnt = new HashMap<>();

        // Store frequency of each element
        for (int num : arr) {
            cnt.put(num, cnt.getOrDefault(num, 0) + 1);
        }

        // Return the value with count = 1
        for (Map.Entry<Integer, Integer> entry : cnt.entrySet()) {
            if (entry.getValue() == 1) {
                return entry.getKey();
            }
        }

        // If no element exists that appears only once
        return -1;
    }

    public static void main(String[] args) {
        int[] arr = { 2, 3, 5, 4, 5, 3, 4 };
        System.out.println(findUnique(arr));
    }
}

Python

def findUnique(arr):
    # Dictionary to store the count of each element
    cnt = {}

    # Store frequency of each element
    for num in arr:
        cnt[num] = cnt.get(num, 0) + 1

    # Return the value with count = 1
    for key, value in cnt.items():
        if value == 1:
            return key

    # If no element exists that appears only once
    return -1

arr = [2, 3, 5, 4, 5, 3, 4]
print(findUnique(arr))

C#

using System;
using System.Collections.Generic;

class GfG {
    public static int findUnique(int[] arr) {
        // Dictionary to store the count of each element
        Dictionary<int, int> cnt = new Dictionary<int, int>();

        // Store frequency of each element
        foreach (int num in arr) {
            if (cnt.ContainsKey(num)) {
                cnt[num]++;
            } else {
                cnt[num] = 1;
            }
        }

        // Return the value with count = 1
        foreach (var pair in cnt) {
            if (pair.Value == 1) {
                return pair.Key;
            }
        }

        // If no element exists that appears only once
        return -1;
    }

    static void Main() {
        int[] arr = { 2, 3, 5, 4, 5, 3, 4 };
        Console.WriteLine(findUnique(arr));
    }
}

JavaScript

function findUnique(arr) {
    
    // Object to store the count of each element
    const cnt = {};

    // Store frequency of each element
    for (const num of arr) {
        cnt[num] = (cnt[num] || 0) + 1;
    }

    // Return the value with count = 1
    for (const key in cnt) {
        if (cnt[key] === 1) {
            return parseInt(key);
        }
    }

    // If no element exists that appears only once
    return -1;
}

const arr = [2, 3, 5, 4, 5, 3, 4];
console.log(findUnique(arr));

Output

[Expected Approach] Using XOR Operation – O(n) Time and O(1) Space

This approach uses the XOR operation to find the unique element in an array where every other element appears twice. XOR of two identical numbers cancels them out (results in zero), so after XORing all the elements, only the element that appears once will remain.

C++

#include <iostream>
#include <vector>
using namespace std;

int findUnique(vector<int>& arr) {
    int n = arr.size();
    
    int res = 0;
    
    // Find XOR of all elements
    for (int i = 0; i < n; i++) {
        res = res ^ arr[i];
    }
    
    return res;
}

int main() {
    vector<int> arr = { 2, 3, 5, 4, 5, 3, 4 };
    cout << findUnique(arr) << endl;
    return 0;
}

Java

import java.util.List;
import java.util.Arrays;

public class GfG {
    public static int findUnique(int[] arr) {
        int res = 0;

        // Find XOR of all elements
        for (int i = 0; i < arr.length; i++) {
            res ^= arr[i];
        }

        return res;
    }

    public static void main(String[] args) {
        int[] arr = {2, 3, 5, 4, 5, 3, 4};
        System.out.println(findUnique(arr));
    }
}

Python

def findUnique(arr):
    res = 0
    
    # Find XOR of all elements
    for num in arr:
        res ^= num
    
    return res

if __name__ == '__main__':
    arr = [2, 3, 5, 4, 5, 3, 4]
    print(findUnique(arr))

C#

using System;

class GfG {
    static int findUnique(int[] arr) {
        int res = 0;

        // Find XOR of all elements
        foreach (int num in arr) {
            res ^= num;
        }

        return res;
    }

    static void Main() {
        int[] arr = { 2, 3, 5, 4, 5, 3, 4 };
        Console.WriteLine(findUnique(arr));
    }
}

JavaScript

function findUnique(arr) {
    let res = 0;
    
    // Find XOR of all elements
    for (let i = 0; i < arr.length; i++) {
        res ^= arr[i];
    }
    
    return res;
}

const arr = [2, 3, 5, 4, 5, 3, 4];
console.log(findUnique(arr));

Output

Leaders in an array

R

Ravi

Improve

Article Tags :

Practice Tags :

Similar Reads

Array Data Structure

Complete Guide to ArraysLearn more about Array in DSA Self Paced CoursePractice Problems on ArraysTop Quizzes on Arrays What is Array?An array is a collection of items stored at contiguous memory locations. The idea is to store multiple items of the same type together. This makes it easier to calcul

Array is a linear data structure where all elements are arranged sequentially. It is a collection of elements of same data type stored at contiguous memory locations. For simplicity, we can think of an array as a flight of stairs where on each step is placed a value (let's say one of your friends).

Getting Started with Array Data Structure

Array is a collection of items of the same variable type that are stored at contiguous memory locations. It is one of the most popular and simple data structures used in programming. Basic terminologies of ArrayArray Index: In an array, elements are identified by their indexes. Array index starts fr

Applications, Advantages and Disadvantages of Array

Array is a linear data structure that is a collection of data elements of same types. Arrays are stored in contiguous memory locations. It is a static data structure with a fixed size. Table of Content Applications of Array Data Structure:Advantages of Array Data Structure:Disadvantages of Array Dat

Subarrays, Subsequences, and Subsets in Array

What is a Subarray?AÂ subarrayÂ is a contiguous part of array, i.e., Subarray is an array that is inside another array. In general, for an array of size n, there areÂ n*(n+1)/2Â non-empty subarrays. For example, Consider the array [1, 2, 3, 4], There are 10 non-empty sub-arrays. The subarrays are: (1),

Top 50 Array Coding Problems for Interviews

Array is one of the most widely used data structure and is frequently asked in coding interviews to the problem solving skills. The following list of 50 array coding problems covers a range of difficulty levels, from easy to hard, to help candidates prepare for interviews. Easy Problems Second Large