O(n+m) python solution

def climbingLeaderboard(ranked, player):
    r2 = sorted(set(ranked))[::-1]
    i, res = 0, []
    for score in player[::-1]:
        while i < len(r2) and score < r2[i]: i += 1
        res.append(i+1)

    return res[::-1]

I finally wrote a code faster, better and more destructive than the AI chatbot generated. Have a look. Python. But it is so simple you can transplant it to anything.

def climbingLeaderboard(ranked, player):

ranked = sorted(list(set(ranked)), reverse=True)
ans = []

for p in player:

    while len(ranked) > 0 and ranked[-1] < p:
        ranked.pop()

    if len(ranked) == 0:
        ans.append(1)
    elif ranked[-1] == p:
        ans.append(len(ranked))
    else:
        ans.append(len(ranked)+1)

return ans

vector result; size_t r_ind = 0; int place = 0; result.resize(player.size());

for (size_t p_ind = player.size(); p_ind-- > 0;) {
    int old_ranked = -1;
    while (r_ind < ranked.size() && ranked[r_ind] > player[p_ind]) {
        if (old_ranked != ranked[r_ind]) {
            place++;
        }
        old_ranked = ranked[r_ind];
        r_ind++;
    }
    result[p_ind]= place + 1;
}
return result;

vector result; size_t r_ind = 0; int place = 0; result.resize(player.size());

for (size_t p_ind = player.size(); p_ind-- > 0;) {
    int old_ranked = -1;
    while (r_ind < ranked.size() && ranked[r_ind] > player[p_ind]) {
        if (old_ranked != ranked[r_ind]) {
            place++;
        }
        old_ranked = ranked[r_ind];
        r_ind++;
    }
    result[p_ind]= place + 1;
}
return result;

JAVA15; import java.io.; import java.util.; import java.util.stream.*; import static java.util.stream.Collectors.toList;

class Result {

public static List<Integer> climbingLeaderboard(List<Integer> ranked, List<Integer> player) {
    // Remove duplicates and sort in descending order
    List<Integer> uniqueRanked = ranked.stream()
        .distinct()
        .sorted(Comparator.reverseOrder())
        .collect(Collectors.toList());

    List<Integer> result = new ArrayList<>();
    int index = uniqueRanked.size() - 1;

    for (int score : player) {
        while (index >= 0 && score >= uniqueRanked.get(index)) {
            index--;
        }
        result.add(index + 2); // +2 because index is 0-based and we want rank
    }

    return result;
}

}

public class Solution { public static void main(String[] args) throws IOException { BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in)); BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

    int rankedCount = Integer.parseInt(bufferedReader.readLine().trim());
    List<Integer> ranked = Arrays.stream(bufferedReader.readLine().trim().split(" "))
        .map(Integer::parseInt)
        .collect(toList());

    int playerCount = Integer.parseInt(bufferedReader.readLine().trim());
    List<Integer> player = Arrays.stream(bufferedReader.readLine().trim().split(" "))
        .map(Integer::parseInt)
        .collect(toList());

    List<Integer> result = Result.climbingLeaderboard(ranked, player);

    for (Integer rank : result) {
        bufferedWriter.write(rank.toString());
        bufferedWriter.newLine();
    }

    bufferedReader.close();
    bufferedWriter.close();
}

}