Finding duplicate values only for 2 highest values in a dict

Question

Code:

candidates_and_fp_votes = {'a': 25, 'b': 0, 'c': 17, 'd': 23, 'e': 0}

print(candidates_and_fp_votes)
final_vals = [a for a, b in candidates_and_fp_votes.items() if
              list(candidates_and_fp_votes.values()).count(b) > 1]
print("Duplicates are: ")
for i in final_vals:
    print(i)
print(final_vals)

if not final_vals:
    print("No tiebreaker sys required")
else:
    print("Tie-breaker required")

Currently, this outputs "Tie-breaker required" as 'b' and 'e' have a value of 0. I would like this so it only finds duplicates that affect the highest or second highest value. Eg:

1. Right now, it should print "No tiebreaker sys required because even if there is a duplicate with 'b' and 'e' it is not a duplicate with the second and highest values '25' and '23'

2. if the dict to be = {'a': 25, 'b': 0, 'c': 23, 'd': 23, 'e': 0} it would print out "Tie-breaker required as it is affecting the 2nd highest value - 23.

Also, I just had a little change in mind, if the highest score is duplicating with a number but this number does not duplicate with the second highest, it would just output "No tiebreaker sys required"

How can I do this?

Thanks in advance.

Answer 1

If the 2nd highest value in candidates_and_fp_votes is having a tie, then it prints "Tie-breaker required".

#candidates_and_fp_votes = {'a': 25, 'b': 0, 'c': 17, 'd': 23, 'e': 0}

candidates_and_fp_votes = {'a': 25, 'b': 0, 'c': 23, 'd': 23, 'e': 0}
    print(candidates_and_fp_votes)
final_vals = [ b for a, b in candidates_and_fp_votes.items() if list(candidates_and_fp_votes.values()).count(b) > 1]
dup=sorted(set(final_vals), reverse=True)

act=sorted(set(list(candidates_and_fp_votes.values())), reverse=True)

print("duplicates: ", dup)
print("actual:     ", act)

if dup:
    if dup[0] == act[0]:
        del act[0]
        del dup[0]

if dup:
    if dup[0] == act[0] or dup[0] == act[1]:
        print("Tie breaker required")
    else:
        print("No tie breaker required")
else:
    print("No tie breaker required")

Answer 2

Just preserve a and b to take the rigth choice:

candidates_and_fp_votes =  {'a': 25, 'c': 25, 'b': 0, 'e': 23, 'd': 23}

print(candidates_and_fp_votes)
final_vals = [[a,b] for a, b in candidates_and_fp_votes.items() if
              list(candidates_and_fp_votes.values()).count(b) > 1]
print("Duplicates are: ")
for i in final_vals:
    print(i)

fAndS=sorted(candidates_and_fp_votes.values())[len(candidates_and_fp_votes)-2:len(candidates_and_fp_votes)]
maxVals=[[a,b] for a, b in candidates_and_fp_votes.items() if b==max(candidates_and_fp_votes.values())]
if final_vals:
    print("There is a duplicate with")
    print(final_vals)

if len(maxVals)==2:
    print("2 highest scoring candidates are equal")
    print(maxVals)
    print("No tiebreaker sys required")
else:
    final_vals = [ a for a,b in final_vals if b in fAndS]
    if not final_vals:
        print("It is not a duplicate with the second and highest values")
        print(fAndS)
        print("No tiebreaker sys required")
    else:
        print("There is a duplicate with the second and highest values")
        print(fAndS)
        print("Tie-breaker required")

Output 1:

{'a': 25, 'c': 17, 'b': 0, 'e': 0, 'd': 23}
Duplicates are: 
['b', 0]
['e', 0]
There is a duplicate with
[['b', 0], ['e', 0]]
It is not a duplicate with the second and highest values
[23, 25]
No tiebreaker sys required

Output 2:

{'a': 25, 'c': 23, 'b': 0, 'e': 0, 'd': 23}
Duplicates are: 
['c', 23]
['b', 0]
['e', 0]
['d', 23]
There is a duplicate with
[['c', 23], ['b', 0], ['e', 0], ['d', 23]]
There is a duplicate with the second and highest values
[23, 25]
Tie-breaker required

Output 3:

{'a': 25, 'c': 25, 'b': 0, 'e': 23, 'd': 23}
Duplicates are: 
['a', 25]
['c', 25]
['e', 23]
['d', 23]
There is a duplicate with
[['a', 25], ['c', 25], ['e', 23], ['d', 23]]
2 highest scoring candidates are equal
[['a', 25], ['c', 25]]
No tiebreaker sys required

[EDIT] Here is a more simple answer, just thinking all conditions together: (Based only the dict sorted)

candidates_and_fp_votes =  {'a': 25, 'c': 25, 'b': 0, 'e': 0, 'd': 23}
sorted_votes = sorted([[value,key] for key,value in candidates_and_fp_votes.items()])

resultList=[]
dictSize = len(candidates_and_fp_votes)
print sorted_votes
if(dictSize>=3):
  if sorted_votes[dictSize-2][0]==sorted_votes[dictSize-3][0]:
    print("Need tie break between")
    resultList = [ key for value,key in sorted_votes if value==sorted_votes[dictSize-2][0] ]
    print resultList
  else:
    print("Winers")
    resultList = [key for value,key in sorted_votes[dictSize-2:dictSize]]
    print resultList

Output:

[[0, 'b'], [0, 'e'], [23, 'd'], [25, 'a'], [25, 'c']]
Winers
['a', 'c']

Answer 3

To find the duplicates that are the maximum of the values or the second highest, you can try this:

candidates_and_fp_votes = {'a': 25, 'b': 0, 'c': 17, 'd': 23, 'e': 0}
tie_breakers = [a for a, b in candidates_and_fp_votes.items() if list(candidates_and_fp_votes.values()).count(b) > 1 and b in [d for c, d in sorted(candidates_and_fp_votes.items(), key=lambda x:x[-1])[-2:]]]

Output:

['c', 'd']

Answer 4

You can use heapq.nlargest to find the three largest values and then inspect them:

import heapq
max3 = heapq.nlargest(3, candidates_and_fp_votes.values())

max3 will now contain the three largest values (preserving multiple occurrences) in descending order. The rest should be easy.

Answer 5

As I understand it, you are looking to determine a winner based on the highest number of votes and whether a tie breaker is necessary. You could do that like this:

import operator
candidates_and_fp_votes = {'a': 25, 'b': 0, 'c': 17, 'd': 23, 'e': 0}
sorted_candidates = sorted(candidates_and_fp_votes.items(), key=operator.itemgetter(1), reverse=True)

The output of sorted_candidates will look like:

[('a', 25), ('d', 23), ('c', 17), ('b', 0), ('e', 0)]

You can then iterate over this:

tie = False
for idx, _ in enumerate(sorted_candidates):
     candidate, votes = sorted_candidates[idx]
     next_candidate, next_votes = sorted_candidates[idx+1]

     if votes > next_votes:
         if tie is True:
             print("Tie Breaker needed!")
         else:
             print(f"Candidate {candidate} is the Winner!")
         break

     elif votes == next_votes:
         print("Tie!")
         tie = True

Just one of many ways to get there. I hope that helps.

Reference:

• Python 3.6
• Googled: python sort dict on value
• Result: How to sort a dictionary by value?

Edit:

You are asking to determine if the is a tie. My approach would be to reverse the dict. Making the votes the key and creating a list of candidates that have an equal number of votes. Something like this:

from collections import defaultdict
reversed_dict = defaultdict(list)
for key,value in candidates_and_fp_votes.items():
    reversed_dict[value].append(key)

Outputting:

defaultdict(list, {0: ['b', 'e'], 17: ['c'], 23: ['d'], 25: ['a']})

Any key that has a candidate value-list of len > 1 needs a tie breaker.