परिचय

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

एक कोड स्निपेट नामित कार्यों (या निकटतम समकक्ष) के संग्रह को परिभाषित करता है।
अभिव्यक्तियों का एक संग्रह जो नामित या अनाम कार्यों (या निकटतम समकक्ष) का मूल्यांकन करता है।
एक एकल अभिव्यक्ति जो कई नामित या अनाम फ़ंक्शन (या निकटतम समकक्ष) का मूल्यांकन करती है।
कमांड लाइन, एसटीडीआईएन या निकटतम समकक्ष से इनपुट लेने वाले स्वतंत्र कार्यक्रमों का एक संग्रह, और एसटीडीयूटी या निकटतम समकक्ष के लिए आउटपुट।

कार्य करता है

यदि वांछित हो, तो आप निम्न नामों को लागू करेंगे।

uniformइनपुट के रूप में दो फ़्लोटिंग पॉइंट नंबर लेता है aऔर b, और समान वितरण को वापस लौटाता है [a,b]। तुम मान सकते हो कि a < b; मामला a ≥ bअपरिभाषित है।
blendआदानों के रूप में तीन संभावना वितरण लेता है P, Qऔर R। यह एक संभावना वितरण रिटर्न S, जो मूल्यों खींचता है x, yऔर zसे P, Qऔर R, क्रमशः, और पैदावार yकरता है, तो x ≥ 0है, और zयदि x < 0।
overइनपुट के रूप में एक फ्लोटिंग पॉइंट नंबर fऔर एक प्रायिकता डिस्ट्रीब्यूशन लेता है P, और x ≥ fएक रैंडम नंबर से xखींची गई संभावना को वापस लौटाता है P।

संदर्भ के लिए, overनिम्नानुसार परिभाषित किया जा सकता है (छद्मकोश में):

over(f, uniform(a, b)):
    if f <= a: return 1.0
    else if f >= b: return 0.0
    else: return (b - f)/(b - a)

over(f, blend(P, Q, R)):
    p = over(0.0, P)
    return p*over(f, Q) + (1-p)*over(f, R)

आप मान सकते हैं कि सभी संभावना को देखते हुए वितरण करने के लिए overका उपयोग कर निर्माण कर रहे हैं uniformऔर blend, और करने के लिए इसे खिलाने के लिए है कि केवल एक चीज एक उपयोगकर्ता एक प्रायिकता वितरण के साथ क्या करने जा रहा है है blendया over। आप वितरण का प्रतिनिधित्व करने के लिए किसी भी सुविधाजनक डेटाटाइप का उपयोग कर सकते हैं: संख्याओं, तारों, कस्टम ऑब्जेक्ट्स आदि की सूची। केवल महत्वपूर्ण बात यह है कि एपीआई सही ढंग से काम करता है। इसके अलावा, आपका कार्यान्वयन नियतात्मक होना चाहिए, हमेशा एक ही इनपुट के लिए एक ही आउटपुट वापस करने के अर्थ में।

परीक्षण के मामलों

इन परीक्षण मामलों पर दशमलव बिंदु के बाद आपका आउटपुट मान कम से कम दो अंकों तक सही होना चाहिए।

over(4.356, uniform(-4.873, 2.441)) -> 0.0
over(2.226, uniform(-1.922, 2.664)) -> 0.09550806803314438
over(-4.353, uniform(-7.929, -0.823)) -> 0.49676329862088375
over(-2.491, uniform(-0.340, 6.453)) -> 1.0
over(0.738, blend(uniform(-5.233, 3.384), uniform(2.767, 8.329), uniform(-2.769, 6.497))) -> 0.7701533851999125
over(-3.577, blend(uniform(-3.159, 0.070), blend(blend(uniform(-4.996, 4.851), uniform(-7.516, 1.455), uniform(-0.931, 7.292)), blend(uniform(-5.437, -0.738), uniform(-8.272, -2.316), uniform(-3.225, 1.201)), uniform(3.097, 6.792)), uniform(-8.215, 0.817))) -> 0.4976245638164541
over(3.243, blend(blend(uniform(-4.909, 2.003), uniform(-4.158, 4.622), blend(uniform(0.572, 5.874), uniform(-0.573, 4.716), blend(uniform(-5.279, 3.702), uniform(-6.564, 1.373), uniform(-6.585, 2.802)))), uniform(-3.148, 2.015), blend(uniform(-6.235, -5.629), uniform(-4.647, -1.056), uniform(-0.384, 2.050)))) -> 0.0
over(-3.020, blend(blend(uniform(-0.080, 6.148), blend(uniform(1.691, 6.439), uniform(-7.086, 2.158), uniform(3.423, 6.773)), uniform(-1.780, 2.381)), blend(uniform(-1.754, 1.943), uniform(-0.046, 6.327), blend(uniform(-6.667, 2.543), uniform(0.656, 7.903), blend(uniform(-8.673, 3.639), uniform(-7.606, 1.435), uniform(-5.138, -2.409)))), uniform(-8.008, -0.317))) -> 0.4487803553043079

code-golf probability-theory

— Zgarb
स्रोत

2

क्या हम उन्हें बनाने के लिए अंतर्निहित कार्यों का उपयोग कर सकते हैं?

— म्युटोर

@ AndréMuta मैं भूल गया कि शायद गणितज्ञ ने इस सब के लिए अंतर्निहित है ... लेकिन मैं उन्हें अनुमति देने जा रहा हूं, जब तक वे नियमों का पालन करते हैं।

— जर्बर्ग

ब्रेनफक में फ्लोटिंग पॉइंट डेटा का प्रतिनिधित्व करने के बारे में आपका क्या सुझाव है?

— दोष अष्टक

@flawr उन भाषाओं के लिए जिनमें देशी फ़्लोटिंग पॉइंट नंबर नहीं हैं, आप -10.0 और 10.0 (अनन्य) के बीच फ़्लोट के लिए किसी भी सुविधाजनक एन्कोडिंग का उपयोग कर सकते हैं, जिसमें लगातार मूल्यों के बीच 0.001 अंतर है। परीक्षण मामलों के लिए आउटपुट 0.01 अंतर के भीतर सटीक होना चाहिए।

— ज़गारब

1

सीजेएम, 58 बाइट्स

{[\]}:U;
{[@]}:B;
{_,2={~1$-@@-\/0e>1e<}{6Yb@f*\.{O})[_1@-].*:+}?}:O;

ये पोस्टफ़िक्स ऑपरेटर हैं जो स्टैक पर काम करते हैं: 2.0 1.0 3.0 U Oहै over(2, uniform(1, 3))।

स्कोर की गिनती

{[\]}फ़ंक्शन ही है, :U;इसे नाम देता है Uऔर इसे पॉप करता है। अनिवार्य रूप से यह फ़ंक्शन का हिस्सा नहीं है, इसलिए स्कोर गणना नियम 2 से, मुझे केवल गिनती करनी होगी {[\]}। Bइसी तरह परिभाषित किया गया है।

हालाँकि, Oपुनरावर्ती है, और अगर मैं कोई नाम निर्दिष्ट नहीं करता हूं, तो पुनरावृत्ति करने का कोई तरीका नहीं है। तो यहाँ, मैं :O;हिस्सा गिनना चाहूँगा । फिर मेरा स्कोर 5+5+48=58कुल मिलाकर बाइट्स है।

व्याख्या

Uदो तर्कों को पॉप करता है और रिवर्स ऑर्डर में एक जोड़ी बनाता है a b => [b a]:।

Bतीन तर्कों को पॉप करता है और घुमाए गए क्रम में एक ट्रिपल बनाता है a b c => [b c a]:।

Oसंरचना इस प्रकार है:

{             }:O;   Define O as this function:
 _,2=        ?       If the argument list's length is 2:
     {~Γ}            Append the list to the stack and execute subprogram Γ.
         {~Δ}        Else, do the same, but execute subprogram Δ.

Subprogram Γ वर्दी वितरण संभालती है:

Executed ops      Explanation   Stack contents
============      ===========   ==============
                  Initial       f; b; a
1$                Copy b        f; b; a; b
  -               Difference    f; b; (a-b)
   @@             Rotate x2     (a-b); f, b
     -            Difference    (a-b); (f-b)
      \/          Flip divide   (f-b)/(a-b)
        0e>       Clamp low     max(0, (f-b)/(a-b))
           1e<    Clamp high    min(1, max(0, (f-b)/(a-b)))

Subprogram Δ मिश्रित वितरण संभालती है:

Executed ops              Explanation    Stack contents
============              ===========    ==============
                          Initial        f; [Q R P]
6Yb                       Push [1,1,0]   f; [Q R P]; [1 1 0]
   @                      Rotate         [Q R P]; [1 1 0]; f
    f*                    Multiply each  [Q R P]; [f f 0]
      \                   Swap           [f f 0]; [Q R P]
       .{O}               Pairwise O     [q r p]
           )              Uncons         [q r] p
            [_1@-]        [p, 1-p]       [q r] [p 1-p]
                  .*:+    Dot product    q*p+r*(1-p)

— लिन
स्रोत

2

रूबी, 103

u=b=->*a{a}
o=->f,d{d[2]?(p=o[0,d[0]])*o[f,d[1]]+(1-p)*o[f,d[2]]:(f<a=d[0])?1:(f>b=d[1])?0:(b-f)/(b-a)}

परिभाषित करता है तीन lambdas, u, b, और o। uऔर bक्रमशः दो-तत्व और तीन-तत्व सरणियों का निर्माण करें। oदो-तत्व सरणी मानता है एक समान वितरण और तीन-तत्व एक तीन वितरण का एक मिश्रण है। बाद के मामले में यह खुद को पुनरावर्ती कहता है।

— histocrat
स्रोत

2

MATLAB, 73

MATLAB में थोड़ा "कार्यात्मक प्रोग्रामिंग" के लिए समय। ये 3 अनाम कार्य हैं। उदाहरण के रूप में समान और मिश्रण को उसी तरह से कहा जाता है, लेकिन overतर्कों के लिए स्वैप किया जाना चाहिए। मुझे वास्तव overमें पहले दो रिटर्न फ़ंक्शंस की ज़रूरत नहीं है , लेकिन एक औपचारिकता के रूप fevalमें एक फ़ंक्शन है जो किसी फ़ंक्शन को कॉल कर सकता है।

%uniform
@(a,b)@(x)(x<b)*min(1,(b-x)/(b-a))
%blend
@(P,Q,R)@(x)P(0)*(Q(x)-R(x))+R(x)
%over
@feval

अब MATLAB के पार्सिंग और मूल्यांकन प्रणाली को कम से कम कहने के लिए थोड़ी जीत है। यह आपको एक फ़ंक्शन को सीधे कॉल करने की अनुमति नहीं देता है जो किसी फ़ंक्शन से वापस किया गया था। इसके बजाय, एक परिणाम को पहले एक चर में सहेजना होगा। 4 उदाहरण इस प्रकार किया जा सकता है:

x=uniform(-5.233,3.384);y=uniform(2.767,8.329);z=uniform(-2.769,6.497);over(blend(x,y,z),0.738)

हालांकि, fevalसभी फ़ंक्शन को कॉल करने के लिए उपयोग करके इसके चारों ओर प्राप्त करना संभव है । यदि निम्नलिखित परिभाषाओं का उपयोग किया जाता है, तो उदाहरणों का मूल्यांकन ठीक उसी तरह किया जा सकता है, जैसा वे लिखे जाते हैं।

uniform=@(a,b)@(x)(x<b)*min(1,(b-x)/(b-a))
blend=@(P,Q,R)@(x)feval(P,0)*(feval(Q,x)-feval(R,x))+feval(R,x)
over=@(x,f)feval(f,x)

— feersum
स्रोत

कार्य करने वाले कार्य ... कैसे विकृत!

— लुइस मेंडो

1

गणितज्ञ, 129 116 बाइट्स

u=UniformDistribution@{##}&;b=If[x<0,z,y]~TransformedDistribution~{x\uF3D2#,y\uF3D2#2,z\uF3D2#3}&;o=Probability[x>=#,x\uF3D2#2]&

u, bऔर oहैं uniform, blendऔर overक्रमशः। मानक मानकों पर काम करते हैं। \uF3D23-बाइट वर्ण के साथ एस बदलें । सिर्फ रिटर्न 0और 1मामलों 1, 4, और 7 के लिए।

— LegionMammal978
स्रोत

1

पायथन, 146 बाइट्स

u=lambda*a:a
b=u
x=lambda f,a,b:[int(f<=a),(b-f)/(b-a)][a<f<b]
y=lambda f,p,q,r:o(0,p)*o(f,q)+(1-o(0,p))*o(f,r)
o=lambda f,p:[x,y][len(p)-2](f,*p)

हिस्टोक्रेट की रूबी जवाब के रूप में एक ही रणनीति, लेकिन पायथन में। जेड-कॉम्बिनेटर (जो महंगा होगा) के बिना पुनरावृत्ति करने के लिए, xऔर yसहायक कार्यों के रूप में परिभाषित किया जाता है जो over2- और 3-लंबाई तर्क ट्यूपल्स ( uniformऔर blendतर्क) के लिए मूल्यांकन करते हैं ।

आइडोन पर टेस्ट केस

— मै जाऊं
स्रोत

0

मतलाब, 104 बाइट्स

मुझे उम्मीद है कि यह अभी भी मान्य है, क्योंकि यह केवल [-10,10] में समर्थन के साथ वितरण के लिए काम करता है, जो उन भाषाओं के लिए आवश्यक है जिनके पास कोई फ़्लोटिंग बिंदु समर्थन नहीं है। समर्थन वेक्टर और सटीकता को आसानी से इसी संख्याओं में फेरबदल करके समायोजित किया जा सकता है। u,o,bके लिए है uniform,blend,over। पीडीएफ को सिर्फ असतत वेक्टर के रूप में दर्शाया गया है। मुझे लगता है कि इस दृष्टिकोण को आसानी से अन्य भाषाओं में स्थानांतरित किया जा सकता है।

D=1e-4;X=-10:D:10;
u=@(a,b)(1/(b-a))*(a<X&X<b);
o=@(x,d)sum(d.*(X>x))*D;
b=@(p,q,r)o(0,p).*q+(1-o(0,p)).*r;

यदि आप उन कार्यों को पहले परिभाषित करते हैं तो आप उनका परीक्षण कर सकते हैं और फिर इस कोड को चिपका सकते हैं:

[o(4.356, u(-4.873, 2.441)) , 0.0;
o(2.226, u(-1.922, 2.664)) , 0.09550806803314438;
o(-4.353, u(-7.929, -0.823)) , 0.49676329862088375;
o(-2.491, u(-0.340, 6.453)) , 1.0;
o(0.738, b(u(-5.233, 3.384), u(2.767, 8.329), u(-2.769, 6.497))) , 0.7701533851999125;
o(-3.577, b(u(-3.159, 0.070), b(b(u(-4.996, 4.851), u(-7.516, 1.455), u(-0.931, 7.292)), b(u(-5.437, -0.738), u(-8.272, -2.316), u(-3.225, 1.201)), u(3.097, 6.792)), u(-8.215, 0.817))) , 0.4976245638164541;
o(3.243, b(b(u(-4.909, 2.003), u(-4.158, 4.622), b(u(0.572, 5.874), u(-0.573, 4.716), b(u(-5.279, 3.702), u(-6.564, 1.373), u(-6.585, 2.802)))), u(-3.148, 2.015), b(u(-6.235, -5.629), u(-4.647, -1.056), u(-0.384, 2.050)))) , 0.0;
o(-3.020, b(b(u(-0.080, 6.148), b(u(1.691, 6.439), u(-7.086, 2.158), u(3.423, 6.773)), u(-1.780, 2.381)), b(u(-1.754, 1.943), u(-0.046, 6.327), b(u(-6.667, 2.543), u(0.656, 7.903), b(u(-8.673, 3.639), u(-7.606, 1.435), u(-5.138, -2.409)))), u(-8.008, -0.317))) , 0.4487803553043079]

— flawr
स्रोत

मतलब को FP सपोर्ट है, इसलिए मुझे लगता है कि यह अमान्य होगा।

— लीजनमोनमल 978

मुझे इसकी अनुमति देने में संकोच है, क्योंकि मतलब मूल रूप से फ्लोटिंग पॉइंट नंबरों का समर्थन करता है। आप बदल सकते हैं तो Xऔर Dसाथ MIN_FLOATऔर MAX_FLOAT(या जो भी मैटलैब उन्हें कॉल), तो यह एक वैध तरीका है।