พิจารณากลไก ASCII รุ่นนี้ที่คล้ายกับเครื่องทำถั่วหรือเกมplinko / pachinko :

    O

    ^
   \ ^
  ^ ^ \
 \ ^ / ^
U U U U U
1 2 3 4 5

Oเป็นลูกที่ตกลง

• เมื่อมันกระทบ a ^มีโอกาส 50-50 ที่มันจะไปทางซ้ายหรือขวา
• เมื่อมันกระทบ a /มันจะไปทางซ้ายเสมอ
• เมื่อมันกระทบ a \มันจะไปทางขวาเสมอ

ในที่สุดลูกบอลตกลงไปในหนึ่งในUรางหมายเลขที่ด้านล่าง คำถามคือความน่าจะเป็นที่จะเกิดขึ้นในแต่ละรางคือเท่าไหร่?

สำหรับกรณีนี้โดยเฉพาะอย่างยิ่งความน่าจะเป็น0.0, 0.1875, 0.5625, 0.125และ0.125สำหรับร่องที่ 1 ถึง 5 ตามลำดับ

นี่เป็นอีกตัวอย่างหนึ่งที่มี 3 รางแทน 5. ความน่าจะเป็น0.5, 0.5และ0.0:

  O

  /
 ^ ^
U U U
1 2 3

ในความท้าทายนี้เราจะพูดถึงปัญหานี้กับกลไกที่มีเลเยอร์จำนวนมากไม่ว่าจะเป็นแบบใด

ท้าทาย

เขียนโปรแกรมหรือฟังก์ชั่นที่ใช้ในการแทน ASCII ของโครงสร้างพีระมิดของกลไก (อินพุตผ่าน stdin / บรรทัดคำสั่ง / ฟังก์ชัน ARG)

คุณอาจคิดว่ามันมาพร้อมกับช่องว่างที่วางไว้ในรูปร่างที่เหมาะสมเช่น

   ^
  \ ^
 ^ ^ \
\ ^ / ^

หรือคุณอาจคิดว่ามันไม่มีที่ว่างเลยเช่น

^
\^
^^\
\^/^

(หากต้องการคุณอาจสมมติว่ามีบรรทัดใหม่ต่อท้ายและ / หรือรูปแบบที่สอดคล้องกันของช่องว่างต่อท้าย)

โครงสร้างปิรามิดอินพุตอาจมีจำนวนระดับ (เส้น aka) รวมถึงศูนย์ แต่ละระดับจะมีอีกหนึ่ง^, /หรือ\กว่าที่ผ่านมาและมีlevels + 1ร่องที่ด้านล่าง (ซึ่งไม่ได้เป็นส่วนหนึ่งของการป้อนข้อมูล)

โปรแกรม / ฟังก์ชั่นของคุณจะต้องพิมพ์ / ส่งคืนรายการความน่าจะเป็นที่ลูกบอลตกลงไปในแต่ละราง (ตามลำดับรางซ้ายสุดถึงรางขวาสุด) เหล่านี้ควรค่าจุดที่เมื่อพิมพ์ได้อย่างน้อย 3 ตำแหน่งทศนิยมลอย (ศูนย์ฟุ่มเฟือยหรือจุดทศนิยมไม่จำเป็น; 1จะดีสำหรับ1.000, .5จะดีสำหรับ0.500ฯลฯ ) หากคุณเขียนฟังก์ชันคุณอาจพิมพ์ค่าหรือส่งกลับรายการ / อาร์เรย์ของการลอย

รูปแบบรายการที่พิมพ์ที่สมเหตุสมผลนั้นใช้ได้ เช่น0.5 0.5 0.0, [0.5 0.5 0.0], [0.5, 0.5, 0.0], {0.5, 0.5, 0.0}หรือ0.5\n0.5\n0.0ทุกคนจะต้องไม่เป็นไร

ตัวอย่าง

0 ระดับ: (เดือดลงไปเล็กน้อยหนึ่งU)

อินพุต: [no input/empty string given]
เอาต์พุต:1.0

1 ระดับ:

อินพุต: ^
เอาต์พุต:0.5 0.5

อินพุต: /
เอาต์พุต:1.0 0.0

อินพุต: \
เอาต์พุต:0.0 1.0

2 ระดับ: (ตัวอย่างที่สองด้านบน)

การป้อนข้อมูล:

 /
^ ^

เอาท์พุท: 0.5 0.5 0.0

3 ระดับ:

การป้อนข้อมูล:

  ^
 ^ ^
^ ^ ^

เอาท์พุท: 0.125 0.375 0.375 0.125

การป้อนข้อมูล:

  \
 / \
/ / \

เอาท์พุท: 0.0 0.0 0.0 1.0

4 ระดับ: (ตัวอย่างแรกด้านบน)

การป้อนข้อมูล:

   ^
  \ ^
 ^ ^ \
\ ^ / ^

เอาท์พุท: 0.0 0.1875 0.5625 0.125 0.125

7 ระดับ:

การป้อนข้อมูล:

      ^
     / ^
    ^ ^ /
   / \ / \
  ^ ^ / ^ \
 ^ \ ^ \ / ^
\ ^ ^ ^ \ ^ /

เอาท์พุท: 0.0 0.09375 0.28125 0.4375 0.1875 0.0 0.0 0.0

เกณฑ์การให้คะแนน

คำตอบที่สั้นที่สุดเป็นไบต์ชนะ Tiebreaker เป็นโพสต์ก่อนหน้า

CJam, 50 48 45 44 42 40 ไบต์

1]q{iD%"(+0 0+( (\Y/::+ (d2/_a+"S/=~+}/p

สิ่งนี้คาดว่าอินพุตจะไม่มีที่ว่างและมีบรรทัดใหม่ต่อท้าย ตัวอย่างเช่น:

^
\^
^^\
\^/^

[0 0.1875 0.5625 0.125 0.125]

ขั้นตอนวิธี

แนวคิดพื้นฐานคือให้คุณทำการแยกวิเคราะห์อักขระแต่ละตัว (มีเพียง 4 ตัวอักษรที่แตกต่างกัน) และดำเนินการต่าง ๆ ในการแจกแจงความน่าจะเป็น (ตอนแรกอาร์เรย์ที่มี 1 องค์ประกอบของค่า 1) สำหรับแต่ละแถวของอักขระอินพุต (เริ่มต้นด้วยอักขระแรกในแถวแรก) เรารักษาอาร์เรย์ความน่าจะเป็นที่มีขนาดเดียวกัน ตัวละครแต่ละตัวทำหน้าที่ความน่าจะเป็นครั้งแรกจากรายการและผลักดันคู่ผลลัพธ์ไปยังจุดสิ้นสุดของรายการ หลังจากแต่ละบรรทัดเรารวมคู่จากรายการเพื่อรับจำนวนรายการที่แน่นอนเป็นรายการในบรรทัดถัดไป

นี่คืออักขระสี่ตัวและการดำเนินการที่จำเป็นที่เกี่ยวข้องกับแต่ละตัว

• ^: เมื่อตัวละครนี้เกิดขึ้นคุณแบ่งความน่าจะเป็นปัจจุบันเป็นสองส่วน ตัวอย่างเช่นถ้าเรามีนี้ในบรรทัดแรกเราจะต้องแปลง[1]ไป[0.5 0.5]
• /: เมื่อตัวละครตัวนี้เกิดขึ้นเราต้อง<current probability> 0แทนที่ความน่าจะเป็นในปัจจุบันในอาร์เรย์
• \: เมื่อตัวละครตัวนี้เกิดขึ้นเราต้อง0 <current probability>แทนที่ความน่าจะเป็นในปัจจุบันในอาร์เรย์
• \n: เมื่อตัวละครนี้เกิดขึ้นเรามีบรรทัดใหม่ ดังนั้นเราจึงจัดกลุ่มคู่ทั้งหมดจากอักขระ 3 ตัวด้านบนและสรุปผลรวมเพื่อรับความน่าจะเป็นของแต่ละรายการสำหรับบรรทัดถัดไป สำหรับอดีต ได้รับการแปลง[0 0.5 0.25 0.25] [0 0.75 0.25]โปรดทราบว่ารายการแรกและสุดท้ายมีคู่โดยนัย (มูลค่า 0) ก่อนและหลังพวกเขา

ตอนนี้เราต้องระบุตัวละครที่ถูกต้องและดำเนินการอย่างถูกต้อง ให้ใช้คณิตศาสตร์ปกติที่นี่เพื่อทำเช่นนั้น รหัส ASCII สำหรับ^, \, /และ\nมี94, 92, และ47 10หลังจากการทดลองสองสามครั้งเราได้สมการง่าย ๆ นี้เพื่อแปลงตัวเลขเหล่านี้เป็น 0, 1, 2 และ 3:

"^\/
":ied13f%ed4f%ed

ให้:

Stack: [[94 92 47 10]]
Stack: [[3 1 8 10]]
Stack: [[3 1 0 2]]
3102

ในอาร์เรย์ที่มีความยาว 4 ค่าสุดท้าย4f%จะเป็นค่านัย ดังนั้นเราเพียงแค่ทำ%13ตามรหัส ASCII ของตัวละครและเลือกการกระทำที่ถูกต้องจากอาร์เรย์ของการกระทำ

คำอธิบายรหัส :

1]                                 e# Initial probability array with 1 probability
  q{                          }/   e# Read the whole input and iterate char by char
    iD%                            e# mod the ASCII code of the character with 13
"(+0 0+( (\Y/::+ (d2/_a+"S/        e# This is our actions array in order of [\ / \n ^]
                           =~      e# We pick the correct action and eval it
                             +     e# Evaling each action will leave one number out of the
                                   e# pairs out of the array. So we put it back in
                                p  e# Print the final probability array

ลองออนไลน์ได้ที่นี่

ทับทิม 140

->s{r=[1.0]
s.lines.map{|l|n=[i=0.0]*(r.size+1)
l.scan(/\S/).map{|e|a,b=e>?/?e>?]?[0.5]*2:[0,1]:[1,0]
z=r[i]
n[i]+=z*a
n[i+=1]+=z*b}
r=n}
r}

ฟังก์ชั่นที่รับอินพุตเป็นสตริง (สามารถจัดรูปแบบเป็นพีระมิด) และส่งกลับอาร์เรย์แบบลอย

ทดสอบออนไลน์: http://ideone.com/kmsZMe

การดำเนินการตรงไปตรงมาสวย นี่มัน ungolfed:

F = -> input {
  probabilities = [1.0]

  input.lines.each { |line|

    new_probabilities = [0.0] * (probabilities.size+1)
    elements = line.scan /\S/
    elements.map.with_index{|el, i|
      deltas = el > '/' ? (el > ']' ? [0.5,0.5] : [0,1]) : [1,0]

      d1, d2 = deltas

      new_probabilities[i] += probabilities[i] * d1
      new_probabilities[i + 1] += probabilities[i] * d2
    }
    probabilities = new_probabilities
  }
  return probabilities
}

Ruby, 140 158ไบต์

ไม่ควรเก็บ upvoting นี้เมื่อมีรุ่นที่ดีกว่าทับทิม นี่คือเทคนิคเพิ่มเติมสำหรับคุณ

ฟังก์ชั่นที่ไม่มีชื่อกับหนึ่งอาร์กิวเมนต์ ต้องไม่มีช่องว่างใด ๆ อาจหรือไม่อาจมีบรรทัดใหม่ต่อท้าย

->s{Z=(s.split'
')<<[]
K=[]
F=->i,j,f{k=Z[i][j]
K[i]||=0
k==?^?2.times{|m|F[i+1,j+m,f/2]}:!k ?K[j]+=f :F[i+1,j+(k==?/?0:1),f]}
F[0,0,1.0]
K}

เสีย 9 ไบต์เมื่อต้องจัดการ0 levels(สตริงว่าง) กรณีทดสอบทั้งหมดผลงานออกมาได้อย่างถูกต้องดูที่นี่ที่ ideone

Pyth, 43 42 41 ไบต์

umsdc+0sm@c[ZJhkJZKcJ2K)2x"\/"ekC,GH2.z]1

สิ่งนี้คาดว่าอินพุตจะไม่มีช่องว่าง ลองใช้งานออนไลน์: Pyth Compiler / Executor

Pyth, 40 ไบต์ (น่าสงสัย)

umsdc+0sm,K@[ZJhkcJ2)x"\/"ek-JKC,GH2.z]1

ขอบคุณ @isaacg สำหรับการบันทึกหนึ่งไบต์ โปรดสังเกตว่ารุ่นนี้ใช้งานไม่ได้ในเวอร์ชันของ Pyth เมื่อมีคำถามถาม มีข้อบกพร่องเล็ก ๆ ในคอมไพเลอร์ แม้ว่ารหัสนี้จะไม่ใช้ฟีเจอร์ใหม่ของ Pyth (มีเพียงสิ่งเดียวที่อยู่ในเอกสาร Pyth เป็นเวลานานและน่าจะใช้ได้) แต่อาจไม่ใช่คำตอบที่ถูกต้อง ตัดสินใจด้วยตัวเอง

ลองใช้งานออนไลน์: Pyth Compiler / Executor

คำอธิบาย:

umsdc+0sm,K@[ZJhkcJ2)x"\/"ek-JKC,GH2.z]1   
u                                   .z]1  reduce G, starting with G = [1], for H in all_input():
                               C,GH         zip(G,H)
        m                                   map each pair k to:
            [ZJhkcJ2)                         create a list [0, k[0], k[0]/2]
                     x"\/"ek                  index of k[1] in "\/" (-1 for "^")
          K@                                  take the correspondent element of the list and store in K
         ,                  -JK               create a pair (K, k[0]-K)                                                      
     +0s                                    sum and insert 0 at the begin
    c                              2        chop into pairs
 msd                                        sum up each pair
                                            G gets updated with this new list

ตัวอย่างเช่นถ้าฉันมีความน่าจะเป็นอินพุตG = [0.5, 0.5, 0.0]และแถวH = "^/^"เกิดขึ้นต่อไปนี้:

• ซิป ... [(0.5,"^"), (0.5,"/"), (0.0,"^")]
• สร้างความน่าจะเป็นผลลัพธ์ ... [[0.25,0.25], [0.5,0.0], [0.0, 0.0]]
• 0 + ผลรวม ... [0, 0.25, 0.25, 0.5, 0.0, 0.0, 0.0]
• สับ ... [0,0.25], [0.25,0.5], [0.0,0.0], [0.0]]
• รวม ... [0.25, 0.75, 0.0, 0.0]

C #, 274 247 ไบต์

ไม่มีอะไรแฟนซีโปรแกรมสมบูรณ์แบบที่อ่านบรรทัด (ไม่ว่าจะมีหรือไม่มีช่องว่างมันแค่ดึงออก) จาก STDIN และพิมพ์ผลลัพธ์ที่คั่นด้วยช่องว่างไปยัง STDOUT

using Q=System.Console;class P{static void Main(){decimal[]k={1},t;string L;for(int l=0,i;(L=Q.ReadLine())!=null;k=t)for(L=L.Replace(" ",""),t=new decimal[++l+1],i=0;i<l;)t[i]+=k[i]-(t[i+1]=(8-L[i]%8)/2*k[i++]/2);Q.WriteLine(string.Join(" ",k));}}

รหัส Tidier พร้อมความคิดเห็น:

using Q=System.Console;

class P
{
    // / 47
    // \ 92
    // ^ 94

    static void Main()
    {
        decimal[]k={1},t; // k is old array, t is new array

        string L; // L is the current line, R is the current result (1 if no rows)
        for(int l=0,i; // l is length of old array, i is index in old array
            (L=Q.ReadLine())!=null; // for each line of input
            k=t) // swap array over
            for(L=L.Replace(" ",""), // remove spaces
                t=new decimal[++l+1], // create a new array
                i=0;

                i<l;) // for each position

                t[i]+=k[i]-( // add to left position (for last time)
                        t[i+1]=(8-L[i]%8)/2*k[i++]/2 // assign right position (k is decimal)
                    );

        Q.WriteLine(string.Join(" ",k)); // print result
    }
}

Python 3, 113

P=[1]
for C in input().split():
 l,*Q=0,
 for p,c in zip(P,C):r=p*"\^/".find(c)/2;Q+=l+r,;l=p-r
 P=Q+[l]
print(P)

อัพเดทเวกเตอร์ความน่าจะเป็นซ้ำ ๆPเพื่อตอบสนองต่อแต่ละบรรทัด เวกเตอร์ความน่าจะQเป็นแบบใหม่นี้ถูกสร้างขึ้นครั้งละหนึ่งรายการ ซ้ำผ่านสล็อตใหม่และคำนวณการสนับสนุนจากหมุดไปทางขวาในrขณะที่ยังคำนวณการสนับสนุนที่เหลือไปยังสล็อตที่จะมาถึงp-rด้วย

คาดว่าแต่ละบรรทัดจะสิ้นสุดในพื้นที่อย่างน้อยหนึ่งช่องเพื่อหลีกเลี่ยงปัญหาที่บรรทัดลงท้ายด้วยแบ็กสแลช

Python 3, 138 ไบต์

def f(s):
 r=[1];p=t=0
 for e in s:
  if'!'<e:b=p==t*-~t/2;r+=[0]*b;t+=b;v=ord(e)%7+1;a=r[p]/2;r[-1]+=v//3*a;r+=v%3*a,;p+=1
 return r[~t:]

ทำงานร่วมกับช่องว่างใด ๆ ที่พวกเขาจะถูกกรองออก (โดยif'!'<e)

วิธี:

• เราเก็บรายการที่เพิ่มขึ้นเรื่อย ๆ rความน่าจะในการเข้าถึงสิ่งกีดขวางและรางด้านล่าง [1]เราเริ่มต้นจากรายการ
• หากเราอยู่ในอุปสรรคแรกในแถวที่เราต้องเพิ่มพิเศษ0ในรายการสำหรับรางนำ เราตัดสินใจว่าเป็นอุปสรรคแรกหรือไม่โดยการเปรียบเทียบดัชนีpt*-~t/2ไปยังหมายเลขสามเหลี่ยมถัดไป
• สำหรับทุกสิ่งกีดขวางเราเพิ่ม list-value บางส่วนไปยังองค์ประกอบสุดท้ายและบางส่วนเป็นองค์ประกอบต่อท้ายใหม่ เราแบ่ง list-value ตามตัวอักษรอุปสรรค (^:0.5 0.5; /:1 0; \:0 1 ) เราใช้วิธีการดังต่อไปนี้:
  • เอา v = ord(char) mod 7 + 1ผลผลิต^:4 /:6 \:2
  • v div 3 / 2 ให้เศษส่วนแรก (^:0.5 /:1 \:0 )
  • v mod 3 / 2ให้เศษส่วนที่สอง ( ^:0.5 /:0 \:1)
• ผลลัพธ์คือt + 1องค์ประกอบสุดท้ายของรายการสุดท้ายrองค์ประกอบของรายการสุดท้าย

2 ไบต์ขอบคุณคำแนะนำการแชทของ @ Sp3000

Perl, 78

#!perl -p0a
@r=($/=1);$^=.5;@r=map$r-$l+($l=$$_*($r=shift@r)),/./g,$r=$l=0for@F;$_="@r"

ใช้อินพุตโดยไม่มีช่องว่าง

ลองฉัน

TI-BASIC, 73 76

รับอินพุตทีละหนึ่งบรรทัดและสิ้นสุดเมื่อช่องว่างถูกป้อนด้วยตัวเองเนื่องจากไม่มีตัวแบ่งบรรทัดในสตริงหรือสตริงว่างถูกกฎหมายใน TI-BASIC

{1→X
Input Str1
While Str1≠"  //one space
.5seq(inString("^/",sub(Str1,I,1)),I,1,dim(Ans
augment(Ans∟X,{0})+augment({0},∟X-∟XAns→X
Input Str1
End
∟X

ฉันค่อนข้างแน่ใจว่าฉันมีขนาดที่ถูกต้อง (TI-BASIC เป็นโทเค็นดังนั้นแต่ละคำสั่งจะใช้หนึ่งหรือสองไบต์ - seq () ใช้เวลาหนึ่ง inString () ใช้เวลาสอง, สลัว () ใช้เวลาหนึ่งและอื่น ๆ ฉัน นับขนาดด้วยตนเอง)

แม้ว่าอักขระเครื่องหมายแบ็กสแลชจะใช้ได้ในสตริงโปรดทราบว่าไม่มีวิธีการป้อนข้อมูลจากภายในโปรแกรมเว้นแต่ว่าคุณจะแก้ไขเครื่องคิดเลขของคุณ

Javascript - 117

พยายามใช้การสอบถามซ้ำ แต่นานเกินไป ...

เลื่อนปลายให้เป็นxnorสำหรับแนวคิดการลบซึ่งจะตัดอักขระหนึ่งโหลขึ้นไป

w=s=>{a=[1];s.split('\n').map(m=>{for(b=[i=0];z=a[i],f=m[i];b[i++]+=z-b[i])b[i+1]=f>']'?z/2:f<':'?0:z;a=b})
return a}

Ungolfed:

// s must not have spaces
w=s=>{
  // a is the current probability array
  a=[1];
  s.split('\n').map(
    // for each row of input...
    m=>{
      b=[0];  // b is the next row's probability array
      for(i=0; i<m.length;){
        z=a[i]; // z = probability
        f=m[i]; // f = letter
                                  // let's assume i == 0
        b[i+1] = (f>']') ? z/2 :  // if f == '^', b[1] = z/2
          (f<':' ? 0 :            // else if f == '/', b[1] = 0 
            z);                   // else b[1] = z
        b[i++]+=z-b[i];           // then add (z-b[1]) to b[0]
      }
      a=z-b    // increment current probability array
    }
  )
  return a;
}