Skip to content
Related Articles

Related Articles

Improve Article

Find sum of non-repeating (distinct) elements in an array

  • Difficulty Level : Basic
  • Last Updated : 24 May, 2021

Given an integer array with repeated elements, the task is to find sum of all distinct elements in array.
Examples: 

Input  : arr[] = {12, 10, 9, 45, 2, 10, 10, 45,10};
Output : 78
Here we take 12, 10, 9, 45, 2 for sum
because it's distinct elements 

Input : arr[] = {1, 10, 9, 4, 2, 10, 10, 45 , 4};
Output : 71

A Simple Solution 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 ignores the element.
Time Complexity : O(n2) 
Auxiliary Space : O(1)
A Better Solution of this problem is that using sorting technique we firstly sort all elements of array in ascending order and and find one by one distinct elements in array. 
 

C++




// C++ Find the sum of all non-repeated
// elements in an array
#include<bits/stdc++.h>
using namespace std;
 
// Find the sum of all non-repeated elements
// in an array
int findSum(int arr[], int n)
{
    // sort all elements of array
    sort(arr, arr + n);
 
    int sum = 0;
    for (int i=0; i<n; i++)
    {
        if (arr[i] != arr[i+1])
            sum = sum + arr[i];
    }
 
    return sum;
}
 
// Driver code
int main()
{
    int arr[] = {1, 2, 3, 1, 1, 4, 5, 6};
    int n = sizeof(arr)/sizeof(int);
    cout << findSum(arr, n);
    return 0;
}
Java



import java.util.Arrays;
 
// Java Find the sum of all non-repeated
// elements in an array
public class GFG {
 
// Find the sum of all non-repeated elements
// in an array
    static int findSum(int arr[], int n) {
        // sort all elements of array
 
        Arrays.sort(arr);
        
        int sum = arr[0];
        for (int i = 0; i < n-1; i++) {
            if (arr[i] != arr[i + 1]) {
                sum = sum + arr[i+1];
            }
        }
 
        return sum;
    }
 
// Driver code
    public static void main(String[] args) {
        int arr[] = {1, 2, 3, 1, 1, 4, 5, 6};
        int n = arr.length;
        System.out.println(findSum(arr, n));
 
    }
}
Python3



     
# Python3 Find the sum of all non-repeated
# elements in an array
 
  
# Find the sum of all non-repeated elements
# in an array
def findSum(arr,  n):
    # sort all elements of array
    arr.sort()
  
    sum = arr[0]
    for i in range(0,n-1):
        if (arr[i] != arr[i+1]):
            sum = sum + arr[i+1]
     
    return sum
  
# Driver code
def main():
    arr= [1, 2, 3, 1, 1, 4, 5, 6]
    n = len(arr)
    print(findSum(arr, n))
 
if __name__ == '__main__':
    main()
# This code is contributed by 29AjayKumar
C#



// C# Find the sum of all non-repeated
// elements in an array
using System;
class GFG
{
 
    // Find the sum of all non-repeated elements
    // in an array
    static int findSum(int []arr, int n)
    {
        // sort all elements of array
        Array.Sort(arr);
         
        int sum = arr[0];
        for (int i = 0; i < n - 1; i++)
        {
            if (arr[i] != arr[i + 1])
            {
                sum = sum + arr[i + 1];
            }
        }
        return sum;
    }
 
    // Driver code
    public static void Main()
    {
        int []arr = {1, 2, 3, 1, 1, 4, 5, 6};
        int n = arr.Length;
        Console.WriteLine(findSum(arr, n));
    }
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
 
// JavaScript Program to find the sum of all non-repeated
// elements in an array
 
// Find the sum of all non-repeated elements
// in an array
function findSum(arr, n)
{
    // sort all elements of array
    arr.sort();
 
    let sum = 0;
    for (let i=0; i<n; i++)
    {
        if (arr[i] != arr[i+1])
            sum = sum + arr[i];
    }
 
    return sum;
}
 
// Driver code
 
    let arr = [1, 2, 3, 1, 1, 4, 5, 6];
    let n = arr.length;
    document.write(findSum(arr, n));
 
// This code is contributed by Surbhi Tyagi
 
</script>
Output: 
21
Time Complexity : O(n log n) 
Space Complexity : O(1)
An Efficient solution of this problem is that using unordered_set we run a single for loop and which value comes first time its add in sum variable and store in hash table that for next time we not use this value.
 
C++



// C++ Find the sum of all non- repeated
// elements in an array
#include<bits/stdc++.h>
using namespace std;
 
// Find the sum of all non-repeated elements
// in an array
int findSum(int arr[],int n)
{
    int sum = 0;
 
    // Hash to store all element of array
    unordered_set< int > s;
    for (int i=0; i<n; i++)
    {
        if (s.find(arr[i]) == s.end())
        {
            sum += arr[i];
            s.insert(arr[i]);
        }
    }
 
    return sum;
}
 
// Driver code
int main()
{
    int arr[] = {1, 2, 3, 1, 1, 4, 5, 6};
    int n = sizeof(arr)/sizeof(int);
    cout << findSum(arr, n);
    return 0;
}
Java



// Java Find the sum of all non- repeated
// elements in an array
import java.util.*;
 
class GFG
{
     
    // Find the sum of all non-repeated elements
    // in an array
    static int findSum(int arr[], int n)
    {
        int sum = 0;
 
        // Hash to store all element of array
        HashSet<Integer> s = new HashSet<Integer>();
        for (int i = 0; i < n; i++)
        {
            if (!s.contains(arr[i]))
            {
                sum += arr[i];
                s.add(arr[i]);
            }
        }
        return sum;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = {1, 2, 3, 1, 1, 4, 5, 6};
        int n = arr.length;
        System.out.println(findSum(arr, n));
    }
}
 
// This code is contributed by Rajput-Ji
Python3



# Python3 Find the sum of all
# non- repeated elements in an array
 
# Find the sum of all non-repeated
# elements in an array
def findSum(arr, n):
    s = set()
    sum = 0
 
    # Hash to store all element
    # of array
    for i in range(n):
        if arr[i] not in s:
            s.add(arr[i])
    for i in s:
        sum = sum + i
 
    return sum
 
# Driver code
arr = [1, 2, 3, 1, 1, 4, 5, 6]
n = len(arr)
print(findSum(arr, n))
 
# This code is contributed by Shrikant13
C#



// C# Find the sum of all non- repeated
// elements in an array
using System;
using System.Collections.Generic;
 
class GFG
{
     
    // Find the sum of all non-repeated elements
    // in an array
    static int findSum(int []arr, int n)
    {
        int sum = 0;
 
        // Hash to store all element of array
        HashSet<int> s = new HashSet<int>();
        for (int i = 0; i < n; i++)
        {
            if (!s.Contains(arr[i]))
            {
                sum += arr[i];
                s.Add(arr[i]);
            }
        }
        return sum;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int []arr = {1, 2, 3, 1, 1, 4, 5, 6};
        int n = arr.Length;
        Console.WriteLine(findSum(arr, n));
    }
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
 
//  Javascript program Find the sum of all non- repeated
// elements in an array
 
    // Find the sum of all non-repeated elements
    // in an array
    function findSum(arr, n)
    {
        let sum = 0;
  
        // Hash to store all element of array
        let s = new Set();
        for (let i = 0; i < n; i++)
        {
            if (!s.has(arr[i]))
            {
                sum += arr[i];
                s.add(arr[i]);
            }
        }
        return sum;
    }
     
    // Driver code
     
    let arr = [1, 2, 3, 1, 1, 4, 5, 6];
        let n = arr.length;
        document.write(findSum(arr, n));
     
</script>
Output: 
 


21
Time Complexity: O(n) 
Auxiliary Space: O(n)
 
Method #3:Using Built-in python functions:
Approach:
  • Calculate the frequencies using Counter() function
  • Convert the frequency keys to the list.
  • Calculate the sum of the list.
Below is the implementation of the above approach.
Python3



# Python program for the above approach
from collections import Counter
 
# Function to return the sum of distinct elements
def sumOfElements(arr, n):
 
    # Counter function is used to
    # calculate frequency of elements of array
    freq = Counter(arr)
     
    # Converting keys of freq dictionary to list
    lis = list(freq.keys())
     
    # Return sum of list
    return sum(lis)
 
 
# Driver code
if __name__ == "__main__":
 
    arr = [1, 2, 3, 1, 1, 4, 5, 6]
    n = len(arr)
 
    print(sumOfElements(arr, n))
 
# This code is contributed by vikkycirus
Output:
21
This article is contributed by DANISH_RAZA. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
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
Next

Non-Repeating Element
Recommended Articles
Page :
Form an array of distinct elements with each element as sum of an element from each array
26, Mar 20
Sum of distinct elements when elements are in range 1 to n
27, Jul 17
Length of array pair formed where one contains all distinct elements and other all same elements
16, May 20
Split an array containing N elements into K sets of distinct elements
31, May 20
Longest remaining array of distinct elements possible after repeated removal of maximum and minimum elements of triplets
06, Aug 21
Find the Array Permutation having sum of elements at odd indices greater than sum of elements at even indices
07, Jul 21
Construct a distinct elements array with given size, sum and element upper bound
20, Nov 17
Check if K distinct array elements form an odd sum
20, Jun 20
Minimize sum of points assigned to distinct elements present in an array
14, Jun 21
Maximum sum of K-length subarray consisting of same number of distinct elements as the given array
02, Mar 21
Maximize sum of count of distinct prime factors of K array elements
01, Feb 21
Find minimum changes required in an array for it to contain k distinct elements
09, Aug 19
Find the largest three distinct elements in an array
30, Jul 15
Count all distinct pairs of repeating elements from the array for every array element
10, Sep 20
Count distinct ways to replace array elements such that product of the array becomes even
09, Mar 21
Count distinct elements after adding each element of First Array with Second Array
31, Jul 20
Find all distinct quadruplets in an array that sum up to a given value
12, May 21
Sum of array elements possible by appending arr[i] / K to the end of the array K times for array elements divisible by K
19, Apr 21
Count all N-length arrays made up of distinct consecutive elements whose first and last elements are equal
06, Jan 21
Count distinct sequences obtained by replacing all elements of subarrays having equal first and last elements with the first element any number of times
29, Jun 21
Maximum distinct elements after removing k elements
14, Dec 17
Find the index having sum of elements on its left equal to reverse of the sum of elements on its right
13, Jan 21
Modify array to another given array by replacing array elements with the sum of the array
12, Feb 21
Find an element in array such that sum of left array is equal to sum of right array
07, Sep 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Basic





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox