I had a much longer program at first, and then came across your solution. Very elegant! Thanks for sharing

Here is my Python 3 solution using the bisect library.

from bisect import bisect_right

n = int(input())
scores = sorted(set(map(int,input().split())))
m = int(input())
alice = map(int,input().split())

# your code goes here
for i in alice:
    print(len(scores)-bisect_right(scores,i)+1)

can you explain me how the while condition always satisfy i think somewhere it does not satisfy but then also it goes in while loop. But your solution is best.

Very cool, thank you for sharing.

very elegant indeed!

it has timeout error

Mine is so similar to your solution: But I have to append a zero at the end. You bet me by that.

#!/bin/python3

import sys

if __name__ == "__main__":
    n = int(input().strip())
    scores = sorted(list(set(list(map(int, input().strip().split(' '))))), reverse=True)
    m = int(input().strip())
    alice = list(map(int, input().strip().split(' ')))
    scores.append(0)
    l = len(scores)
    # Write Your Code Here
    for a in alice:
        while (l > 0) and (a >= scores[l-1]):
            l -= 1
        print(l+1)

I think the key that I was missing is to make the array distinct. But WHY does making the array distinct solve the problem?

Here is an annotated version of albiewalbie's solution, but in Python3 and applied within the definition of the function.

I hope this helps others with the logic!

def climbingLeaderboard(scores, alice):
    # List to contain and return Alice's ranks.
    results = []
    
    # Unique values from scores, since duplicate scores will have same rank (their index value).
    leaderboard = sorted(set(scores), reverse = True)
    
    # Use this var to track index within leaderboard later.
    l = len(leaderboard)
    
    # Loop through each of Alice's scores
    for a in alice:
        
        # If Alice's score is >= the score at the index of the end of leaderboard...
        # Subtract 1 from that index value (which is also the rank) to check the next score up.
        # If the score is less than the next score up, the index (rank) will be added to results.
        while (l > 0) and (a >= leaderboard[l-1]):
            l -= 1
            
        # We add 1 to the appended value to account for 0-indexing.
        results.append(l+1)
        
    return results

your code is giving eof error

I think this is a very good program, but it has the problem with arrays of type [25, 5, 50, 10]

I have used two for loops in my solution and it failed in four test cases due to time complexity.you used one while and for loops but it turned out it is error clear how is this happening,what is the principle in time complexity.

scores=list(map(int,input().split())) alice=list(map(int,input().split())) climberank=[] for i in alice: temp=set(sorted(scores)) temp.add(i) for index,value in enumerate(sorted(temp,reverse=True),1): if value==i: climberank.append(index) temp.discard(i) print(*climberank)

1. scores=list(map(int,input().split())) alice=list(map(int,input().split())) climberank=[] for i in alice: temp=set(sorted(scores)) temp.add(i) for index,value in enumerate(sorted(temp,reverse=True),1): if value==i: climberank.append(index) temp.discard(i) print(*climberank)

I though this would cause TLE becuase O(N) complexity in each search?

Correct me if I am worng, I think this solution works only when the first element in the player is less than last element of ranked array. Remaining elements of player array sholud be greater than the least element of ranked array. For example: if ranked= [100 90 90 80 75 60] and player = [50 55 65 77 90 102] it doesnt satisfy.

wow, neat and powerful. Solves the time issue. so, it basically cuts down the list which is being searched when the a in alice is seen

Thumbs up for this solution, the day we reach to use while loops and it's subsequent increments or decrements, it will become a cakewalk to solve such problems.

awesome

This code works only because test cases are flawed. This wouldn't work if player (alice) list has 2 or more values that are greater than maximum value of ranked (leaderboard) list.

veryyyy nicely done bro