How many bystanders will help? Flavortext
The Bystander Effect is a phenomenon where individuals are less likely to help a victim if other people are present. The idea is that as there are more people around, the individual burden is less, and each individual thinks &quot;someone else will help them&quot;, which results in the counterintuitive fact that fewer people will help when there are more people.
(This is why if you're in public and something bad happens and you / someone else needs help, you should address random individuals (&quot;you in the red shirt&quot;) to help specifically rather than &quot;someone please help&quot; to bypass this psychological phenomenon)
Let's take a very simplified interpretation of this theory and assume everyone has a numerical threshold for helping.
Specification
A list of people will be given, each with a threshold to help. The threat level is 1. A person will help if and only if the threat level divided by the number of people in the crowd is greater than equal to their threshold. When a person decides to help, they leave the crowd. This means that the individual threat, which is the threat level (1) divided by the size of the crowd, is now higher as a result because the crowd is smaller.
The total threat level (1) never changes, for simplicity.
How many people end up helping?
Input
You are given a list of floating point numbers in any reasonable format. This list will be non-empty, and every number will be in the inclusive range from 0 to 1. You may assume the list is sorted in either order you would like.
Output
You are to output a single integer, indicating how many of the individuals decide to help.
Example
Consider the test case 0.2, 0.2, 0.3, 0.6, 0.8. The crowd has five people, so the threat to each individual is 0.2. Therefore, the first two people will help. Now, the crowd is 0.3, 0.6, 0.8. Since there are only three people, the threat to each individual is now 0.3. Therefore, the third person will now decide to help. The crowd is now 0.6, 0.8, so the individual threat is 0.5, and nobody decides to help anymore. Therefore, the final result is 3.
Test Cases
1                        -&gt; 1
0.5, 0.8                 -&gt; 2 # 0.8 initially won't help, but will when 0.5 leaves
0.2, 0.2                 -&gt; 2 # both will help initially
0.2, 0.2, 0.3, 0.6, 0.8  -&gt; 3 # 0.2 and 0.2 leaving prompts 0.3 to help, but the other two won't help
0, 0.25, 0.33, 0.5, 1    -&gt; 5 # all of them help only after the previous person left, starting with 0
0, 0.25, 0.34, 0.34, 1   -&gt; 2 # 0 and 0.25 help, but 0.34 is just a bit too indifferent to help, which means 1 will never help either
0.5, 0.5, 0.5            -&gt; 0 # nobody helps. RIP

Reference Implementation
This implementation (Python) shows the final answer at the very end. It also breaks down the process stage-by-stage.
Jelly,  9 8  7 bytes
(Saved 1 when the assumption of sorted input was allowed, and another realising there was no need to floor the inverses.)
İ&lt;Jṣ1ṪL

A monadic Link accepting a list of floating-point numbers in \$[0,1]\$ sorted in descending order that yields an integer.
Try it online! Or see the test-suite.
How?
Effectively this evaluates how many people need to be in the crowd to stop each person helping, identifies crowd sizes that would be too big for anyone to help if those most likely to help have been removed, then counts those in excess of the biggest of those crowd sizes.
İ&lt;Jṣ1ṪL - Link: list of thresholds, T  e.g. [1, 0.34, .34, .25, 0]
İ       - inverse (T)                       [1, 2.94, 2.94. 4, inf]
  J     - range of length (T)               [1, 2, 3, 4, 5]
 &lt;      - less than?                        [0, 0, 1, 0, 0]
   ṣ1   - split at ones                     [[0, 0], [0, 0]]
     Ṫ  - tail                              [0, 0]
      L - length                            2


Equivalently:
İ&lt;JṚÄċ0
   Ṛ    - reverse                           [0, 0, 1, 0, 0]
    Ä   - cumulative sums                   [0, 0, 1, 1, 1]
     ċ0 - count zeros                       2