Unique Number I

Find all distinct elements in a given array

Last Updated : 07 Jul, 2025

Try it on GfG Practice

Given an integer array arr[], find all the distinct elements of the given array. The given array may contain duplicates and the output should contain every element only once.

Examples:

Input: arr[] = [2, 2, 3, 3, 7, 5]
Output: [2, 3, 7, 5]
Explanation : After removing the duplicates 2 and 3 we get 2 3 7 5.

Input: arr[] = [1, 2, 3, 4, 5]
Output: [1, 2, 3, 4, 5]
Explanation : There doesn't exists any duplicate element.

Table of Content

[Naive Approach] Using Nested loops - O(n^2) Time and O(1) Space
[Better Approach] Using Sorting - O(n*logn) Time and O(1) Space
[Expected Approach] Using Hashset - O(n) Time and O(n) Space

[Naive Approach] Using Nested loops - O(n^2) Time and O(1) Space

The idea is to use two nested loops. The outer loop picks an element one by one starting from the leftmost element. The inner loop checks if the element is present on left side of it. If present, then ignore the element, else store it in result.

C++

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

vector<int> remDuplicate(vector<int> &arr) {
    vector<int> res;

    for (int i = 0; i < arr.size(); i++) {

        // Check if this element is included in result
        int j;
        for (j = 0; j < i; j++)
            if (arr[i] == arr[j])
                break;

        // Include this element if not included previously
        if (i == j)
            res.push_back(arr[i]);
    }
    return res;
}

int main() {
    vector<int> arr = {2, 2, 3, 3, 7, 5};
    vector<int> res = remDuplicate(arr);

    for (int ele : res)
        cout << ele << " ";
    return 0;
}

C

#include <stdio.h>

int* remDuplicate(int *arr, int size, int *resSize) {
    int *res = (int*)malloc(size * sizeof(int));
    *resSize = 0;

    for (int i = 0; i < size; i++) {
        
        // Check if this element is included in result
        int j;
        for (j = 0; j < i; j++)
            if (arr[i] == arr[j])
                break;

        // Include this element if not included previously
        if (i == j)
            res[(*resSize)++] = arr[i];
    }
    return res;
}

int main() {
    int arr[] = {2, 2, 3, 3, 7, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    int resSize;
    
    int *res = remDuplicate(arr, size, &resSize);

    for (int i = 0; i < resSize; i++)
        printf("%d ", res[i]);
    
    free(res);
    return 0;
}

Java

import java.util.Arrays;
import java.util.ArrayList;

class GFG {
    public ArrayList<Integer> remDuplicate(int[] arr) {
        ArrayList<Integer> res = new ArrayList<>();

        for (int i = 0; i < arr.length; i++) {

            // Check if this element is included in result
            int j;
            for (j = 0; j < i; j++)
                if (arr[i] == arr[j])
                    break;

            // Include this element if not included previously
            if (i == j)
                res.add(arr[i]);
        }
        return res;
    }

    public static void main(String[] args) {
        int[] arr = {2, 2, 3, 3, 7, 5};
      
        ArrayList<Integer> res = remDuplicate(arr);
        for (int val : res) {
            System.out.print(val + " ");
        }
    }
}

Python

def remDuplicate(arr):
    res = []

    for i in range(len(arr)):

        # Check if this element is included in result
        j = 0
        while j < i:
            if arr[i] == arr[j]:
                break
            j += 1

        # Include this element if not included previously
        if i == j:
            res.append(arr[i])

    return res

if __name__ == "__main__":
    arr = [2, 2, 3, 3, 7, 5]
    res = remDuplicate(arr)
    for val in res:
        print(val, end=" ")

C#

using System;
using System.Collections.Generic;

class GFG {
    public List<int> remDuplicate(int[] arr) {
        List<int> res = new List<int>();
        for (int i = 0; i < arr.Length; i++) {

            // Check if this element is included in result
            int j;
            for (j = 0; j < i; j++)
                if (arr[i] == arr[j])
                    break;

            // Include this element if not included previously
            if (i == j)
                res.Add(arr[i]);
        }
        return res;
    }

    static void Main() {
        int[] arr = {2, 2, 3, 3, 7, 5};
      
        List<int> res = remDuplicate(arr);
        foreach (int val in res) {
            Console.Write(val + " ");
        }
    }
}

JavaScript

function remDuplicate(arr) {
    let res = [];

    for (let i = 0; i < arr.length; i++) {

        // Check if this element is included in result
        let j;
        for (j = 0; j < i; j++)
            if (arr[i] === arr[j])
                break;

        // Include this element if not included previously
        if (i === j)
            res.push(arr[i]);
    }

    return res;
}

// Driver Code
let arr = [2, 2, 3, 3, 7, 5];
let res = remDuplicate(arr);
console.log(res.join(" "));

Output

2 3 7 5

[Better Approach] Using Sorting - O(n*logn) Time and O(1) Space

The idea is to sort the array so that all occurrences of every element become consecutive. Once the occurrences become consecutive, we can traverse the sorted array and print distinct elements by ignoring elements if they are same as the previous element.

C++

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

vector<int> remDuplicate(vector<int> &arr) {
  	vector<int> res;
  	int n = arr.size();
  
    // First sort the array so that all occurrences 
    // become consecutive
    sort(arr.begin(), arr.end());

    for (int i = 0; i < n; i++) {
      
       // Store elements only if they are different 
       // from previous element
       if(i == 0 || arr[i] != arr[i - 1]) {
           res.push_back(arr[i]);
       }
    }
  	return res;
}

int main() {
    vector<int> arr = {2, 2, 3, 3, 7, 5};
  
    vector<int> res = remDuplicate(arr);
  	for(int ele: res) {
      	cout << ele << " ";
    }
    return 0;
}

C

#include <stdio.h>

int compare(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

void remDuplicate(int *arr, int n, int **res, int *resSize) {
    
    // First sort the array so that all occurrences 
    // become consecutive
    qsort(arr, n, sizeof(int), compare);

    *res = (int *)malloc(n * sizeof(int));
    int index = 0;

    for (int i = 0; i < n; i++) {
        
        // Store elements only if they are different 
        // from previous element
        if (i == 0 || arr[i] != arr[i - 1]) {
            (*res)[index++] = arr[i];
        }
    }
    *resSize = index;
}

int main() {
    int arr[] = {2, 2, 3, 3, 7, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    int *res;
    int resSize;
    
    remDuplicate(arr, n, &res, &resSize);
    for (int i = 0; i < resSize; i++) {
        printf("%d ", res[i]);
    }
    return 0;
}

Java

import java.util.Arrays;
import java.util.ArrayList;

class GFG {
    public ArrayList<Integer> remDuplicate(int[] arr) {
        ArrayList<Integer> res = new ArrayList<>();
        int n = arr.length;

        // First sort the array so that all occurrences 
        // become consecutive
        Arrays.sort(arr);

        for (int i = 0; i < n; i++) {
            
            // Store elements only if they are different 
            // from previous element
            if (i == 0 || arr[i] != arr[i - 1]) {
                res.add(arr[i]);
            }
        }
        return res;
    }

    public static void main(String[] args) {
        int[] arr = {2, 2, 3, 3, 7, 5};

        ArrayList<Integer> res = remDuplicate(arr);
        for (int ele : res) {
            System.out.print(ele + " ");
        }
    }
}

Python

def remDuplicate(arr):
    res = []
    n = len(arr)

    # First sort the array so that all occurrences 
    # become consecutive
    arr.sort()

    for i in range(n):
        
        # Store elements only if they are different 
        # from previous element
        if i == 0 or arr[i] != arr[i - 1]:
            res.append(arr[i])
    
    return res

if __name__ == "__main__":
    arr = [2, 2, 3, 3, 7, 5]
  
    res = remDuplicate(arr)
    for ele in res:
        print(ele, end=" ")

C#

using System;
using System.Collections.Generic;

class GFG {
    public List<int> remDuplicate(int[] arr) {
        
        // First sort the array so that all occurrences 
        // become consecutive
        Array.Sort(arr);

        var res = new List<int>();
        int n = arr.Length;
        for (int i = 0; i < n; i++) {
            
            // Store elements only if they are different 
            // from previous element
            if (i == 0 || arr[i] != arr[i - 1]) {
                res.Add(arr[i]);
            }
        }
        return res;
    }

    static void Main() {
        int[] arr = { 2, 2, 3, 3, 7, 5 };

        List<int> res = remDuplicate(arr);
        foreach (int ele in res) {
            Console.Write(ele + " ");
        }
    }
}

JavaScript

function remDuplicate(arr) {
    let res = [];
    let n = arr.length;

    // First sort the array so that all occurrences 
    // become consecutive
    arr.sort((a, b) => a - b);

    for (let i = 0; i < n; i++) {
        
        // Store elements only if they are different 
        // from previous element
        if (i === 0 || arr[i] !== arr[i - 1]) {
            res.push(arr[i]);
        }
    }
    return res;
}

// Driver Code
const arr = [2, 2, 3, 3, 7, 5];

const res = remDuplicate(arr);
console.log(res.join(" "));

Output

2 3 5 7

[Expected Approach] Using Hashset - O(n) Time and O(n) Space

We can use Hashset to store distinct element. The idea is to insert all the elements in a hash set and then traverse the hash set to store the distinct elements in the resultant array.

C++

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

vector<int> remDuplicate(vector<int> &arr) {
  	
    // Initialize set with all elements of array
    unordered_set<int> st (arr.begin(), arr.end());
  
    // Return the result array by inserting all 
    // elements from hash set
  	return vector<int> (st.begin(), st.end());
}

int main () {
    vector<int> arr = {2, 2, 3, 3, 7, 5};
    
  	vector<int> res = remDuplicate(arr);
  	for (int ele: res)
      	cout << ele << " ";
    return 0;
}

Java

import java.util.HashSet;
import java.util.ArrayList;

class GFG {

    public ArrayList<Integer> remDuplicate(int[] arr) {
        
        // Initialize set with all elements of array
        HashSet<Integer> st = new HashSet<>();
        for (int num : arr) {
            st.add(num);
        }
        
        // Return the result array by inserting all 
        // elements from hash set
        return new ArrayList<>(st);
    }

    public static void main(String[] args) {
        int[] arr = {2, 2, 3, 3, 7, 5};
        
        ArrayList<Integer> res = remDuplicate(arr);
        for (int ele : res) {
            System.out.print(ele + " ");
        }
    }
}

Python

def remDuplicate(arr):
    
    # Initialize set with all elements of array
    st = set(arr)
  
    # Return the result array by inserting all 
    # elements from hash set
    return list(st)

if __name__ == "__main__":
    arr = [2, 2, 3, 3, 7, 5]
    
    res = remDuplicate(arr)
    for ele in res:
        print(ele, end=" ")

C#

using System;
using System.Collections.Generic;
using System.Linq;

class GFG {
  
    public List<int> remDuplicate(int[] arr) {
        
        // Initialize HashSet with all elements of the array
        var st = new HashSet<int>(arr);
        
        // Return the result array by inserting all 
        // elements from hash set
        return st.ToList();
    }

    static void Main() {
        int[] arr = {2, 2, 3, 3, 7, 5};
        
        List<int> res = remDuplicate(arr);
        foreach (int ele in res)
            Console.Write(ele + " ");
    }
}

JavaScript

function remDuplicate(arr) {
    
    // Initialize set with all elements of array
    const st = new Set(arr);
  
    // Return the result array by inserting all 
    // elements from hash set
    return Array.from(st);
}

// Driver Code
const arr = [2, 2, 3, 3, 7, 5];

const res = remDuplicate(arr);
console.log(res.join(" "));

Output

5 7 3 2

Unique Number I

K

kartik

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. Applications of Array Data Structure:Arrays mainly have advantages like random access and cache friendliness over o

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 ProblemsSecond Largest