Problem:
Look for the Winner! The citizens of TKB City are famous for their deep love in elections and vote counting.
Today they hold an election for the next chairperson of the electoral commission.
Now the voting has just been closed and the counting is going to start.
The TKB citizens have strong desire to know the winner as early as possible during vote counting. The election candidate receiving the most votes shall be the next chairperson.
Suppose for instance that we have three candidates A , B , and C and ten votes.
Suppose also that we have already counted six of the ten votes and the vote counts of A , B , and C are four, one, and one, respectively.
At this moment, every candidate has a chance to receive four more votes and so everyone can still be the winner.
However, if the next vote counted is cast for A , A is ensured to be the winner since A already has five votes and B or C can have at most four votes at the end.
In this example, therefore, the TKB citizens can know the winner just when the seventh vote is counted. Your mission is to write a program that receives every vote counted, one by one, identifies the winner, and determines when the winner gets ensured. Input The input consists of at most 1500 datasets, each consisting of two lines in the following format.  n  c 1  c 2 … c n   n in the first line represents the number of votes, and is a positive integer no greater than 100.
The second line represents the n votes, separated by a space.
Each c i (1 ≤ i ≤ n ) is a single uppercase letter, i.e. one of 'A' through 'Z'.
This represents the election candidate for which the i -th vote was cast.
Counting shall be done in the given order from c 1 to c n . You should assume that at least two stand as candidates even when all the votes are cast for one candidate. The end of the input is indicated by a line containing a zero. Output For each dataset, unless the election ends in a tie, output a single line containing an uppercase letter c and an integer d separated by a space: c should represent the election winner and d should represent after counting how many votes the winner is identified.
Otherwise, that is, if the election ends in a tie, output a single line containing `TIE'. Sample Input 1
A
4
A A B B
5
L M N L N
6
K K K K K K
6
X X X Y Z X
10
A A A B A C A C C B
10
U U U U U V V W W W
0 Output for the Sample Input A 1
TIE
TIE
K 4
X 5
A 7
U 8

Solution (Python):
def solve():
  n = int(input())
  if n == 0:
    exit()
  C = [c for c in input().split()]

  V = [0] * 26

  for i, c in enumerate(C, 1):
    V[ord(c) - ord('A')] += 1
    maxi = 0
    ma1 = 0
    ma2 = 0
    for j, v in enumerate(V):
      if v > ma1:
        ma1, ma2 = v, ma1
        maxi = j
      elif v > ma2:
        ma2 = v

    if ma1 - ma2 > n - i:
      print(chr(ord('A') + maxi), i)
      return

  print('TIE')

while True:
  solve()

Solution (Python):
def main():
    while True:
        votesum = int(input())
        
        halfsum = votesum // 2
        if votesum == 0: break

        votedata = []
        votedata = list(map(str, input().split()))
        
        

        nowdata = dict()
        nowdata['o'] = 0
        

        for i in range(len(votedata)):
            cand = votedata[i]

            voteremn = votesum - (i + 1)

            if newcand(votedata, cand, i): nowdata[cand] = 1
            else: nowdata[cand] += 1

            nowdata = sorted(nowdata.items(), key = lambda x:x[1], reverse = True)
            
            
            if nowdata[0][1] > halfsum:
                print(str(nowdata[0][0] + " " +  str(i + 1)))
                break
            elif nowdata[0][1] > nowdata[1][1] + voteremn:
                print(str(nowdata[0][0] + " " + str(i + 1)))
                break

            nowdata = dict(nowdata)

            if i == len(votedata) - 1:
                print("TIE")
                break
            
        


def newcand(data, cand, now):
    for i in range(now):
        item = data[i]
        if item == cand: return False
    return True
main()

Solution (Python):
n=int(input())
large=list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
while n!=0:
    vote=list(input().split())
    vote_number=0
    stack=[0]*26
    flag=False
    for i in vote:
        vote_number+=1
        stack[large.index(i)]+=1
        second_max=[i for i in stack]
        second_max[stack.index(max(stack))]=-1
        if max(stack)>max(second_max)+len(vote)-vote_number:
            print(large[stack.index(max(stack))],vote_number)
            flag=True
            break
    if flag==False:
        print("TIE")
    n=int(input())

Solution (Python):
import collections

while 1:
    n = int(input())
    if n == 0:
        break

    data = list(input().split())
    vote = [0] * 26
    alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    alpha = list(alpha)

    for i, v in enumerate(data):
        num = alpha.index(v)
        vote[num] += 1
        tmp = zip(vote, alpha)
        tmp = sorted(tmp, key=lambda x: -x[0])
        vote, alpha = zip(*tmp)
        vote = list(vote)
        alpha = list(alpha)

        if vote[0] > (n-i-1) + vote[1]:
            print(alpha[0], i+1)
            break
    else:
        print("TIE")

Solution (Python):
while 1:
        n=int(input())
        if not n:break
        vote={"":0}
        cnt=0
        for c in input().split(" "):
            cnt+=1
            if c in vote:vote[c]+=1
            else:vote[c]=1
            v=sorted(vote.items(), key=lambda x: x[1])
            if v[-1][-1]>v[-2][-1]+n-cnt:
                print(*[v[-1][-2],cnt])
                break
            elif n==cnt:print("TIE")

Solution (Python):
while 1:
    n=int(input())
    if n==0:
        break
    _dic={}
    dic={}
    s=input().split()
    for p in s:
        if p in _dic:
            _dic[p]+=1
        else:
            _dic[p]=1
            dic[p]=0
    data=sorted(_dic.items(), key=lambda x:-x[1])
    if len(data)==1:
        print(data[0][0],n//2+1)
        continue
    if data[0][1]==data[1][1]:
        print('TIE')
        continue
    i=1
    for p in s:
        dic[p]+=1
        d=sorted(dic.items(), key=lambda x:-x[1])
        if d[0][1]>d[1][1]+(n-i):
            print(d[0][0],i)
            break
        i+=1