找到唯一出现b次的元素-yiteyi-C++库

给定一个数组，其中每个元素出现“a”次，除了一个元素出现b（a>b）次。找到出现b次的元素。

null

例如：

Input : arr[]  = [1, 1, 2, 2, 2, 3, 3, 3]         a = 3, b = 2Output : 1

推荐：请尝试你的方法 {IDE} 首先，在进入解决方案之前。

将每个数字相加一次，然后将总和乘以a，我们将得到a乘以数组中每个元素的总和。将其存储为_sum。从a_和中减去整个数组的和，并将结果除以（a-b）。我们得到的数字是所需的数字（在数组中出现b次）。

C++

                         // CPP program to find the only element that                       
                         // appears b times                       
                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         int                                     appearsbTimes(                                     int                                     arr[],                                     int                                     n,                                     int                                     a,                                     int                                     b)                       
                         {                       
                                                 unordered_set<                                     int                                     > s;                       
           
                                                 int                                     a_sum = 0, sum = 0;                       
           
                                                 for                                     (                                     int                                     i = 0; i < n; i++) {                       
                                                 if                                     (s.find(arr[i]) == s.end()) {                       
                                                 s.insert(arr[i]);                       
                                                 a_sum += arr[i];                       
                                                 }                       
           
                                                 sum += arr[i];                       
                                                 }                       
           
                                                 a_sum = a * a_sum;                       
           
                                                 return                                     ((a_sum - sum) / (a - b));                       
                         }                       
           
                         int                                     main()                       
                         {                       
                                                 int                                     arr[] = { 1, 1, 2, 2, 2, 3, 3, 3 };                       
                                                 int                                     a = 3, b = 2;                       
                                                 int                                     n =                                     sizeof                                     (arr) /                                     sizeof                                     (arr[0]);                       
                                                 cout << appearsbTimes(arr, n, a, b);                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java program to find the only element that                       
                         // appears b times                       
                         import                                     java.util.*;                       
           
                         class                                     GFG                       
                         {                       
                         static                                     int                                     appearsbTimes(                                     int                                     arr[],                                     int                                     n,                       
                                                 int                                     a,                                     int                                     b)                       
                         {                       
                                                 HashSet<Integer> s =                                     new                                     HashSet<Integer>();                       
           
                                                 int                                     a_sum =                                     0                                     , sum =                                     0                                     ;                       
           
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < n; i++)                       
                                                 {                       
                                                 if                                     (!s.contains(arr[i]))                       
                                                 {                       
                                                 s.add(arr[i]);                       
                                                 a_sum += arr[i];                       
                                                 }                       
           
                                                 sum += arr[i];                       
                                                 }                       
                                                 a_sum = a * a_sum;                       
           
                                                 return                                     ((a_sum - sum) / (a - b));                       
                         }                       
           
                         // Driver Code                       
                         public                                     static                                     void                                     main(String[] args)                       
                         {                       
                                                 int                                     arr[] = {                                     1                                     ,                                     1                                     ,                                     2                                     ,                                     2                                     ,                                     2                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     };                       
                                                 int                                     a =                                     3                                     , b =                                     2                                     ;                       
                                                 int                                     n = arr.length;                       
                                                 System.out.println(appearsbTimes(arr, n, a, b));                       
                         }                       
                         }                       
           
                         // This code is contributed by 29AjayKumar                       

Python3

                         # Python3 program to find the only                       
                         # element that appears b times                       
                         def                                     appearsbTimes(arr, n, a, b):                       
           
                                                 s                                     =                                     dict                                     ()                       
           
                                                 a_Sum                                     =                                     0                       
                                                 Sum                                     =                                     0                       
           
                                                 for                                     i                                     in                                     range                                     (n):                       
                                                 if                                     (arr[i]                                     not                                     in                                     s.keys()):                       
                                                 s[arr[i]]                                     =                                     1                       
                                                 a_Sum                                     +                                     =                                     arr[i]                       
           
                                                 Sum                                     +                                     =                                     arr[i]                       
                                   
                                                 a_Sum                                     =                                     a                                     *                                     a_Sum                       
           
                                                 return                                     ((a_Sum                                     -                                     Sum                                     )                                     /                                     /                                     (a                                     -                                     b))                       
           
                         # Driver code                       
                         arr                                     =                                     [                                     1                                     ,                                     1                                     ,                                     2                                     ,                                     2                                     ,                                     2                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ]                       
                         a, b                                     =                                     3                                     ,                                     2                       
                         n                                     =                                     len                                     (arr)                       
                         print                                     (appearsbTimes(arr, n, a, b))                       
           
                         # This code is contributed by mohit kumar                       

C#

                         // C# program to find the only element that                       
                         // appears b times                       
                         using                                     System;                       
                         using                                     System.Collections.Generic;                       
           
                         class                                     GFG                       
                         {                       
                                   
                         static                                     int                                     appearsbTimes(                                     int                                     []arr,                                     int                                     n,                       
                                                 int                                     a,                                     int                                     b)                       
                         {                       
                                                 HashSet<                                     int                                     > s =                                     new                                     HashSet<                                     int                                     >();                       
           
                                                 int                                     a_sum = 0, sum = 0;                       
           
                                                 for                                     (                                     int                                     i = 0; i < n; i++)                       
                                                 {                       
                                                 if                                     (!s.Contains(arr[i]))                       
                                                 {                       
                                                 s.Add(arr[i]);                       
                                                 a_sum += arr[i];                       
                                                 }                       
           
                                                 sum += arr[i];                       
                                                 }                       
                                                 a_sum = a * a_sum;                       
           
                                                 return                                     ((a_sum - sum) / (a - b));                       
                         }                       
           
                         // Driver Code                       
                         public                                     static                                     void                                     Main(String[] args)                       
                         {                       
                                                 int                                     []arr = { 1, 1, 2, 2, 2, 3, 3, 3 };                       
                                                 int                                     a = 3, b = 2;                       
                                                 int                                     n = arr.Length;                       
                                                 Console.WriteLine(appearsbTimes(arr, n, a, b));                       
                         }                       
                         }                       
           
                         // This code is contributed by Princi Singh                       

Javascript

                         <script>                       
           
                         // Javascript program to find the only element that                       
                         // appears b times                       
           
                         function                                     appearsbTimes(arr, n, a, b)                       
                         {                       
                                                 var                                     s =                                     new                                     Set();                       
           
                                                 var                                     a_sum = 0, sum = 0;                       
           
                                                 for                                     (                                     var                                     i = 0; i < n; i++) {                       
                                                 if                                     (!s.has(arr[i])) {                       
                                                 s.add(arr[i]);                       
                                                 a_sum += arr[i];                       
                                                 }                       
           
                                                 sum += arr[i];                       
                                                 }                       
           
                                                 a_sum = a * a_sum;                       
           
                                                 return                                     ((a_sum - sum) / (a - b));                       
                         }                       
           
                         var                                     arr = [1, 1, 2, 2, 2, 3, 3, 3];                       
                         var                                     a = 3, b = 2;                       
                         var                                     n = arr.length;                       
                         document.write( appearsbTimes(arr, n, a, b));                       
           
                         </script>                       

输出：

有关更多方法，请参阅下面的文章。查找唯一出现k次的元素。

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

THE END

技术文章