Sie paddeln mit einem Kanu einen ziemlich schnellen Wildwasserfluss hinunter. Plötzlich explodieren Ihre Paddel und Sie befinden sich in einer gefährlichen Situation, die schnell und ohne Paddel den Fluss hinunter rast. Zum Glück haben Sie noch Programmierkenntnisse und beschließen, ein Programm neben Ihrem Kanu zu erstellen, um die Stromschnellen zu überstehen. Es gibt jedoch nicht viel Fläche an der Seite des Kanus, mit der Sie Ihr Programm schreiben können. Daher müssen Sie das Programm so kurz wie möglich halten.

Der Fluss kann als 8 mal 16 Raster dargestellt werden. Wir werden die Spalten mit den Zahlen 0bis 7und die Zeilen mit den Zahlen 0bis beschriften 15.

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

Oben: Ein völlig ruhiger, gewöhnlicher Fluss ohne Hindernisse. Dies ist natürlich nicht der Fluss, auf dem Sie sich befinden.

Sie beginnen an der Koordinate (4, 0) und bewegen sich von dort unkontrolliert den Fluss hinauf (dh den Vektor (0,1)), bis Sie auf einen Felsen stoßen ( oin diesen Beispielen durch dargestellt). Wenn Sie auf einen Felsen stoßen, haben Sie eine 55% ige Chance, links am Felsen (dh am Vektor (-1,1)) vorbeizukommen, und eine 45% ige Chance, rechts am Felsen (dh am Vektor (1,1)) vorbeizukommen . Befindet sich das Kanu in der linken oder rechten Spalte, bewegt es sich immer in die Mitte. Wenn es keine Steine ​​gibt, bewegt es sich gerade nach oben.

        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

Oben: Eine mögliche Route, die das Kanu nehmen könnte, dargestellt anhand des Zeichens x

Schreiben Sie auf der Karte des Flusses ein Programm, das die Wahrscheinlichkeit ausgibt, dass das Kanu an einer bestimmten Spalte endet.

Akzeptieren Sie Eingaben in einer für Ihr Programm geeigneten Methode (z. B. STDIN, Befehlszeilenargument raw_input(), Lesen aus einer Datei usw.). Der erste Teil der Eingabe ist eine einzelne Ganzzahl von 0 bis 7, die die Spalte darstellt, für die das Programm die Wahrscheinlichkeit findet. Darauf folgt eine Liste von Tupeln in der Form, x,ydie die Position der Steine ​​darstellen.

Ein Beispiel:

Eingang:

4 4,1 5,5 3,5

Dies würde einen Fluss mit Steinen an den Positionen (4,1), (5,5) und (3,5) anzeigen und nach der Wahrscheinlichkeit fragen, dass das Kanu an der 4. Säule endet.

Ausgabe:

0.495

Beachten Sie, dass in diesem Beispiel die Positionen der Gesteine ​​symmetrisch waren, sodass das Problem mit einer Binomialverteilung gelöst werden konnte. Dies wird nicht immer der Fall sein!

Auch der Fluss wird immer überquerbar sein. Das heißt, es wird niemals zwei Felsen geben, die horizontal nebeneinander liegen. Ein Beispiel für einen unmöglichen Fall finden Sie in Glenns Kommentar .

Dies ist Codegolf, daher gewinnt die niedrigste Anzahl von Zeichen. Fühlen Sie sich frei, Fragen in den Kommentaren zu stellen, wenn die Spezifikation nicht klar ist.

GolfScript, 105 Zeichen

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

Eine GolfScript-Version, die viel länger wurde als beabsichtigt - aber jeder Versuch mit einer anderen Herangehensweise war noch länger. Die Eingabe muss auf STDIN erfolgen.

Beispiel:

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

Kommentierter Code:

# 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?*

Ruby, 204 191 172 Zeichen

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]

Es simuliert rekursiv alle möglichen Ergebnisse und verfolgt dabei die Wahrscheinlichkeit jedes einzelnen Ergebnisses. Diese Wahrscheinlichkeit wird dann zu einem kumulativen Zähler addiert, wenn y == 15.

Ausgefallene Tricks:

• c,*r=gets.split- Der "splat" -Operator ( *) nimmt alle verbleibenden Elemente von gets.splitund fügt sie in das rArray ein

• next {something} if {condition}: im Wesentlichen gleichwertig mit

  if {condition}
      {something}
      return
  end
  

  "Entdeckt" durch die Entwicklung von if condition; something; return; endnach return something if conditionnach break something if condition, und dann dachte ich, ich würde einen kürzeren "Schleifenoperator" ausprobieren, um zu sehen, ob es funktionieren würde (was es natürlich tat).

• Vielen Dank an @ MartinBüttner, der vorgeschlagen hat, verkettete ternäre Operatoren zu verwenden (die letztendlich die enorme dritte Zeile im oben genannten Code darstellen) und den oben genannten Punkt zu eliminieren (der 19 (!) Zeichen sparte).

  Bei diesen habe ich allerdings einen etwas ausgefallenen Trick angewendet: Mir ist aufgefallen, dass s[foo],s[bar]das in Ruby für zwei Methodenaufrufe in einer Anweisung nicht funktioniert. Also zuerst habe ich es zu (_=s[foo],s[bar])(einer Dummy - Variablen), aber dann merkte ich , ich konnte einfach hinzufügen und die Rückgabewerte wegzuwerfen: s[foo]+s[bar]. Dies funktioniert nur, weil Anrufe an simmer nur andere Anrufe an soder eine Nummer ( o[x]+=p) "zurückgeben" , so dass ich mich nicht darum kümmern muss, nach zu suchen nil.

• Andere verschiedene Optimierungen: panstatt putszum Drucken von Zahlen, <1anstatt ==0(da das Kanu niemals den Fluss verlässt) und ähnliche Vergleiche an anderer Stelle, [0]*8für anfängliche Wahrscheinlichkeiten, da Rubys Zahlen immer "vorbeigehende Werte" sind

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]

C # 418 364 Byte

Vollständiges C # -Programm erwartet Eingabe von STDIN. Liest die Felsen in ein Array aller Stellen im Fluss ein, erstellt effektiv eine Karte und führt dann nur 16 Iterationen von Bewegungswahrscheinlichkeiten um ein 8-stelliges Dezimalarray durch, bevor das Ergebnis ausgegeben wird.

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

Formatierter Code:

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

Haskell, 256 Bytes

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

Hier ist eine sehr ungolfed Version zusammen mit einigen Tricks, die verwendet wurden:

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)

Der letzte Trick, den ich verwendet habe, war zu bemerken, dass man so tun kann, als ob Steine ​​in einer einzelnen Reihe tatsächlich durch einen infinitesimalen Betrag getrennt sind. Mit anderen Worten, Sie können den Wahrscheinlichkeitsverteilungstransformator für jeden Stein in derselben Reihe nacheinander und in beliebiger Reihenfolge anwenden, anstatt sie alle gleichzeitig anzuwenden. Dies funktioniert nur, weil das Problem zwei horizontal benachbarte Felsen nicht zulässt.

Das Programm wandelt also die Position jedes Felsens in einen Wahrscheinlichkeitsverteilungstransformator um, der nach der y-Koordinate des Felsens geordnet ist. Die Transformatoren werden dann nur der Reihe nach verkettet und auf die anfängliche Wahrscheinlichkeitsverteilung angewendet. Und das ist das!

Perl 169 Bytes

Liest von 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{$&}

Ganz einfach, verwendet implizit die Spalten -1 und 8, um Grenzfälle zu glätten. Wahrscheinlichkeiten können sicher auf jede nächste Ebene übertragen werden, da keine angrenzenden Steine ​​vorhanden sind und somit ein einziger Durchgang ausreicht.

PHP, 358

Das Ermitteln der möglichen Pfade und ihrer Wahrscheinlichkeiten mithilfe von Brainpower ist schwierig und würde wahrscheinlich mehr Code erfordern, als nur 1.000.000 Kanuunfälle zu simulieren. Oh die Menschlichkeit!

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

Beispiel:

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

Golf gespielt:

<? 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);

Diese Version druckt nicht besonders gut und gibt die Wahrscheinlichkeit aus, dass das Kanu an der angegebenen Position landet.

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

PHP, 274

Ich kann GolfScript nicht lesen / schreiben, um mein Leben zu retten, aber ein Blick über @ Howards Beitrag zeigte mir eine bessere Richtung, als nur 1 Million Kanuunfälle zu simulieren.

Ausgehend von einer Reihe von Wahrscheinlichkeiten für Startpositionen können wir diese Zahlen einfach bei jedem Auftreffen auf einen Stein aufteilen.

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

Beispielausgabe:

# 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

Golf gespielt:

<? $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];

Beispiellauf:

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

Haskell, 237

Ich hoffe nur, das Kanu kommt mit Ghc installiert ...

Der Trick mit der unendlichen Liste ist Matt Noonan gestohlen, ein großes Lob an ihn!

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

Ich hoffe, ich habe die Logik richtig verstanden, aber Matts Beispiel "5 4,4 1,5 5,3 3,6 2,9 4,12 3,13"liefert 0.5613750000000001und OPs Beispiel "4 4,1 5,5 3,5"liefert 0.49500000000000005, was abgesehen von einigen Gleitkommafehlern korrekt zu sein scheint.

Hier ist es in Aktion:

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