कम से कम ज के साथ कम से कम ज

Question

इनपुट

Nonnegative पूर्णांक की एक सूची।

उत्पादन

सबसे बड़ा nonnegative पूर्णांक 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 द्वारा
• बैश + कोरटिल्स: 29 बाइट्स @DigitalTrauma द्वारा
• C # : 103 बाइट्स @ LegionMammal978 द्वारा
• C ++ : 219 बाइट्स @ user9587 द्वारा
• सीजाम : 15 बाइट्स @ नटकी द्वारा
• GolfScript : 13 बाइट्स @IlmariKaronen द्वारा
• हास्केल : 40 बाइट्स @proudhaskeller द्वारा
• J : 12 बाइट्स @ ʇǝɥʇıʇǝɥʇu .s द्वारा
• जावा : @Ypnypn द्वारा 107 बाइट्स
• जावास्क्रिप्ट : @ edc65 द्वारा 48 बाइट्स
• गणितज्ञ : @ kukac67 द्वारा 38 बाइट्स
• पर्ल : 32 बाइट्स @ कुटकी द्वारा
• पायथ : @ बाईसैग द्वारा 10 बाइट्स
• पायथन : @ फ़ेर्ससम द्वारा 49 बाइट्स
• R : 29 बाइट्स @MickyT द्वारा
• रूबी : 41 बाइट्स @daniero द्वारा
• स्काला : @ChadRetz द्वारा 62 बाइट्स
• SQL : 83 बाइट्स @MickyT द्वारा
• TI-BASIC : 22 बाइट्स @Timtech द्वारा

Answer 1

एपीएल 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

Answer 2

पायथन, 52

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

एक पुनरावर्ती समाधान। स्टैकलेस पायथन में इसे चलाएं यदि आप ओवरफ्लो से परेशान हैं।

से शुरू n=0, जाँच करता है कि क्या कम से कम n+1संख्या में कम से कम हैं n+1। यदि हां, तो वेतन वृद्धि nऔर फिर से शुरू होती है। यदि नहीं, तो आउटपुट n।

यह शर्त बूलियन के लिए पाइथन के शॉर्ट-सर्कुटिंग का उपयोग करके की जाती है। अभिव्यक्ति संकेतक sum(n<x for x in s)की संख्या को गिनाती है जो संकेतक बूलियन को जोड़कर sअधिक होती nहै, जिसे 0या के रूप में माना जाता है 1।

तुलना के लिए, पुनरावृत्त समतुल्य 2 वर्ण लंबा है। इसके लिए अजगर 2 की आवश्यकता है।

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

दुर्भाग्य से, इनपुट को चर पर प्रसारित होने से पहले सहेजने की आवश्यकता होती है, अन्यथा अजगर बार-बार इनपुट पढ़ने की कोशिश करेगा।

Answer 3

पायथ, 13 10 बाइट्स

tf<l-QUTT1

एक फॉर्म में इनपुट जैसे [22,33,1,2,4]STDIN पर।

इसे यहाँ आज़माएँ।

यह काम किस प्रकार करता है:

-QUTइनपुट (में संख्या के सभी है Q, बड़े के रूप में कम से कम) के रूप में किया जा रहा है संख्या की जाँच की T।

<l-QUTTसच है अगर उस सूची की लंबाई से कम है T।

f<l-QUTT1पहले पूर्णांक को ढूँढता है जो आंतरिक जाँच के लिए सही है, शुरू 1और ऊपर जा रहा है।

tf<l-QUTT1 घटता है कि एक के द्वारा, सबसे बड़ा मूल्य जिसके लिए शर्त झूठी है, जो कि एच-इंडेक्स है।

1 से शुरू करना यह सुनिश्चित करता है कि 0जब परीक्षण हमेशा सही हो, तो पहले टेस्ट केस में वापस लौटा दिया जाए।

Answer 4

पायथन 2, 49

उदाहरण के रूप में इनपुट को उसी प्रारूप में टाइप किया जाना चाहिए।

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

Comments

क्या अद्भुत एल्गोरिथम है!

— घमंडी हैस्केलर

Answer 5

सीजेएम, 15 बाइट्स

मेरे पर्ल समाधान का सीधा अनुवाद।

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

Comments

l~$W%{W):W>},,- 14 बाइट्स

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र थैंक्स, मुझे उम्मीद थी कि टेबल को पलटने का एक छोटा तरीका होना चाहिए। मुझे आश्चर्य है कि हालांकि मानचित्रों में पुनरावृत्ति गणना की कोई पहुंच नहीं है। वैसे भी अगर 1 बाइट आप सभी ले सकते हैं जो मेरे पहले CJam कोड के लिए बुरा नहीं है।

— नटकी

अब कुछ 12 बाइट समाधान हैं: {$W%ee::<1b}( ee2015-04-17 जोड़ा गया था) और {$W%_,,.>1b}( .2015-02-21 जोड़ा गया था)।

— पीटर टेलर

Answer 6

जे ( १३ १२)

[:+/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

Comments

का उपयोग #\<:करने के बजाय i.@#<एक चरित्र की बचत होती है।

— एल्गोरिद्मशार्क

Answer 7

गणितज्ञ, 44 42 40 38 बाइट्स

अनाम फ़ंक्शन:

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

इनपुट को अंत तक इस तरह से निपटा कर चलाएं:

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

Comments

@ मार्टिनबटनर आप सही कह रहे हैं, मैं उपयोग कर सकता हूं #>i++। मैंने कुछ और मामलों का परीक्षण किया। (और सभी सुझावों के लिए धन्यवाद!)

— kukac67

Answer 8

एसक्यूएल, 81 94 83

मानों (V) की तालिका (I) को देखते हुए, निम्नलिखित क्वेरी h वापस आ जाएगी। PostgreSQL में परीक्षण किया गया और SQL सर्वर में भी काम करेगा। संपादित करें इसे 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 उदाहरण

अनिवार्य रूप से यह पंक्तियों को मूल्यों के अवरोही क्रम पर रखता है। फिर यह अधिकतम पंक्ति संख्या देता है जहाँ पंक्ति संख्या मान के बराबर होती है।

Comments

आप NULL समस्या COUNT(R)के COALESCE(MAX(R),0)लिए एक छोटे से फिक्स के बजाय उपयोग कर सकते हैं ।

— नटकी

@ कुट्टी का ... शुक्रिया

— मिकटी

Answer 9

आर, ३ ९ ३५ २ ९

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

I में पूर्णांक के एक वेक्टर को देखते हुए और रिवर्स सॉर्ट के तर्क का उपयोग करते हुए फिर वेक्टर की लंबाई लौटाते हैं जहां तत्व संख्या एस से कम है। अच्छी टिप के लिए @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

Comments

अच्छा! आप तार्किक वेक्टर को सीधे योग करके 29 को भी छोटा कर सकते हैं:s=sort(i);sum(s>=length(s):1)

— प्लाननैपस

Answer 10

सीजेएम, 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 लौटाएगा।

Answer 11

पर्ल 5: 32 (30 + 2) के लिए -pa )

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

STDIN पर अंतरिक्ष अलग इनपुट लेता है:

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

Comments

sort{$b-$a}2 अधिक बचाता है

— भीड़

Answer 12

पायथन (63)

मूल रूप से मेरे J समाधान का सीधा पोर्ट है। जाहिर है, बहुत लंबा, जैसा कि कोई कल्पना कर सकता है।

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

Comments

आप कुछ वर्णों का उपयोग करके बचा सकते हैं enumerate।

— xnor

Answer 13

हास्केल, 40

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

यह योजना को फिट नहीं करने के लिए पहले नंबर की खोज करता है और यह पूर्ववर्ती रिटर्न देता है।

Comments

39 बाइट्स के साथ until: इसे ऑनलाइन आज़माएं!

— लकोनी

Answer 14

रूबी ४४ ४१

पुनरावर्ती, कमोबेश यही रणनीति एक्सनोर के पायथन समाधान के रूप में है:

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

रूबी ५२

गैर पुनरावर्ती:

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

"स्टैबी" लैम्ब्डा / अनाम फ़ंक्शन, रूबी 1.9 या नए की आवश्यकता होती है। उदाहरण के साथ कॉल करेंf[[22,33,1,2,4]]

Answer 15

बैश + कोरुटिल्स, 29

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

एक नई पंक्ति-पृथक सूची के रूप में स्टड से लिया गया इनपुट।

• sort अवरोही क्रम में पूर्णांक
• nl प्रत्येक लाइन को उसके 1-आधारित लाइन नंबर के साथ उपसर्ग करता है, लाइन नंबर और बाकी लाइन को अधिक से अधिक के साथ अलग करता है >
• हिसाब के साथ प्रत्येक पंक्ति का मूल्यांकन bc। Integers उनकी लाइन संख्या के परिणाम से कम 0. 0. 1।
• grep0एस की संख्या को गिनता है , यानी पूर्णांकों की संख्या से अधिक या उसके बराबर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
$ 

Answer 16

जावास्क्रिप्ट (ईएस 6) 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

Comments

47 बाइट्स: f=(l,h=0)=>l.map(v=>x+=v>h,x=0)&&x>h?f(l,h+1):h। हालांकि, अपने समाधान 47 बाइट्स भी अगर आप सिर्फ बदल किया जाएगा h=-1करने के लिए h=0।

— वृजथेल

Answer 17

जावा 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;}}

Answer 18

एपीएल, 12 वर्ण

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

Answer 19

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

Answer 20

जेली, 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

Answer 21

सीजेएम, 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

इसे यहाँ आज़माएँ

Answer 22

गोल्फस्क्रिप्ट, 13 बाइट्स

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

इस कोड को ऑनलाइन टेस्ट करें। ¹

स्टैक पर एक सरणी के रूप में इनपुट लेता है। फ़ेर्सुम के पायथन समाधान के समान एल्गोरिथ्म का उपयोग करता है , सरणी में संख्याओं पर पुनरावृत्ति करता है और 0 से एक काउंटर बढ़ाता है जब तक कि यह बराबर या सरणी के वर्तमान तत्व से अधिक न हो।

^{1) ऑनलाइन गोल्फस्क्रिप्ट सर्वर फिर से यादृच्छिक समय का सामना कर रहा है। यदि आपके लिए कार्यक्रम का समय समाप्त हो गया है, तो इसे पुनः चलाने का प्रयास करें।}

Answer 23

टीआई-बेसिक, 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।

Answer 24

जेएजीएल अल्फा 1.2 - 14

गिनती नहीं है क्योंकि 'सी' रिवर्स सरणी कार्यक्षमता सवाल के बाद जोड़ा गया था, लेकिन वैसे भी मनोरंजन के लिए जवाब दे रहा हूं।

मान लेता है कि सरणी स्टैक पर पहला आइटम है, और स्टैक के शीर्ष पर उत्तर डालता है।

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

Answer 25

जे, 15 11 वर्ण

(वर्तमान सबसे छोटा जम्मू समाधान।)

   [:+/#\<:\:~

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

1..n + 1 के साथ <:सूची \:~तत्वों को क्रमबद्ध करता है #\और वास्तविक तुलना को गिनता है +/।

100 यादृच्छिक परीक्षण मामलों पर अन्य जे समाधान के खिलाफ परीक्षण समानता:

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

Answer 26

रेंग 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 < b। इस प्रकार, यह अभिव्यक्ति के बराबर है a < b।

हालाँकि, यह शून्य के साथ मापांक के साथ समस्याओं के कारण काफी काम नहीं करता है। इसलिए, हम शुरू में स्टैक और काउंटर के प्रत्येक सदस्य को बढ़ाते हैं।

स्टैक पर असमानता बूलियन प्राप्त करने के बाद, x+इसे एक्स में जोड़ता है, लेकिन इसे स्टैक पर छोड़ देता है। y1-घटता है y, और ?^iff ऊपर जाता है y == 0और हम अंतिम चरण में आगे बढ़ते हैं। अन्यथा, हम और नए y-1में डालते हैंyx में x।

अंतिम

             ~n-1$\

यह y-1स्टैक से अवशिष्ट को पॉप करता है , परिणाम को घटाता है, इसे आउटपुट करता है, और प्रोग्राम को समाप्त करता है।

Answer 27

05AB1E , 5 बाइट्स

{Rā@O

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

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

Answer 28

गणितज्ञ, 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}
}

Answer 29

सी #, 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;
    }
}

Answer 30

स्काला, ६२

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