อินพุต

รายการของจำนวนเต็มที่ไม่ใช่ค่าลบ

เอาท์พุต

ที่ใหญ่ที่สุดติดลบ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-ดัชนีเป็นความคิดที่ใช้ในสถาบันการศึกษาที่มีจุดมุ่งหมายในการจับภาพผลกระทบและผลผลิตของนักวิจัย ตามที่วิกิพีเดียนักวิจัยมีดัชนีชั่วโมงถ้าเขาหรือเธอได้รับการตีพิมพ์ชั่วโมงบทความทางวิทยาศาสตร์ของแต่ละคนซึ่งได้รับการอ้างถึงในบทความอื่น ๆ อย่างน้อยชั่วโมงครั้ง ดังนั้นความท้าทายนี้เกี่ยวกับการคำนวณดัชนี h จากรายการการนับการอ้างอิง

ปรับปรุง

ว้าวคำตอบที่ดีทุกรอบ! ฉันยอมรับคนที่สั้นที่สุด แต่ถ้ามีคนอื่นที่มากับคนที่เตี้ยกว่าฉันจะอัปเดตตัวเลือกของฉันตามนั้น

ผู้ชนะด้วยภาษา

นี่คือตารางผู้ชนะตามภาษาที่ฉันจะพยายามอัปเดตอยู่เสมอ ฉันได้รวมโพสต์ทั้งหมดด้วยคะแนนที่ไม่ติดลบ โปรดแก้ไขฉันหากฉันทำผิดที่นี่

• APL : 7 ไบต์โดย @MorisZucca
• Bash + coreutils : 29 ไบต์โดย @DigitalTrauma
• C # : 103 bytes โดย @ LegionMammal978
• C ++ : 219 ไบต์โดย @ user9587
• CJam : 15 ไบต์โดย @nutki
• GolfScript : 13 ไบต์โดย @IlmariKaronen
• Haskell : 40 bytes โดย @proudhaskeller
• J : 12 ไบต์โดย @ ɐɔıʇǝɥʇuʎs
• Java : 107 ไบต์โดย @Ypnypn
• JavaScript : 48 bytes โดย @ edc65
• Mathematica : 38 bytes โดย @ kukac67
• Perl : 32 ไบต์โดย @nutki
• Pyth : 10 ไบต์โดย @isaacg
• Python : 49 ไบต์โดย @feersum
• R : 29 ไบต์โดย @MickyT
• Ruby : 41 ไบต์โดย @daniero
• Scala : 62 bytes โดย @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

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 n+1ถ้าเป็นเช่นนั้นเพิ่มขึ้นnและเริ่มอีกครั้ง nถ้าไม่เอาท์พุท

ทำตามเงื่อนไขโดยใช้การลัดวงจรของ Python สำหรับ Booleans การแสดงออกsum(n<x for x in s)นับจำนวนของค่าในsที่มากกว่าnโดยการเพิ่ม Booleans ตัวบ่งชี้ซึ่งจะถือว่าเป็นหรือ01

สำหรับการเปรียบเทียบนั้นซ้ำที่ซ้ำกันคือ 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-QUTTTเป็นจริงถ้าความยาวของรายการที่มีค่าน้อยกว่า

f<l-QUTT1ค้นหาจำนวนเต็มแรกที่ส่งกลับค่าจริงสำหรับการตรวจสอบภายในเริ่มต้น1และขึ้นไป

tf<l-QUTT1 การลดลงทีละค่าให้มากที่สุดซึ่งเงื่อนไขเป็นเท็จซึ่งเป็นดัชนี h

การเริ่มต้นที่ 1 ช่วยให้มั่นใจได้ว่า0จะได้รับคืนเมื่อการทดสอบเป็นจริงเสมอเช่นในกรณีทดสอบครั้งแรก

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

ให้ค่า (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'

Python (63)

โดยพื้นฐานแล้วเป็นพอร์ตโดยตรงของโซลูชัน J ของฉัน เห็นได้ชัดว่าอีกต่อไปนานมากอย่างที่ใคร ๆ ก็อาจจินตนาการ

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

การค้นหานี้เป็นหมายเลขแรกที่ไม่พอดีกับโครงร่างและส่งกลับค่าของรุ่นก่อน

รูบี44 41

เรียกซ้ำกลยุทธ์ที่เหมือนกันมากกว่าหรือน้อยกว่ากับโซลูชัน Python ของ xnor:

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

ทับทิม 52

Non-recursive:

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

ฟังก์ชั่น "Stabby" แลมบ์ดา / นิรนามต้องการ Ruby 1.9 หรือใหม่กว่า โทรด้วยเช่นf[[22,33,1,2,4]]

Bash + coreutils, 29

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

อินพุตที่นำมาจาก stdin เป็นรายการที่คั่นด้วยบรรทัดใหม่

• sort จำนวนเต็มตามลำดับจากมากไปน้อย
• nl นำหน้าแต่ละบรรทัดด้วยหมายเลขบรรทัดที่อ้างอิง 1 โดยแยกหมายเลขบรรทัดและส่วนที่เหลือของบรรทัดด้วยมากกว่า >
• arithmetically 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

การถ่ายโอนข้อมูล Hex:

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 และการวนซ้ำอีกครั้ง หากไม่เป็นเช่นนั้นจะให้เอาท์พุต

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

เร็งไม่ได้สร้างความไม่เท่าเทียมในตัว ดังนั้นจึงต้องมีการใช้อัลกอริทึม อัลกอริทึมที่สั้นที่สุดที่ผมพบ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 < ba < b

อย่างไรก็ตามสิ่งนี้ก็ใช้งานไม่ได้เช่นกันเนื่องจากปัญหาเกี่ยวกับโมดูลัสกับศูนย์ ดังนั้นเราจึงเพิ่มสมาชิกทุกคนของสแต็กและตัวนับในตอนแรก

หลังจากที่เราได้อสมการบูลีนที่ไม่เท่ากันบนสแต็กให้x+เพิ่มมันเข้าไปใน x แต่ทิ้งมันไว้ในสแต็กสักครู่ y1-การลดลงyและ?^ขึ้นไป iff y == 0และเราดำเนินการในขั้นตอนสุดท้าย มิฉะนั้นเราจะนำy-1เข้าyและใหม่เข้ามาxx

สุดท้าย

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

สกาลา, 62

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