查找数组中非重复（不同）元素的总和-yiteyi-C++库

给定一个包含重复元素的整数数组，任务是找到数组中所有不同元素的和。 例如：

null

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

建议：请在“上解决” 实践 “首先，在讨论解决方案之前。

A. 简单解决方案 就是使用两个嵌套循环。外部循环从最左边的元素开始逐个拾取元素。内部循环检查元素是否存在于其左侧。如果存在，则忽略该元素。 时间复杂性： O（n） ^2. ) 辅助空间： O（1） A. 更好的解决方案 这个问题的关键在于，使用排序技术，我们首先将数组中的所有元素按升序排序，然后在数组中逐个找到不同的元素。

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>                       

输出：

时间复杂性： O（n日志n） 空间复杂性： O（1）一 有效解决方案 这个问题的关键在于，使用无序_集，我们运行一个for循环，哪个值第一次出现在它的add-in-sum变量中，并存储在哈希表中，下次我们不使用这个值。

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>                       

输出：

时间复杂性： O（n） 辅助空间： O（n）

方法#3：使用内置python函数：

方法：

使用以下公式计算频率： 计数器（） 作用
将频率键转换为列表。
计算列表的总和。

以下是该计划的实施情况 这个 以上方法。

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                       

输出：

本文由 丹麦拉扎 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章