Bạn đang chèo xuồng xuống một dòng sông nước trắng khá nhanh. Đột nhiên, mái chèo của bạn nổ tung, và bạn thấy mình trong một tình huống nguy hiểm đang xuôi dòng sông một cách nhanh chóng mà không có mái chèo nào. May mắn thay, bạn vẫn có kỹ năng lập trình của mình, vì vậy bạn quyết định khắc một chương trình bên cạnh chiếc xuồng của mình để giúp bạn sống sót qua ghềnh. Tuy nhiên, không có nhiều diện tích bề mặt bên cạnh xuồng để viết chương trình của bạn, vì vậy bạn phải làm cho chương trình càng ngắn càng tốt.

Sông có thể được biểu diễn dưới dạng lưới 8 x 16. Chúng tôi sẽ gắn nhãn các cột với các số 0đến 7và các hàng với các số 0đến 15.

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

Trên: Một dòng sông hoàn toàn bình tĩnh, bình thường không có vật cản. Đương nhiên, đây không phải là dòng sông bạn đang ở.

Bạn bắt đầu tại tọa độ (4, 0) và từ đó di chuyển không kiểm soát lên sông (tức là vectơ (0,1)) cho đến khi bạn va vào một tảng đá (đại diện bởi một otrong các ví dụ này). Khi bạn va vào tảng đá, bạn sẽ có 55% cơ hội di chuyển qua tảng đá sang trái (tức là vectơ (-1,1)) và 45% cơ hội di chuyển qua tảng đá sang phải (tức là vectơ (1,1)). Nếu ca nô nằm ở cột ngoài cùng bên trái hoặc bên phải, nó sẽ luôn di chuyển về phía trung tâm. Nếu không có đá, nó sẽ di chuyển thẳng lên trên.

        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

Hình trên: Một lộ trình khả dĩ mà ca nô có thể đi, được biểu diễn bằng ký tự x

Đưa ra bản đồ của dòng sông, viết một chương trình sẽ đưa ra xác suất hoàn thành ca nô tại một cột nhất định.

Chấp nhận đầu vào theo bất kỳ phương thức nào thuận tiện cho chương trình của bạn (ví dụ STDIN, đối số dòng lệnh raw_input(), đọc từ tệp, v.v.). Phần đầu tiên của đầu vào là một số nguyên duy nhất từ ​​0 đến 7, đại diện cho cột mà chương trình sẽ tìm xác suất cho. Tiếp theo đó là danh sách các bộ dữ liệu ở dạng x,yđại diện cho vị trí của các viên đá.

Một ví dụ:

Đầu vào:

4 4,1 5,5 3,5

Điều này sẽ chỉ ra một dòng sông có đá ở các vị trí (4,1), (5,5) và (3,5) và hỏi xác suất của ca nô kết thúc ở cột thứ 4.

Đầu ra:

0.495

Lưu ý rằng trong ví dụ này, vị trí của các tảng đá là đối xứng, cho phép giải quyết vấn đề bằng phân phối nhị thức. Điều này sẽ không luôn luôn như vậy!

Ngoài ra, dòng sông sẽ luôn luôn có thể vượt qua. Đó là, sẽ không bao giờ có hai tảng đá được đặt liền kề nhau theo chiều ngang. Xem bình luận của Glenn để biết ví dụ về trường hợp không thể.

Đây là mã golf, vì vậy số lượng nhân vật thấp nhất sẽ thắng. Vui lòng đặt câu hỏi trong các nhận xét nếu thông số kỹ thuật không rõ ràng.

GolfScript, 105 ký tự

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

Một phiên bản GolfScript trở nên dài hơn nhiều so với dự định - nhưng mỗi lần thử với một cách tiếp cận khác nhau thậm chí còn dài hơn. Đầu vào phải được đưa ra trên STDIN.

Thí dụ:

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

Mã chú thích:

# 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 ký tự

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]

Nó mô phỏng đệ quy tất cả các kết quả có thể có trong khi theo dõi xác suất của từng kết quả riêng lẻ, sau đó nó thêm xác suất đó vào một bộ đếm tích lũy khi y == 15.

Thủ thuật ưa thích:

• c,*r=gets.split- toán tử "splat" ( *) lấy tất cả các phần tử còn lại của gets.splitvà dán chúng vào rmảng

• next {something} if {condition}: về cơ bản tương đương với

  if {condition}
      {something}
      return
  end
  

  "Phát hiện" bởi phát triển từ if condition; something; return; endđể return something if conditionđến break something if condition, và sau đó tôi figured tôi sẽ thử một "hành vòng lặp" ngắn hơn để xem nếu nó sẽ làm việc (mà nó đã làm, tất nhiên).

• Cảm ơn @ MartinBüttner đã gợi ý sử dụng các toán tử ternary xích (cuối cùng trở thành dòng thứ ba khổng lồ trong mã golf ở trên) và loại bỏ điểm trên (đã lưu 19 ký tự (!)).

  Mặc dù vậy, tôi đã sử dụng một mẹo khá lạ mắt với những thứ đó: Tôi nhận ra rằng s[foo],s[bar]nó không hoạt động trong Ruby cho hai lệnh gọi phương thức trong một câu lệnh. Vì vậy, lúc đầu tôi đã thay đổi nó thành (_=s[foo],s[bar])(một biến giả), nhưng sau đó tôi nhận ra rằng tôi chỉ có thể thêm và vứt bỏ các giá trị trả về : s[foo]+s[bar]. Điều này chỉ hoạt động vì các cuộc gọi ssẽ chỉ "trả lại" các cuộc gọi khác đến shoặc một số ( o[x]+=p), vì vậy tôi không phải lo lắng về việc kiểm tra nil.

• Các tối ưu hóa khác nhau: pthay vì putsin số, <1thay vì ==0(vì ca nô không bao giờ rời sông) và so sánh tương tự ở nơi khác, [0]*8cho xác suất ban đầu vì số của Ruby luôn "vượt qua giá trị"

Ung dung:

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 364byte

Hoàn thành chương trình C # mong đợi đầu vào từ STDIN. Hoạt động bằng cách đọc các tảng đá vào một mảng của tất cả các vị trí trên sông, tạo ra bản đồ một cách hiệu quả, và sau đó nó chỉ thực hiện 16 lần lặp xác suất di chuyển xung quanh một mảng thập phân 8 chiều trước khi đưa ra kết quả.

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

Mã định dạng:

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 byte

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

Đây là một phiên bản rất vô dụng cùng với một số thủ thuật đã được sử dụng:

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)

Thủ thuật cuối cùng tôi sử dụng là lưu ý rằng bạn có thể hành động như thể các tảng đá trong một hàng thực sự được phân tách bằng một số lượng vô hạn. Nói cách khác, bạn có thể áp dụng biến áp phân phối xác suất cho từng tảng đá trong cùng một hàng liên tục và theo bất kỳ thứ tự nào bạn muốn, thay vì áp dụng đồng thời tất cả chúng. Điều này chỉ hoạt động vì vấn đề không cho phép hai tảng đá nằm ngang.

Vì vậy, chương trình biến vị trí của mỗi tảng đá thành một biến áp phân phối xác suất, được sắp xếp theo tọa độ y của đá. Các máy biến áp sau đó được xích theo thứ tự và áp dụng cho phân phối xác suất ban đầu. Và đó là điều đó!

Perl 169 byte

Đọc từ 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{$&}

Khá thẳng về phía trước, ngầm sử dụng các cột -1 và 8 để làm mịn các trường hợp viền. Xác suất có thể được truyền một cách an toàn đến từng cấp độ tiếp theo bởi vì không có bất kỳ viên đá liền kề nào, do đó chỉ cần một lần chạy.

PHP, 358

Sử dụng trí tuệ để xác định các đường dẫn có thể và xác suất của chúng là khó, và có lẽ sẽ cần nhiều mã hơn là chỉ mô phỏng 1.000.000 vụ tai nạn ca nô. Oh nhân loại!

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

Thí dụ:

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

Chơi gôn

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

Phiên bản này không thực hiện bất kỳ thao tác in ấn đẹp nào và đưa ra xác suất thả nổi của việc hạ cánh xuồng tại vị trí đã chỉ định.

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

PHP, 274

Tôi không thể đọc / viết GolfScript để cứu cuộc đời mình, nhưng liếc qua bài nộp của @ Howard đã chỉ cho tôi một hướng tốt hơn là chỉ mô phỏng 1 triệu tai nạn ca nô.

Bắt đầu với một loạt các xác suất cho các vị trí bắt đầu, chúng ta có thể chỉ cần chia các số đó mỗi khi gặp phải một tảng đá.

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

Kết quả ví dụ:

# 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

Chơi gôn

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

Chạy ví dụ:

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

Haskell, 237

Tôi chỉ hy vọng ca nô đi kèm với ghc được cài đặt ...

Thủ thuật với danh sách vô hạn bị đánh cắp từ Matt Noonan, danh tiếng cho anh ta!

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

Tôi hy vọng tôi có logic đúng, nhưng Matt dụ "5 4,4 1,5 5,3 3,6 2,9 4,12 3,13"sản lượng 0.5613750000000001và dụ OP của "4 4,1 5,5 3,5"sản lượng 0.49500000000000005, mà có vẻ là đúng ngoài một số lỗi dấu chấm động.

Đây là hành động:

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