Find winner of an election where votes are represented as candidate names
Last Updated :
01 Mar, 2023
Given an array of names of candidates in an election. A candidate’s name in the array represents a vote cast on the candidate. Print the name of candidates who received the maximum vote. If there is a tie, print a lexicographically smaller name.
Examples:
Input: votes[] = {“john”, “johnny”, “jackie”, “johnny”, “john”, “jackie”, “jamie”, “jamie”, “john”, “johnny”, “jamie”, “johnny”, “john”}
Output: John
Explanation: We have four Candidates with name as ‘John’, ‘Johnny’, ‘jamie’, ‘jackie’. The candidates John and Johny get maximum votes. Since John is alphabetically smaller.
Input: votes[] = {“virat”, “rohit”, “rishabh”, “rohit”, “virat”, “rohit”}
Output: rohit
Explanation: We have three Candidates with name as ‘virat’, ‘rohit’, ‘rishabh’. rohit get maximum votes.
Naive Approach:
A simple solution is to run two loops and count the occurrences of every word. And then find the maximum count.
- Iterate over every string
- Count the occurrence of the current string in the given votes[]
- Maximise the result if count > previous count
- return the result
Below is the implementation of the above approach:
C++
Java
Python3
import math
def findWinner(votes):
n = len (votes);
prevCount = 0 ;
result = "";
for i in range ( 0 , n):
count = 0 ;
for j in range ( 0 , n):
if (votes[i] = = votes[j]):
count + = 1 ;
if (count > prevCount):
prevCount = count;
result = votes[i];
elif (count = = prevCount) :
result = min (result, votes[i]);
print (result);
votes = [ "john" , "johnny" , "jackie" , "johnny" ,
"john" , "jackie" , "jamie" , "jamie" ,
"john" , "johnny" , "jamie" , "johnny" ,
"john" ];
findWinner(votes);
|
C#
using System;
using System.Linq;
using System.Collections.Generic;
class Gfg {
public static void findWinner(List< string > votes)
{
int n = votes.Count;
int prevCount = 0;
string result = "" ;
for ( int i = 0; i < n; i++) {
int count = 0;
for ( int j = 0; j < n; j++) {
if (votes[i] == votes[j]) {
count++;
}
if (count > prevCount) {
prevCount = count;
result = votes[i];
}
else if (count == prevCount) {
if (votes[i].CompareTo(result) < 0)
result = votes[i];
}
}
}
Console.WriteLine(result);
}
public static void Main( string [] args)
{
List< string > votes = new List< string >() {
"john" , "johnny" , "jackie" , "johnny" , "john" ,
"jackie" , "jamie" , "jamie" , "john" ,
"johnny" , "jamie" , "johnny" , "john"
};
findWinner(votes);
}
}
|
Javascript
function findWinner(votes) {
let n = votes.length;
let prevCount = 0;
let result = "" ;
for (let i = 0; i < n; i++) {
let count = 0;
for (let j = 0; j < n; j++) {
if (votes[i] == votes[j])
count++;
if (count > prevCount) {
prevCount = count;
result = votes[i];
}
else if (count == prevCount) {
result = Math.min(result, votes[i]);
}
}
}
console.log(result);
}
let votes
= [ "john" , "johnny" , "jackie" , "johnny" ,
"john" , "jackie" , "jamie" , "jamie" ,
"john" , "johnny" , "jamie" , "johnny" ,
"john" ];
findWinner(votes);
|
Time Complexity: O(n * n * MAX_WORD_LEN).
Auxiliary Space: O(MAX_WORD_LEN)
Find winner of an election where votes are represented as candidate names using Hashing:
An efficient solution is to use Hashing. Insert all votes in a hash map and keep track of counts of different names. Finally, traverse the map and print the person with the maximum votes.
Follow the steps below to solve the problem:
- Create a map of string, value pair
- Now iterate on the votes array and increment the count of every string
- Traverse the map and the string having maximum count store it as a string variable
- If there is a tie pick the smaller one
Below is the Implementation of the above approach:
C++
#include "bits/stdc++.h"
using namespace std;
void findWinner(vector<string>& votes)
{
unordered_map<string, int > mapObj;
for ( auto & str : votes) {
mapObj[str]++;
}
int maxValueInMap = 0;
string winner;
for ( auto & entry : mapObj) {
string key = entry.first;
int val = entry.second;
if (val > maxValueInMap) {
maxValueInMap = val;
winner = key;
}
else if (val == maxValueInMap && winner > key)
winner = key;
}
cout << winner << endl;
}
int main()
{
vector<string> votes
= { "john" , "johnny" , "jackie" , "johnny" ,
"john" , "jackie" , "jamie" , "jamie" ,
"john" , "johnny" , "jamie" , "johnny" ,
"john" };
findWinner(votes);
return 0;
}
|
Java
import java.util.*;
public class ElectoralVotingBallot {
public static void findWinner(String votes[])
{
Map<String, Integer> map
= new HashMap<String, Integer>();
for (String str : votes) {
if (map.keySet().contains(str))
map.put(str, map.get(str) + 1 );
else
map.put(str, 1 );
}
int maxValueInMap = 0 ;
String winner = "" ;
for (Map.Entry<String, Integer> entry :
map.entrySet()) {
String key = entry.getKey();
Integer val = entry.getValue();
if (val > maxValueInMap) {
maxValueInMap = val;
winner = key;
}
else if (val == maxValueInMap
&& winner.compareTo(key) > 0 )
winner = key;
}
System.out.println(winner);
}
public static void main(String[] args)
{
String[] votes
= { "john" , "johnny" , "jackie" , "johnny" ,
"john" , "jackie" , "jamie" , "jamie" ,
"john" , "johnny" , "jamie" , "johnny" ,
"john" };
findWinner(votes);
}
}
|
Python3
from collections import defaultdict
def findWinner(votes):
mapObj = defaultdict( int )
for st in votes:
mapObj[st] + = 1
maxValueInMap = 0
winner = ""
for entry in mapObj:
key = entry
val = mapObj[entry]
if (val > maxValueInMap):
maxValueInMap = val
winner = key
else if (val = = maxValueInMap and
winner > key):
winner = key
print (winner)
if __name__ = = "__main__" :
votes = [ "john" , "johnny" , "jackie" ,
"johnny" , "john" , "jackie" ,
"jamie" , "jamie" , "john" ,
"johnny" , "jamie" , "johnny" ,
"john" ]
findWinner(votes)
|
C#
using System;
using System.Collections.Generic;
public class ElectoralVotingBallot {
public static void findWinner(String[] votes)
{
Dictionary<String, int > map
= new Dictionary<String, int >();
foreach (String str in votes)
{
if (map.ContainsKey(str))
map[str] = map[str] + 1;
else
map.Add(str, 1);
}
int maxValueInMap = 0;
String winner = "" ;
foreach (KeyValuePair<String, int > entry in map)
{
String key = entry.Key;
int val = entry.Value;
if (val > maxValueInMap) {
maxValueInMap = val;
winner = key;
}
else if (val == maxValueInMap
&& winner.CompareTo(key) > 0)
winner = key;
}
Console.WriteLine(winner);
}
public static void Main(String[] args)
{
String[] votes
= { "john" , "johnny" , "jackie" , "johnny" ,
"john" , "jackie" , "jamie" , "jamie" ,
"john" , "johnny" , "jamie" , "johnny" ,
"john" };
findWinner(votes);
}
}
|
Javascript
<script>
function findWinner(votes)
{
let map = new Map();
for (let i=0;i<votes.length;i++)
{
if (map.has(votes[i]))
{
map.set(votes[i], map.get(votes[i]) + 1);
}
else
map.set(votes[i], 1);
}
let maxValueInMap = 0;
let winner = "" ;
for (let [key, value] of map.entries())
{
let Key = key;
let val = value;
if (val > maxValueInMap)
{
maxValueInMap = val;
winner = key;
}
else if (val == maxValueInMap &&
winner>Key)
winner = Key;
}
document.write(winner);
}
let votes=[ "john" , "johnny" , "jackie" ,
"johnny" , "john" , "jackie" ,
"jamie" , "jamie" , "john" ,
"johnny" , "jamie" , "johnny" ,
"john" ];
findWinner(votes);
</script>
|
Time Complexity: O(N), where N is the total number of votes.
Auxiliary Space: O(N), since unordered_map data structure is used.
Another efficient solution is to use Trie. Please refer most frequent word in an array of strings.
Share your thoughts in the comments
Please Login to comment...