입력

음이 아닌 정수 목록입니다.

산출

목록의 숫자 h중 적어도 하나 이상이 되도록하는 가장 큰 음이 아닌 정수 입니다.hh

테스트 사례

[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-지수는 연구원의 영향과 생산성을 캡처하는 것을 목표로 학계에서 사용되는 개념이다. Wikipedia에 따르면, 연구원은 h 개의 과학 논문 을 출판 한 경우 색인 h 를 가지며 , 각 논문은 적어도 h 번 다른 논문에서 인용되었습니다 . 따라서이 과제는 인용 횟수 목록에서 h- 인덱스를 계산하는 것입니다.

최신 정보

와! 나는 가장 짧은 것을 받아 들였지만 다른 누군가가 더 짧은 것을 내면 그에 따라 내 선택을 업데이트 할 것입니다.

언어 별 수상자

다음은 언어 별 수상자 표입니다. 또한 최신 정보를 제공하려고합니다. 음수가 아닌 모든 게시물을 포함 시켰습니다. 내가 여기서 실수를 한 경우 수정 해주세요.

• 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 : 38 바이트 @ kukac67
• Perl : @nutki의 32 바이트
• Pyth : @isaacg에 의해 10 바이트
• 파이썬 : @feersum의 49 바이트
• R : @MickyT에 의한 29 바이트
• 루비 : @daniero의 41 바이트
• 스칼라 : @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

파이썬, 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)값의 수를 계산합니다 .sn01

비교를 위해 반복되는 동등한 길이는 2 자입니다. 파이썬 2가 필요합니다.

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

불행히도, 반복하기 전에 변수에 대한 입력을 저장해야합니다. 그렇지 않으면 파이썬은 입력을 반복적으로 읽으려고합니다.

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 조건이 거짓 인 가장 큰 값인 h- 인덱스를 제공하여 1 씩 줄입니다.

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

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

수학, 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을 반환 하십시오 . @nutki 덕분에 COUNT 개로 더 나아졌습니다.

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를 반환합니다.

펄 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}}

"Stabby"람다 / 익명 함수에는 Ruby 1.9 이상이 필요합니다. 예를 들어 전화f[[22,33,1,2,4]]

배쉬 + 코어 유틸리티, 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
$ 

자바 스크립트 (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 (화장실 -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 이상인지 확인합니다. 그렇다면 An을 증가시키고 다시 반복합니다. 그렇지 않은 경우 Ans를 출력합니다.

JAGL 알파 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 요소 #\와 카운트 진정한 비교 +/.

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

여기 사용해보십시오! 이 코드는 초기, 계산 및 최종의 세 부분으로 나눌 수 있습니다.

머리 글자

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.

그러나, 계수가 0 인 문제로 인해 제대로 작동하지 않습니다. 따라서 스택의 모든 구성원과 카운터를 처음에 증가시킵니다.

스택에서 부등식 부울을 얻은 후 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