Giriş

Olumsuz tam sayıların listesi.

Çıktı

Büyük pozitif bir tamsayı h, en azından bu tür hlistesi sayıların daha büyük olan ya da eşit h.

Test Kılıfları

[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

kurallar

Tam bir program veya bir işlev yazabilirsiniz ve adsız işlevlere de izin verilir. Bu kod golf, yani en az bayt sayısı kazanır. Standart boşluklara izin verilmez.

Arka fon

H-endeksi araştırmacı etkisini ve verimliliğini pay almayı amaçlamaktadır akademi olarak kullanılan bir kavramıdır. Wikipedia göre, araştırmacı indeksi vardır h o yayınladı eğer, h en azından diğer makalelerde atıf yapıldı, her biri bilimsel makaleler, h zamanlarda. Bu nedenle, bu zorluk h-endeksini bir alıntı sayımı listesinden hesaplamakla ilgilidir.

Güncelleme

Vay canına, her konuda harika cevaplar! En kısa olanı kabul ettim, ancak bir başkası daha da kısa olanı ile karşılaşırsa, seçimimi buna göre güncelleyeceğim.

Dile göre kazananlar

İşte dile göre kazananlar tablosu ve aynı zamanda güncel kalmaya çalışacağım bir tablo. Negatif olmayan puanları olan tüm yayınları ekledim. Burada bir hata yaptıysam lütfen beni düzeltin.

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

APL 7

+/⊢≥⍋∘⍒

Tryapl.org adresinden çevrimiçi olarak denenebilir

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

Özyinelemeli bir çözüm. Taşmaları hakkında endişeleniyorsanız bunu Stackless Python'da çalıştırın .

Başlangıçtan itibaren n=0, en az n+1sayıların en az olup olmadığını kontrol eder n+1. Eğer öyleyse, artar nve tekrar başlar. Değilse çıktılar n.

Koşullu Python'un Boolean'lar için kısa devre sistemi kullanılarak yapıldı. Bu ifade , veya gibi davranan gösterge Boole'lerini eklemekten daha büyük sum(n<x for x in s)olan değerlerin sayısını sayar .sn01

Karşılaştırma için yinelemeli eşdeğeri 2 karakter uzunluğundadır. Python 2 gerektirir.

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

Ne yazık ki, giriş yinelenmeden önce bir değişken için kaydedilmelidir, aksi takdirde Python girişi tekrar tekrar okumaya çalışır.

Pyth, 13 10 bayt

tf<l-QUTT1

[22,33,1,2,4]STDIN gibi bir formda giriş yapın .

Burada dene.

Nasıl çalışır:

-QUT( Q) girişindeki ( ) en az kontrol edilen sayı kadar büyük T.

<l-QUTTBu listenin uzunluğu daha az ise doğrudur T.

f<l-QUTT1İç kontrol için doğru olan ilk tamsayıyı bulur, başlar 1ve başlar.

tf<l-QUTT1 koşulun yanlış olduğu en yüksek değeri veren, h-endeksi olan değeri tek tek düşürür.

1'den 0başlamak, ilk test durumundaki gibi test her zaman doğru olduğunda geri dönmesini sağlar .

Python 2, 49

Giriş, örneklerle aynı formatta yazılmalıdır.

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

CJam, 15 bayt

Perl çözümümün doğrudan çevirisi.

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

J ( 13 12)

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

Random'ın çözümüne oldukça benzer. gösteri:

   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 bayt

Anonim işlev:

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

Girdiyi sonuna kadar tıklatarak çalıştırın:

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

SQL, 81 94 83

(V) değerine sahip bir tablo (I) verildiğinde, aşağıdaki sorgu h döndürür. PostgreSQL'de test edilmiştir ve SQL Server'da da çalışacaktır. Düzen NULL yerine 0 döndürmesini sağlayın. COUNT ile daha da iyi oldu, teşekkürler @ nutki

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

SQLFiddle örneği

Temel olarak, azalan bir değer sırasındaki satırları numaralandırır. Ardından, satır numarasının değerden büyük olduğu maksimum satır numarasını döndürür.

R, 39 35 29

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

İ içerisindeki bir tamsayı vektörü verildiğinde ve bir ters sıralama mantığının kullanılmasıyla, eleman sayısının s'den küçük olduğu vektörün uzunluğu döndürülür . Güzel bahşiş için @plannapus'a teşekkürler.

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

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

Bu, listeyi STDIN'deki gibi bir dizi olarak alır.

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

Burada test et.

Bunu tüm test senaryolarını çalıştırmak için kullanabilirsiniz:

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

açıklama

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

Mantık biraz geriye, ancak birkaç bayt kurtardı. Temel olarak, blok 0geçerli adaylar için geri dönüşleri sıralamak için geçti 1. Bu nedenle geçerli adaylar, dizilen dizide ilk sırada yer alır. Ve sıralama kararlı olduğundan ve N'den 1'e kadar olan bir listeyle başladığımızda, bu en büyük geçerli h değerini döndürür.

Perl 5: 32 (30 + 2 için -pa)

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

STDIN'de boşlukla ayrılmış girdi alır:

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

Python (63)

Temelde J çözümümün doğrudan bir limanı. Açıkçası, tahmin edilebileceği gibi, çok daha uzun.

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

bu, şemaya uymayan ilk numarayı arar ve selefine döner.

Yakut 44 41

Özyinelemeli, xnor'ın Python çözümü ile aşağı yukarı aynı strateji.

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

Ruby 52

Sigara özyinelemeli:

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

"Stabby" lambda / anonymous işlevleri, Ruby 1.9 veya daha yenisini gerektirir. Örn ile arayınf[[22,33,1,2,4]]

Bash + coreutils, 29

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

Stdin'den yeni satır ayrılmış bir liste olarak alınan girdi.

• sort tamsayı azalan sırada
• nl her bir satırı 1 tabanlı bir satır numarası ile ön ekler, satır numarasını ve satırın kalanını bir büyük harfle ayırarak >
• Her satırı aritmetik olarak değerlendiriniz bc. Satır numaralarından daha az tamsayılar 0 olur. Aksi takdirde 1.
• grep0s sayısını , yani değerinden büyük veya ona eşit olan tam sayı sayısını sayar .h

Örnek

$ 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

Özyinelemeli çözüm.

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

FireFox / FireBug konsolunda test edin

;[
  [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)))

Çıktı

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

Tam sınıf:

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

İşlev:

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 karakter

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

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

Tamam, işte şimdiye kadar yazdığım en kötü kodlardan bazıları! :)

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

Jöle, 6 bayt

NỤỤ<’S

Açıklama:

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 bayt

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

Listeyi girdi olarak alır:

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

Çıktı:

20

Burada dene

GolfScript, 13 bayt

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

Bu kodu çevrimiçi olarak test edin. ¹

Girdiyi yığında bir dizi olarak alır. Feersum'un Python çözümü ile aynı algoritmayı kullanır, dizideki sayılar üzerinde yinelenir ve dizinin o andaki elemanına eşit olana veya bu sayıyı aşıncaya kadar bir sayacı 0'dan arttırır .

^{1) Çevrimiçi GolfScript sunucusu tekrar rasgele zaman aşımına uğramış gibi görünüyor. Program sizin için zaman aşımına uğrarsa, yeniden çalıştırmayı deneyin.}

TI-BASIC, 22 bayt

ASCII gösterimi:

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

Hex dökümü:

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

Giriş olarak bir liste alır. Ans = 0'dan başlayarak, sayıların en az Ans + 1'in en az Ans + 1 olup olmadığını kontrol eder. Öyleyse, Ans'ı artırır ve tekrar döngüler. Değilse, Ans çıktılarını verir.

JAGL Alfa 1.2 - 14

Sayılmaz'C' ters dizi işlevi sorudan sonra eklendiğinden , ancak yine de eğlence için cevap veriyorum.

Dizinin yığındaki ilk öğe olduğunu varsayar ve cevabı yığının en üstüne koyar.

0SJC{Sd@>+1}/S

Yazdırmak için, sadece ekleyin P bir bayt ekleyerek sonuna .

Açıklama:

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 karakter

(Güncel en kısa J çözümü.)

   [:+/#\<:\:~

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

Karşılaştırır <:sıralı liste \:~1..n + 1 elemanları #\ve sayımlar gerçek karşılaştırmalar+/ .

100 rastgele test durumunda diğer J çözümüne benzerliği test etme:

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

Reng v.3.2, 43 bayt

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

Burada dene!Bu kod üç bölüme ayrılabilir: ilk, hesaplamalı ve son.

ilk

1#xk#yaïí'1ø

Bu depolar 1için x, girdi yığınına uzunluğu kiçin y, ve giriş (alır aïísonra sıralanır) ( ').1øBir sonraki satıra, yani bir sonraki kısma gider.

Hesaplamalı

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

Reng'in eşitsizlik için yerleşik bir hakkı yoktur. Bu nedenle, bir algoritma uygulanmalıdır. I Bulunan kısa algoritma a < bIS %:1,%1e; bu şuna benziyor:

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)

Eminim o it up temizlendi! Daha fazla açıklayayım. x % 1Yani modül 1 ile eşleyen xiçin (-1,1). Bunu biliyoruz (a/b) % 1olduğu a/bzaman a < b. Böylece, bu ifade eşittira < b .

Ancak, sıfır modüllü problemler nedeniyle bu oldukça iyi çalışmaz. Böylece, başlangıçta yığının her üyesini ve sayacı arttırırız.

Boolean eşitsizliği yığında aldıktan sonra, x+x'e ekler, ancak şimdilik yığında bırakır. y1-azalır y, ?^iff artar y == 0ve son aşamaya geçilir . Aksi takdirde, y-1içine yve xyenisinex .

final

             ~n-1$\

Bu, artıkları y-1yığından çıkarır, sonucu azaltır, çıkarır ve programı sonlandırır.

05AB1E , 5 bayt

{Rā@O

Çevrimiçi deneyin! veya Test Paketi olarak

açıklama

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

Mathematica, 57 bayt

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

Bu liste alarak ve bir tamsayı döndüren isimsiz bir işlevdir.

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

Tüm test durumlarını kontrol etmek için bunu kullanın:

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

Anonim işlev

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

Girintili'ye:

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