### Problem Statement :

```An arcade game player wants to climb to the top of the leaderboard and track their ranking. The game uses Dense Ranking, so its leaderboard works like this:

The player with the highest score is ranked number 1 on the leaderboard.
Players who have equal scores receive the same ranking number, and the next player(s) receive the immediately following ranking number.

Example
ranked = [100, 90, 90, 80]
player = [70, 80, 105]

The ranked players will have ranks 1, 2, 2, and 3, respectively. If the player's scores are 70, 80 and 105, their rankings after each game are 4th, 3rd and 1st. Return [4, 3, 1].

Function Description

Complete the climbingLeaderboard function in the editor below.

int player[m]: the player's scores

Returns

int[m]: the player's rank after each new score

Input Format

The first line contains an integer n, the number of players on the leaderboard.
The next line contains n space-separated integers ranked[i], the leaderboard scores in decreasing order.
The next line contains an integer, m, the number games the player plays.
The last line contains m space-separated integers player[j], the game scores.

Constraints
1 <= n, m <= 2 * 10^5
0 <= ranked[i], player[j] <= 10^9  for 0 <= i, j < n
The existing leaderboard, ranked, is in descending order.
The player's scores, player, are in ascending order.```

### Solution :

```                            ```Solution in C :

python 3  :

#!/bin/python3

import sys
import bisect

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(sorted(set(scores)))
#print('scores=%s' % scores, file = sys.stderr)
#print('alice=%s' % alice, file = sys.stderr)
aa = [bisect.bisect_right(scores, a) for a in alice]
#print('aa=%s' % aa, file = sys.stderr)
for a in aa:
v = len(scores) + 1 - a
print(v)

Java  :

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
Stack<Integer> scores = new Stack<>();
scores.push(in.nextInt());
for (int i = 1; i < n; i++) {
int cur = in.nextInt();
if (!scores.peek().equals(cur)) scores.push(cur);
}
int m = in.nextInt();
for (int i = 0; i < m; i++) {
int cur = in.nextInt();
while (scores.size() > 0 && cur > scores.peek()) scores.pop();
System.out.println(scores.size() +(scores.size() > 0 && scores.peek().equals(cur) ? 0 : 1));
}
}
}

C++  :

#include <ios>
#include <iostream>
#include <vector>
#include <algorithm>

std::vector<int> vec;

int main()
{
int n, q, v;
std::cin >> n;
for (int i = 0; i < n; i++)
{
std::cin >> v;
vec.push_back(v);
}
std::sort(vec.begin(), vec.end());
vec.resize(std::distance(vec.begin(), std::unique(vec.begin(), vec.end())));
std::cin >> q;
while (q--)
{
std::cin >> v;
std::cout << std::distance(std::upper_bound(vec.begin(), vec.end(), v), vec.end())+1 << '\n';
}
}

C  :

#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>

int main(){
int n;
scanf("%d",&n);
int *scores = malloc(sizeof(int) * n);
for(int scores_i = 0; scores_i < n; scores_i++){
scanf("%d",&scores[scores_i]);
if(scores_i){
if(scores[scores_i]==scores[scores_i-1]){
scores_i--;
n--;
}
}
}
//printf("%d\n",n);//
int m;
scanf("%d",&m);
int *alice = malloc(sizeof(int) * m);
for(int alice_i = 0; alice_i < m; alice_i++){
scanf("%d",&alice[alice_i]);
}
int rank=n;
for(int j=0; j<m; j++){
while(alice[j]>=scores[rank-1] && rank>0){
rank--;
if(rank==0) break;
}
printf("%d\n",rank+1);
}

return 0;
}```
```

## Print the Elements of a Linked List

This is an to practice traversing a linked list. Given a pointer to the head node of a linked list, print each node's data element, one per line. If the head pointer is null (indicating the list is empty), there is nothing to print. Function Description: Complete the printLinkedList function in the editor below. printLinkedList has the following parameter(s): 1.SinglyLinkedListNode

## Insert a Node at the Tail of a Linked List

You are given the pointer to the head node of a linked list and an integer to add to the list. Create a new node with the given integer. Insert this node at the tail of the linked list and return the head node of the linked list formed after inserting this new node. The given head pointer may be null, meaning that the initial list is empty. Input Format: You have to complete the SinglyLink

Given a pointer to the head of a linked list, insert a new node before the head. The next value in the new node should point to head and the data value should be replaced with a given value. Return a reference to the new head of the list. The head pointer given may be null meaning that the initial list is empty. Function Description: Complete the function insertNodeAtHead in the editor below

## Insert a node at a specific position in a linked list

Given the pointer to the head node of a linked list and an integer to insert at a certain position, create a new node with the given integer as its data attribute, insert this node at the desired position and return the head node. A position of 0 indicates head, a position of 1 indicates one node away from the head and so on. The head pointer given may be null meaning that the initial list is e

## Delete a Node

Delete the node at a given position in a linked list and return a reference to the head node. The head is at position 0. The list may be empty after you delete the node. In that case, return a null value. Example: list=0->1->2->3 position=2 After removing the node at position 2, list'= 0->1->-3. Function Description: Complete the deleteNode function in the editor below. deleteNo

## Print in Reverse

Given a pointer to the head of a singly-linked list, print each data value from the reversed list. If the given list is empty, do not print anything. Example head* refers to the linked list with data values 1->2->3->Null Print the following: 3 2 1 Function Description: Complete the reversePrint function in the editor below. reversePrint has the following parameters: Sing