Posted on by Kalkicode
Code Hash

# Find the sum of all highest occurring elements in an Array

Here given code implementation process.

``````import java.util.HashMap;
/*
Java program for
Find the sum of all highest occurring elements in an Array
*/
public class Occurrence
{
public void sumHighestOccurrence(int[] arr, int n)
{
int sum = 0;
int max = 1;
HashMap < Integer, Integer > record =
new HashMap < Integer, Integer > ();
// Count frequency of array elements
for (int i = 0; i < n; ++i)
{
if (record.containsKey(arr[i]))
{
// Increase the frequency
record.put(arr[i], record.get(arr[i]) + 1);

if (record.get(arr[i]) > max)
{
// Get most occuring element frequency
max = record.get(arr[i]);
}
}
else
{
record.put(arr[i], 1);
}
}
for (int v: record.keySet())
{
if (record.get(v) == max)
{
sum += (v * max);
}
}
//
System.out.println(" Result : " + sum);
}
public static void main(String[] args)
{
int[] arr = {
8 , 6 , -3 , 8 , 3 , 1 , 5 , 1 , 1 , -2 , -3 , -3 , 8
};
int n = arr.length;
/*
[8 + 8 + 8]          =  24
[(-3) + (-3) + (-3)] = -9
[1+1+1]              =  3
------------------------------
Result           18
-----------------------------
Note most occuring element frequency are 3
*/
}
}``````

#### Output

`` Result : 18``
``````// Include header file
#include <iostream>
#include <unordered_map>

using namespace std;
/*
C++ program for
Find the sum of all highest occurring elements in an Array
*/
class Occurrence
{
public: void sumHighestOccurrence(int arr[], int n)
{
int sum = 0;
int max = 1;
unordered_map < int, int > record;
// Count frequency of array elements
for (int i = 0; i < n; ++i)
{
if (record.find(arr[i]) != record.end())
{
// Increase the frequency
record[arr[i]] = record[arr[i]] + 1;
if (record[arr[i]] > max)
{
// Get most occuring element frequency
max = record[arr[i]];
}
}
else
{
record[arr[i]] = 1;
}
}
for (auto &v: record)
{
if (v.second == max)
{
sum += (v.first * max);
}
}
//
cout << " Result : " << sum << endl;
}
};
int main()
{
int arr[] = {
8 , 6 , -3 , 8 , 3 , 1 , 5 , 1 , 1 , -2 , -3 , -3 , 8
};
int n = sizeof(arr) / sizeof(arr[0]);
/*
[8 + 8 + 8]          =  24
[(-3) + (-3) + (-3)] = -9
[1+1+1]              =  3
------------------------------
Result           18
-----------------------------
Note most occuring element frequency are 3
*/
return 0;
}``````

#### Output

`` Result : 18``
``````// Include namespace system
using System;
using System.Collections.Generic;
/*
Csharp program for
Find the sum of all highest occurring elements in an Array
*/
public class Occurrence
{
public void sumHighestOccurrence(int[] arr, int n)
{
int sum = 0;
int max = 1;
Dictionary < int, int > record =
new Dictionary < int, int > ();
// Count frequency of array elements
for (int i = 0; i < n; ++i)
{
if (record.ContainsKey(arr[i]))
{
// Increase the frequency
record[arr[i]] = record[arr[i]] + 1;
if (record[arr[i]] > max)
{
// Get most occuring element frequency
max = record[arr[i]];
}
}
else
{
}
}
foreach(KeyValuePair < int, int > v in record)
{
if (v.Value == max)
{
sum += (v.Key * max);
}
}
//
Console.WriteLine(" Result : " + sum);
}
public static void Main(String[] args)
{
int[] arr = {
8 , 6 , -3 , 8 , 3 , 1 , 5 , 1 , 1 , -2 , -3 , -3 , 8
};
int n = arr.Length;
/*
[8 + 8 + 8]          =  24
[(-3) + (-3) + (-3)] = -9
[1+1+1]              =  3
------------------------------
Result           18
-----------------------------
Note most occuring element frequency are 3
*/
}
}``````

#### Output

`` Result : 18``
``````package main
import "fmt"
/*
Go program for
Find the sum of all highest occurring elements in an Array
*/

func sumHighestOccurrence(arr[] int, n int) {
var sum int = 0
var max int = 1
var record = make(map[int] int)
// Count frequency of array elements
for i := 0 ; i < n ; i++ {
if _, found := record[arr[i]] ; found {
// Increase the frequency
record[arr[i]] = record[arr[i]] + 1
if record[arr[i]] > max {
// Get most occuring element frequency
max = record[arr[i]]
}
} else {
record[arr[i]] = 1
}
}
for k, v := range record {
if v == max {
sum += (k * max)
}
}
//
fmt.Println(" Result : ", sum)
}
func main() {

var arr = [] int {8, 6, -3, 8, 3, 1, 5, 1, 1, -2, -3, -3, 8}
var n int = len(arr)
/*
[8 + 8 + 8]          =  24
[(-3) + (-3) + (-3)] = -9
[1+1+1]              =  3
------------------------------
Result           18
-----------------------------
Note most occuring element frequency are 3
*/
sumHighestOccurrence(arr, n)
}``````

#### Output

`` Result : 18``
``````<?php
/*
Php program for
Find the sum of all highest occurring elements in an Array
*/
class Occurrence
{
public	function sumHighestOccurrence(\$arr, \$n)
{
\$sum = 0;
\$max = 1;
\$record = array();
// Count frequency of array elements
for (\$i = 0; \$i < \$n; ++\$i)
{
if (array_key_exists(\$arr[\$i], \$record))
{
// Increase the frequency
\$record[\$arr[\$i]] = \$record[\$arr[\$i]] + 1;
if (\$record[\$arr[\$i]] > \$max)
{
// Get most occuring element frequency
\$max = \$record[\$arr[\$i]];
}
}
else
{
\$record[\$arr[\$i]] = 1;
}
}
foreach(\$record as \$key => \$value)
{
if (\$value == \$max)
{
\$sum += (\$key * \$max);
}
}
//
echo(" Result : ".\$sum."\n");
}
}

function main()
{
\$arr = array(8, 6, -3, 8, 3, 1, 5, 1, 1, -2, -3, -3, 8);
\$n = count(\$arr);
/*
[8 + 8 + 8]          =  24
[(-3) + (-3) + (-3)] = -9
[1+1+1]              =  3
------------------------------
Result           18
-----------------------------
Note most occuring element frequency are 3
*/
}
main();``````

#### Output

`` Result : 18``
``````/*
Node JS program for
Find the sum of all highest occurring elements in an Array
*/
class Occurrence
{
sumHighestOccurrence(arr, n)
{
var sum = 0;
var max = 1;
var record = new Map();
// Count frequency of array elements
for (var i = 0; i < n; ++i)
{
if (record.has(arr[i]))
{
// Increase the frequency
record.set(arr[i], record.get(arr[i]) + 1);
if (record.get(arr[i]) > max)
{
// Get most occuring element frequency
max = record.get(arr[i]);
}
}
else
{
record.set(arr[i], 1);
}
}
for (let [key, value] of record)
{
if (value == max)
{
sum += (key * max);
}
}
//
console.log(" Result : " + sum);
}
}

function main()
{
var arr = [8, 6, -3, 8, 3, 1, 5, 1, 1, -2, -3, -3, 8];
var n = arr.length;
/*
[8 + 8 + 8]          =  24
[(-3) + (-3) + (-3)] = -9
[1+1+1]              =  3
------------------------------
Result           18
-----------------------------
Note most occuring element frequency are 3
*/
}
main();``````

#### Output

`` Result : 18``
``````#    Python 3 program for
#    Find the sum of all highest occurring elements in an Array
class Occurrence :
def sumHighestOccurrence(self, arr, n) :
sum = 0
max = 1
record = dict()
i = 0
#  Count frequency of list elements
while (i < n) :
if ((arr[i] in record.keys())) :
#  Increase the frequency
record[arr[i]] = record.get(arr[i]) + 1
if (record.get(arr[i]) > max) :
#  Get most occuring element frequency
max = record.get(arr[i])

else :
record[arr[i]] = 1

i += 1

for key, value in record.items() :
if (value == max) :
sum += (key * max)

print(" Result : ", sum)

def main() :
arr = [8, 6, -3, 8, 3, 1, 5, 1, 1, -2, -3, -3, 8]
n = len(arr)
#   [8 + 8 + 8]          =  24
#   [(-3) + (-3) + (-3)] = -9
#   [1+1+1]              =  3
#   ------------------------------
#          Result           18
#    -----------------------------
#    Note most occuring element frequency are 3

if __name__ == "__main__": main()``````

#### Output

`` Result :  18``
``````#    Ruby program for
#    Find the sum of all highest occurring elements in an Array
class Occurrence
def sumHighestOccurrence(arr, n)
sum = 0
max = 1
record = Hash.new()
i = 0
#  Count frequency of array elements
while (i < n)
if (record.key?(arr[i]))
#  Increase the frequency
record[arr[i]] = record[arr[i]] + 1
if (record[arr[i]] > max)
#  Get most occuring element frequency
max = record[arr[i]]
end

else

record[arr[i]] = 1
end

i += 1
end

record.each { | key, value |
if (value == max)
sum += (key * max)
end

}
print(" Result : ", sum, "\n")
end

end

def main()
arr = [8, 6, -3, 8, 3, 1, 5, 1, 1, -2, -3, -3, 8]
n = arr.length
#   [8 + 8 + 8]          =  24
#   [(-3) + (-3) + (-3)] = -9
#   [1+1+1]              =  3
#   ------------------------------
#          Result           18
#    -----------------------------
#    Note most occuring element frequency are 3
end

main()``````

#### Output

`````` Result : 18
``````
``````import scala.collection.mutable._;
/*
Scala program for
Find the sum of all highest occurring elements in an Array
*/
class Occurrence()
{
def sumHighestOccurrence(arr: Array[Int], n: Int): Unit = {
var sum: Int = 0;
var max: Int = 1;
var record = new HashMap[Int, Int]();
var i: Int = 0;
// Count frequency of array elements
while (i < n)
{
if (record.contains(arr(i)))
{
// Increase the frequency
if (record.get(arr(i)).get > max)
{
// Get most occuring element frequency
max = record.get(arr(i)).get;
}
}
else
{
}
i += 1;
}
for ((key, value) <- record)
{
if (value == max)
{
sum += (key * max);
}
}
//
println(" Result : " + sum);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Occurrence = new Occurrence();
var arr: Array[Int] = Array(
8, 6, -3, 8, 3, 1, 5, 1, 1, -2, -3, -3, 8
);
var n: Int = arr.length;
/*
[8 + 8 + 8]          =  24
[(-3) + (-3) + (-3)] = -9
[1+1+1]              =  3
------------------------------
Result           18
-----------------------------
Note most occuring element frequency are 3
*/
}
}``````

#### Output

`` Result : 18``
``````import Foundation;
/*
Swift 4 program for
Find the sum of all highest occurring elements in an Array
*/
class Occurrence
{
func sumHighestOccurrence(_ arr: [Int], _ n: Int)
{
var sum: Int = 0;
var max: Int = 1;
var record = [Int : Int]();
var i: Int = 0;
// Count frequency of array elements
while (i < n)
{
if (record.keys.contains(arr[i]))
{
// Increase the frequency
record[arr[i]] = record[arr[i]]! + 1;
if (record[arr[i]]! > max)
{
// Get most occuring element frequency
max = record[arr[i]]!;
}
}
else
{
record[arr[i]] = 1;
}
i += 1;
}
for (key, value) in record
{
if (value == max)
{
sum += (key * max);
}
}
//
print(" Result : ", sum);
}
}
func main()
{
let arr: [Int] = [8, 6, -3, 8, 3, 1, 5, 1, 1, -2, -3, -3, 8];
let n: Int = arr.count;
/*
[8 + 8 + 8]          =  24
[(-3) + (-3) + (-3)] = -9
[1+1+1]              =  3
------------------------------
Result           18
-----------------------------
Note most occuring element frequency are 3
*/
}
main();``````

#### Output

`` Result :  18``
``````/*
Kotlin program for
Find the sum of all highest occurring elements in an Array
*/
class Occurrence
{
fun sumHighestOccurrence(arr: Array < Int > , n: Int): Unit
{
var sum: Int = 0;
var max: Int = 1;
val record: HashMap < Int, Int > = HashMap < Int, Int > ();
var i: Int = 0;
// Count frequency of array elements
while (i < n)
{
if (record.containsKey(arr[i]))
{
// Increase the frequency
record.put(arr[i], record.getValue(arr[i]) + 1);
if (record.getValue(arr[i]) > max)
{
// Get most occuring element frequency
max = record.getValue(arr[i]);
}
}
else
{
record.put(arr[i], 1);
}
i += 1;
}
for ((key, value) in record)
{
if (value == max)
{
sum += (key * max);
}
}

println(" Result : " + sum);
}
}
fun main(args: Array < String > ): Unit
{
val arr: Array < Int > = arrayOf(
8, 6, -3, 8, 3, 1, 5, 1, 1, -2, -3, -3, 8
);
val n: Int = arr.count();
/*
[8 + 8 + 8]          =  24
[(-3) + (-3) + (-3)] = -9
[1+1+1]              =  3
------------------------------
Result           18
-----------------------------
Note most occuring element frequency are 3
*/
}``````

#### Output

`` Result : 18``

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

Categories
Relative Post