Вхідні дані

Список невід’ємних цілих чисел.

Вихідні дані

Найбільше невід’ємне ціле число hтаке, що принаймні hчисла чисел у списку більше або дорівнюють h.

Випробування

[0,0,0,0] -> 0
[12,312,33,12] -> 4
[1,2,3,4,5,6,7] -> 4
[22,33,1,2,4] -> 3
[1000,2,2,2] -> 2
[23,42,12,92,39,46,23,56,31,12,43,23,54,23,56,73,35,73,42,12,10,15,35,23,12,42] -> 20

Правила

Ви можете написати або повну програму, або функцію, і анонімні функції також дозволені. Це код-гольф, тому виграє найменше число байтів. Стандартні лазівки заборонені.

Фон

Ч-індекс являє собою поняття , яке використовується в наукових колах , яка прагне захопити вплив і продуктивність дослідника. Згідно з Вікіпедією, дослідник має індекс h , якщо він або вона опублікував h наукових статей, кожна з яких цитується в інших статтях принаймні h разів. Таким чином, це завдання полягає в обчисленні h-індексу зі списку посилань.

Оновлення

Нічого собі, чудові відповіді на всі сторони! Я прийняв найкоротший, але якщо хтось придумає ще коротший, я відповідно оновлюю свій вибір.

Переможці за мовою

Ось таблиця переможців за мовою, яку я також намагатимусь бути в курсі. Я включив усі повідомлення з негативною оцінкою. Будь ласка, виправте мене, якщо я тут помилився.

• APL : 7 байт від @MorisZucca
• Bash + coreutils : 29 байт від @DigitalTrauma
• C # : 103 байти від @ LegionMammal978
• C ++ : 219 байт від @ user9587
• CJam : 15 байт від @nutki
• GolfScript : 13 байт від @IlmariKaronen
• Haskell : 40 байт від @proudhaskeller
• J : 12 байт від @ ɐɔıʇǝɥʇuʎs
• Java : 107 байт від @Ypnypn
• JavaScript : 48 байт від @ edc65
• Mathematica : 38 байт від @ kukac67
• Perl : 32 байти від @nutki
• Pyth : 10 байт від @isaacg
• Python : 49 байт від @feersum
• R : 29 байт від @MickyT
• Ruby : 41 байт від @daniero
• Скала : 62 байти від @ChadRetz
• SQL : 83 байти від @MickyT
• TI-BASIC : 22 байти від @Timtech

APL 7

+/⊢≥⍋∘⍒

Можна спробувати в Інтернеті на tryapl.org

f←+/⊢≥⍋∘⍒
f¨(4⍴0)(12 312 33 12)(⍳7)(22 33 1 2 4)(1000 2 2 2)(23 42 12 92 39 46 23 56 31 12 43 23 54 23 56 73 35 73 42 12 10 15 35 23 12 42)
0 4 4 3 2 20

Пітона, 52

f=lambda s,n=0:n<sum(n<x for x in s)and f(s,n+1)or n

Рекурсивне рішення. Виконайте це в Stackless Python, якщо турбуєтесь про переливи.

Починаючи з n=0, перевіряє, чи є хоча б n+1числа n+1. Якщо так, збільшується nі починається знову. Якщо ні, виводи n.

Умовно робиться за допомогою короткого замикання Python для булевих. Вираз sum(n<x for x in s)підраховує кількість значень, sщо перевищують nдодавання індикатора булевих, які трактуються як 0або 1.

Для порівняння, ітеративний еквівалент на 2 символи довший. Для цього потрібен Python 2.

s=input()
n=0
while n<sum(n<x for x in s):n+=1
print n

На жаль, вхід потрібно зберегти для змінної, перш ніж переглядати інакше, інакше Python буде намагатися прочитати вхід кілька разів.

Pyth, 13 10 байт

tf<l-QUTT1

Введіть таку форму, як [22,33,1,2,4]на STDIN.

Спробуйте тут.

Як це працює:

-QUTце все числа на вході ( Q) , по крайней мере , як великий , як число перевіряється, T.

<l-QUTTвірно, якщо довжина цього списку менше T.

f<l-QUTT1знаходить перше ціле число, яке повертає істинне для внутрішньої перевірки, починаючи з 1і піднімаючись.

tf<l-QUTT1 декременти, що по одному, даючи найбільше значення, для якого умова хибна, що є h-індексом.

Починаючи з 1 гарантує 0повернення, коли тест завжди відповідає дійсності, як, наприклад, у першому тестовому випадку.

Пітон 2, 49

Введення має бути введено у тому ж форматі, що і приклади.

i=0
for z in sorted(input())[::-1]:i+=z>i
print i

CJam, 15 байт

Прямий переклад мого рішення Perl.

l~{~}${W):W>},,

J ( 13 12)

[:+/i.@#<\:~

Досить схоже на рішення випадкових випадків. Демонстрація:

   f=:[:+/i.@:#<\:~
   f 0,0,0,0
0
   f 12,312,33,12
4
   f 1,2,3,4,5,6,7
4
   f 22,33,1,2,4
3
   f 1000,2,2,2
2
   f 23,42,12,92,39,46,23,56,31,12,43,23,54,23,56,73,35,73,42,12,10,15,35,23,12,42
20

Математика, 44 42 40 38 байт

Анонімні функції:

LengthWhile[i=0;SortBy[#,-#&],#>i++&]&

Запустіть його, позначивши вхід до кінця так:

In: LengthWhile[i=0;SortBy[#,-#&],#>i++&]&@{1,2,3,4,5,6,7}
Out: 4

SQL, 81 94 83

Давши таблицю (I) значень (V), наступний запит поверне h. Тестується в PostgreSQL і також буде працювати в SQL Server. Редагувати Зробити повернення 0, а не NULL. Зроблено краще з COUNT, дякую @nutki

SELECT COUNT(R)FROM(SELECT ROW_NUMBER()OVER(ORDER BY V DESC)R,V FROM I)A WHERE R<=V

SQLFiddle приклад

По суті він нумерує рядки за низхідним сортом значень. Потім він повертає максимальний номер рядка, де число рядка більше, ніж дорівнює значенню.

R, 39 35 29

s=sort(i);sum(s>=length(s):1)

Дано вектор цілих чисел у i та використовує логіку зворотного сортування, а потім повертає довжину вектора, де число елементів менше s. Дякуємо @plannapus за приємну пораду.

> i=c(23,42,12,92,39,46,23,56,31,12,43,23,54,23,56,73,35,73,42,12,10,15,35,23,12,42)
> s=sort(i);length(s[s>=length(s):1])
[1] 20
> i=c(0,0,0,0)
> s=sort(i);length(s[s>=length(s):1])
[1] 0

CJam, 23 байти

l~:I,),W%{_If>:!:+>}$0=

Це сприймає список як масив на STDIN, як

[23 42 12 92 39 46 23 56 31 12 43 23 54 23 56 73 35 73 42 12 10 15 35 23 12 42]

Перевірте це тут.

Ви можете використовувати це для запуску всіх тестових випадків:

[0 0 0 0]
[12 312 33 12]
[1 2 3 4 5 6 7]
[22 33 1 2 4]
[1000 2 2 2]
[23 42 12 92 39 46 23 56 31 12 43 23 54 23 56 73 35 73 42 12 10 15 35 23 12 42]]
{:I,),W%{_If>:!:+>}$0=N}/

Пояснення

l~:I,),W%{_If>:!:+>}$0=
l~:I                    "Read input, evaluate, store in I.";
    ,                   "Get length of input N.";
     ),W%               "Create range from 0 to N, reverse.";
         {         }$   "Sort stably.";
          _I            "Duplicate candidate h, push input list.";
            f>          "Map each number to 1 if it's less or 0 otherwise.";
              :!        "Invert all results.";
                :+      "Sum them up.";
                  >     "Check if the sum is less than the candidate h.";
                     0= "Pick the first element.";

Логіка трохи назад, але це зберегло пару байтів. В основному, блок пройшов для сортування повернень 0для дійсних кандидатів та в 1іншому випадку. Тож дійсні кандидати виходять першими у відсортованому масиві. І оскільки сорт стабільний, і ми починаємо зі списку від N вниз до 1, це поверне найбільший дійсний h.

Perl 5: 32 (30 + 2 для -pa)

#!perl -pa
$_=grep$_>$i++,sort{$b<=>$a}@F

Займає розділений пробілом вхід на STDIN:

perl hidx.pl <<<'1 2 3 4 5 6 7'

Пітон (63)

В основному це прямий порт мого рішення J. Очевидно, набагато довше, як можна було б собі уявити.

lambda x:sum(a>b for a,b in zip(sorted(x)[::-1],range(len(x))))

Хаскелл, 40

f s=[x-1|x<-[1..],x>sum[1|r<-s,r>=x]]!!0

при цьому пошук першого номера не відповідає схемі і повертає його попередника.

Рубін 44 41

Рекурсивна, більш-менш така ж стратегія, як xnor's Python:

f=->a,n=0{a.count{|x|x>n}<n+1?n:f[a,n+1]}

Рубін 52

Нерекурсивні:

f=->a{a.size.downto(0).find{|x|a.count{|y|y>=x}>=x}}

"Стабільні" лямбда / анонімні функції потребують Ruby 1.9 або новіших. Дзвоніть, наприкладf[[22,33,1,2,4]]

Bash + coreutils, 29

sort -nr|nl -s\>|bc|grep -c 0

Вхідні дані, взяті зі stdin, як новий розділений список.

• sort цілі числа у порядку зменшення
• nl префіксів кожного рядка з його номером рядка на основі 1, відокремлюючи номер рядка та решту рядка на більший, ніж на >
• Арифметично оцінюйте кожен рядок за допомогою bc. Цілі числа, менші за номер рядка, призводять до 0. В іншому випадку 1.
• grepпідраховує кількість 0s, тобто кількість цілих чисел, що перевищує або дорівнюєh

Приклад

$ for i in {23,42,12,92,39,46,23,56,31,12,43,23,54,23,56,73,35,73,42,12,10,15,35,23,12,42}; do echo $i; done | ./atleasth.sh
20
$ for i in {1,2,3,4,5,6,7}; do echo $i; done | ./atleasth.sh
4
$ 

JavaScript (ES6) 48

Рекурсивне рішення.

F=(l,h=-1)=>l.filter(v=>v>h).length>h?F(l,h+1):h

Тест в консолі FireFox / FireBug

;[
  [0,0,0,0],
  [12,312,33,12],
  [1,2,3,4,5,6,7],
  [22,33,1,2,4],
  [1000,2,2,2],
  [23,42,12,92,39,46,23,56,31,12,43,23,54,23,56,73,35,73,42,12,10,15,35,23,12,42]
 ].forEach(l=>console.log(l,F(l)))

Вихідні дані

[0, 0, 0, 0] 0
[12, 312, 33, 12] 4
[1, 2, 3, 4, 5, 6, 7] 4
[22, 33, 1, 2, 4] 3
[1000, 2, 2, 2] 2
[23, 42, 12, 92, 39, 46, 23, 56, 31, 12, 43, 23, 54, 23, 56, 73, 35, 73, 42, 12, 10, 15, 35, 23, 12, 42] 20

Java 8, 116 байт.

Повний клас:

import java.util.*;
import java.util.stream.*;

class H{

    public static void main(String[]a){
        System.out.println(new H().f(Stream.of(a[0].split(",")).mapToInt(Integer::parseInt).toArray()));
    }

    int i;

    int f(int[]n){
        Arrays.sort(n);
        i=n.length;
        Arrays.stream(n).forEach(a->i-=a<i?1:0);
        return i;
    }
}

Функція:

import java.util.*;int i;int f(int[]n){Arrays.sort(n);i=n.length;Arrays.stream(n).forEach(a->i-=a<i?1:0);return i;}}

APL, 12 символів

(+/⊢≥⍒)⊂∘⍒⌷⊢

C ++ 815 219 від (wc -c main.cpp)

Добре ось ось найгірший код, який я коли-небудь писав! :)

#include <iostream>
#include <list>
using namespace std;int main(int c,char** v){list<int>n(--c);int h=c;for(int&m:n)m=atoi(*(v+(h--)));n.sort();for(auto r=n.rbegin();r!=n.rend()&&*r++>++h;);cout<<(h==c?h:--h)<<endl;}

Желе, 6 байт

NỤỤ<’S

Пояснення:

N           Negate (so that repeated elements won't mess up the second grade down)
 Ụ          Grade down
  Ụ         Twice.
   <’       Predicate, check for each element if the new one (after grading) is lower than original array (minus 1 on each element)
     S      Sum

CJam, 22 байти

q~:Q,),{Q{1$>},,>!},W=

Список приймає як вхідний:

[23 42 12 92 39 46 23 56 31 12 43 23  54 23 56 73 35 73 42 12 10 15 35 23 12 42]

Вихід:

20

Спробуйте тут

GolfScript, 13 байт

$-1%0\{1$>+}/

Перевірте цей код в Інтернеті. ¹

Приймає введення як масив стека. Використовується той же алгоритм, що і рішення Python feersum , ітерація над числами в масиві та збільшення кількості лічильника від 0 до тих пір, поки він не дорівнює або перевищить поточний елемент масиву.

^{1) Здається, що онлайн-сервер GolfScript знову відчуває випадкові таймаути. Якщо у вас програма вичерпана, спробуйте її повторно запустити.}

TI-BASIC, 22 байти

Представлення ASCII:

Input L1:1:While Ans≤sum(Ans≥L1:Ans+1:End:Ans

Шістнадцятковий дамп:

DC 5D 00 3E 31 3E D1 72 6D B6 72 6C 5D 00 3E 72 70 31 3E D4 3E 72

Показує список як вхідний. Починаючи з Ans = 0, перевіряє, чи принаймні Ans + 1 з чисел принаймні Ans + 1. Якщо так, збільшуйте Ans і петлі знову. Якщо ні, виводить Ans.

JAGL Alpha 1.2 - 14

Не зараховується, оскільки функція зворотного масиву "C" була додана після запитання, але я все одно відповідаю на задоволення.

Передбачає, що масив є першим елементом у стеку, і ставить відповідь у верхній частині стека.

0SJC{Sd@>+1}/S

Для друку просто додайте Pв кінці, додаючи байт.

Пояснення:

0               Push the number 0 (the counter)
 SJC            Swap to array, sort and reverse
    {Sd@>+1}/   For each item in the array, add 1 to counter if counter is less than item
             S  Swap counter to top of stack

J, 15 11 символів

(Поточне найкоротше рішення J).

   [:+/#\<:\:~

   ([:+/#\<:\:~) 1 2 3 4 5 6 7
4

Порівняє <:відсортовані \:~елементи списку з 1..n + 1 #\і підраховує справжні порівняння +/.

Тестування подібності з іншими J-рішеннями на 100 випадкових тестових випадках:

   */ (([:+/#\<:\:~) = ([:+/i.@#<\:~))"1 ?100 100$100
1

Reng v.3.2, 43 байти

1#xk#yaïí'1ø ~n-1$\
1+)x(%:1,%1ex+y1-?^#y#x

Спробуйте тут! Цей код можна розділити на три частини: початкову, обчислювальну та заключну.

Початкові

1#xk#yaïí'1ø

Це зберігає 1до x, довжину вхідного стека kдо y, і отримує весь вхід ( aïí), який потім сортується ( '). 1øпереходить до наступного рядка, тобто до наступної частини.

Обчислювальна

1+)x(%:1,%1ex+y1-?^#y#x

Reng не має вбудованого для нерівності. Таким чином, алгоритм повинен бути реалізований. Найкоротший алгоритм, який я знайшов, - a < bце %:1,%1e; це виглядає приблизно так:

Command | Stack
  ---   | a, b
   %    | a/b
   :    | a/b, a/b
   1    | a/b, a/b, 1
   ,    | a/b, (a/b)%1
   e    | (a/b) == ((a/b)%1)

Я впевнений, що очистив це! Дозвольте пояснити далі. x % 1, тобто модуль з 1, відображається xна (-1,1). Ми знаємо, що (a/b) % 1це a/bколи a < b. Таким чином, цей вираз дорівнює a < b.

Однак це працює не так добре через проблеми з модулем з нулем. Отже, ми нарощуємо кожного члена стека та лічильника спочатку.

Після того, як ми отримаємо нерівність Boolean на стеці, x+додаємо її до x, але залишаємо її на стеці на даний момент. y1-декременти y, і ?^йде вгору iff, y == 0і ми переходимо до завершальної фази. В іншому випадку, ми поміщаємо y-1в yі новому xв x.

Фінал

             ~n-1$\

Це вискакує залишок y-1із стека, зменшує результат, виводить його та закінчує програму.

05AB1E , 5 байт

{Rā@O

Спробуйте в Інтернеті! або як тестовий набір

Пояснення

{R      # sort descending
  ā@    # check each element if it's greater than or equal to its 1-based index
    O   # sum

Математика, 57 байт

FirstCase[Range[Length@#,0,-1],h_/;Count[#,k_/;k>=h]>=h]&

Це анонімна функція, яка бере список і повертає ціле число, наприклад

FirstCase[Range[Length@#,0,-1],h_/;Count[#,k_/;k>=h]>=h]&@{1,2,3,4,5,6,7}

Використовуйте це для перевірки всіх тестових випадків:

FirstCase[Range[Length@#,0,-1],h_/;Count[#,k_/;k>=h]>=h]& /@ {
  {0, 0, 0, 0},
  {12, 312, 33, 12},
  {1, 2, 3, 4, 5, 6, 7},
  {22, 33, 1, 2, 4},
  {1000, 2, 2, 2},
  {23, 42, 12, 92, 39, 46, 23, 56, 31, 12, 43, 23, 54, 23, 56, 73, 35,
    73, 42, 12, 10, 15, 35, 23, 12, 42}
}

C #, 103

Анонімна функція.

a=>{try{return a.OrderBy(b=>-b).Select((b,c)=>new{b,c}).First(b=>b.b<b.c+1).c;}catch{return a.Length;}}

Відступ:

a =>
{
    try
    {
        return a.OrderBy(b => -b).Select((b, c) => new { b, c }).First(b => b.b < b.c + 1);
    }
    catch
    {
        return a.Length;
    }
}

Скала, 62

def h(a:Int*)=Range(a.size,-1,-1).find(b=>a.count(b<=)>=b).get