Ingresso

Un elenco di numeri interi non negativi.

Produzione

Il numero intero non negativo più grande in modo htale che almeno hi numeri nell'elenco siano maggiori o uguali a h.

Casi test

[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

Regole

Puoi scrivere un programma completo o una funzione e sono consentite anche funzioni anonime. Questo è code-golf, quindi vince il minor numero di byte. Le scappatoie standard non sono ammesse.

sfondo

L' h-index è una nozione utilizzata nel mondo accademico che mira a catturare l'impatto e la produttività di un ricercatore. Secondo Wikipedia, un ricercatore ha un indice h , se ha pubblicato h articoli scientifici, ciascuno dei quali è stato citato in altri articoli almeno h volte. Pertanto, questa sfida riguarda il calcolo dell'indice h da un elenco di conteggi delle citazioni.

Aggiornare

Caspita, ottime risposte a tutto tondo! Ho accettato il più breve, ma se qualcun altro ne presenta uno ancora più corto, aggiornerò di conseguenza la mia scelta.

Vincitori per lingua

Ecco una tabella di vincitori per lingua che cercherò anche di tenermi aggiornato. Ho incluso tutti i post con punteggio non negativo. Per favore, correggimi se ho fatto un errore qui.

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

APL 7

+/⊢≥⍋∘⍒

Può essere provato online su 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

Una soluzione ricorsiva. Esegui questo in Stackless Python se sei preoccupato per gli overflow.

A partire da n=0, controlla se almeno n+1dei numeri sono almeno n+1. In tal caso, incrementa ne ricomincia. In caso contrario, uscite n.

Il condizionale viene fatto usando il corto circuito di Python per i booleani. L'espressione sum(n<x for x in s)conta il numero di valori sche sono maggiori rispetto nall'aggiunta dell'indicatore booleani, che vengono trattati come 0o 1.

Per confronto, l'equivalente iterativo è più lungo di 2 caratteri. Richiede Python 2.

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

Sfortunatamente, l'input deve essere salvato per una variabile prima di essere ripetuto, altrimenti Python proverà a leggere l'input ripetutamente.

Pyth, 13 10 byte

tf<l-QUTT1

Immettere in una forma come [22,33,1,2,4]su STDIN.

Provalo qui.

Come funziona:

-QUTè tutti i numeri in ingresso ( Q) almeno grande quanto l'essere numero controllato, T.

<l-QUTTè vero se la lunghezza di tale elenco è inferiore a T.

f<l-QUTT1trova il primo numero intero che ritorna vero per il controllo interno, iniziando da 1e salendo.

tf<l-QUTT1 lo decrementa di uno, dando il valore più grande per cui la condizione è falsa, che è l'indice h.

A partire da 1 si garantisce che 0venga restituito quando il test è sempre vero, come nel primo caso di test.

Python 2, 49

L'input deve essere digitato nello stesso formato degli esempi.

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

CJam, 15 byte

Traduzione diretta della mia soluzione Perl.

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

J ( 13 12)

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

Abbastanza simile alla soluzione di randomra. Dimostrazione:

   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 byte

Funzione anonima:

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

Esegui virando l'input fino alla fine in questo modo:

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

SQL, 81 94 83

Data una tabella (I) di valori (V), la seguente query restituirà h. Testato in PostgreSQL e funzionerà anche in SQL Server. Modifica Fallo restituire 0 anziché NULL. Reso meglio con un COUNT, grazie @nutki

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

Esempio SQLFiddle

In sostanza, numera le righe in ordine decrescente dei valori. Quindi restituisce il numero di riga massimo in cui il numero di riga è maggiore di uguale al valore.

R, 39 35 29

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

Dato un vettore di numeri interi in i e utilizzando la logica di un ordinamento inverso, quindi restituendo la lunghezza del vettore in cui il numero dell'elemento è inferiore a s. Grazie a @plannapus per il bel suggerimento.

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

Questo prende l'elenco come un array su STDIN, come

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

Provalo qui.

Puoi usarlo per eseguire tutti i casi di test:

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

Spiegazione

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

La logica è un po 'arretrata, ma ha salvato un paio di byte. Fondamentalmente, il blocco è passato per ordinare i resi 0per candidati validi e 1non. Quindi i candidati validi vengono prima nell'array ordinato. E poiché l'ordinamento è stabile e iniziamo con un elenco da N fino a 1, questo restituirà il valore massimo valido h.

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

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

Accetta input separato da spazio su STDIN:

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

Python (63)

Fondamentalmente una porta diretta della mia soluzione J. Ovviamente, molto più a lungo, come si potrebbe immaginare.

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

Haskell, 40 anni

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

questo cerca il primo numero non adatto allo schema e restituisce il suo predecessore.

Ruby 44 41

Strategia ricorsiva, più o meno la stessa della soluzione Python di xnor:

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

Ruby 52

Non ricorsiva:

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

Funzioni lambda / anonime "Stabby", richiedono Ruby 1.9 o versioni successive. Chiama con esf[[22,33,1,2,4]]

Bash + coreutils, 29

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

Input prelevato da stdin come elenco separato da nuova riga.

• sort gli interi in ordine decrescente
• nl antepone ogni riga con il suo numero di riga in base 1, separando il numero di riga e il resto della riga con un maggiore di >
• Valutare aritmeticamente ogni riga con bc. I numeri interi inferiori al loro numero di riga risultano in 0. Altrimenti 1.
• grepconta il numero di 0s, ovvero il numero di numeri interi maggiori o uguali ah

Esempio

$ 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

Soluzione ricorsiva.

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

Test nella console 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)))

Produzione

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

Classe completa:

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

Funzione:

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 caratteri

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

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

Bene, ecco alcuni dei peggiori codici che abbia mai scritto! :)

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

Gelatina, 6 byte

NỤỤ<’S

Spiegazione:

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=

Prende l'elenco come input:

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

Produzione:

20

Provalo qui

GolfScript, 13 byte

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

Prova questo codice online. ¹

Accetta input come una matrice nello stack. Utilizza lo stesso algoritmo della soluzione Python di feersum, ripetendo i numeri nell'array e incrementando un contatore da 0 fino a quando non è uguale o supera l'elemento corrente dell'array.

^{1) Il server GolfScript online sembra riscontrare nuovamente timeout casuali. Se il programma scade per te, prova a eseguirlo nuovamente.}

TI-BASIC, 22 byte

Rappresentazione ASCII:

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

Discarica esadecimale:

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

Ottiene un elenco come input. A partire da Ans = 0, controlla se almeno Ans + 1 dei numeri sono almeno Ans + 1. In tal caso, aumenta nuovamente Ans e loops. In caso contrario, genera Ans.

JAGL Alpha 1.2 - 14

Non conta perché la funzionalità di matrice inversa "C" è stata aggiunta dopo la domanda, ma rispondo comunque per divertimento.

Presuppone che l'array sia il primo elemento nello stack e inserisce la risposta nella parte superiore dello stack.

0SJC{Sd@>+1}/S

Per stampare, basta aggiungere Palla fine, aggiungendo un byte.

Spiegazione:

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 caratteri

(La soluzione J più corta attuale.)

   [:+/#\<:\:~

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

Confronta gli elementi <:dell'elenco ordinati \:~con 1..n + 1 #\e conta i confronti veri +/.

Test di somiglianza con altre soluzioni J su 100 casi di test casuali:

   */ (([:+/#\<:\:~) = ([:+/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

Provalo qui! Questo codice può essere diviso in tre parti: iniziale, computazionale e finale.

Iniziale

1#xk#yaïí'1ø

Memorizza 1in x, la lunghezza dello stack di input kin ye ottiene tutto l'input ( aïí) che viene quindi ordinato ( '). 1øpassa alla riga successiva, ovvero alla parte successiva.

computazionale

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

Reng non ha incorporato la disuguaglianza. Pertanto, è necessario implementare un algoritmo. L'algoritmo più corto che ho trovato a < bè %:1,%1e; questo assomiglia a questo:

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)

Sono sicuro che l'ha chiarito! Lasciami spiegare ulteriormente. x % 1, ovvero modulo con 1, mappa xa (-1,1). Sappiamo che (a/b) % 1è a/bquando a < b. Pertanto, questa espressione è uguale a a < b.

Tuttavia, questo non funziona altrettanto bene a causa di problemi con il modulo con zero. Quindi, inizialmente incrementiamo ogni membro dello stack e del contatore.

Dopo aver ottenuto la disuguaglianza booleana nello stack, la x+aggiunge a x, ma per il momento la lascia nello stack. y1-decrementa ye ?^sale iff y == 0e procediamo alla fase finale. In caso contrario, abbiamo messo y-1in ye il nuovo xin x.

Finale

             ~n-1$\

Ciò estrae il residuo y-1dallo stack, diminuisce il risultato, lo emette e termina il programma.

05AB1E , 5 byte

{Rā@O

Provalo online! o come una suite di test

Spiegazione

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

Mathematica, 57 byte

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

Questa è una funzione anonima che prende un elenco e restituisce un intero, come

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

Utilizzare questo per controllare tutti i casi di test:

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

Funzione anonima.

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

rientrato:

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