def climbingLeaderboard(ranked, player):
    ranked = list(set(ranked))
    scores = []
    length = len(ranked)
    
    player.reverse() # We use reversed list, we basically want the ranked and player arrays in the same order.
    matched = {}
    current_rank = 0
    for i in player:

        if matched.get(i, None): # remove duplicated computations.
            scores.append(matched[i])
            continue

        if current_rank >= length: # in last elements, it is likely to rank as last. 
            scores.append(current_rank + 1)
            continue

        if i > ranked[current_rank] or i == ranked[current_rank]: # if score is higher than current rank, assign the rank.
            matched[i] = current_rank + 1
            scores.append(current_rank + 1)
        else: # if it is lesser, we need an iteration since it is getting higher than current_rank. In short, we skip unnecessary parts. This is the optimization part.
            while current_rank < length and i < ranked[current_rank]:
                current_rank += 1
            matched[i] = current_rank + 1
            scores.append(current_rank + 1)
    scores.reverse() # we have reversed the player list, so we need to reverse scores.
    print(scores)
    return scores

function climbingLeaderboard(ranked: number[], player: number[]): number[] {
  const rankedSet = Array.from(new Set(ranked)).reverse();
  const playerRank: number[] = [];

  let lastIndex = 0;

  player.forEach((score) => {
    for (let i = lastIndex; i < rankedSet.length; i++) {
      if (score < rankedSet[i]) {
        playerRank.push(rankedSet.length - i + 1);
        lastIndex = i;
        break;
      } else if (i === rankedSet.length - 1) {
        playerRank.push(1);
      }
    }
  });

  return playerRank;
}

vector<int> climbingLeaderboard(vector<int> ranked, vector<int> player) {
    vector<int> 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;
}