入力

非負の整数のリスト。

出力

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を持っています。したがって、この課題は、引用カウントのリストからh-indexを計算することです。

更新

うわー、すべてのラウンドで素晴らしい回答！私は最短のものを受け入れましたが、他の誰かがさらに短いものを思いついたら、それに応じて選択を更新します。

言語別の受賞者

以下に、言語別の受賞者の表を示します。これもまた、最新の状態に保つよう努めます。非負のスコアを持つすべての投稿を含めました。ここで間違えた場合は修正してください。

• APL：@MorisZuccaによる7バイト
• Bash + coreutils：@DigitalTraumaによる29バイト
• C＃：@ LegionMammal978による103バイト
• C ++：@ user9587による219バイト
• CJam：@nutkiによる 15バイト
• GolfScript：@IlmariKaronenによる13バイト
• Haskell：@proudhaskellerによる40バイト
• J：@ɐɔıʇǝɥʇuʎsによる12バイト
• Java：@Ypnypnによる107バイト
• JavaScript：@ edc65による48バイト
• Mathematica：@ kukac67による38バイト
• Perl：@nutkiによる32バイト
• Pyth：@isaacgによる 10バイト
• Python：@feersumによる49バイト
• R：@MickyTによる29バイト
• Ruby：@danieroによる41バイト
• Scala：@ChadRetzによる62バイト
• SQL：@MickyTによる83バイト
• TI-BASIC：@Timtechによる22バイト

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

Python、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数字の少なくとも1つであるかどうかをチェックしますn+1。その場合、増分nして再起動します。そうでない場合は、を出力しますn。

条件はPythonのブールの短絡を使用して行われます。この式sum(n<x for x in s)は、またはとして扱われるインジケーターブール値を追加することにより、sより大きい値の数をカウントします。n01

比較のために、同等の反復は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そのリストの長さが未満の場合はtrueですT。

f<l-QUTT1内部チェックでtrueを返す最初の整数を見つけます1。

tf<l-QUTT1 それを1つ減らし、条件が偽である最大値、つまりh-indexを与えます。

1から開始すると0、最初のテストケースのように、テストが常にtrueのときに返されることが保証されます。

Python 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.@#<\:~

randomraのソリューションにかなり似ています。デモンストレーション：

   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

Mathematica、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

値（V）のテーブル（I）を指定すると、次のクエリはhを返します。PostgreSQLでテストされており、SQL Serverでも動作します。 編集 NULLではなく0を返すようにします。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の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です。
• grep0s の数、つまり以上の整数の数をカウントします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（WC -C main.cppに）から219

さて、これまでに書いた中で最悪のコードをいくつか紹介します！:)

#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$>+}/

このコードをオンラインでテストします。¹

スタック上の配列として入力を受け取ります。feersumのPythonソリューションと同じアルゴリズムを使用しますして、配列内の数値を反復処理し、配列の現在の要素以上になるまでカウンターを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は、最後に1バイト追加するだけです。

説明：

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を持つ要素#\とカウント真の比較を+/。

100のランダムテストケースで、他のJソリューションとの類似性をテストします。

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

Reng v.3.2、43バイト

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

ここで試してみてください！このコードは、初期、計算、および最終の3つの部分に分割できます。

初期

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ます。

ただし、モジュラスがゼロの問題があるため、これはあまりうまくいきません。そのため、最初にスタックのすべてのメンバーとカウンターをインクリメントします。

不等式のブール値をスタックで取得した後、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

Mathematica、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;
    }
}

Scala、62

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