चरम व्हिट्यूवाटर कैनोइंग

Question

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

नदी को 8 बाय 16 ग्रिड के रूप में दर्शाया जा सकता है। हम संख्या के साथ कॉलम लेबल होगा 0करने के लिए 7और संख्या के साथ पंक्तियों 0को 15।

        y
--------15
--------14
--------13
--------12
--------11
--------10
--------9
--------8
--------7
--------6
--------5
--------4
--------3
--------2
--------1
--------0
01234567
x

ऊपर: बिना किसी रुकावट के एक पूरी तरह से शांत, साधारण नदी। स्वाभाविक रूप से, यह नदी आप पर नहीं है।

आप समन्वय (4, 0) से शुरू करते हैं और वहां से अनियंत्रित रूप से नदी (यानी सदिश (0,1)) तक चलते हैं जब तक कि आप एक चट्टान को नहीं मारते ( oइन उदाहरणों में एक का प्रतिनिधित्व करते हैं)। जब आप किसी चट्टान से टकराते हैं, तो आपके पास चट्टान को बाईं ओर ले जाने का 55% मौका होगा (यानी वेक्टर (-1,1)) और रॉक को दाईं ओर (यानी वेक्टर (1,1)) पर ले जाने का 45% मौका होगा । यदि डोंगी दूर बाएं या दाएं स्तंभों पर है, तो यह हमेशा केंद्र की ओर बढ़ेगा। यदि चट्टानें नहीं हैं, तो यह सीधे ऊपर की ओर बढ़ेगी।

        y
----x---15
----xo--14
-o--x---13
----x---12
---ox---11
---x----10
---xo---9
---ox---8
----xo--7
-----x--6
----ox--5
-o--x---4
----x---3
----xo--2
----x---1
----x---0
01234567

ऊपर: डोंगी एक संभावित मार्ग को ले जा सकता है, जिसका उपयोग चरित्र का प्रतिनिधित्व करता है x

नदी के नक्शे को देखते हुए, एक प्रोग्राम लिखें जो किसी दिए गए कॉलम में डोंगी परिष्करण की संभावना का उत्पादन करेगा।

जो भी विधि में इनपुट स्वीकार करें वह आपके प्रोग्राम के लिए सुविधाजनक है (जैसे STDIN, कमांड लाइन तर्क, raw_input()फ़ाइल से पढ़ना, आदि)। इनपुट का पहला भाग 0 से 7 तक एक एकल पूर्णांक है, कॉलम का प्रतिनिधित्व करने से कार्यक्रम के लिए संभावना मिल जाएगी। इसके बाद x,yपत्थरों की स्थिति का प्रतिनिधित्व करने वाले रूप में टुपल्स की एक सूची है ।

एक उदाहरण:

इनपुट:

4 4,1 5,5 3,5

यह स्थिति (4,1), (5,5), और (3,5) पर चट्टानों के साथ एक नदी को इंगित करता है, और 4 स्तंभ पर डोंगी के समाप्त होने की संभावना के लिए पूछता है।

आउटपुट:

0.495

ध्यान दें कि इस उदाहरण में, चट्टानों की स्थिति सममित थी, जिससे समस्या को द्विपद वितरण के साथ हल किया जा सकता था। यह हमेशा मामला नहीं होगा!

साथ ही, नदी हमेशा पार करने योग्य होगी। यही है, कभी भी दो चट्टानें नहीं होंगी जो क्षैतिज रूप से एक दूसरे से सटे हों। एक असंभव मामले के उदाहरण के लिए ग्लेन की टिप्पणी देखें ।

यह कोड गोल्फ है, इसलिए सबसे कम संख्या में वर्ण जीतते हैं। यदि विनिर्देश स्पष्ट नहीं हैं, तो टिप्पणियों में प्रश्न पूछने के लिए स्वतंत्र महसूस करें।

Comments

विडंबना यह है कि कार्यक्रम वास्तव में किसी को भी रैपिड्स से बचने में मदद नहीं करता है। यह उन्हें बताना है कि यह कैसे की संभावना है वे हालांकि जीवित रहने देंगे करता है।

— चिरायता

क्या होता है जब दो या दो से अधिक चट्टानें एक साथ पंक्ति में होती हैं? उदाहरण के लिए, यदि नक्शा "0 1,0 1,1" है, तो डोंगी 1,1 में चट्टान से टकरा जाएगी। (ए) की स्थिति अस्वीकृत है, या (बी) पाठ्यक्रम पूरा करने की संभावना 0. है

— ग्लेन रैंडर्स-पेहर्सन

आह अच्छा। क्षमा करें, मेरे द्वारा उस भाग पर ध्यान नहीं गया।

— दरवाज़े

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

— काई

मैं देखना चाहता हूं कि पैडल फटने पर यह कैसा दिखता है।

— रोबी विंस्ज़

Answer 1

GolfScript, 105 वर्ण

~](\2/:A;8,{4=}%15,{:B;{20*}%A{~B={[\\,.1,*\[2$=..20/9*:C-\~)C]+(1,\+1,6*2$8>+]zip{{+}*}%.}*;}/}/=20-15?*

एक गोल्फस्क्रिप्ट संस्करण जो इरादा से अधिक लंबा हो गया - लेकिन एक अलग दृष्टिकोण के साथ प्रत्येक प्रयास और भी लंबा था। इनपुट STDIN पर दिया जाना चाहिए।

उदाहरण:

> 4 4,1 5,5 3,5
99/200

एनोटेट कोड:

# Evaluate the input
#  - stack contains the first number (i.e. column)
#  - variable A contains the rock coordinates (pairs of X y)
#    where X is an array of length x (the coordinate itself)
~](\2/:A;

# Initial probabilities
#  - create array [0 0 0 0 1 0 0 0] of initial probabilities
8,{4=}%

# Loop over rows 
15,{:B;           # for B = 0..14
  {20*}%          #   multiply each probability by 20
  A{              #   for each rock 
    ~B={          #     if rock is in current row then
                  #       (prepare an array of vectors [v0 vD vL vR] 
                  #       where v0 is the current prob. before rocks,
                  #       vD is the change due to rocks,
                  #       vL is a correction term for shifting out to the left
                  #       and vR the same for the right side)
      [\\         #       move v0 inside the array
      ,           #       get x coordinate of the rock
      .1,*        #       get [0 0 ... 0] with x terms
      \[2$=       #       get x-th item of v0
      ..20/9*:C-  #       build array [0.55P -P 0.45P]
      \~)C]+      #       and append to [0 0 ... 0]
      (1,\+       #       drop the leftmost item of vD and prepend [0] again
                  #       which gives vL
      1,6*2$8>+   #       calculate vR using the 8th item of vD
      ]           #       
      zip{{+}*}%  #       sum the columns of this list of vectors
      .           #       dummy dup for end-if ;
    }*;           #     end if
  }/              #   end for
}/                # end for

# take the n-th column and scale with 20^-15
=
20-15?*

Answer 2

रूबी, 204 191 172 वर्ण

c,*r=gets.split
o=[0]*8
s=->x,y,p{y>14?o[x]+=p :(r.index("#{x},#{y+=1}")?(x<1?s[x+1,y,p]:(x>6?s[x-1,y,p]:(s[x-1,y,p*0.55]+s[x+1,y,p*0.45]))):s[x,y,p])}
s[4,0,1]
p o[c.to_i]

यह प्रत्येक व्यक्ति के परिणाम की संभावना पर नज़र रखते हुए सभी संभावित परिणामों का पुनरावर्ती रूप से अनुकरण करता है, तब यह उस संभावना को सह-काउंटर काउंटर से जोड़ता है y == 15।

फैंसी ट्रिक्स:

• c,*r=gets.split- "स्पैट" ऑपरेटर ( *) शेष सभी तत्वों को लेता है gets.splitऔर उन्हें rसरणी में चिपका देता है

• next {something} if {condition}: अनिवार्य रूप से के बराबर है

  if {condition}
      {something}
      return
  end
  

  "से खोजा" से विकसित if condition; something; return; endकरने के return something if conditionलिए break something if condition, और फिर मुझे लगा कि मैं एक छोटे "लूप ऑपरेटर" को देखने की कोशिश करूंगा कि क्या यह काम करेगा (जो यह किया था, निश्चित रूप से)।

• जंजीर टर्नरी ऑपरेटरों का उपयोग करने के सुझाव के लिए @ मार्टिनबरंटनर को धन्यवाद (जो ऊपर दिए गए गोल्फ कोड में बड़ी तीसरी लाइन बन गया) और उपरोक्त बिंदु (जो 19 (!) वर्णों को बचाया गया) को समाप्त कर रहा है।

  मैं उन लोगों के साथ कुछ हद तक फैंसी चाल का उपयोग करता था, हालांकि: मुझे एहसास हुआ कि s[foo],s[bar]एक बयान में दो विधि कॉल के लिए रूबी में काम नहीं करता है। इसलिए पहले तो मैंने इसे (_=s[foo],s[bar])(एक डमी वैरिएबल) में बदल दिया , लेकिन फिर मुझे एहसास हुआ कि मैं रिटर्न वैल्यूज को जोड़ और फेंक सकता हूं s[foo]+s[bar]:। यह केवल इसलिए काम करता है क्योंकि कॉल sकभी भी sया किसी नंबर ( o[x]+=p) पर अन्य कॉल को "वापस" करने के लिए होता है , इसलिए मुझे चेक करने के लिए चिंता करने की आवश्यकता नहीं है nil।

• अन्य विभिन्न अनुकूलन: pके बजाय putsसंख्या मुद्रण, के लिए <1की बजाय ==0कहीं और, और इसी तरह की तुलना (के बाद से डोंगी कभी नहीं नदी छोड़ देता है) [0]*8हमेशा "मूल्य से गुजरती हैं" कर रहे हैं रूबी के संख्या के रूप में प्रारंभिक संभावनाओं के लिए

Ungolfed:

column, *rocks = gets.chomp.split
outcomes = Array.new(8, 0)
simulate = -> x, y, probability {
    if y == 15
        outcomes[x] += probability
    elsif rocks.index("#{x},#{y + 1}")
        case x
        when 0 then simulate[x + 1, y + 1, probability]
        when 7 then simulate[x - 1, y + 1, probability]
        else
            simulate[x - 1, y + 1, probability * 0.55]
            simulate[x + 1, y + 1, probability * 0.45]
        end
    else
        simulate[x, y + 1, probability]
    end
}
simulate[4, 0, 1.0]
p outcomes
puts outcomes[column.to_i]

Comments

क्या यह अभी भी उन सभी next X if Yको नेस्टेड टर्नरी ऑपरेटरों में इकट्ठा करने के लिए कम नहीं होगा ? हालांकि, आप इसे रूबी सुझावों में जोड़ना चाहते हैं, अच्छा लगा!

— मार्टिन एंडर

@ मार्टिनबरनर हां, यह वास्तव में एक छोटा 19 अक्षर छोटा है! धन्यवाद, हालांकि यह एक हास्यास्पद लंबी लाइन में दुर्भाग्यपूर्ण दुष्परिणाम है: पी

— दरवाज़े

Answer 3

C # 418 364bytes

STDIN से इनपुट की अपेक्षा पूर्ण C # प्रोग्राम। नदी में सभी स्थानों की एक सरणी में चट्टानों को पढ़कर, प्रभावी रूप से एक मानचित्र बनाकर काम करता है, और फिर यह परिणाम को आउटपुट करने से पहले 8-चौड़ाई के दशमलव सरणी के आसपास चलती संभावनाओं के 16 पुनरावृत्तियों को करता है।

using C=System.Console;class P{static void Main(){var D=C.ReadLine().Split();int i=0,j=D.Length;var R=new int[8,16];var p=new decimal[8];for(p[4]=1;--j>0;)R[D[j][0]-48,int.Parse(D[j].Substring(2))]=1;for(;i<16;i++){var n=new decimal[j=8];for(;j-->0;)if(R[j,i]>0){n[j<1?1:j-1]+=p[j]*0.55M;n[j>6?6:j+1]+=p[j]*0.45M;}else n[j]+=p[j];p=n;}C.WriteLine(p[D[0][0]-48]);}}

प्रारूपित कोड:

using C=System.Console;

class P
{
    static void Main()
    {
        var D=C.ReadLine().Split();
        int i=0,j=D.Length;
        var R=new int[8,16];
        var p=new decimal[8];

        for(p[4]=1;--j>0;) // read rocks into map (R)
            R[D[j][0]-48,int.Parse(D[j].Substring(2))]=1;

        for(;i<16;i++) // move up the river
        {
            var n=new decimal[j=8];
            for(;j-->0;)
                if(R[j,i]>0)
                { // we hit a rock!
                    n[j<1?1:j-1]+=p[j]*0.55M;
                    n[j>6?6:j+1]+=p[j]*0.45M;
                }
                else
                    n[j]+=p[j];
            p=n; // replace probability array
        }

        C.WriteLine(p[D[0][0]-48]); // output result
    }
}

Comments

+1 "ऑपरेटर" ( for(;j-->0;)) को जाता है । आप कुछ वर्णों से छुटकारा पा सकते हैं, हालांकि अंतिम C.WriteLineद्वारा प्रतिस्थापित करके C.Write। इसके अलावा, यदि आप floatइसके बजाय का उपयोग करते हैं decimalतो एक जोड़े को अधिक बाइट बचा सकते हैं।

— क्रिस्टोफ़ बोहमलडर

@HackerCow मानक अभ्यास;) को आपके फॉर-लूप्स से सबसे अधिक लाभ मिला! मैं उपयोग कर रहा हूं decimalक्योंकि floatयह सटीक नहीं होगा, लेकिन दशमलव को इन समस्याओं के लिए करना चाहिए, लेकिन जैसा कि आप कहते हैं, शायद इससे दूर हो सकते हैं। मैं में डाल देता हूँ C.Writeकल्पना करने के लिए अगर मैं गोल्फ के लिए प्रबंधन करते हैं यह शायद करीब है यह किसी भी आगे के रूप में की तुलना में C.WriteLineके रूप में मुझे नहीं लगता कि 4 बाइट वारंट इस आकार के कार्यक्रम के लिए एक संपादन;)

— VisualMelon

Answer 4

हास्केल, 256 बाइट्स

import Data.List
m=map;v=reverse
a p n x=take n x++(x!!n+p:drop(n+1)x)
l=abs.pred
o[_,n]s=n#(s!!n)$s
n#p=a(11*p/20)(l n).a(9*p/20)(7-(l$7-n)).a(-p)n
b=0:0:0:0:1:b
k(c:w)=(foldl1(.)$m o$v$sort$m(v.read.('[':).(++"]"))w)b!!read c
main=getLine>>=print.k.words

यहाँ कुछ चाल के साथ एक बहुत ही ungolfed संस्करण है जिसका उपयोग किया गया था:

import Data.List

-- Types to represent the distribution for the canoe's location
type Prob = Double
type Distribution = [Prob]

-- Just for clarity..
type Index = Int

-- An Action describes some change to the probability distribution
-- which represents the canoe's location.
type Action = Distribution -> Distribution

-- Helper to add k to the nth element of x, since we don't have mutable lists.
add :: Index -> Prob -> Action
add n k x = take n x ++ [p] ++ drop (n + 1) x
    where p = k + x!!n  

-- A trick for going finding the index to the left of n,
-- taking the boundary condition into account.
leftFrom n = abs (n - 1)

-- A trick for getting the other boundary condition cheaply.
rightFrom = mirror . leftFrom . mirror
    where mirror = (7 -)

-- Make the action corresponding to a rock at index n.
doRock :: Index -> Action
doRock n p = (goLeft . goRight . dontGoForward) p
    where goLeft  =  (leftFrom n) `add` (p_n * 11/20)
          goRight = (rightFrom n) `add` (p_n * 9/20)
          dontGoForward =  (at n) `add` (-p_n)
          p_n = p!!n
          at = id

initialProb = [0,0,0,0,1,0,0,0]

-- Parse a pair "3,2" ==> (3,2)
readPair :: String -> (Index,Index)
readPair xy = read $ "(" ++ xy ++ ")"

-- Coordinate swap for the sorting trick described below.
swap (x,y) = (y,x)

-- Put it all together and let it rip!
main = do
    input <- getLine
    let (idx : pairs) = words input
    let coords = reverse . sort $ map (swap . readPair) pairs
    let rockActions = map (doRock . snd) coords
    let finalProb = (foldl1 (.) rockActions) initialProb
    print $ (finalProb !! read idx)

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

इसलिए कार्यक्रम प्रत्येक रॉक के स्थान को संभाव्यता वितरण ट्रांसफार्मर में बदल देता है, जो रॉक के y निर्देशांक द्वारा आदेशित होता है। तब ट्रांसफार्मर को क्रम में जंजीर और प्रारंभिक संभाव्यता वितरण के लिए लागू किया जाता है। और वही जो है!

Answer 5

पर्ल 169 बाइट्स

STDIN से पढ़ता है।

$_=<>;s/ (.),(\d+)/$s{$1,$2}=1/eg;/./;$x{4}=1.0;for$y(1..15){for$x(0..7){if($s{$x,$y}){$x{$x-1}+=$x{$x}*($x%7?.55:1);$x{$x+1}+=$x{$x}*($x%7?.45:1);$x{$x}=0}}}print$x{$&}

सुंदर सीधे आगे, स्पष्ट रूप से सीमा के मामलों को सुचारू करने के लिए कॉलम -1 और 8 का उपयोग करता है। संभाव्यता को प्रत्येक अगले स्तर पर सुरक्षित रूप से प्रचारित किया जा सकता है क्योंकि किसी भी निकटवर्ती पत्थरों में, इस प्रकार एक ही रन पर्याप्त होता है।

Answer 6

PHP, 358

संभावित रास्तों और उनकी संभावनाओं को निर्धारित करने के लिए ब्रेनपावर का उपयोग करना कठिन है, और संभवतः केवल 1,000,000 कैनो दुर्घटनाओं का अनुकरण करने की तुलना में अधिक कोड की आवश्यकता होगी। ओह मानवता!

define('MX',7);
define('MY',16);
define('IT',1000000);
error_reporting(0);

function roll(){return rand()%100 > 44;}

function drift($rocks,$print=false) {
    for($px=4,$py=0;$py<MY;$py++) {
        if(isset($rocks[$px][$py])){
            if(roll()) $px--;
            else $px++;
        }
        else if($px==0) $px++;
        else if($px==MX) $px--;
        if($print) {
            for($i=0;$i<MX;$i++){
                if($i==$px) echo 'x';
                else if(isset($rocks[$i][$py])) echo 'o';
                else echo '-';
            }
            echo " $py\n";
        }
    }
    return $px;
}

$input = $argv[1];
$tmp = explode(' ',$input);
$end_target = array_shift($tmp);
$rocks = array();
array_map(function($a) use(&$rocks) {
    list($x,$y) = explode(',',$a);
    $rocks[$x][$y]=1;
}, $tmp);

$results=array();
for($i=0;$i<IT;$i++) {
    $results[drift($rocks)]++;
}

drift($rocks, true); // print an example run

foreach($results as $id=>$result) {
    printf("%d %0.2f\n", $id, $result/IT*100);
}

उदाहरण:

php river.php "4 4,1 5,5 3,3 6,2 9,4 12,3 13,5"
----x-- 0
---xo-- 1
---x--o 2
--xo--- 3
--x---- 4
--x--o- 5
--x---- 6
--x---- 7
--x---- 8
--x---- 9
--x---- 10
--x---- 11
--x---- 12
--x---- 13
--x---- 14
--x---- 15
4 49.53
2 30.18
6 20.29

golfed:

<? function d($r){for($x=4,$y=0;$y<16;$y++){if(isset($r[$x][$y])){if(rand()%100>44)$x--;else $x++;}elseif($x==0)$x++;elseif($x==7)$x--;}return $x;}$t=explode(' ',$argv[1]);$e=array_shift($t);$r=array();array_map(function($a)use(&$r){list($x,$y)=explode(',',$a);$r[$x][$y]=1;},$t);$c=0;for($i=0;$i<1000000;$i++){if(d($r)==$e)$c++;}printf("%.4f", $c/1000000);

यह संस्करण कोई सुंदर मुद्रण नहीं करता है और निर्दिष्ट स्थान पर डोंगी लैंडिंग की फ्लोट संभावना को आउटपुट करता है।

# php river_golf.php "4 4,1 5,5 3,3 6,2 9,4 12,3 13,5"
0.4952

Comments

मुझे लगता है कि यहां इनपुट प्रारूप थोड़ा बंद है, उदाहरण के लिए River.php को "5 4,4 1,5 5,3 3,6 2,9 4,12 3,13" पर 0.561375 देना चाहिए

— मैट नूनन

@MattNoonan कल एक मोटा दिन था। मुझे इसे ठीक करने में सक्षम होना चाहिए ...

— सैममाइच

Answer 7

PHP, 274

मैं अपने जीवन को बचाने के लिए GolfScript नहीं पढ़ / लिख सकता, लेकिन @ हावर्ड के प्रस्तुतिकरण पर नज़र डालने से मुझे केवल 1 मिलियन डोंगी दुर्घटनाओं का अनुकरण करने से बेहतर दिशा मिली।

पदों को शुरू करने के लिए प्रायिकताओं की एक सरणी के साथ शुरू करके हम उन संख्याओं को विभाजित कर सकते हैं जो हर बार एक चट्टान का सामना करती हैं।

function psplit($i){ return array(.55*$i,.45*$i); }
function pt($a) {
    foreach($a as $p) {
        printf("%1.4f ", $p);
    }
    echo "\n";
}

$input = $argv[1];
$tmp = explode(' ',$input);
$end_target = array_shift($tmp);
$rocks = array();
array_map(function($a) use(&$rocks) {
    list($x,$y) = explode(',',$a);
    $rocks[$x][$y]=1;
}, $tmp);

$state = array(0,0,0,0,1,0,0,0);
pt($state);
for($y=1;$y<16;$y++){
    for($x=0;$x<8;$x++){
        if(isset($rocks[$x][$y])){
            echo('   o   ');
            list($l,$r)=psplit($state[$x]);
            $state[$x]=0;
            $state[$x-1]+=$l;
            $state[$x+1]+=$r;
        } else { echo '   -   '; }
    }
    echo "\n";
    pt($state);
}

उदाहरण आउटपुट:

# php river2.php "4 4,1 5,5 3,3 6,2 9,4 12,3 13,5"
0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000
   -      -      -      -      o      -      -      -
0.0000 0.0000 0.0000 0.5500 0.0000 0.4500 0.0000 0.0000
   -      -      -      -      -      -      o      -
0.0000 0.0000 0.0000 0.5500 0.0000 0.4500 0.0000 0.0000
   -      -      -      o      -      -      -      -
0.0000 0.0000 0.3025 0.0000 0.2475 0.4500 0.0000 0.0000
   -      -      -      -      -      -      -      -
0.0000 0.0000 0.3025 0.0000 0.2475 0.4500 0.0000 0.0000
   -      -      -      -      -      o      -      -
0.0000 0.0000 0.3025 0.0000 0.4950 0.0000 0.2025 0.0000
   -      -      -      -      -      -      -      -
0.0000 0.0000 0.3025 0.0000 0.4950 0.0000 0.2025 0.0000
   -      -      -      -      -      -      -      -
0.0000 0.0000 0.3025 0.0000 0.4950 0.0000 0.2025 0.0000
   -      -      -      -      -      -      -      -
0.0000 0.0000 0.3025 0.0000 0.4950 0.0000 0.2025 0.0000
   -      -      -      -      -      -      -      -
0.0000 0.0000 0.3025 0.0000 0.4950 0.0000 0.2025 0.0000
   -      -      -      -      -      -      -      -
0.0000 0.0000 0.3025 0.0000 0.4950 0.0000 0.2025 0.0000
   -      -      -      -      -      -      -      -
0.0000 0.0000 0.3025 0.0000 0.4950 0.0000 0.2025 0.0000
   -      -      -      -      -      -      -      -
0.0000 0.0000 0.3025 0.0000 0.4950 0.0000 0.2025 0.0000
   -      -      -      -      -      -      -      -
0.0000 0.0000 0.3025 0.0000 0.4950 0.0000 0.2025 0.0000
   -      -      -      -      -      -      -      -
0.0000 0.0000 0.3025 0.0000 0.4950 0.0000 0.2025 0.0000
   -      -      -      -      -      -      -      -
0.0000 0.0000 0.3025 0.0000 0.4950 0.0000 0.2025 0.0000

golfed:

<? $t=explode(' ',$argv[1]);$e=array_shift($t);$r=array();foreach($t as $n){list($j,$k)=explode(',',$n);$r[$j][$k]=1;}$s=array(0,0,0,0,1,0,0,0);for($y=1;$y<16;$y++){for($x=0;$x<8;$x++){if(isset($r[$x][$y])){$s[$x-1]+=$s[$x]*.55;$s[$x+1]+=$s[$x]*.45;$s[$x]=0;}}}echo $s[$e];

उदाहरण रन:

# php river2_golf.php "4 4,1 5,5 3,3 6,2 9,4 12,3 13,5"
0.495

Answer 8

हास्केल, 237

मुझे उम्मीद है कि डोंगी स्थापित ghc के साथ आता है ...

अनंत सूची वाली चाल मैट नूनन से चुरा ली जाती है, उसे यश!

import Data.List
r=reverse
(a:b:x)%0=0:a+b:x
x%7=r(r x%0)
x%n=take(n-1)x++(x!!(n-1)+x!!n*0.55:0:x!!(n+1)+x!!n*0.45:drop(n+2)x)
q=0:0:0:0:1:q
u(w:x)=(foldl(%)q.map last.sort.map(r.read.('[':).(++"]"))$x)!!read w
main=interact$show.u.words

मुझे आशा है कि मुझे तर्क सही मिला, लेकिन मैट का उदाहरण "5 4,4 1,5 5,3 3,6 2,9 4,12 3,13"पैदावार 0.5613750000000001और ओपी का उदाहरण "4 4,1 5,5 3,5"पैदावार है 0.49500000000000005, जो कुछ अस्थायी बिंदु त्रुटियों से अलग प्रतीत होता है।

यहाँ यह कार्रवाई में है:

>>> echo 5 4,4 1,5 5,3 3,6 2,9 4,12 3,13 | codegolf
0.5613750000000001