ท้าทาย

ให้เมทริกซ์ซ้ายหรือขวาสุ่มซึ่งขีด จำกัด เมื่อ x เข้าใกล้อนันต์ของเมทริกซ์กับกำลังของ x เข้าใกล้เมทริกซ์ด้วยค่า จำกัด ทั้งหมดคืนเมทริกซ์ที่เมทริกซ์ลู่เข้าหากัน โดยพื้นฐานแล้วคุณต้องการคูณเมทริกซ์ด้วยตัวเองจนกว่าผลลัพธ์จะไม่เปลี่ยนแปลงอีกต่อไป

กรณีทดสอบ

[[7/10, 4/10], [3/10, 6/10]] -> [[4/7, 4/7], [3/7, 3/7]]
[[2/5, 4/5], [3/5, 1/5]] -> [[4/7, 4/7], [3/7, 3/7]]
[[1/2, 1/2], [1/2, 1/2]] -> [[1/2, 1/2], [1/2, 1/2]]
[[1/3, 2/3], [2/3, 1/3]] -> [[1/2, 1/2], [1/2, 1/2]]
[[1/10, 2/10, 3/10], [4/10, 5/10, 6/10], [5/10, 3/10, 1/10]] -> [[27/130, 27/130, 27/130], [66/130, 66/130, 66/130], [37/130, 37/130, 37/130]]
[[1/7, 2/7, 4/7], [2/7, 4/7, 1/7], [4/7, 1/7, 2/7]] -> [[1/3, 1/3, 1/3], [1/3, 1/3, 1/3], [1/3, 1/3, 1/3]]

กฎระเบียบ

• ช่องโหว่มาตรฐานใช้
• คุณอาจเลือกว่าคุณต้องการเมทริกซ์ขวาหรือซ้ายสุ่ม
• คุณสามารถใช้ประเภทตัวเลขที่สมเหตุสมผลเช่นลอย, ปันส่วน, ทศนิยมที่ไม่มีที่สิ้นสุดอย่างแม่นยำ ฯลฯ
• นี่คือโค้ดกอล์ฟดังนั้นการส่งที่สั้นที่สุดในหน่วยไบต์สำหรับแต่ละภาษาจะถูกประกาศให้เป็นผู้ชนะสำหรับภาษานั้น ๆ จะไม่ยอมรับคำตอบ

R ,  44  43 ไบต์

function(m){X=m
while(any(X-(X=X%*%m)))0
X}

ลองออนไลน์!

แค่คูณมันเรื่อย ๆ จนกระทั่งพบเมทริกซ์คงที่ เห็นได้ชัดว่าX!=(X=X%*%m)ไม่เปรียบเทียบแล้ว reassigns Xเพื่อให้เป็นที่เรียบร้อย

ขอบคุณ @Vlo สำหรับการกำจัดไบต์ แม้ว่าขีดฆ่า 44 ยังคงเป็นปกติ 44

ระดับแปดเสียง45 42 35 ไบต์

@(A)([v,~]=eigs(A,1))/sum(v)*any(A)

ลองออนไลน์!

บันทึกแล้ว 3 ไบต์ขอบคุณ Giuseppe และขอขอบคุณ Luis Mendo อีก 7 คน!

สิ่งนี้ใช้ว่า eigenvector สอดคล้องกับ eigenvalue 1 (เช่น eigenvalue สูงสุด) เป็นเวกเตอร์คอลัมน์ที่ทำซ้ำสำหรับแต่ละค่าของเมทริกซ์ที่ จำกัด เราต้องทำให้เวกเตอร์เป็นปกติให้มีผลรวม 1 เพื่อให้สุ่ม, จากนั้นเราก็ทำซ้ำเพื่อกรอกเมทริกซ์ ฉันไม่เชี่ยวชาญในการเล่นกอล์ฟอ็อกเทฟมากเกินไป แต่ฉันไม่สามารถหาวิธีที่ใช้ในการคูณซ้ำได้และโปรแกรมเต็มดูเหมือนว่ามันจะนานกว่านี้

เราสามารถใช้any(A)ตั้งแต่ข้อ จำกัด ที่เรารู้ว่าเมทริกซ์จะต้องอธิบายห่วงโซ่มาร์คอฟที่ลดไม่ได้และแต่ละรัฐจะต้องสามารถเข้าถึงได้จากรัฐอื่น ๆ ดังนั้นอย่างน้อยหนึ่งค่าในแต่ละคอลัมน์จะต้องไม่ใช่ศูนย์

ภาษา Wolfram (Mathematica)ขนาด 14 ไบต์

เอาท์พุทลอย:

N@#//.x_:>x.#&

ลองออนไลน์!

ภาษา Wolfram (Mathematica)ขนาด 30 ไบต์

เศษส่วนของผลผลิต:

Limit[#~MatrixPower~n,n->∞]&

ลองออนไลน์!

เยลลี่ขนาด 6 ไบต์

æ׳$ÐL

นี่เป็นโปรแกรมเต็ม

ลองออนไลน์!

APL (Dyalog) , 18 6 ไบต์

บันทึก 12 ไบต์ด้วย @ H.PWiz

+.×⍨⍣≡

ลองออนไลน์!

k / q, 10 ไบต์

k / q เนื่องจากโปรแกรมเหมือนกันทั้งสองภาษา รหัสเป็นจริงเพียงสำนวน k / q

{$[x]/[x]}

คำอธิบาย

{..}อยู่นอกไวยากรณ์แลมบ์ดาพร้อมกับxพารามิเตอร์ implicit

$[x] มี $ เป็นตัวดำเนินการคูณเมทริกซ์ไบนารีโดยมีเพียงพารามิเตอร์เดียวเท่านั้นที่สร้างโอเปอเรเตอร์ยูนารีที่เหลืออยู่คูณด้วยมาร์คอฟเมตริกซ์

/[x] ใช้การคูณทางซ้ายจนกระทั่งการบรรจบกันเริ่มต้นด้วย x เอง

C (gcc) , 207 192 190 181 176 ไบต์ + 2 ตั้งค่าสถานะไบต์-lm

• ที่บันทึกไว้ สิบห้า สิบเจ็ดยี่สิบ-ไบต์ที่สองต้องขอบคุณceilingcat
• บันทึกเก้าไบต์ ลบreturn A;ลบ

float*f(A,l,k,j)float*A;{for(float B[l*l],S,M=0,m=1;fabs(m-M)>1e-7;wmemcpy(A,B,l*l))for(M=m,m=0,k=l*l;k--;)for(S=j=0;j<l;)m=fmax(m,fdim(A[k],B[k]=S+=A[k/l*l+j]*A[k%l+j++*l]));}

ลองออนไลน์!

Python 3 , 75 61 ไบต์

f=lambda n:n if allclose(n@n,n)else f(n@n)
from numpy import*

ลองออนไลน์!

ในกรณีทดสอบมีความคลาดเคลื่อนลอยตัวดังนั้นค่าอาจแตกต่างกันเล็กน้อยจากเศษส่วนที่แน่นอน

PS numpy.allclose()ใช้เพราะnumpy.array_equal()มีความยาวมากกว่าและมีแนวโน้มที่จะลอยคลาดเคลื่อน

-14 bytes ขอบคุณ HyperNeutrino;) โอ้ใช่ฉันลืม @ operator; P

Java 8, 356 339 ไบต์

import java.math.*;m->{BigDecimal t[][],q;RoundingMode x=null;for(int l=m.length,f=1,i,k;f>0;m=t.clone()){for(t=new BigDecimal[l][l],i=l*l;i-->0;)for(f=k=0;k<l;t[i/l][i%l]=(q!=null?q:q.ZERO).add(m[i/l][k].multiply(m[k++][i%l])))q=t[i/l][i%l];for(;++i<l*l;)f=t[i/l][i%l].setScale(9,x.UP).equals(m[i/l][i%l].setScale(9,x.UP))?f:1;}return m;}

-17 ไบต์ขอบคุณที่@ceilingcat

ไม่ใช่ภาษาที่ถูกต้องแน่นอน .. ความแม่นยำของจุดลอยตัวประณาม ..

คำอธิบาย:

ลองออนไลน์

import java.math.*;     // Required import for BigDecimal and RoundingMode
m->{                    // Method with BigDecimal-matrix as both parameter and return-type
  BigDecimal t[][],q;   //  Temp BigDecimal-matrix
  RoundingMode x=null;  //  Static RoundingMode value to reduce bytes
  for(int l=m.length,   //  The size of the input-matrix
          f=1,          //  Flag-integer, starting at 1
          i,k;          //  Index-integers
      f>0;              //  Loop as long as the flag-integer is still 1
      m=t.clone()){     //    After every iteration: replace matrix `m` with `t`
    for(t=new BigDecimal[l][l],
                        //   Reset matrix `t`
        i=l*l;i-->0;)   //   Inner loop over the rows and columns
      for(f=k=0;        //    Set the flag-integer to 0
          k<l           //    Inner loop to multiply
          ;             //      After every iteration:
           t[i/l][i%l]=(q!=null?q:q.ZERO).add(
                        //       Sum the value at the current cell in matrix `t` with:
             m[i/l][k]  //        the same row, but column `k` of matrix `m`,
             .multiply(m[k++][i%l])))
                        //        multiplied with the same column, but row `k` of matrix `m`
        q=t[i/l][i%l];  //     Set temp `q` to the value of the current cell of `t`
    for(;++i<l*l;)      //   Loop over the rows and columns again
      f=t[i/l][i%l].setScale(9,x.UP).equals(m[i/l][i%l].setScale(9,x.UP))?
                        //    If any value in matrices `t` and `m` are the same:
         f              //     Leave the flag-integer unchanged
        :               //    Else (they aren't the same):
         1;}            //     Set the flag-integer to 1 again
  return m;}            //  Return the modified input-matrix `m` as our result