Unique Number I

Print all Distinct (Unique) Elements in given Array

Last Updated : 02 Nov, 2024

Try it on GfG Practice

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

Examples:

Input: arr[] = {12, 10, 9, 45, 2, 10, 10, 45}
Output: {12, 10, 9, 45, 2}
Input: arr[] = {1, 2, 3, 4, 5}
Output: {1, 2, 3, 4, 5}
Input: arr[] = {1, 1, 1, 1, 1}
Output: {1}

Table of Content

[Naive Approach] Using Nested loops - O(n^2) Time and O(1) Space
[Better Approach] Using Sorting - O(n * log n) Time and O(1) Space
[Expected Approach] Using Hashing - 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++

// C++ program to print all distinct elements in an
// array using nested loops

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

vector<int> findDistinct(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 = {12, 10, 9, 45, 2, 10, 10, 45};
    vector<int> res = findDistinct(arr);

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

C

// C program to print all distinct elements in an
// array using nested loops

#include <stdio.h>

int* findDistinct(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[] = {12, 10, 9, 45, 2, 10, 10, 45};
    int size = sizeof(arr) / sizeof(arr[0]);
    int resSize;
    
    int *res = findDistinct(arr, size, &resSize);

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

Java

// JAva program to print all distinct elements in an
// array using nested loops

import java.util.*;

class GfG {
    static ArrayList<Integer> findDistinct(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 = {12, 10, 9, 45, 2, 10, 10, 45};
      
        ArrayList<Integer> res = findDistinct(arr);
        for (int val : res) {
            System.out.print(val + " ");
        }
    }
}

Python

# Python program to print all distinct elements in an
# array using nested loops

def findDistinct(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 = [12, 10, 9, 45, 2, 10, 10, 45]
    res = findDistinct(arr)
    for val in res:
        print(val, end=" ")

C#

// C# program to print all distinct elements in an
// array using nested loops

using System;
using System.Collections.Generic;

class GfG {
    static List<int> findDistinct(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 = {12, 10, 9, 45, 2, 10, 10, 45};
      
        List<int> res = findDistinct(arr);
        foreach (int val in res) {
            Console.Write(val + " ");
        }
    }
}

JavaScript

// JavaScript program to print all distinct elements in an
// array using nested loops

function findDistinct(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;
}


let arr = [12, 10, 9, 45, 2, 10, 10, 45];
let res = findDistinct(arr);
console.log(res.join(" "));

Output

12 10 9 45 2

[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++

// C++ program to print all distinct elements in an
// array using sorting

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

using namespace std;

vector<int> findDistinct(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 = {12, 10, 9, 45, 2, 10, 10, 45};
  
    vector<int> res = findDistinct(arr);
  	for(int ele: res) {
      	cout << ele << " ";
    }
    return 0;
}

C

// C program to print all distinct elements in an
// array using sorting

#include <stdio.h>

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

void findDistinct(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[] = {12, 10, 9, 45, 2, 10, 10, 45};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    int *res;
    int resSize;
    
    findDistinct(arr, n, &res, &resSize);
    for (int i = 0; i < resSize; i++) {
        printf("%d ", res[i]);
    }
    return 0;
}

Java

// Java program to print all distinct elements in an
// array using sorting

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

class GfG {
    static ArrayList<Integer> findDistinct(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 = {12, 10, 9, 45, 2, 10, 10, 45};

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

Python

# Python program to print all distinct elements in an
# array using sorting

def findDistinct(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 = [12, 10, 9, 45, 2, 10, 10, 45]
  
    res = findDistinct(arr)
    for ele in res:
        print(ele, end=" ")

C#

// C# program to print all distinct elements in an
// array using sorting

using System;
using System.Collections.Generic;

class GfG {
    static List<int> findDistinct(List<int> arr) {
        List<int> res = new List<int>();
        int n = arr.Count;

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

        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() {
        List<int> arr = new List<int> { 12, 10, 9, 45, 2, 10, 10, 45 };

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

JavaScript

// JavaScript program to print all distinct elements in an
// array using sorting

function findDistinct(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;
}

const arr = [12, 10, 9, 45, 2, 10, 10, 45];

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

Output

2 9 10 12 45

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

We can use Hashing 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++

// C++ program to print all distinct elements 
// of a given array 

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

// function to return all distinct elements
vector<int> findDistinct(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 = {12, 10, 9, 45, 2, 10, 10, 45};
    
  	vector<int> res = findDistinct(arr);
  	for (int ele: res)
      	cout << ele << " ";
    return 0;
}

Java

// Java program to print all distinct elements 
// of a given array 

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

class GfG {

    // function to return all distinct elements
    static ArrayList<Integer> findDistinct(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 = {12, 10, 9, 45, 2, 10, 10, 45};
        
        ArrayList<Integer> res = findDistinct(arr);
        for (int ele : res) {
            System.out.print(ele + " ");
        }
    }
}

Python

# Python program to print all distinct elements 
# of a given array 

# function to return all distinct elements
def findDistinct(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 = [12, 10, 9, 45, 2, 10, 10, 45]
    
    res = findDistinct(arr)
    for ele in res:
        print(ele, end=" ")

C#

// C# program to print all distinct elements 
// of a given array 

using System;
using System.Collections.Generic;

class GfG {
  
    // function to return all distinct elements
    static List<int> findDistinct(List<int> arr) {
      
        // Initialize set with all elements of array
        HashSet<int> st = new HashSet<int>(arr);
  
        // Return the result array by inserting all 
        // elements from hash set
        return new List<int>(st);
    }

    static void Main() {
        List<int> arr = new List<int> { 12, 10, 9, 45, 2, 10, 10, 45 };
        
        List<int> res = findDistinct(arr);
        foreach (int ele in res)
            Console.Write(ele + " ");
    }
}

JavaScript

// JavaScript program to print all distinct elements 
// of a given array 

// function to return all distinct elements
function findDistinct(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);
}

const arr = [12, 10, 9, 45, 2, 10, 10, 45];

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

Output

2 9 10 45 12

Unique Number I

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.Table of ContentApplications of Array Data Structure:Advantages of Array Data Structure:Disadvantages of Array Data

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