HackerRank Climbing the Leaderboard Solution

#include<stdio.h>
struct scoreranks
{
    long int score,rank;
};
long int search(struct scoreranks arr[],long int l,long int r,long int no)
{
    if(l<=r)
    {

        long int m=l+(r-l)/2;
        if(arr[m].score<=no)
            return search(arr,l,m-1,no);
        else
            return search(arr,m+1,r,no);
    }
    else
        return l;
}
int main()
{
    long int n,m,i;

    scanf("%ld",&n);
    long int scores[n],l;
    struct scoreranks scorerank[n];
    for(i=0;i<n;i++)scanf("%ld",&scores[i]);
    scanf("%ld",&m);
    long int alice[m];
    for(i=0;i<m;i++)scanf("%ld",&alice[i]);
    l=0;
    scorerank[l].score=scores[0];
    scorerank[l].rank=1;
    long int rank=1;
    for(i=1;i<n;i++)
    {
        if(scores[i]!=scores[i-1])
        {
            rank++;l++;
            scorerank[l].score=scores[i];
            scorerank[l].rank=rank;
        }
    }
    for(i=0;i<m;i++)
    {
        long int loc=search(scorerank,0,l,alice[i]);
        printf("%ld\n",loc+1);
    }

    return 0;

}

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
vector<pair<int, int> > vp;

inline int find_rank(int score) {
    int lf = 0, rf = vp.size() - 1;
    while (lf <= rf) {
        int mid = (lf + rf) / 2;
        if (vp[mid].first == score) return vp[mid].second;
        if (vp[mid].first > score) lf = mid + 1;
        else rf = mid - 1;
    }
    return vp[rf].second + 1;
}
int main() {
    int n; cin >> n;
    vp.reserve(n);
    int last_rank = 0, last_score = 2000000000;
    for (int i = 0; i < n; ++i) {
        int x; cin >> x;
        if (x != last_score) ++last_rank;
        last_score = x;
        vp.push_back(make_pair(last_score, last_rank));
    }
    int m; cin >> m;
    while (m--) {
        int x; cin >> x;
        cout << find_rank(x) << '\n';
    }
    return 0;
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

class Solution {
    
    static Solution()
    {
        var inputBuffer = new byte[1048576];
        var inputStream = Console.OpenStandardInput(inputBuffer.Length);
        Console.SetIn(new StreamReader(inputStream, Console.InputEncoding, false, inputBuffer.Length));        
    }
    
    static void Main(String[] args) {
        var n = Convert.ToInt32(Console.ReadLine());
        var scores = Console.ReadLine().Split(' ').Select(x => Convert.ToInt32(x)).Distinct().ToArray();
        var m = Convert.ToInt32(Console.ReadLine());
        var alice = Console.ReadLine().Split(' ').Select(x => Convert.ToInt32(x)).ToArray();
        
        var aliceScore = 0;
        
        var p = scores.Length-1;
        
        for(var i = 0; i < m; i++)
        {
            var rank = scores.Length-1;

            while (p >= 0 && alice[i] > scores[p]) p--;

            if (p == -1) 
            {
                rank = 1;
            }
            else if (alice[i] == scores[p]) 
            {
                rank = p + 1;
            }
            else if (alice[i] < scores[p]) 
            {
                rank = p + 2;
            }
            
            Console.WriteLine(rank);
        }
    }
}

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] scores = new int[n];
        int[] ranks = new int[n]; //The dense ranking of the scores
        
        //Initialize dense ranking and scores
        for(int i=0, rank=1; i < n; i++){
            int s = in.nextInt();
            scores[i] = s;
            if(i > 0 && scores[i-1] != s)
                rank++;
            ranks[i] = rank;    
        }
        
        //Interate over Alice's level scores
        //int level = 0;
        int aliceRank = ranks[ranks.length-1] + 1; //Set it to worst rank+1
        int leaderboardIndex = n-1;
        int m = in.nextInt();
        
        int prevScore = -1; //Last score we saw
        
        for(int aliceScores=0; aliceScores < m; aliceScores++)
        {
            int levelScore = in.nextInt();
        
            //We iterate 1 past the front of the array incase we are greater than the best score
            for(int i = leaderboardIndex; i >= -1; i--)
            {
                if(i < 0 || scores[i] > levelScore)
                {
                    System.out.println(aliceRank);
                    break;
                }
                else if(scores[i] < levelScore)
                {
                    if(scores[i] != prevScore)//We have went up a ranking
                    {
                        aliceRank--;    
                    }
                    leaderboardIndex--;
                }
                else//scores[i] == alice[level]
                {
                    leaderboardIndex--;
                    aliceRank = ranks[i];
                }
                prevScore = scores[i];
            }
        }
    }
}

process.stdin.resume();
process.stdin.setEncoding('ascii');

var input_stdin = "";
var input_stdin_array = "";
var input_currentline = 0;

process.stdin.on('data', function (data) {
    input_stdin += data;
});

process.stdin.on('end', function () {
    input_stdin_array = input_stdin.split("\n");
    main();    
});

function readLine() {
    return input_stdin_array[input_currentline++];
}

/////////////// ignore above this line ////////////////////

function main() {
    var n = parseInt(readLine());
    scores = readLine().split(' ');
    scores = scores.map(Number);
    var m = parseInt(readLine());
    alice = readLine().split(' ');
    alice = alice.map(Number);
    
    const ranks = [];
    for (let i = 0; i < n; i++) {
        if (!ranks.length || scores[i] < ranks[ranks.length - 1]) ranks.push(scores[i]);
    }
    
    console.log(alice.map(a => insertPosition(ranks, a) + 1).join('\n'));
}
    
function insertPosition(arr, el) {
    const n = arr.length;
    let low = 0;
    let high = n - 1;
    let i = -1;
    while (low < high) {
        const mid = Math.floor((low + high) / 2);
        i = mid;
        if (el > arr[mid]) {
            high = mid;
        } else if (el < arr[mid]){
            low = mid + 1;
        } else {
            return i;
        }
    }
    return arr[low] > el ? low + 1 : low;
}

#!/bin/python3

import sys

n = int(input().strip())
scores = [int(scores_temp) for scores_temp in input().strip().split(' ')]
m = int(input().strip())
alice = [int(alice_temp) for alice_temp in input().strip().split(' ')]

scores = list(set(scores))
scores.sort()
rank = len(scores)+1
pos = 0
for x in alice:
    while pos != len(scores) and x >= scores[pos]:
        rank -= 1
        pos += 1
    print(rank)