บทนำ

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

• Uการแจกแจงแบบสม่ำเสมอในช่วง [0,1]
• Tการแจกแจงสามเหลี่ยมในช่วง [0,1] ด้วยโหมด c = 1/2
• B, การแจกแจงแบบเบต้าในช่วงเวลา [0,1] พร้อมพารามิเตอร์α = β = 1/2
• E, การแจกแจงแบบเอ็กซ์โพเนนเชียลในช่วงเวลา [0, ∞) ด้วยอัตราλ = 2
• G, การแจกแจงแกมมาตามช่วงเวลา [0, ∞) พร้อมพารามิเตอร์ k = 3 และθ = 1/6

โปรดทราบว่าการแจกแจงด้านบนทั้งหมดมีค่า 1/2

งาน

ข้อมูลที่คุณป้อนเป็นจำนวนจุดลอยตัวที่ไม่ใช่ค่าลบซึ่งมีความยาวระหว่าง 75 ถึง 100 ผลลัพธ์ของคุณจะเป็นหนึ่งในตัวอักษรUTBEGซึ่งขึ้นอยู่กับการแจกแจงข้างต้นที่คุณคาดเดาว่าตัวเลขนั้นมาจาก

กฎและเกณฑ์การให้คะแนน

คุณสามารถให้ทั้งโปรแกรมหรือฟังก์ชั่นเต็มรูปแบบ ช่องโหว่มาตรฐานไม่ได้รับอนุญาต

ในที่เก็บนี้มีไฟล์ข้อความห้าไฟล์หนึ่งไฟล์สำหรับแต่ละการแจกจ่ายแต่ละไฟล์มีความยาว 100 บรรทัด แต่ละบรรทัดประกอบด้วยรายการที่คั่นด้วยจุลภาคของ 75 ถึง 100 ลอยวาดอิสระจากการกระจายและตัดให้เหลือ 7 หลักหลังจุดทศนิยม คุณสามารถแก้ไขตัวคั่นเพื่อให้ตรงกับรูปแบบอาร์เรย์ดั้งเดิมของภาษาของคุณ จะมีคุณสมบัติเป็นคำตอบที่โปรแกรมของคุณอย่างถูกต้องควรแยกประเภทอย่างน้อย 50 รายการจากแต่ละไฟล์ คะแนนของคำตอบที่ถูกต้องคือการนับไบต์ + จำนวนรวมของรายการแบ่ง คะแนนต่ำสุดชนะ

Julia, 60 62 ไบต์ + 25 2 ข้อผิดพลาด = 82 64

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

มันค่อนข้างง่าย ความแปรปรวนของการแจกแจงส่วนใหญ่จะแตกต่างกัน - มันคือ 1/4 สำหรับเลขชี้กำลัง, 1/8 สำหรับเบต้า, 1/12 สำหรับแกมม่าและเครื่องแบบ, และ 1/24 สำหรับสามเหลี่ยม เช่นถ้าเราใช้ความแปรปรวน (นี่ใช้stdเพื่อเบี่ยงเบนมาตรฐาน, สแควร์รูทของความแปรปรวน) เพื่อกำหนดการกระจายที่เป็นไปได้เราเพียง แต่ต้องทำมากกว่านี้เพื่อแยกความแตกต่างของแกมม่าออกจากชุด สำหรับสิ่งนั้นเรามองหาค่าที่มากกว่า 1 (โดยใช้any(k.>1)) - ที่กล่าวว่าเราทำการตรวจสอบทั้งเอ็กซ์โปเนนเชียลและแกมม่าเนื่องจากช่วยปรับปรุงประสิทธิภาพโดยรวม

ในการบันทึกไบต์การทำดัชนีสตริง"EGTBU"จะทำแทนการประเมินสตริงโดยตรงภายในเงื่อนไข

สำหรับการทดสอบให้บันทึกไฟล์ txt ไว้ในไดเรกทอรี (เก็บชื่อตามเดิม) และเรียกใช้ Julia REPL ในไดเรกทอรีนั้น จากนั้นแนบฟังก์ชั่นเข้ากับชื่อเป็น

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

และใช้รหัสต่อไปนี้เพื่อทำการทดสอบอัตโนมัติ (จะอ่านจากไฟล์แปลงเป็นอาร์เรย์ของอาร์เรย์ใช้ฟังก์ชั่นและเอาท์พุทสำหรับแต่ละที่ไม่ตรงกัน):

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)

ผลลัพธ์จะประกอบด้วยแถวที่มีกรณีที่ไม่ตรงกันการแจกแจงที่ถูกต้อง -> การแจกแจงที่กำหนดและความแปรปรวนที่คำนวณได้ (เช่น13 G->E 0.35008999281668357หมายความว่าแถวที่ 13 ใน G.txt ซึ่งควรจะเป็นการแจกแจงแกมม่าถูกกำหนดให้เป็นเลขชี้กำลัง การกระจายโดยมีค่าเบี่ยงเบนมาตรฐานเท่ากับ 0.35008999 ... )

หลังจากแต่ละไฟล์มันจะแสดงผลจำนวนของการจับคู่ที่ไม่ตรงกันสำหรับไฟล์นั้นและในตอนท้ายก็จะแสดงการจับคู่ที่ไม่ตรงกันทั้งหมด (และควรอ่าน 2 หากเรียกใช้ตามข้างบน) อนึ่งควรมี 1 ไม่ตรงกันสำหรับ G.txt และ 1 ไม่ตรงกันสำหรับ U.txt

R, 202 192 184 182 162 154 ไบต์ + 0 ข้อผิดพลาด

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

สิ่งนี้ขึ้นอยู่กับสูตร Bayesian P (D = d | X = x) = P (X = x | D = d) * P (D = d) / P (X = x) โดยที่ D คือการแจกแจงและ X เป็นตัวอย่างแบบสุ่ม เราเลือก d ซึ่ง P (D = d | X = x) นั้นยิ่งใหญ่ที่สุดใน 5

ฉันถือว่าแบนก่อน (เช่น P (D = di) = 1/5 สำหรับฉันใน [1,5]) ซึ่งหมายความว่า P (D = d) ในตัวเศษเหมือนกันในทุกกรณี (และตัวส่วนจะ จะเหมือนกันในทุกกรณีอย่างไรก็ตามเราสามารถตีทุกอย่างได้ แต่ P (x = X | D = d) ซึ่ง (ยกเว้นการกระจายสามเหลี่ยม) ลดความซับซ้อนของฟังก์ชันดั้งเดิมใน R

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))]
}

โปรดทราบว่าเวอร์ชัน ungolfed นั้นไม่เท่ากับเวอร์ชั่น golfed เนื่องจากการกำจัดตัวส่วนจะหลีกเลี่ยงกรณีของ Inf / Inf ซึ่งเกิดขึ้นหากคุณอนุญาตให้การแจกแจงแบบเบต้าอยู่ในช่วงปิด [0,1] แทน (0, 1) - เช่นเดียวกับข้อมูลตัวอย่าง เพิ่มเติมถ้าคำสั่งจะจัดการกับที่ แต่เนื่องจากมันมีวัตถุประสงค์เพื่อเป็นตัวอย่างเท่านั้นมันอาจจะไม่คุ้มค่าที่จะเพิ่มความซับซ้อนที่ไม่ได้เป็นหัวใจของอัลกอริทึม

ขอบคุณ @Alex A. สำหรับการลดรหัสเพิ่มเติม โดยเฉพาะอย่างยิ่งสำหรับสูงสุด!

CJam, 76

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

รหัสแหล่งที่มาคือ ยาว43ไบต์และจำแนกรายการได้33รายการ

การตรวจสอบ

$ 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

ความคิด

การจำแนกการแจกแจงแบบเอ็กซ์โปเนนเชียลและแกมม่าจากส่วนที่เหลือนั้นเป็นเรื่องง่ายเนื่องจากมันเป็นเพียงดิสทริบิวชันที่รับค่ามากกว่า 1

จะตัดสินใจระหว่างแกมมา ,ชี้แจงและอื่น ๆ เราจะดูที่มูลค่าสูงสุดเป็นอันดับสองของกลุ่มตัวอย่างที่

• ถ้ามันอยู่ใน[1.5, ∞)เราจะเดาแกมม่าแกมมา

• ถ้ามันอยู่ใน[1, 1.5)เราจะเดาเลขชี้กำลังชี้แจง

• ถ้ามันอยู่ใน [0, 1)เรามีความเป็นไปได้สามทางที่เหลืออยู่

  การแจกแจงที่เหลือสามารถแตกต่างกันได้โดยเปอร์เซ็นต์ของค่าตัวอย่างที่อยู่ใกล้กับค่าเฉลี่ย ( 0.5 )

  เราแบ่งความยาวของตัวอย่างโดยการนับค่าที่อยู่ใน(0.3, 0.7)และดูความฉลาดทางผลลัพธ์

  • ถ้ามันอยู่ใน(1, 2]เราเดาว่าสามเหลี่ยมเป็นรูปสามเหลี่ยม

  • ถ้ามันอยู่ใน(2, 3]เราเดาเครื่องแบบ

  • ถ้ามันอยู่ใน(3, ∞)เราคาดเดาเบต้า

รหัส

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, 428 328 ไบต์ + 33 misclassified

โปรแกรมนี้เป็นการเปรียบเทียบ CDF จริงกับข้อมูลที่ได้รับจากการประมาณแล้วคำนวณระยะทางเฉลี่ยระหว่างสอง: ฉันคิดว่าภาพอธิบายเพิ่มเติม:

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

วิธีการนี้เป็นอิสระจากไฟล์ PDF ที่เลือกซึ่งจะใช้งานได้กับทุก ๆการแจกแจงชุด

การติดตามโค้ด (ไม่ได้รับการอภินิหาร) ควรแสดงให้เห็นว่ามันเป็นอย่างไร รุ่น golfed อยู่ด้านล่าง

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

รุ่น golfed อย่างเต็มที่:

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 ไบต์ + 8 การจัดประเภทอื่น = 127

ฉันได้สร้างแผนผังการตัดสินใจเล็ก ๆ สามประการ:

• $ o: บูลีน: ถ้ามีตัวอย่างใด ๆ > 1.0
• $ t: นับ: 0-th ลบ 6-th 13-ile ที่ตัดเข้ามาในช่วง 0-1
• $ h: นับ: 0-th ลบ 6-th บวก 12-th 13-ile ที่ถูกตัดเข้าในช่วง 0-1

perl -F, -lane -e '...'เรียกด้วย ฉันไม่แน่ใจว่าควรเพิ่มบทลงโทษสำหรับพารามิเตอร์ที่ไม่ได้มาตรฐานหรือไม่ ถ้าเครื่องหมายจุลภาคเป็นช่องว่างฉันเดาว่าฉันจะไปได้โดยไม่ต้อง -F

สำหรับ (F @) {$ ข [$ _ * 13] ++; $ o ++ ถ้า _ $> 1}
$ H = ($ t = $ ข [0] - $ ข [6]) + $ ข [12];
พิมพ์ $ o ($ T> -2 "อี": "g"?): ($ H = 19 "B": "U"));
$ o = @ B = ()

เอาต์พุตที่จัดรูปแบบเล็กน้อย (ไม่มีแฟล็ก -l) คือ:

bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
    bbbbbbbbbbbbbbbbbbbbbbbbubbbbbbbbbbbbbbbbbbbbbbb
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
    eeegeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
gggggggegggggggggggggggggggggggggggggggggggggggggggg
    gggggggggggggggggggggggggggggggggggggggggggggggg
tttttttttttttttttttttttttttttttttttttttttttttttttttt
    ttttttttttttttttttttttttttttuttttttttttttutttttt
uuuuuuuuuuuuuuuuuuuuuuuuuuutuuuuuuuuuuuuuuuubuuuuuuu
    uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuutuuuu

Python 318 ไบต์ + 35 missclassifications

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)

แนวคิด:การกระจายจะเดาตามค่า p ของการทดสอบ Kolmogorov-Smirnov

ทดสอบ

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