CODEWITHSUNDEEP
c#algorithm
Brandon
Brandon

Reputation:

The Most frequent Number in an array

I have this Array i wrote a function MostFreq that takes an array of integers and return 2 values : the more frequent number in the array and its frequency check this code i worte what do you think ? is there a better way to do it?

static void Main()
{ 
    int [] M={4,5,6,4,4,3,5,3};
    int x;
    int f=MyMath.MostFreq(M,out x );
    console.WriteLine("the most Frequent Item = {0} with frequency = {1}",x,f);
}

=====

in the class Mymath

public static int MostFreq(int[] _M, out int x)
{
    //First I need to sort the array in ascending order
    int Max_Freq, No_Freq, i, k;
    Array.Sort(_M);                         
    k = _M[0];
    Max_Freq = 0; i = 0; x = 0;
    while (i < _M.Length)
    {
        //No_Freq= the frequency of the current number
        No_Freq = 0;
        //X here is the number which is appear in the array Frequently 
        while (k == _M[i])
        {
            No_Freq++;
            i++;
            if (i == _M.Length) 
                break;
        }
        if (No_Freq > Max_Freq)
        {
            //so it will be printed the same
            Max_Freq = No_Freq;
            x = k;
        }
        if (i < _M.Length) k = _M[i];
    }
    return (Max_Freq);
}

Upvotes: 12

Views: 23589

Answers (11)

Pekler
Pekler

Reputation: 33

int[] numbers = new int[] {1, 2, 3, 2, 1, 4, 2};

Dictionary<int, int> numberCounts = new Dictionary<int, int>();

foreach (int number in numbers)
{
    if (numberCounts.ContainsKey(number))
    {
        numberCounts[number]++;
    }
    else
    {
        numberCounts[number] = 1;
    }
}

int maxCount = numberCounts.Values.Max();
int mostFrequentNumber = numberCounts.Where(x => x.Value == maxCount).OrderByDescending(x => x.Key).First().Key;

Console.WriteLine("Most frequent number: " + mostFrequentNumber);

Upvotes: 0

BorisSh
BorisSh

Reputation: 571

int[] arr = { 4, 5, 6, 4, 4, 3, 5, 3 };
var gr = arr.GroupBy(x => x).OrderBy(x => x.Count()).Last();
Console.WriteLine($"The most Frequent Item = {gr.Key} with frequency = {gr.Count()}"); // The most Frequent Item = 4 with frequency = 3

Upvotes: 0

Ashish Jain
Ashish Jain

Reputation: 1

Lets suppose the array is as follows :

int arr[] = {10, 20, 10, 20, 30, 20, 20,40,40,50,15,15,15};

int max = 0;
int result = 0;
Map<Integer,Integer> map = new HashMap<>();

for (int i = 0; i < arr.length; i++) {
    if (map.containsKey(arr[i])) 
        map.put(arr[i], map.get(arr[i]) + 1);
    else
        map.put(arr[i], 1);
    int key = map.keySet().iterator().next();
    if (map.get(key) > max) {
        max = map.get(key) ;
        result = key;
    }
}
System.out.println(result);

Explanation:

In the above code I have taken HashMap to store the elements in keys and the repetition of the elements as values. We have initialized variable max = 0 ( max is the maximum count of repeated element) While iterating over elements We are also getting the max count of keys.

The result variable returns the keys with the mostly repeated.

Upvotes: 0

AnthonyLambert
AnthonyLambert

Reputation: 8830

Done in 1 pass....

public class PopularNumber
    {
        private Int32[] numbers = {5, 4, 3, 32, 6, 6, 3, 3, 2, 2, 31, 1, 32, 4, 3, 4, 5, 6};

        public PopularNumber()
        {
            Dictionary<Int32,Int32> bucket = new Dictionary<Int32,Int32>();
            Int32 maxInt = Int32.MinValue;
            Int32 maxCount = 0;
            Int32 count;

            foreach (var i in numbers)
            {
                if (bucket.TryGetValue(i, out count))
                {
                    count++;
                    bucket[i] = count;
                }
                else
                {
                    count = 1;
                    bucket.Add(i,count);
                }

                if (count >= maxCount)
                {
                    maxInt = i;
                    maxCount = count;
                }

            }

            Console.WriteLine("{0},{1}",maxCount, maxInt);

        }
    }

Upvotes: 1

Pazzo
Pazzo

Reputation: 1

Here's an example how you could do it without LINQ and no dictionaries and lists, just two simple nested loops: 

public class MostFrequentNumber
{
    public static void Main()
    {
        int[] numbers = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();

        int counter = 0;
        int longestOccurance = 0;
        int mostFrequentNumber = 0;

        for (int i = 0; i < numbers.Length; i++)
        {
            counter = 0;

            for (int j = 0; j < numbers.Length; j++)
            {
                if (numbers[j] == numbers[i])
                {
                    counter++;
                }
            }

            if (counter > longestOccurance)
            {
                longestOccurance = counter;
                mostFrequentNumber = numbers[i];
            }
        }

        Console.WriteLine(mostFrequentNumber);
        //Console.WriteLine($"occured {longestOccurance} times");
    }
}

You get the value of the most frequently occurring number, and (commented) you could get also the numbers of the occurrences. I know I have an "using Linq;", that's just to convert the initial input string to an int array and to spare a couple of lines and a parsing loop. Algorithm is fine even without it, if you fill the array the "long" way...

Upvotes: 0

AJIT AGARWAL
AJIT AGARWAL

Reputation: 9

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MostFrequentElement
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = new int[] { 4, 1, 1, 4, 2, 3, 4, 4, 1, 2, 4, 9, 3, 1, 1, 7, 7, 7, 7, 7 };
            Array.Sort(array, (a, b) => a.CompareTo(b));
            int counter = 1;
            int temp=0 ;

            List<int> LOCE = new List<int>();
            foreach (int i in array)
            {
                counter = 1;
                foreach (int j in array)

{
                    if (array[j] == array[i])
                    {
                        counter++;
                    }
                    else {
                    counter=1;
                    }
                    if (counter == temp)
                    {
                        LOCE.Add(array[i]);
                    }
                    if (counter > temp)
                    {
                        LOCE.Clear();
                        LOCE.Add(array[i]);
                        temp = counter;

                    }
                }

            }
            foreach (var element in LOCE)
            {
                Console.Write(element + ",");
            }
            Console.WriteLine();
            Console.WriteLine("(" + temp + " times)");
            Console.Read();
        }
    }
}

Upvotes: 0

wally
wally

Reputation: 7

int count = 1;
int currentIndex = 0;
for (int i = 1; i < A.Length; i++)
{
    if (A[i] == A[currentIndex])
        count++;
    else
        count--;
    if (count == 0)
    {
        currentIndex = i;
        count = 1;
    }
}

int mostFreq = A[currentIndex];

Upvotes: -1

jTresidder
jTresidder

Reputation: 466

You could eliminate the sort you do at the start by iterating the entire array once, keeping a count of how many times you come across each value in a temporary array, and then iterating the temporary array for the highest number. You could keep both the highest frequency count and the most frequent item throughout, too.

Different sorts have different efficiencies on different types of data, of course, but this would be a worst case of just two iterations.

Edit: Apologies for the repeat... 'Tweren't there when I started :)

Upvotes: 2

FlySwat
FlySwat

Reputation: 175733

Assuming you can't use LINQ, I'd probably approach the algorithm like this:

  • Create Key/Value dictionary
  • Iterate your array, add a key the dictionary for each unique elem, increment the value each time that element is repeated.
  • Walk the dictionary keys, and return the elem with the highest value.

This isn't a great solution but it is simple, ContainsKey is an O(1) lookup, so you'll be at most iterating your array twice.

Upvotes: 7

Nathan W
Nathan W

Reputation: 55502

LINQ it up. I know this is in VB but you should be able to convert it to C#:

Dim i = From Numbers In ints _
            Group Numbers By Numbers Into Group _
            Aggregate feq In Group Into Count() _
            Select New With {.Number = Numbers, .Count = Count}

EDIT: Now in C# too:

var i = from numbers in M
                group numbers by numbers into grouped
                select new { Number = grouped.Key, Freq = grouped.Count()};

Upvotes: 9

Tom Ritter
Tom Ritter

Reputation: 101400

From a software engineering standpoint, I would expect a function called MostFreq to return the element with the highest frequency - not the frequency itself. I would switch your out and return values.

Upvotes: 3

Related Questions