Thử thách

Đưa ra một ma trận ngẫu nhiên trái hoặc phải trong đó giới hạn khi x tiếp cận vô hạn của ma trận với sức mạnh của x tiếp cận một ma trận với tất cả các giá trị hữu hạn, trả về ma trận mà ma trận hội tụ. Về cơ bản, bạn muốn tiếp tục nhân ma trận cho đến khi kết quả không còn thay đổi.

Các trường hợp thử nghiệm

[[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]]

Quy tắc

• Áp dụng sơ hở tiêu chuẩn
• Bạn có thể chọn xem bạn muốn một ma trận ngẫu nhiên phải hay trái
• Bạn có thể sử dụng bất kỳ loại số hợp lý nào, chẳng hạn như số float, số hữu tỷ, số thập phân chính xác vô hạn, v.v.
• Đây là môn đánh gôn , vì vậy việc gửi byte ngắn nhất cho mỗi ngôn ngữ được tuyên bố là người chiến thắng cho ngôn ngữ của nó. Không có câu trả lời sẽ được chấp nhận

R ,  44  43 byte

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

Hãy thử trực tuyến!

Chỉ cần tiếp tục nhân cho đến khi nó tìm thấy một ma trận cố định. Rõ ràng X!=(X=X%*%m)là so sánh, sau đó gán lại X, vì vậy đó là gọn gàng.

Cảm ơn @Vlo đã cạo sạch một byte; mặc dù gạch bỏ 44 vẫn là 44 thường xuyên.

Octave ,45 42 35 byte

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

Hãy thử trực tuyến!

Đã lưu 3 byte nhờ Giuseppe và 7 byte nữa nhờ Luis Mendo!

Điều này sử dụng rằng hàm riêng tương ứng với giá trị riêng 1 (cũng là giá trị riêng tối đa) là vectơ cột được lặp lại cho mỗi giá trị của ma trận giới hạn. Chúng ta phải chuẩn hóa vectơ để có tổng 1 cho nó là ngẫu nhiên, sau đó chúng ta chỉ cần lặp lại nó để điền vào ma trận. Tôi không rành về chơi golf Octave, nhưng tôi chưa thể tìm ra một cách chức năng để thực hiện phép nhân lặp lại, và một chương trình đầy đủ có vẻ như sẽ luôn dài hơn thế này.

Chúng ta có thể sử dụng any(A)từ các hạn chế mà chúng ta biết rằng ma trận phải mô tả chuỗi Markov không thể sửa chữa và do đó mỗi trạng thái phải có thể truy cập được từ các trạng thái khác. Do đó, ít nhất một giá trị trong mỗi cột phải khác không.

Ngôn ngữ Wolfram (Mathicala) , 14 byte

Phao đầu ra:

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 30 byte

Phân số đầu ra:

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

Hãy thử trực tuyến!

Thạch , 6 byte

æ׳$ÐL

Đây là một chương trình đầy đủ.

Hãy thử trực tuyến!

APL (Dyalog) , 18 6 byte

12 byte được lưu nhờ @ H.PWiz

+.×⍨⍣≡

Hãy thử trực tuyến!

k / q, 10 byte

k / q vì chương trình giống hệt nhau ở cả hai ngôn ngữ. Mã này thực sự chỉ là thành ngữ k / q.

{$[x]/[x]}

Giải trình

{..}là cú pháp lambda, với xmột tham số ngầm định

$[x] có $ là toán tử nhân ma trận nhị phân, chỉ cung cấp một tham số sẽ tạo ra một toán tử đơn nguyên còn lại nhân với Ma trận Markov

/[x] áp dụng phép nhân trái cho đến khi hội tụ, bắt đầu bằng chính x.

C (gcc) , 207 192 190 181 176 byte + 2 byte cờ-lm

• Đã lưu mười lăm mười hai hai mươi hai byte nhờ trần .
• Đã lưu chín byte; loại bỏ 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]));}

Hãy thử trực tuyến!

Python 3 , 75 61 byte

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

Hãy thử trực tuyến!

Trong các trường hợp thử nghiệm có sự không chính xác nổi, vì vậy các giá trị có thể khác nhau một chút so với các phân số chính xác.

Tái bút numpy.allclose()được sử dụng vì numpy.array_equal()dài hơn và dễ nổi không chính xác.

-14 byte Cảm ơn HyperNeutrino;) Ồ vâng, tôi đã quên toán tử @; P

Java 8, 356 339 byte

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 byte nhờ @ceilingcat .

Chắc chắn không phải ngôn ngữ phù hợp .. Độ chính xác điểm nổi chết tiệt ..

Giải trình:

Hãy thử trực tuyến.

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