We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
  1. Prepare
  2. Algorithms
  3. Implementation
  4. Climbing the Leaderboard
  5. Discussions

Climbing the Leaderboard

Sort by

recency

|

2385 Discussions

|

  • mohammed_abrar_1
     + 0 comments

    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();
}

    }

  • quote_unquote
     + 0 comments
    /*
 * Complete the 'climbingLeaderboard' function below.
 *
 * The function is expected to return an INTEGER_ARRAY.
 * The function accepts following parameters:
 *  1. INTEGER_ARRAY ranked
 *  2. INTEGER_ARRAY player
 */

void _print(const vector<int>& v) {
    for (auto e: v) { cout << e << " "; }
    cout << endl;
}

vector<int> climbingLeaderboard(vector<int> ranked, vector<int> player) {
    vector<int> rx;

    // _print(ranked);
    ranked.erase(
        std::unique(ranked.begin(), ranked.end()),
        ranked.end()
    );
    // _print(ranked);

    for (auto p: player) {
        auto it = lower_bound(ranked.begin(), ranked.end(), p, std::greater<int>());
        auto k = distance(ranked.begin(), it);
        rx.push_back(k+1);
    }

    return rx;
}

  • rezl_jaws
     + 0 comments

    Finally managed to crack it after persevering so many times.. Here is my C++ solution. 1. I have converted the ranking vector to a set , to remove duplicates, thus giving me the actual ranking order, i.e. 1 to size of set 2. I have converted the set back to a vector to get the index position if we were to insert Alice's score, using lower_bound , remember lower_bound returns an iterator past the index 3. I work out potential idices and push them to the res vector. 4. I also check existing items in both ranking/player.. the code follows here..

    vector climbingLeaderboard(vector &ranked, vector player) { vector res;

    set<int> s(ranked.begin(), ranked.end());
vector<int> j(s.begin(), s.end());
int sz_s = j.size();

int idx = 0;
for (auto p : player)
{
    auto iter = lower_bound(j.begin(), j.end(), p);
    idx = iter - j.begin();
    if (*iter == p )
    {
        idx = sz_s - idx;
    }
    else
    {
        idx = sz_s + 1 - idx;
    }
    res.push_back(idx);
}

return res;

    }

  • abyssal_cojode
     + 0 comments
    def climbingLeaderboard(ranked, player):
# Time: O(n + m) where n = len(ranked), m = len(player)
    # Space: O(m) for result storage (excluding input storage)
    # Initialize result list, ranked index (ri), and current rank
    result, ri, rank = [], 0, 1
    
    # Process player scores in reverse order (from highest to lowest)
    for pi in range(len(player) - 1, -1, -1):
        # Find the correct position in the ranked leaderboard for current player score
        while ri < len(ranked) and ranked[ri] > player[pi]:
            current_ranked_score = ranked[ri]
            # Skip all duplicates of the current ranked score
            # Since ranked is in descending order, duplicates are adjacent
            while ri < len(ranked) and current_ranked_score == ranked[ri]:
                ri += 1
            # After skipping duplicates, increment rank (new unique score found)
            rank += 1
        
        # At this point, either:
        # 1. We've exhausted all ranked scores (player score is lowest)
        # 2. Found first ranked score <= player score (correct rank found)
        result.append(rank)
    
    # Reverse results to match original player score order
    return result[::-1]

  • palocko
     + 0 comments

    C# version with binary search:

        public static int FindRankBinary(List<int> data, int value)
    {
        var left = 0;
        var right = data.Count - 1;
        
        while (left < right)
        {
            var mid = Convert.ToInt32(Math.Ceiling((right - left) / (decimal)2) + left);
            
            if (data[mid] == value)
            {
                return mid;
            }
            
            if (mid == right)
            {
                return data[mid] < value ? mid : mid + 1;
            }
                
            if (data[mid] > value)
            {
                left = mid;
            }
            else
            {
                right = mid;
            }
        }
        
        return data.Count;
    }

    public static List<int> climbingLeaderboard(List<int> ranked, List<int> player)
    {
        var result = new List<int>();
        var rankedDeduplicated = new List<int>();
        
        var rank = 0;
        rankedDeduplicated.Add(ranked[0]);
        for (var i = 1; i < ranked.Count; i++)
        {
            if (ranked[i] != ranked[i-1])
            {
                rank++;
                rankedDeduplicated.Add(ranked[i]);   
            }
        }
        
        for (var j = 0; j < player.Count; j++)
        {
            if (player[j] >= ranked[0])
            {
                result.Add(1);
                continue;
            }
            
            result.Add(FindRankBinary(rankedDeduplicated, player[j]) + 1);
        }
        
        return result;
    }