H Index

                                            
class Solution {
public:
    int hIndex(vector<int>& citations) {
        sort(citations.begin(), citations.end(), greater<int>());
        for (int i = 0; i < citations.size(); ++i) {
            if (i >= citations[i]) {
                return i;
            }
        }
        return citations.size();
    }
};

                                            
class Solution {
    public int hIndex(int[] citations) {
        Arrays.sort(citations);
        int hIndex = 0;
        for (int i = 0; i < citations.length; i++) {
            int count = citations.length - i;
            if (citations[i] >= count) {
                hIndex = Math.max(hIndex, count);
            }
        }
        return hIndex;
    }
}

                                            
class Solution(object):
    def hIndex(self, citations):
        citations.sort(reverse=True)
        i = 0
        while i < len(citations) and citations[i] > i:
            i += 1
        return i

                                            
public class Solution {
    public int HIndex(int[] citations) {
        Array.Sort(citations);
        int n = citations.Length;
        for (int i = 0; i < n; i++) {
            if (citations[i] >= n - i) {
                return n - i;
            }
        }
        return 0;
    }
}

                                            
/**
 * @param {number[]} citations
 * @return {number}
 */
const hIndex = (citations) => {
    citations.sort((a, b) => b - a);
    let hIndex = 0;
    
    for (let i = 0; i < citations.length; i++) {
        if (citations[i] >= i + 1) {
            hIndex = i + 1;
        } else {
            break;
        }
    }
    
    return hIndex;
};

                                            
function hIndex(citations: number[]): number {
    citations.sort((a, b) => b - a);
    let hIndex = 0;
    for (let i = 0; i < citations.length; i++) {
        if (citations[i] > hIndex) {
            hIndex++;
        } else {
            break;
        }
    }
    return hIndex;
};

                                            
class Solution {
    /**
     * @param Integer[] $citations
     * @return Integer
     */
    function hIndex($citations) {
        sort($citations);
        $n = count($citations);
        $left = 0;
        $right = $n - 1;
        $hIndex = 0;
        
        while($left <= $right) {
            $mid = $left + intval(($right - $left) / 2);
            if($citations[$mid] >= $n - $mid) {
                $hIndex = $n - $mid;
                $right = $mid - 1;
            } else {
                $left = $mid + 1;
            }
        }
        
        return $hIndex;
    }
}

                                            
class Solution {
    func hIndex(_ citations: [Int]) -> Int {
        let n = citations.count
        var bucket = Array(repeating: 0, count: n + 1)
        
        for citation in citations {
            if citation >= n {
                bucket[n] += 1
            } else {
                bucket[citation] += 1
            }
        }
        
        var count = 0
        for i in stride(from: n, through: 0, by: -1) {
            count += bucket[i]
            if count >= i {
                return i
            }
        }
        
        return 0
    }
}

                                            
class Solution {
    fun hIndex(citations: IntArray): Int {
        citations.sort()
        var hIndex = 0
        var i = 0
        while (i < citations.size && citations[citations.size - 1 - i] > i) {
            hIndex++
            i++
        }
        return hIndex
    }
}

                                            
class Solution {
  int hIndex(List<int> citations) {
    citations.sort((a, b) => b - a);
    int h = 0;
    for (int i = 0; i < citations.length; i++) {
      if (citations[i] > h) {
        h++;
      } else {
        break;
      }
    }
    return h;
  }
}

                                            
func hIndex(citations []int) int {
    n := len(citations)
    count := make([]int, n+1)
    
    for _, c := range citations {
        if c >= n {
            count[n]++
        } else {
            count[c]++
        }
    }
    
    total := 0
    for i := n; i >= 0; i-- {
        total += count[i]
        if total >= i {
            return i
        }
    }
    
    return 0
}

                                            
# @param {Integer[]} citations
# @return {Integer}
def h_index(citations)
    citations.sort!
    n = citations.length
    h = 0
    
    for i in 0...n
        if citations[i] >= n - i
            return n - i
        end
    end
    
    return h
end

                                            
object Solution {
    def hIndex(citations: Array[Int]): Int = {
        citations.sortWith(_ > _).zipWithIndex.foldLeft(0)((hIndex, citation) => {
            val (c, i) = citation
            if (c >= i + 1) Math.max(hIndex, i + 1) else hIndex
        })
    }
}

                                            
impl Solution {
    pub fn h_index(citations: Vec<i32>) -> i32 {
        let n = citations.len();
        let mut count = vec![0; n + 1];

        for &citation in &citations {
            if citation >= n as i32 {
                count[n] += 1;
            } else {
                count[citation as usize] += 1;
            }
        }

        let mut sum = 0;
        for i in (0..=n).rev() {
            sum += count[i];
            if sum >= i {
                return i as i32;
            }
        }

        0
    }
}

                                            
-spec h_index(Citations :: [integer()]) -> integer().
h_index(Citations) ->
    lists:last([H || H <- lists:seq(0, length(Citations)), H =< lists:sum([1 || C <- Citations, C >= H])]).

To solve this coding challenge, we need to determine the researcher's h-index based on the number of citations each of their papers has received. The h-index is the maximum value \( h \) such that the researcher has at least \( h \) papers that have been cited \( h \) times or more.

Explanation

The challenge requires us to find the h-index, which indicates the number of papers \( h \) that have been cited at least \( h \) times each. The process can be broken down into the following detailed steps:

Sort the Citations in Descending Order : By sorting the citation counts from highest to lowest, we can more easily determine how many papers meet the requirement for a certain h-index.
Iterate Through the Sorted Citations : We will iterate through the sorted list and keep a count of the papers to determine the highest h-index that satisfies the condition.
Track the Current Index : During the iteration, we will use an index tracker to determine if the number of citations is greater than the current index (which represents the potential h-index).

By following these steps, we can efficiently compute the h-index in \( O(n \log n) \) due to the sorting step.

Detailed Steps in Pseudocode

Sort the citation array in descending order
Initialize an index counter at 0
Iterate through the sorted array while the citation count at the current index is greater than the index itself :

Increment the index counter by 1

Return the index counter as the h-index

Pseudocode

                                            
# Function to calculate h-index
function compute_h_index(citations):
# Step 1: Sort the array in descending order
sort citations in descending order

# Step 2: Initialize the index counter
index_counter = 0

# Step 3: Iterate through the sorted citations
while index_counter < length of citations and citations[index_counter] > index_counter:
# Increment the index counter if the condition is met
index_counter = index_counter + 1

# Step 4: Return the index counter as the h-index
return index_counter

Breakdown of the Pseudocode:

Sort the array in descending order :

This ensures that we start by considering the papers with the highest number of citations, making it easier to find the maximum value of \( h \).

                                            
sort citations in descending order

Initialize an index counter :

We start by setting the index counter (which acts as our h-index candidate) to 0.

                                            
index_counter = 0

Iterate through the array :

We use a
while

loop to traverse the sorted citation list. The loop continues as long as the current citation count is greater than the index counter. This ensures we only consider valid h-indices.

                                            
while index_counter < length of citations and citations[index_counter] > index_counter:
# If the condition is satisfied, increment the index counter
index_counter = index_counter + 1

Return the index counter :

Once the loop terminates, the value of the index counter will be the highest h-index satisfying the condition.

                                            
return index_counter

Using this methodology, we can efficiently determine the h-index for a given list of citation counts. The sorting step ensures that we consider the highest citation counts first, allowing us to find the maximum h-index quickly.