Getting the most frequent value from an string array

Question

The answer to this has already been posted on SO, but I want to find a way that does not include complicated data structures like hashmaps. The solution needs to be from ints and football_club[0].equals(football_club[1])

String[] football_club = {"Barcelona", "Real Madrid", "Chelsea", "Real Madrid", "Barcelona", "Barcelona"};

//result
Sting result_club = "a value most in the array"

thank you very much.

Why don't you want to use a hashmap? It isn't difficult to get set up. — sparkyShorts, Jan 21 '15 at 22:19
they want that i will make it simple as i can, so i have to do it like they want me to do it.. can you help? — Forbs, Jan 21 '15 at 22:20
Why do you think that everyone would suggest using a `Map` if that were *not* the simplest solution? Just use it. It works. — 5gon12eder, Jan 21 '15 at 22:21
Does it have to efficient? If it doesn't, two nested for loops will do. — kraskevich, Jan 21 '15 at 22:27
If he runs an n^2 nested loop combo instead of a n-time HashMap implementation, I'm going to be so disappointed. — Cody S, Jan 21 '15 at 22:28
You can sort it and then just count, but its not faster than hashmap. — eckes, Jan 21 '15 at 22:29
Hashmap would be your best choice, but if you have a restriction you can use a counter for each new value in the array :? — geekybedouin, Jan 21 '15 at 22:30
possible duplicate of [Get the element with the highest occurrence in an array](http://stackoverflow.com/questions/1053843/get-the-element-with-the-highest-occurrence-in-an-array) — geekybedouin, Jan 21 '15 at 22:37

MaxZoom · Answer 1 · 2015-01-21T23:14:43.357

Here is the prototype:

import java.util.Arrays;

public class WordCount
{
  public static void main(String[] args)
  {
    String[] football_club = {"Barcelona", "Real Madrid", "Chelsea", "Real Madrid", "Barcelona", "Barcelona"};
    // First sort the array to have the same words group togheter
    Arrays.sort(football_club);

    String result_club = "";
    String word = football_club[0];
    int count = 1, winner = 0; // word counters

    for (int i = 1 ; i < football_club.length; i++) {
      String current = football_club[i];
      if (word.equals(current)) {
        count++;
      }
      else { // word changed
        if (count > winner) { // save winner
          winner = count;
          result_club = word;
        }
        word = current; // start new word count
        count = 1;
      }
    }
    System.out.println("A value most appearing in the array " + result_club + "(" + winner +")");
  }

score 0 · Answer 2 · answered Jan 21 '15 at 22:36

As everyone insists, you should be using a HashMap, but for the sake of the question, let's try this (untested):

String mostFrequent = null;
int frequency = 0;
Arrays.sort(football_club);    // Use a copy if necessary

int count = 0;
for(int i = 0; i < football_club.length; i++) {
    count++;
    if(i == football_club.length - 1 || !football_club[i].equals(football_club[i + 1])) {
        if(count > frequency) {
            mostFrequent = football_club[i];
            frequency = count;
        }
        count = 0;
    }
}

mostFrequent should now contain the most frequent element.

Master Slave · Answer 3 · 2015-01-21T22:48:33.423

The comments are true with respect to Maps and efficiency, and its arguable what's simple. Anyways, you can do a few neat tricks and get your solution by falling back to string manipulation only, without the need for sorting or multiple loops e.g.

public void theMostOftenClub() {
    String[] football_club = {"Barcelona", "Real Madrid", "Chelsea", "Real Madrid", "Barcelona", "Barcelona"};
    String arrayToString = Arrays.toString(football_club);
    int length = arrayToString.length();
    String result_club = "";
    int count = 0;
    for (String club : football_club) {
        int clubLength = club.length();
        int clubCount =  (length - arrayToString.replace(club,"").length()) / clubLength;
        if (count < clubCount) {
            count = clubCount;
            result_club = club;
        }
    }
    System.out.println(result_club); // prints Barcelona
}

The two main lines

String arrayToString = Arrays.toString(football_club);

will give you a string equal to [Barcelona, Real Madrid, Chelsea, Real Madrid, Barcelona, Barcelona]

and

int clubCount =  (length - arrayToString.replace(club,"").length()) / clubLength;

will give you a count of each word within a script

flo · Answer 4 · 2015-01-21T23:14:25.730

You could use the Stream API, but it also comes down to using a Map, although you are not seeing it:

String result_club = Stream.of(football_club)
             .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())) 
             .entrySet().stream()
             .max(Comparator.comparingLong(e -> e.getValue()))
             .map(e -> e.getKey()).orElse(null);

What it does in parts:

// group array to a map holding unique strings an its counts within the array
Map<String, Long> grouped = Stream.of(football_club)
    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

// find the entry of the map with the maximum count if there is one
Optional<Entry<String, Long>> max = grouped.entrySet().stream()
    .max(Comparator.comparingLong(Entry::getValue));

// geht the key of the maximum element or a default value if there is none
String result_club = max.map(Entry::getKey).orElse("Fortuna Düsseldorf");

score 0 · Accepted Answer · answered Jan 21 '15 at 22:56

Here's a solution using zero features from java.util package, just raw arrays and looping.

public static void main(String[] args)
{
    String[] football_club = { "Barcelona", "Real Madrid", "Chelsea", "Real Madrid", "Barcelona", "Barcelona" };
    boolean[] seen = new boolean[football_club.length];
    String result_club = null;
    int result_count = 0;
    for (int i = 0; i < football_club.length; i++) {
        if (!seen[i]) {
            seen[i] = true;
            int count = 1;
            for (int j = i + 1; j < football_club.length; j++) {
                if (!seen[j]) {
                    if (football_club[i].equals(football_club[j])) {
                        seen[j] = true;
                        count++;
                    }
                }
            }
            if (count > result_count) {
                result_count = count;
                result_club = football_club[i];
            }
        }
    }
    System.out.println(result_club);
}

Getting the most frequent value from an string array

5 Answers5