Đầu vào

Một danh sách các số nguyên không âm.

Đầu ra

Số nguyên không âm lớn nhất hsao cho ít nhất hcác số trong danh sách lớn hơn hoặc bằng h.

Các trường hợp thử nghiệm

[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

Quy tắc

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng và các chức năng ẩn danh cũng được cho phép. Đây là môn đánh gôn, vì vậy số byte ít nhất sẽ thắng. Sơ hở tiêu chuẩn là không được phép.

Lý lịch

Chỉ số h là một khái niệm được sử dụng trong giới hàn lâm nhằm mục đích nắm bắt tác động và năng suất của một nhà nghiên cứu. Theo Wikipedia, một nhà nghiên cứu có chỉ số h , nếu người đó đã xuất bản h bài báo khoa học, mỗi trong số đó đã được trích dẫn trong các bài viết khác ít nhất h lần. Do đó, thách thức này là về việc tính toán chỉ số h từ một danh sách số lượng trích dẫn.

Cập nhật

Wow, câu trả lời tuyệt vời tất cả các vòng! Tôi đã chấp nhận cái ngắn nhất, nhưng nếu người khác nghĩ ra cái ngắn hơn, tôi sẽ cập nhật lựa chọn của mình cho phù hợp.

Người chiến thắng bằng ngôn ngữ

Đây là bảng những người chiến thắng theo ngôn ngữ mà tôi cũng sẽ cố gắng cập nhật. Tôi đã bao gồm tất cả các bài viết với điểm số không âm. Xin hãy sửa tôi nếu tôi đã làm sai ở đây.

• APL : 7 byte bởi @MorisZucca
• Bash + coreutils : 29 byte bởi @DigitalTrauma
• C # : 103 byte bởi @ LegionMammal978
• C ++ : 219 byte bởi @ user9587
• CJam : 15 byte bởi @nutki
• GolfScript : 13 byte bởi @IlmariKaronen
• Haskell : 40 byte bởi @proudhaskeller
• J : 12 byte bởi @ ɐɔıʇǝɥʇuʎs
• Java : 107 byte bởi @Ypnypn
• JavaScript : 48 byte bởi @ edc65
• Toán học : 38 byte bởi @ kukac67
• Perl : 32 byte bởi @nutki
• Pyth : 10 byte bởi @isaacg
• Python : 49 byte bởi @feersum
• R : 29 byte bởi @MickyT
• Ruby : 41 byte bởi @daniero
• Scala : 62 byte bởi @ChadRetz
• SQL : 83 byte bởi @MickyT
• TI-BASIC : 22 byte bởi @Timtech

APL 7

+/⊢≥⍋∘⍒

Có thể dùng thử trực tuyến trên 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

Con trăn, 52

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

Một giải pháp đệ quy. Chạy cái này trong Stackless Python nếu bạn lo lắng về việc tràn.

Bắt đầu từ n=0, kiểm tra xem ít nhất n+1là số ít nhất n+1. Nếu vậy, tăng nvà bắt đầu lại. Nếu không, đầu ra n.

Điều kiện được thực hiện bằng cách sử dụng ngắn mạch của Python cho Booleans. Biểu thức sum(n<x for x in s)đếm số lượng giá trị trong sđó lớn hơn nbằng cách thêm Booleans chỉ báo, được coi là 0hoặc 1.

Để so sánh, tương đương lặp lại là 2 ký tự dài hơn. Nó đòi hỏi Python 2.

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

Thật không may, đầu vào cần phải được lưu cho một biến trước khi lặp đi lặp lại nếu không Python sẽ cố gắng đọc đầu vào nhiều lần.

Bình thường, 13 10 byte

tf<l-QUTT1

Nhập vào dưới dạng như [22,33,1,2,4]trên STDIN.

Hãy thử nó ở đây.

Làm thế nào nó hoạt động:

-QUTlà tất cả các số trong đầu vào ( Q) ít nhất bằng số được kiểm tra , T.

<l-QUTTlà đúng nếu độ dài của danh sách đó nhỏ hơn T.

f<l-QUTT1tìm số nguyên đầu tiên trả về giá trị true cho kiểm tra bên trong, bắt đầu từ 1và đi lên.

tf<l-QUTT1 giảm giá trị của một, đưa ra giá trị lớn nhất mà điều kiện sai, đó là chỉ số h.

Bắt đầu từ 1 đảm bảo 0được trả về khi thử nghiệm luôn luôn đúng, chẳng hạn như trong trường hợp thử nghiệm đầu tiên.

Con trăn 2, 49

Đầu vào nên được gõ theo cùng định dạng với các ví dụ.

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

CJam, 15 byte

Dịch trực tiếp giải pháp Perl của tôi.

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

J ( 13 12)

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

Khá giống với giải pháp của Randomra. Trình diễn, thuyết trình:

   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

Toán học, 44 42 40 38 byte

Hàm ẩn danh:

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

Chạy nó bằng cách giải quyết đầu vào đến cuối như vậy:

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

SQL, 81 94 83

Cho một bảng (I) các giá trị (V), truy vấn sau sẽ trả về h. Đã thử nghiệm trong PostgreSQL và cũng sẽ hoạt động trong SQL Server. Chỉnh sửa Làm cho nó trả về 0 thay vì NULL. Làm tốt hơn với một COUNT, cảm ơn @nutki

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

Ví dụ SQLFiddle

Về cơ bản, nó đánh số các hàng trên một loại giá trị giảm dần. Sau đó, nó trả về số hàng tối đa trong đó số hàng lớn hơn bằng giá trị.

R, 39 35 29

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

Cho một vectơ số nguyên trong i và sử dụng logic của một sắp xếp ngược lại sau đó trả về độ dài của vectơ trong đó số phần tử nhỏ hơn s. Cảm ơn @plannapus về mẹo hay.

> 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 byte

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

Cái này lấy danh sách dưới dạng một mảng trên STDIN, như

[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]

Kiểm tra nó ở đây.

Bạn có thể sử dụng điều này để chạy tất cả các trường hợp thử nghiệm:

[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}/

Giải trình

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.";

Logic là một chút ngược, nhưng nó đã lưu một vài byte. Về cơ bản, khối được thông qua để sắp xếp trả về 0cho các ứng cử viên hợp lệ và mặt 1khác. Vì vậy, các ứng cử viên hợp lệ đến đầu tiên trong mảng được sắp xếp. Và bởi vì sắp xếp ổn định và chúng tôi bắt đầu với một danh sách từ N xuống 1, điều này sẽ trả về h hợp lệ lớn nhất.

Perl 5: 32 (30 + 2 cho -pa)

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

Mất không gian đầu vào tách biệt trên STDIN:

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

Con trăn (63)

Về cơ bản là một cổng trực tiếp của giải pháp J của tôi. Rõ ràng, lâu hơn rất nhiều, như người ta có thể tưởng tượng.

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

Haskell, 40

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

tìm kiếm này cho số đầu tiên không phù hợp với sơ đồ và trả về tiền thân.

Ruby 44 41

Chiến lược đệ quy, ít nhiều giống như giải pháp Python của xnor:

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

Hồng ngọc 52

Không đệ quy:

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

Các hàm lambda / ẩn danh "Stabby", yêu cầu Ruby 1.9 trở lên. Gọi với ví dụf[[22,33,1,2,4]]

Bash + coreutils, 29

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

Đầu vào được lấy từ stdin dưới dạng danh sách phân tách dòng mới.

• sort các số nguyên theo thứ tự giảm dần
• nl tiền tố mỗi dòng với số dòng dựa trên 1 của nó, phân tách số dòng và phần còn lại của dòng với số lớn hơn >
• Đánh giá một cách hợp lý từng dòng với bc. Số nguyên nhỏ hơn số dòng của họ dẫn đến 0. Nếu không 1.
• grepđếm số 0s, tức là số nguyên lớn hơn hoặc bằngh

Thí dụ

$ 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

Giải pháp đệ quy.

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

Thử nghiệm trong bảng điều khiển 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)))

Đầu ra

[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 byte.

Toàn lớp:

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

Chức năng:

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 ký tự

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

C ++ 815 219 từ (wc -c main.cpp)

Được rồi đây là một số mã tồi tệ nhất tôi từng viết! :)

#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;}

Thạch, 6 byte

NỤỤ<’S

Giải trình:

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 byte

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

Lấy danh sách làm đầu vào:

[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]

Đầu ra:

20

Hãy thử nó ở đây

GolfScript, 13 byte

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

Kiểm tra mã này trực tuyến. ¹

Đưa đầu vào như một mảng trên ngăn xếp. Sử dụng thuật toán tương tự như giải pháp Python của frageum , lặp lại các số trong mảng và tăng bộ đếm từ 0 cho đến khi nó bằng hoặc vượt quá phần tử hiện tại của mảng.

^{1) Máy chủ GolfScript trực tuyến dường như lại gặp thời gian chờ ngẫu nhiên. Nếu chương trình hết thời gian cho bạn, hãy thử chạy lại nó.}

TI-BASIC, 22 byte

Đại diện ASCII:

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

Đổ lục giác:

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

Lấy danh sách làm đầu vào. Bắt đầu từ Ans = 0, kiểm tra xem ít nhất Ans + 1 trong số có ít nhất Ans + 1 hay không. Nếu vậy, tăng Ans và vòng lặp một lần nữa. Nếu không, đầu ra Ans.

JAGL Alpha 1.2 - 14

Không được tính vì chức năng mảng đảo ngược 'C' đã được thêm vào sau câu hỏi, nhưng dù sao cũng đang trả lời cho vui.

Giả sử rằng mảng là mục đầu tiên trên ngăn xếp và đặt câu trả lời ở đầu ngăn xếp.

0SJC{Sd@>+1}/S

Để in, chỉ cần thêm Pvào cuối, thêm một byte.

Giải trình:

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 ký tự

(Giải pháp J ngắn nhất hiện tại.)

   [:+/#\<:\:~

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

So sánh các phần tử <:danh sách được sắp xếp \:~với 1..n + 1 #\và tính các so sánh đúng +/.

Kiểm tra độ tương tự so với giải pháp J khác trên 100 trường hợp thử nghiệm ngẫu nhiên:

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

Reng v.3.2, 43 byte

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

Hãy thử nó ở đây! Mã này có thể được chia thành ba phần: ban đầu, tính toán và cuối cùng.

Ban đầu

1#xk#yaïí'1ø

Này lưu trữ 1để x, độ dài của ngăn xếp đầu vào kđến y, và được tất cả đầu vào ( aïí) sau đó được sắp xếp (' ). 1øđi đến dòng tiếp theo, tức là phần tiếp theo.

Tính toán

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

Reng không có tích hợp cho bất bình đẳng. Do đó, một thuật toán phải được thực hiện. Thuật toán ngắn nhất tôi tìm thấy a < blà %:1,%1e; nó trông như thế này:

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)

Tôi chắc chắn rằng đã xóa nó! Hãy để tôi giải thích thêm. x % 1, tức là mô đun với 1, ánh xạ xtới (-1,1). Chúng tôi biết đó (a/b) % 1là a/bkhia < b . Do đó, biểu thức này bằng a < b.

Tuy nhiên, điều này không hoạt động tốt vì các vấn đề với mô đun bằng không. Vì vậy, chúng tôi tăng từng thành viên của ngăn xếp và bộ đếm ban đầu.

Sau khi chúng ta nhận được bất đẳng thức Boolean trên ngăn xếp, x+thêm nó vào x, nhưng để nó trên ngăn xếp trong giây lát. y1-giảm y, và ?^đi lên y == 0và chúng tôi tiến tới giai đoạn cuối cùng. Nếu không, chúng tôi đưa y-1vào yvà mới xvào x.

Sau cùng, cuối cùng, chung kết

             ~n-1$\

Điều này bật phần dư y-1từ ngăn xếp, giảm kết quả, xuất nó và kết thúc chương trình.

05AB1E , 5 byte

{Rā@O

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

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

Toán học, 57 byte

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

Đây là một hàm ẩn danh lấy một danh sách và trả về một số nguyên, như

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

Sử dụng để kiểm tra tất cả các trường hợp thử nghiệm:

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

Chức năng ẩn danh.

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

Thụt lề:

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