도전

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

규칙

• 표준 허점 적용
• 당신은 오른쪽 또는 왼쪽 확률 행렬을 원하는지 선택할 수 있습니다
• 플로트, 유리수, 무한 정밀도 10 진수 등과 같은 합리적인 숫자 유형을 사용할 수 있습니다.
• 이것은 code-golf 이므로 각 언어에 대한 가장 짧은 바이트 제출은 해당 언어의 승자로 선언됩니다. 응답이 없습니다

R ,  44  43 바이트

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

온라인으로 사용해보십시오!

고정 행렬을 찾을 때까지 계속 곱하기. 분명히 X!=(X=X%*%m)비교를 수행 한 다음을 다시 할당 X하므로 깔끔합니다.

바이트를 줄인 @Vlo에게 감사드립니다. 44를 넘어도 여전히 44입니다.

옥타브 ,45 42 35 바이트

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

온라인으로 사용해보십시오!

Giuseppe 덕분에 3 바이트를 절약했으며 Luis Mendo 덕분에 7 바이트를 더 절약했습니다!

이는 고유 값 1 (최대 고유 값)에 해당하는 고유 벡터가 제한 행렬의 각 값에 대해 반복되는 열 벡터임을 사용합니다. 확률을 갖기 위해 합계 1을 갖도록 벡터를 정규화 한 다음 행렬을 채우기 위해 반복합니다. 나는 골프 옥타브에 정통하지는 않지만 반복적 인 곱셈을 수행하는 기능적인 방법을 찾지 못했으며 전체 프로그램은 항상 이보다 길 것 같습니다.

우리는 any(A)매트릭스가 돌이킬 수없는 마르코프 체인을 설명해야한다는 것을 알고 있기 때문에 사용할 수 있으므로 각 상태는 다른 상태에서 도달 할 수 있어야합니다. 따라서 각 열에서 하나 이상의 값이 0이 아니어야합니다.

Wolfram Language (Mathematica) , 14 바이트

출력 수레 :

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

온라인으로 사용해보십시오!

Wolfram Language (Mathematica) , 30 바이트

출력 분수 :

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

온라인으로 사용해보십시오!

젤리 , 6 바이트

æ׳$ÐL

이것은 전체 프로그램입니다.

온라인으로 사용해보십시오!

APL (Dyalog) , 18 6 바이트

@ H.PWiz 덕분에 12 바이트 절약

+.×⍨⍣≡

온라인으로 사용해보십시오!

k / q, 10 바이트

프로그램이 두 언어에서 동일하기 때문에 k / q. 코드는 실제로 관용적 인 k / q입니다.

{$[x]/[x]}

설명

{..}x암시 적 매개 변수로 람다 구문이 없습니다.

$[x] 이진 행렬 곱셈 연산자로 $가 있으며, 하나의 매개 변수 만 제공하면 Markov Matrix에 곱한 단항 연산자가 생성됩니다.

/[x] x 자체부터 시작하여 수렴까지 왼쪽 곱셈을 적용합니다.

C (GCC) , 207 (192) 190 (181) 176 바이트 + 2 바이트 플래그-lm

• 저장된 15 17 에 20-두 바이트 덕분 ceilingcat을 .
• 9 바이트를 절약했습니다. 제거 중 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]));}

온라인으로 사용해보십시오!

파이썬 3 , 75 61 바이트

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

온라인으로 사용해보십시오!

테스트 사례에서는 부동 소수점이 부정확하므로 값이 정확한 분수와 약간 다를 수 있습니다.

추신. numpy.allclose()가 numpy.array_equal()길고 부정확 한 플로트가 발생하기 때문에 사용됩니다 .

-14 bytes Thanks HyperNeutrino;) 아 맞다 @ 연산자를 잊었다;

자바 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;}

@ceilingcat 덕분에 -17 바이트 .

확실히 올바른 언어가 아닙니다. 젠장 부동 소수점 정밀도 ..

설명:

온라인으로 사용해보십시오.

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