Giriş

Bu meydan okumada, bazı olasılık dağılımlarından bağımsız olarak çizilen negatif olmayan kayan nokta sayılarının bir listesi verilir. Göreviniz bu dağılımı rakamlardan çıkarmaktır. Meydan okumayı mümkün kılmak için, aralarından seçim yapabileceğiniz yalnızca beş dağıtımınız vardır.

• U, aralıkta eşit dağılım [0,1].
• T, c = 1/2 modu ile [0,1] aralığında üçgen dağılım .
• B, α = β = 1/2 parametreleriyle [0,1] aralığında beta dağılımı .
• E, λ = 2 oranıyla [0, ∞) aralığında üstel dağılım .
• G, k = 3 ve θ = 1/6 parametreleriyle [0, ∞) aralığında gama dağılımı .

Yukarıdaki dağılımların hepsinin ortalama 1/2 olduğunu unutmayın.

Görev

Girişiniz, 75 ila 100 dahil uzunluğunda negatif olmayan kayan nokta sayıları dizisidir. Çıktınız, UTBEGyukarıdaki dağılımlardan hangilerinin alındığını tahmin ettiğiniz harflerden biri olacaktır .

Kurallar ve Puanlama

Tam bir program veya bir işlev verebilirsiniz. Standart boşluklara izin verilmez.

Gelen bu depo , beş metin dosyaları, her dağıtım için bir, uzun, her biri tam 100 satır vardır. Her satır, dağıtımdan bağımsız olarak çizilen ve ondalık noktadan sonra 7 basamağa kadar kesilmiş 75 ila 100 kayan noktalı virgülle ayrılmış bir liste içerir. Sınırlayıcıları dilinizin yerel dizi biçimiyle eşleşecek şekilde değiştirebilirsiniz. Yanıt olarak nitelendirilebilmek için, programınızın her dosyadan en az 50 listeyi doğru bir şekilde sınıflandırması gerekir . Geçerli bir yanıtın puanı, bayt sayısı + toplam yanlış sınıflandırılmış liste sayısıdır . En düşük puan kazanır.

Julia, 60 62 bayt + 25 2 hata = 82 64

k->"EGTBU"[(V=std(k);any(k.>1)?V>.34?1:2:V<.236?3:V>.315?4:5)]

Bu oldukça basit. Dağılımlar için varyans çoğunlukla farklıdır - üstel için 1/4, beta için 1/8, gama ve üniforma için 1/12 ve üçgen için 1/24. Bu nedenle, stdolası dağılımı belirlemek için varyans kullanırsak (burada standart sapma, varyansın kare kökü kullanılarak yapılır ), gama üniformadan ayırt etmek için sadece daha fazlasını yapmamız gerekir; bunun için 1'den (kullanarak any(k.>1)) daha büyük bir değer ararız - yani, genel performansı geliştirdiği için hem üstel hem de gama için kontrol yaparız.

Bir baytı kaydetmek için "EGTBU", koşul içindeki bir dizeyi doğrudan değerlendirmek yerine dizeyi indeksleme yapılır.

Test için, txt dosyalarını bir dizine kaydedin (adları olduğu gibi tutarak) ve bu dizinde Julia REPL'i çalıştırın. Ardından, işlevi bir ada ekleyin.

f=k->"EGTBU"[(V=std(k);any(k.>1)?V>.34?1:2:V<.236?3:V>.315?4:5)]

ve testi otomatikleştirmek için aşağıdaki kodu kullanın (bu, dosyadan okunur, bir dizi diziye dönüştürülür, işlevi kullanır ve her uyuşmazlık için çıktı alır):

m=0;for S=["B","E","G","T","U"] K=open(S*".txt");F=readcsv(K);
M=Array{Float64,1}[];for i=1:100 push!(M,filter(j->j!="",F[i,:]))end;
close(K);n=0;
for i=1:100 f(M[i])!=S[1]&&(n+=1;println(i," "S,"->",f(M[i])," ",std(M[i])))end;
println(n);m+=n;end;println(m)

Çıktı, eşleşmeyen durumu, doğru dağılımı -> belirlenen dağılımı ve hesaplanan varyasyonu içeren satırlardan oluşacaktır (örneğin 13 G->E 0.35008999281668357, G.txt'deki bir gama dağılımı olması gereken 13. sıranın üstel olarak belirlendiği anlamına gelir . dağılım, standart sapma 0.35008999 ...)

Her dosyadan sonra, o dosya için uyumsuzlukların sayısını da verir ve sonunda toplam uyumsuzlukları da görüntüler (ve yukarıdaki gibi çalıştırılırsa 2'yi okumalıdır). Bu arada, G.txt için 1 ve U.txt için 1 uyumsuzluk olmalıdır.

R, 20219218218216162 154 bayt + 0 hata

function(x)c("U","T","B","E","G")[which.max(lapply(list(dunif(x),sapply(x,function(y)max(0,2-4*abs(.5-y))),dbeta(x,.5,.5),dexp(x,2),dgamma(x,3,6)),prod))]

Bu, Bayes formül P (D = d | X = x) = P (X = x | D = d) * P (D = d) / P (X = x) formülüne dayanmaktadır, burada D dağılımdır ve X rastgele bir örnektir. D'yi P (D = d | X = x) 5'ten büyük olacak şekilde seçiyoruz.

Önceden düz bir varsayım (yani [1,5] 'de i için P (D = di) = 1/5), yani paydaki P (D = d) tüm durumlarda aynıdır (ve payda her durumda aynı olmak), bu yüzden P (x = X | D = d) hariç her şeyi golf oynayabiliriz, ki bu (üçgen dağılım hariç) R'deki yerel işlevlere basitleştirir.

ungolfed:

function(x){
  u=prod(dunif(x))
  r=prod(sapply(x,function(y)max(0,2-4*abs(.5-y))))
  b=prod(dbeta(x,.5,.5))
  e=prod(dexp(x,2))
  g=prod(dgamma(x,3,6))
  den=.2*u+.2*r+.2*b+.2*e+.2*g
  c("U","T","B","E","G")[which.max(c(u*.2/den,r*.2/den,b*.2/den,e*.2/den,g*.2/den))]
}

Unungolfed versiyonun golfed versiyona tam olarak eşdeğer olmadığını unutmayın, çünkü paydadan kurtulmak, beta dağılımının (0, yerine kapalı aralık [0,1] üzerinde olmasına izin verirseniz oluşan Inf / Inf vakasını önler. 1) - örnek verilerde olduğu gibi. Ek bir if ifadesi bununla başa çıkacaktı, ancak sadece açıklama amaçlı olduğu için, algoritmanın kalbinde olmayan karmaşıklığı eklemeye değmez.

Ek kod indirimleri için @Alex A. teşekkürler. Özellikle hangi için. Max!

CJam, 76

{2f*__{(z.4<},,%,4e<"UBT"="EG"\*\$-2=i3e<=}

Kaynak kodu 43 bayt uzunluktadır ve 33 listeyi yanlış sınıflandırır .

Doğrulama

$ count()(sort | uniq -c | sort -nr)
$ cat score.cjam
qN%{',' er[~]
  {2f*__{(z.4<},,%,4e<"UBT"="EG"\*\$-2=i3e<=}
~N}/
$ for list in U T B E G; { echo $list; cjam score.cjam < $list.txt | count; }
U
     92 U
      6 B
      2 T
T
    100 T
B
     93 B
      7 U
E
     92 E
      8 G
G
     90 G
      6 E
      3 T
      1 U

Fikir

Kalan olanlardan üstel ve gama dağılımını ayırt kolaydır onlar daha büyük değerleri almak sadece dağılımlar olduğundan 1 .

Gama , üstel ve diğerleri arasında karar vermek için numunenin ikinci en yüksek değerine bakıyoruz.

• Eğer [1.5, ∞) yatıyorsa , sanırım gamma .

• Eğer [1, 1.5) ise , üstel olduğunu tahmin ediyoruz .

• Eğer [0, 1) ise , kalan üç ihtimalimiz var.

  Geri kalan dağılımlar, ortalamanın ( 0.5 ) yakınında bulunan örnek değerlerin yüzdesi ile ayırt edilebilir .

  Numunenin uzunluğunu (0,3, 0,7) düşen değer sayısına böleriz ve ortaya çıkan bölüme bakarız.

  • O yatıyor ise (1, 2] , biz tahmin üçgen .

  • O yatıyor ise (2, 3] , biz tahmin üniforma .

  • O yatıyor ise (3, ∞) , biz tahmin beta .

kod

2f*    e# Multiply all sample values by 2.
__     e# Push to copies of the sample.
{      e# Filter; for each (doubled) value in the sample:
  (z   e#   Subtract 1 and apply absolute value.
  .4<  e#   Check if the result is smaller than 0.4.
},     e# If it is, keep the value.
,/     e# Count the kept values (K).
%      e# Select every Kth value form the sample, starting with the first.
,      e# Compute the length of the resulting array.
       e# This performs ceiled division of the sample length by K.
4e<    e# Truncate the quotient at 4.
"UBT"= e# Select 'T' for 2, 'U' for 3 and 'B' for 4.
"EG"\* e# Place the selected character between 'E' and 'G'.
\$     e# Sort the remaining sample.
-2=i   e# Extract the second-highest (doubled) value and cast to integer.
3e<    e# Truncate the result at 3.
=      e# Select 'E' for 3, 'G' for 2 and the character from before for 1.

Matlab, 428328 bayt + 33 yanlış sınıflandırılmış

Bu program temelde gerçek CDF'yi tahmini bir veriyle karşılaştırıyor ve daha sonra bu ikisi arasındaki ortalama mesafeyi hesaplıyor: Sanırım görüntü daha fazla açıklıyor:

Bu görüntüde gösterilen veriler, oldukça yakın olduğu için turkuaz dağılımına ait olduğunu açıkça göstermektedir, bu yüzden temel olarak programım bunu yapıyor. Muhtemelen biraz daha golf edilebilir. Benim için bu kavramsal bir meydan okumaydı, çok golfçu değil.

Bu yaklaşım ayrıca seçilen pdf'lerden bağımsızdır, herhangi bir dağıtım seti için işe yarayacaktır .

Aşağıdaki (çözülmemiş) kodun nasıl yapıldığını göstermelidir. Golfçü versiyon aşağıdadır.

function r=p(x);
data=sort(x(1:75));
%% cumulative probability distributiosn
fu=@(x)(0<x&x<1).*x+(1<=x).*1;
ft=@(x)(0<x&x< 0.5).* 2.*x.^2+(1-2*(1-x).^2).*(0.5<=x&x<1)+(1<=x);
fb=@(x)(0<x&x<1).*2.*asin(sqrt(x))/pi+(1<=x);
fe=@(x)(0<x).*(1-exp(-2*x));
fg=@(x)(0<x).*(1-exp(-x*6).*(1+x*6+1/2*(6*x).^2));
fdata = @(x)sum(bsxfun(@le,data,x.'),2).'/length(data);
f = {fe,fg,fu,ft,fb};
str='EGUTB';
%calculate distance to the different cdfs at each datapoint
for k=1:numel(f);
dist(k) = max(abs(f{k}(x)-fdata(x)));
end;
[~,i]=min(dist);
r=str(i);
end

Tamamen golf versiyonu:

function r=p(x);f={@(x)(0<x).*(1-exp(-2*x)),@(x)(0<x).*(1-exp(-x*6).*(1+x*6+18*x.^2)),@(x)(0<x&x<1).*x+(1<=x),@(x)(0<x&x<.5).*2.*x.^2+(1-2*(1-x).^2).*(.5<=x&x<1)+(1<=x),@(x)(0<x&x<1).*2.*asin(sqrt(x))/pi+(1<=x)};s='EGUTB';for k=1:5;d(k)=max(abs(f{k}(x)-sum(bsxfun(@le,x,x.'),2).'/nnz(x)));end;[~,i]=min(d(1:5-3*any(x>1)));r=s(i)

Perl, 119 bayt + 8 yanlış sınıflandırma = 127

Üç özellik üzerinde küçük bir karar ağacı yaptım:

• $ o: boolean: eğer herhangi bir örnek> 1.0
• $ t: sayım: 0'ıncı eksi 6'ıncı 13'üncü değer 0-1 aralığına kırpılmış,
• $ h: sayım: 0'ıncı eksi 6'ıncı artı 12'inci 13-ile, 0-1 aralığına kırpıldı

İle çağrıldı perl -F, -lane -e '...'. Standart olmayan parametreler için bir ceza eklemem gerekip gerekmediğinden emin değilim. Virgüller boşluk olsaydı, sanırım -F olmadan uzaklaşabilirdim ,

(@F) için {$ b [$ _ * 13] ++; $ o ++ $ ise _> 1}
$ H = ($ t = $ b [0] - $ b [6]) + $ b [12];
$ O baskı ($ t> -2 "e": "g"): (= 19, "b" $ s: "u"));
$ O = Rb = ()

Hafif biçimlendirilmiş çıktı (-l bayrağı olmadan):

bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
    bbbbbbbbbbbbbbbbbbbbbbbbubbbbbbbbbbbbbbbbbbbbbbb
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
    eeegeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
gggggggegggggggggggggggggggggggggggggggggggggggggggg
    gggggggggggggggggggggggggggggggggggggggggggggggg
tttttttttttttttttttttttttttttttttttttttttttttttttttt
    ttttttttttttttttttttttttttttuttttttttttttutttttt
uuuuuuuuuuuuuuuuuuuuuuuuuuutuuuuuuuuuuuuuuuubuuuuuuu
    uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuutuuuu

Python, 318 bayt + 35 yanlış sınıflandırma

from scipy.stats import*
from numpy import*
def f(l):
    r={'U':kstest(l,'uniform')[1],'T':kstest(l,'triang',args=(.5,))[1],'B':kstest(l,'beta',args=(.5,.5))[1],'E':kstest(l,'expon',args=(0,.5,))[1],'G':kstest(l,'gamma',args=(3,0,1/6.0))[1]}
    if sum([x>1 for x in l]): r['U'],r['T'],r['B']=0,0,0
    return max(r,key=r.get)

Fikir: dağılım, Kolmogorov-Smirnov testinin p değerine göre tahmin edilir.

Ölçek

from scipy.stats import*
from numpy import*
import os
from io import StringIO
dir=os.path.dirname(os.path.abspath(__file__))+"/random-data-master/"

def f(l):
    r={'U':kstest(l,'uniform')[1],'T':kstest(l,'triang',args=(.5,))[1],'B':kstest(l,'beta',args=(.5,.5))[1],'E':kstest(l,'expon',args=(0,.5,))[1],'G':kstest(l,'gamma',args=(3,0,1/6.0))[1]}
    if sum([x>1 for x in l]): r['U'],r['T'],r['B']=0,0,0
    return max(r,key=r.get)

U=[line.rstrip('\n').split(',') for line in open(dir+'U.txt')]
U=[[float(x) for x in r] for r in U]
T=[line.rstrip('\n').split(',') for line in open(dir+'T.txt')]
T=[[float(x) for x in r] for r in T]
B=[line.rstrip('\n').split(',') for line in open(dir+'B.txt')]
B=[[float(x) for x in r] for r in B]
E=[line.rstrip('\n').split(',') for line in open(dir+'E.txt')]
E=[[float(x) for x in r] for r in E]
G=[line.rstrip('\n').split(',') for line in open(dir+'G.txt')]
G=[[float(x) for x in r] for r in G]

i,_u,_t,_b,_e,_g=0,0,0,0,0,0
for u,t,b,e,g in zip(U,T,B,E,G):
    _u+=1 if f(u)=='U' else 0
    _t+=1 if f(t)=='T' else 0
    _b+=1 if f(b)=='B' else 0
    _e+=1 if f(e)=='E' else 0
    _g+=1 if f(g)=='G' else 0
    print f(u),f(t),f(b),f(e),f(g)
print _u,_t,_b,_e,_g,100*5-_u-_t-_b-_e-_g