कौन है संभावना वितरण?

Question

परिचय

इस चुनौती में, आपको कुछ संभाव्यता वितरण से स्वतंत्र रूप से खींची गई गैर-अस्थायी फ़्लोटिंग संख्याओं की एक सूची दी जाती है। आपका कार्य संख्याओं से उस वितरण का पता लगाना है। चुनौती को संभव बनाने के लिए, आपके पास चुनने के लिए केवल पांच वितरण हैं।

• U, समान वितरण अंतराल [0,1] पर।
• T, त्रिकोणीय वितरण अंतराल [0,1] मोड ग = 1/2 के साथ पर।
• B, बीटा वितरण अंतराल [0,1] मापदंडों α = β = 1/2 के साथ पर।
• E, दर λ = 2 के साथ अंतराल [0, distribution) पर घातांक वितरण ।
• G, अंतराल पर गामा वितरण [0, with) मापदंडों के साथ k = 3 और ma = 1/6।

ध्यान दें कि उपरोक्त सभी वितरणों का मतलब ठीक 1/2 है।

काम

आपका इनपुट गैर-अस्थायी फ़्लोटिंग पॉइंट की एक सरणी है, जिसकी लंबाई 75 और 100 के बीच है। आपका आउटपुट अक्षरों में से एक होगा UTBEG, जिसके आधार पर आपको लगता है कि उपरोक्त वितरण में से संख्याएँ खींची गई हैं।

नियम और स्कोरिंग

आप या तो एक पूर्ण कार्यक्रम या एक समारोह दे सकते हैं। मानक खामियों को अस्वीकार कर दिया जाता है।

में इस भंडार , वहाँ पाँच पाठ फ़ाइलें, प्रत्येक वितरण के लिए एक, प्रत्येक ठीक 100 लाइनों लंबे होते हैं। प्रत्येक पंक्ति में वितरण से स्वतंत्र रूप से खींची गई 75 से 100 झांकियों की अल्पविराम वाली सूची होती है और दशमलव बिंदु के बाद 7 अंकों तक काट दी जाती है। आप अपनी भाषा के मूल सरणी प्रारूप से मिलान करने के लिए परिसीमन को संशोधित कर सकते हैं। एक उत्तर के रूप में अर्हता प्राप्त करने के लिए, आपके प्रोग्राम को प्रत्येक फ़ाइल से कम से कम 50 सूचियों को वर्गीकृत करना चाहिए । वैध उत्तर का स्कोर बाइट काउंट + कुल संख्या में मिसकॉलिफाइड लिस्ट है । सबसे कम स्कोर जीतता है।

Comments

मुझे शायद पहले पूछना चाहिए था, लेकिन परीक्षण मामलों के प्रति कितना अनुकूलन अपेक्षित है? मैं एक ऐसे बिंदु पर हूं जहां मैं कुछ मापदंडों को जोड़कर अपने स्कोर में सुधार कर सकता हूं, लेकिन स्कोर पर प्रभाव शायद दिए गए परीक्षण मामलों पर निर्भर करेगा।

— डेनिस

@ डेनिस आप जितना चाहें उतना अनुकूलन कर सकते हैं, परीक्षण के मामले चुनौती का एक निश्चित हिस्सा हैं।

— जर्गर्ब

यू नहीं छात्र-टी वितरण? =

— N3buchadnezzar

Answer 1

जूलिया, 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 फ़ाइलों को एक निर्देशिका में रखें (जैसा नाम रखते हैं), और जूलिया 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इसका मतलब है कि G.txt में 13 वीं पंक्ति, जो एक गामा वितरण होनी चाहिए, एक घातांक होने के लिए निर्धारित है। वितरण, मानक विचलन 0.35008999 होने के साथ ...)

प्रत्येक फ़ाइल के बाद, यह उस फ़ाइल के लिए मिसमैच की संख्या को भी आउटपुट करता है, और फिर अंत में यह कुल मिसमैच भी प्रदर्शित करता है (और इसे ऊपर के रूप में चलाने पर इसे 2 पढ़ना चाहिए)। संयोग से, इसमें G.txt के लिए 1 बेमेल और U.txt के लिए 1 बेमेल होना चाहिए

Answer 2

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

यह बायेसियन फॉर्मूले 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 में से सबसे बड़ा है।

मैं एक फ्लैट पहले (यानी पी (डी = डीआई) = 1/5 के लिए [1,5] में मान लेता हूं, जिसका अर्थ है कि अंश में पी (डी = डी) सभी मामलों में समान है (और हर कोई होगा) वैसे भी सभी मामलों में एक ही हो), इसलिए हम सब कुछ निकाल सकते हैं लेकिन 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 संस्करण गोल्फ वाले संस्करण के बिल्कुल समान नहीं है क्योंकि हर से छुटकारा पाने के कारण Inf / Inf के मामले से बचा जाता है जो तब होता है जब आप बीटा वितरण को बंद अंतराल [0,1] के बजाय 0 (0) पर होने देते हैं। 1) - जैसा कि नमूना डेटा करता है। एक अतिरिक्त यदि स्टेटमेंट को संभालता है, लेकिन चूंकि यह चित्रण प्रयोजनों के लिए है, तो शायद यह जटिलता को जोड़ने के लायक नहीं है जो एल्गोरिथम के दिल में नहीं है।

अतिरिक्त कोड कटौती के लिए @Alex A. धन्यवाद। विशेष रूप से जिसके लिए।

Comments

आप इसे 190 बाइट्स को खोलने के बाद लाइन ब्रेक को हटाने {से पहले प्राप्त कर सकते हैं और एक को बंद करने से पहले }, और एलियासिंग prod, जैसे P=prod, फिर कर P(dunif(x)), आदि। फ़ंक्शन को एक मान्य सबमिशन के लिए नाम की आवश्यकता नहीं है, इसलिए आप हटा सकते हैं p=। इसके अलावा, उत्कृष्ट नौकरी। :)

— एलेक्स ए।

आप इसे उपरोक्त सुझावों का उपयोग करके 182 में प्राप्त कर सकते हैं और इसके which.max(c(u,r,b,e,g))स्थान पर उपयोग कर सकते हैं c(u,r,b,e,g)==max(c(u,r,b,e,g))।

— एलेक्स ए।

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

— एलेक्स ए।

आँकड़ों को शामिल करने की चुनौती के लिए आर का उपयोग करने की आपकी हिम्मत कैसे हुई !!

— निर्दोष

Answer 3

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

Answer 4

मतलाब, 428 328 बाइट्स + 33 मिसकॉलिफाइड

यह कार्यक्रम मूल रूप से वास्तविक सीडीएफ की तुलना एक अनुमानित डेटा के साथ कर रहा है, और फिर उन दोनों के बीच की दूरी की गणना करता है: मुझे लगता है कि छवि अधिक बताती है:

यहाँ इस छवि में दिखाया गया डेटा बहुत स्पष्ट रूप से दिखाता है कि यह फ़िरोज़ा वितरण से संबंधित है, क्योंकि यह उस एक के काफी करीब है, इसलिए यह मूल रूप से मेरा कार्यक्रम है। यह शायद कुछ और अधिक गोल्फ हो सकता है। मेरे लिए यह सब एक वैचारिक चुनौती थी, बहुत गोल्फ की नहीं।

यह दृष्टिकोण चुने हुए pdfs से भी स्वतंत्र है, यह वितरण के किसी भी सेट के लिए काम करेगा ।

निम्नलिखित (अनगुल्ड) कोड को दिखाना चाहिए कि यह कैसे किया जाता है। गोल्फ संस्करण नीचे है।

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

पूरी तरह से गोल्फ संस्करण:

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)

Answer 5

पर्ल, 119 बाइट्स + 8 गर्भपात = 127

मैंने तीन विशेषताओं पर एक छोटा निर्णय लिया है:

• $ o: बूलियन: अगर कोई सैंपल> 1.0
• $ t: गिनती: 0-th शून्य से 6-वें 13-ile को 0-1 की श्रेणी में रखा गया,
• $ h: काउंट: 0-th माइनस 6-th प्लस 12-th 13-ile 0-1 रेंज में टकरा गया

के साथ मंगवाया गया perl -F, -lane -e '...'। मुझे यकीन नहीं है कि मुझे गैर-मानक मापदंडों के लिए जुर्माना जोड़ना चाहिए। अगर कॉमा रिक्त स्थान थे, मुझे लगता है कि मैं -F के बिना दूर हो सकता था ,

के लिए (@F) {$ बी [$ _ * 13] ++; $ ओ ++ यदि $ _> 1}
$ ज = ($ टी = $ ख [0] - $ ख [6]) + $ ख [12];
$ ओ प्रिंट ($ टी> -2 "ई": "जी"?): ($ एच = 19 "बी": "यू")?);
$ ओ = @ ख = ()

थोड़ा स्वरूपित आउटपुट (-l ध्वज के बिना) है:

bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
    bbbbbbbbbbbbbbbbbbbbbbbbubbbbbbbbbbbbbbbbbbbbbbb
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
    eeegeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
gggggggegggggggggggggggggggggggggggggggggggggggggggg
    gggggggggggggggggggggggggggggggggggggggggggggggg
tttttttttttttttttttttttttttttttttttttttttttttttttttt
    ttttttttttttttttttttttttttttuttttttttttttutttttt
uuuuuuuuuuuuuuuuuuuuuuuuuuutuuuuuuuuuuuuuuuubuuuuuuu
    uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuutuuuu

Answer 6

पायथन, 318 बाइट्स + 35 मिसक्लासीजेशन

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)

विचार: वितरण को कोलमोगोरोव-स्मिर्नोव परीक्षण के पी-मूल्य के आधार पर अनुमान लगाया गया है।

परीक्षा

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