Skip to main content

Sum of all even frequency elements in matrix

Here given code implementation process.

// Java Program 
// Sum of all even frequency elements in matrix
import java.util.HashMap;
public class Frequency
{
    
    public void evenFrequencySum(int [][]matrix)
    {
        // Get the length
        int r = matrix.length;
        int c = matrix[0].length;

        // Use to count frequency
        HashMap < Integer, Integer > record = new HashMap < Integer, Integer > ();
        // Execute loop through by matrix row
        for (int i = 0; i < r  ;i++ ) 
        {
            // Execute loop through by matrix column
            for (int j = 0; j < c ; ++j ) 
            {
                
                if (record.containsKey(matrix[i][j]))
                {
                    // increase element frequency
                    record.put(matrix[i][j], record.get(matrix[i][j]) + 1);
                }
                else
                {
                    // Add new element
                    record.put(matrix[i][j], 1);
                }  
            }
        }

        int sum = 0;

        for (int key: record.keySet())
        {
            
            if(record.get(key) % 2 == 0)
            {
                // Sum all even occurring elements 
                sum += key*record.get(key);
            }
        }
        // Display calculated result
        System.out.print(" Result "+sum);
    }
    public static void main(String[] args)
    {
        Frequency task = new Frequency();

        int [][]matrix = 
        {
            {1, 7,  4,  6,  5},
            {8, 9,  4,  5, 1},
            {6, 2, 1,  9,  -2},
            {9, 2, 1,  -2,  6},
        };
        // Even Frequency 
        // (1 + 1 + 1 + 1) + (2 + 2) + (-2 + -2)
        // ( 5 + 5) + ( 4 + 4 )
        task.evenFrequencySum(matrix);

    }
}

Output

 Result 22
// Include header file
#include <iostream>
#include <unordered_map>
using namespace std;
#define R 4
#define C 5

// C++ Program
// Sum of all even frequency elements in matrix
class Frequency
{
	public: void evenFrequencySum(int matrix[R][C])
	{
		// Use to count frequency
		unordered_map < int, int > record ;
		// Execute loop through by matrix row
		for (int i = 0; i < R; i++)
		{
			// Execute loop through by matrix column
			for (int j = 0; j < C; ++j)
			{
				if (record.find(matrix[i][j]) != record.end())
				{
					// increase element frequency
					record[matrix[i][j]] = record[matrix[i][j]] + 1;
				}
				else
				{
					// Add new element
					record[matrix[i][j]] = 1;
				}
			}
		}
		int sum = 0;
		for (auto &data: record)
		{
			if ((data.second % 2) == 0)
			{
				// Sum all even occurring elements
				sum += data.second * data.first;
			}
		}
		cout << " Result " << sum;
	}
};
int main()
{
	Frequency task = Frequency();
	int matrix[R][C] = {
		{
			1 , 7 , 4 , 6 , 5
		} , {
			8 , 9 , 4 , 5 , 1
		} , {
			6 , 2 , 1 , 9 , -2
		} , {
			9 , 2 , 1 , -2 , 6
		} 
	};
	// Even Frequency
	// (1 + 1 + 1 + 1) + (2 + 2) + (-2 + -2)
	// ( 5 + 5) + ( 4 + 4 )
	task.evenFrequencySum(matrix);
	return 0;
}

Output

 Result 22
// Include namespace system
using System;
using System.Collections.Generic;

// C# Program
// Sum of all even frequency elements in matrix

public class Frequency
{
	public void evenFrequencySum(int[,] matrix)
	{
		// Get the length
		int r = matrix.GetLength(0);
		int c = matrix.GetLength(1);
		// Use to count frequency
		Dictionary < int, int > record = new Dictionary < int, int > ();
		// Execute loop through by matrix row
		for (int i = 0; i < r; i++)
		{
			// Execute loop through by matrix column
			for (int j = 0; j < c; ++j)
			{
				if (record.ContainsKey(matrix[i,j]))
				{
					// increase element frequency
					record[matrix[i,j]] = record[matrix[i,j]] + 1;
				}
				else
				{
					// Add new element
					record.Add(matrix[i,j], 1);
				}
			}
		}
		int sum = 0;
		foreach(KeyValuePair < int, int > data in record)
		{
			if (data.Value % 2 == 0)
			{
				// Sum all even occurring elements
				sum += data.Key * data.Value;
			}
		}
		// Display calculated result
		Console.Write(" Result " + sum);
	}
	public static void Main(String[] args)
	{
		Frequency task = new Frequency();
		int[,] matrix = {
			{
				1 , 7 , 4 , 6 , 5
			} , {
				8 , 9 , 4 , 5 , 1
			} , {
				6 , 2 , 1 , 9 , -2
			} , {
				9 , 2 , 1 , -2 , 6
			} 
    	};
		// Even Frequency
		// (1 + 1 + 1 + 1) + (2 + 2) + (-2 + -2)
		// ( 5 + 5) + ( 4 + 4 )
		task.evenFrequencySum(matrix);
	}
}

Output

 Result 22
<?php
// Php Program
// Sum of all even frequency elements in matrix
class Frequency
{
	public	function evenFrequencySum( & $matrix)
	{
		// Get the length
		$r = count($matrix);
		$c = count($matrix[0]);
		// Use to count frequency
		$record = array();
		// Execute loop through by matrix row
		for ($i = 0; $i < $r; $i++)
		{
			// Execute loop through by matrix column
			for ($j = 0; $j < $c; ++$j)
			{
				if (array_key_exists($matrix[$i][$j], $record))
				{ // increase element frequency
					$record[$matrix[$i][$j]] = $record[$matrix[$i][$j]] + 1;
				}
				else
				{ // Add new element
					$record[$matrix[$i][$j]] = 1;
				}
			}
		}
		$sum = 0;
		foreach($record as $key => $value)
		{
			if (($value % 2) == 0)
			{
				// Sum all even occurring elements
				$sum += $key * $record[$key];
			}
		}
		// Display calculated result
		echo " Result ".$sum;
	}
}

function main()
{
	$task = new Frequency();
	$matrix = array(
      array(1, 7, 4, 6, 5), 
      array(8, 9, 4, 5, 1), 
      array(6, 2, 1, 9, -2), 
      array(9, 2, 1, -2, 6)
    ); 
    // Even Frequency
	// (1 + 1 + 1 + 1) + (2 + 2) + (-2 + -2)
	// ( 5 + 5) + ( 4 + 4 )
	$task->evenFrequencySum($matrix);
}
main();

Output

 Result 22
// Node Js Program
// Sum of all even frequency elements in matrix
class Frequency
{
	evenFrequencySum(matrix)
	{
		// Get the length
		var r = matrix.length;
		var c = matrix[0].length;
		// Use to count frequency
		var record = new Map();
		// Execute loop through by matrix row
		for (var i = 0; i < r; i++)
		{
			// Execute loop through by matrix column
			for (var j = 0; j < c; ++j)
			{
				if (record.has(matrix[i][j]))
				{
					// increase element frequency
					record.set(matrix[i][j], record.get(matrix[i][j]) + 1);
				}
				else
				{
					// Add new element
					record.set(matrix[i][j], 1);
				}
			}
		}
		var sum = 0;
		for (let [key, value] of record)
		{
			if ((value % 2) == 0)
			{
				// Sum all even occurring elements
				sum += key * value;
			}
		}
		// Display calculated result
		process.stdout.write(" Result " + sum);
	}
}

function main()
{
	var task = new Frequency();
	var matrix = [
		[1, 7, 4, 6, 5] , 
        [8, 9, 4, 5, 1] , 
        [6, 2, 1, 9, -2] , 
        [9, 2, 1, -2, 6]
	];
	// Even Frequency
	// (1 + 1 + 1 + 1) + (2 + 2) + (-2 + -2)
	// ( 5 + 5) + ( 4 + 4 )
	task.evenFrequencySum(matrix);
}
main();

Output

 Result 22
#  Python 3 Program
#  Sum of all even frequency elements in matrix
class Frequency :
	def evenFrequencySum(self, matrix) :
		#  Get the length
		r = len(matrix)
		c = len(matrix[0])
		#  Use to count frequency
		record = dict()
		#  Execute loop through by matrix row
		i = 0
		while (i < r) :
			#  Execute loop through by matrix column
			j = 0
			while (j < c) :
				if (matrix[i][j] in record.keys()) :
					#  increase element frequency
					record[matrix[i][j]] = record.get(matrix[i][j]) + 1
				else :
					#  Add new element
					record[matrix[i][j]] = 1
				
				j += 1
			
			i += 1
		
		sum = 0
		for key, value in record.items() :
			if ((value % 2) == 0) :
				#  Sum all even occurring elements
				sum += key * value
			
		
		#  Display calculated result
		print(" Result ", sum, end = "")
	

def main() :
	task = Frequency()
	matrix = [
		[1, 7, 4, 6, 5] , 
        [8, 9, 4, 5, 1] , 
        [6, 2, 1, 9, -2] , 
        [9, 2, 1, -2, 6]
	] #  Even Frequency
	#  (1 + 1 + 1 + 1) + (2 + 2) + (-2 + -2)
	#  ( 5 + 5) + ( 4 + 4 )
	task.evenFrequencySum(matrix)

if __name__ == "__main__": main()

Output

 Result  22
#  Ruby Program
#  Sum of all even frequency elements in matrix
class Frequency 
	def evenFrequencySum(matrix) 
		#  Get the length
		r = matrix.length
		c = matrix[0].length
		#  Use to count frequency
		record = Hash.new
		#  Execute loop through by matrix row
		i = 0
		while (i < r) 
			#  Execute loop through by matrix column
			j = 0
			while (j < c) 
				if (record.key?(matrix[i][j])) 
					record[matrix[i][j]] = record[matrix[i][j]] + 1
				else 
					record[matrix[i][j]] = 1
				end

				j += 1
			end

			i += 1
		end

		sum = 0
		record.each { | key, value | 
			if ((value % 2) == 0) 
				#  Sum all even occurring elements
				sum += key * value
			end
		}
		#  Display calculated result
		print(" Result ", sum)
	end

end

def main() 
	task = Frequency.new()
	matrix = [
		[1, 7, 4, 6, 5] , 
        [8, 9, 4, 5, 1] , 
        [6, 2, 1, 9, -2] , 
        [9, 2, 1, -2, 6]
	]
	#  Even Frequency
	#  (1 + 1 + 1 + 1) + (2 + 2) + (-2 + -2)
	#  ( 5 + 5) + ( 4 + 4 )
	task.evenFrequencySum(matrix)
end

main()

Output

 Result 22
import scala.collection.mutable._;
// Scala Program
// Sum of all even frequency elements in matrix
class Frequency
{
	def evenFrequencySum(matrix: Array[Array[Int]]): Unit = {
		// Get the length
		var r: Int = matrix.length;
		var c: Int = matrix(0).length;
		// Use to count frequency
		var record = Map[Int, Int]();
		// Execute loop through by matrix row
		var i: Int = 0;
		while (i < r)
		{
			// Execute loop through by matrix column
			var j: Int = 0;
			while (j < c)
			{
				if (record.contains(matrix(i)(j)))
				{
					// increase element frequency
					record.addOne(matrix(i)(j), record.get(matrix(i)(j)).get + 1);
				}
				else
				{
					// Add new element
					record.addOne(matrix(i)(j), 1);
				}
				j += 1;
			}
			i += 1;
		}
		var sum: Int = 0;
		for ((key, value) <- record)
		{
			if ((value % 2) == 0)
			{
				// Sum all even occurring elements
				sum += key * value;
			}
		}
		// Display calculated result
		print(" Result " + sum);
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: Frequency = new Frequency();
		var matrix: Array[Array[Int]] = 
          Array( Array(1, 7, 4, 6, 5), 
                Array(8, 9, 4, 5, 1), 
                Array(6, 2, 1, 9, -2), 
                Array(9, 2, 1, -2, 6)
         );
		// Even Frequency
		// (1 + 1 + 1 + 1) + (2 + 2) + (-2 + -2)
		// ( 5 + 5) + ( 4 + 4 )
		task.evenFrequencySum(matrix);
	}
}

Output

 Result 22
import Foundation
// Swift 4 Program
// Sum of all even frequency elements in matrix
class Frequency
{
	func evenFrequencySum(_ matrix: [[Int]])
	{
		// Get the length
		let r: Int = matrix.count;
		let c: Int = matrix[0].count;
		// Use to count frequency
		var record = [Int: Int]();
		// Execute loop through by matrix row
		var i: Int = 0;
		while (i < r)
		{
			// Execute loop through by matrix column
			var j: Int = 0;
			while (j < c)
			{
				if (record.keys.contains(matrix[i][j]))
				{
					// increase element frequency
					record[matrix[i][j]] = record[matrix[i][j]]! + 1;
				}
				else
				{
					// Add new element
					record[matrix[i][j]] = 1;
				}
				j += 1;
			}
			i += 1;
		}
		var sum: Int = 0;
		for (key, value) in record
		{
			if ((value % 2) == 0)
			{
				// Sum all even occurring elements
				sum += key * value;
			}
		}
		// Display calculated result
		print(" Result ", sum, terminator: "");
	}
}
func main()
{
	let task: Frequency = Frequency();
	let matrix: [[Int]] = [
		[1, 7, 4, 6, 5] , 
        [8, 9, 4, 5, 1] , 
        [6, 2, 1, 9, -2] , 
        [9, 2, 1, -2, 6]
	];
	// Even Frequency
	// (1 + 1 + 1 + 1) + (2 + 2) + (-2 + -2)
	// ( 5 + 5) + ( 4 + 4 )
	task.evenFrequencySum(matrix);
}
main();

Output

 Result  22
// Kotlin Program
// Sum of all even frequency elements in matrix
class Frequency
{
	fun evenFrequencySum(matrix: Array < Array < Int >> ): Unit
	{
		// Get the length
		var r: Int = matrix.count();
		var c: Int = matrix[0].count();
		// Use to count frequency
		var record = mutableMapOf < Int , Int > ();
		// Execute loop through by matrix row
		var i: Int = 0;
		while (i < r)
		{
			// Execute loop through by matrix column
			var j: Int = 0;
			while (j < c)
			{
				if (record.containsKey(matrix[i][j]))
				{
					// increase element frequency
					record.put(matrix[i][j], record.getValue(matrix[i][j]) + 1);
				}
				else
				{
					// Add new element
					record.put(matrix[i][j], 1);
				}
				j += 1;
			}
			i += 1;
		}
		var sum: Int = 0;
		for (key in record.keys)
		{
			if ((record.getValue(key) % 2) == 0)
			{
				// Sum all even occurring elements
				sum += key * record.getValue(key);
			}
		}
		// Display calculated result
		print(" Result " + sum);
	}
}
fun main(args: Array < String > ): Unit
{
	var task: Frequency = Frequency();
	var matrix: Array < Array < Int >> = 
    arrayOf(
        arrayOf(1, 7, 4, 6, 5), 
        arrayOf(8, 9, 4, 5, 1), 
        arrayOf(6, 2, 1, 9, -2), 
        arrayOf(9, 2, 1, -2, 6)
    );
	// Even Frequency
	// (1 + 1 + 1 + 1) + (2 + 2) + (-2 + -2)
	// ( 5 + 5) + ( 4 + 4 )
	task.evenFrequencySum(matrix);
}

Output

 Result 22
Last updated on by Kalkicode




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.

New Comment