/**
 * This assumes arr is sorted in descending order
 */
func binarySearchKey(arr []int32, v int32) int {
    i, j := 0, len(arr)
    for i<j {
        h := int(uint(i+j) >> 1)
        if arr[h] > v {
            i = h+1
        } else {
            j = h
        }
    }
    
    return i
}

func addRank(ranks []int32, scoreIdx int) []int32 {
    return append(ranks, int32(scoreIdx+1))
}

func stripDuplicates(ranked []int32) []int32 {
    j, l := 0, len(ranked)
    for i:=0;i<l;i++ {               
        if i<l-1 && ranked[i] == ranked[i+1] {
            continue
        }
        
        ranked[j] = ranked[i]
        j++
    }
    
    return ranked[:j]
}

func climbingLeaderboard(ranked []int32, player []int32) []int32 {
    var ranks []int32 = make([]int32, 0)
    ranked = stripDuplicates(ranked)
    for _, playerScore := range(player) {
        scoreIdx := binarySearchKey(ranked, playerScore)
        ranks = addRank(ranks, scoreIdx)
    }
    
    return ranks
}

int* climbingLeaderboard(int ranked_count, int* ranked, int player_count, int* player, int* result_count) {
    int* positions=malloc(ranked_count*sizeof(int));
    positions[0]=1;
    for(int i=0, j=1; i<ranked_count-1&&j<ranked_count; i++, j++){
        if(ranked[j]<ranked[i]) positions[j]=positions[i]+1;
        else positions[j]=positions[i];
    }
    int* res = malloc(player_count*sizeof(int));
    for(int i=0; i<player_count; i++){
        *(res+i)=positions[ranked_count-1];
        for(int j=ranked_count-1; j>=0; j--){
            if(player[i]>=ranked[j]) *(res+i)=positions[j];
            else if(j==ranked_count-1) *(res+i)=positions[j]+1;
        }
        printf("%d\n", res[i]);
    }
    free(positions);
    return res;
}

func climbingLeaderboard(ranked: [Int], player: [Int]) -> [Int] {
    var result: [Int] = []
    var clearRanked: [Int] = [ranked [0]]
    var total = 1
        for rank in ranked {
            if rank == clearRanked.last! {
                continue
            } else {
                clearRanked.append(rank)
                total += 1
            }
        }
    for playerTrial in player {
        if playerTrial >= clearRanked [0] {
            result.append(1)
        } else if playerTrial == clearRanked.last! {
            result.append(total)
        } else if playerTrial < clearRanked.last! {
            result.append(total + 1)
        } else {
            func findTheRankIndex(arr: [Int], rank: Int, range: Range<Int>) -> Int {
                if range.lowerBound > range.upperBound {
                    return range.lowerBound
                } else {
                    let midIndex = range.lowerBound + (range.upperBound - range.lowerBound) / 2
                    if rank == arr [midIndex] {
                        return midIndex + 1
                    } else if rank < arr [midIndex] {
                        if midIndex + 1 < total - 1 &&
                           rank > arr [midIndex + 1] {
                            return midIndex + 2
                        } else {
                            return findTheRankIndex(arr: arr, rank: rank, range: midIndex + 1 ..< range.upperBound)
                        }
                    } else //if rank > arr [midIndex]
                    {
                        if midIndex - 1 > 0 &&
                           rank < arr [midIndex - 1] {
                            return midIndex + 1
                        } else {
                            return findTheRankIndex(arr: arr, rank: rank, range: range.lowerBound ..< midIndex)
                        }
                    }
                }
            }
            result.append(findTheRankIndex(arr: clearRanked, rank: playerTrial, range: 0 ..< total))
            }
        }
    return result
}

import bisect

def climbingLeaderboard(ranked, player):   
    ranked=sorted(list(set(ranked)))
    player.sort()
    ladder=[]
    for p in player:        
        i = bisect.bisect_left(ranked, p)
        if i >= len(ranked):
            i = len(ranked) - 1        
        elif p<ranked[i]:
            i-=1            
        ladder.append(len(ranked)-i)       
    return ladder

let uniqueRanked=[... new Set(ranked)].sort((a,b)=>{return b-a});
    let final=[];
    player.map(e=> {
        let i=0;
        while(i<uniqueRanked.length) {
            if(e>=uniqueRanked[i]) {
                final.push(i+1);
                break;
            }
            i++;
        }
        i==uniqueRanked.length? final.push(uniqueRanked.length+1):0;
        })
        return final
    }